commit cdba16ebe88f31c40e33ecc48cc246afd732c628 Author: Sven Carstensen Date: Tue Mar 24 15:03:35 2026 +0100 first commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..1363c81 --- /dev/null +++ b/.gitignore @@ -0,0 +1,50 @@ +# Miscellaneous +*.class +*.log +*.pyc +*.swp +.DS_Store +.atom/ +.build/ +.buildlog/ +.history +.svn/ +.swiftpm/ +migrate_working_dir/ + +# IntelliJ related +*.iml +*.ipr +*.iws +.idea/ + +# The .vscode folder contains launch configuration and tasks you configure in +# VS Code which you may wish to be included in version control, so this line +# is commented out by default. +#.vscode/ + +# Flutter/Dart/Pub related +**/doc/api/ +**/ios/Flutter/.last_build_id +.dart_tool/ +.flutter-plugins-dependencies +.pub-cache/ +.pub/ +**/build/ +**/coverage/ + +# Symbolication related +app.*.symbols + +# Obfuscation related +app.*.map.json + +# Android Studio will place build artifacts here +/app/android/app/debug +/app/android/app/profile +/app/android/app/release + +# Java / Maven / Vaadin +**/target/ +**/node_modules/ +backend/.vaadin/ diff --git a/.vscode/check_emulator.sh b/.vscode/check_emulator.sh new file mode 100755 index 0000000..b13e598 --- /dev/null +++ b/.vscode/check_emulator.sh @@ -0,0 +1,47 @@ +#!/bin/bash + +# Skript zum Prüfen ob Emulator läuft + +YELLOW='\033[1;33m' +GREEN='\033[0;32m' +RED='\033[0;31m' +NC='\033[0m' + +echo "🔍 Prüfe auf Android Emulator..." + +# Prüfe ob Emulator läuft +DEVICE=$(flutter devices 2>/dev/null | grep "emulator" | head -1) + +if [ -n "$DEVICE" ]; then + echo -e "${GREEN}✅ Emulator läuft:${NC}" + echo " $DEVICE" + exit 0 +else + echo -e "${RED}❌ Kein Emulator gefunden!${NC}" + echo "" + echo "Verfügbare Emulatoren:" + flutter emulators + echo "" + echo -e "${YELLOW}Starte Emulator...${NC}" + flutter emulators --launch Pixel_8_Pro_API_29 2>/dev/null & + + echo "" + echo "Warte auf Emulator-Start (ca. 30-60 Sekunden)..." + + # Warte bis Emulator verfügbar ist + for i in {1..30}; do + sleep 2 + DEVICE=$(flutter devices 2>/dev/null | grep "emulator" | head -1) + if [ -n "$DEVICE" ]; then + echo -e "${GREEN}✅ Emulator bereit!${NC}" + echo " $DEVICE" + exit 0 + fi + echo -n "." + done + + echo "" + echo -e "${YELLOW}⚠️ Emulator startet noch...${NC}" + echo " Bitte warten und dann nochmal versuchen." + exit 1 +fi diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 0000000..610b9ee --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,26 @@ +{ + "recommendations": [ + // Flutter & Dart + "Dart-Code.flutter", + "Dart-Code.dart-code", + + // UI-Entwicklung + "eamodio.gitlens", + "usernamehw.errorlens", + "PKief.material-icon-theme", + + // Produktivität + "formulahendry.auto-rename-tag", + "streetsidesoftware.code-spell-checker", + "wmaurer.change-case", + "Tyriar.sort-lines", + + // Flutter Tools + "alexisvt.flutter-snippets", + "Nash.awesome-flutter-snippets", + "miquelddg.dart-barrel-file-generator" + ], + "unwantedRecommendations": [ + "vscjava.vscode-java-pack" + ] +} diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..6506df2 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,89 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "name": "🚀 HHA - Android Emulator (Debug)", + "type": "dart", + "request": "launch", + "program": "${workspaceFolder}/app/lib/main.dart", + "flutterMode": "debug", + "deviceId": "emulator-5554", + "preLaunchTask": "prelaunch: check deps", + "args": [ + "--enable-software-rendering", + "--no-enable-impeller" + ], + "console": "debugConsole", + "toolArgs": [ + "--hot" + ], + "cwd": "${workspaceFolder}/app", + "internalConsoleOptions": "openOnSessionStart" + }, + { + "name": "🚀 HHA - Android Emulator (Verbose)", + "type": "dart", + "request": "launch", + "program": "${workspaceFolder}/app/lib/main.dart", + "flutterMode": "debug", + "deviceId": "emulator-5554", + "preLaunchTask": "flutter: pub get", + "args": [ + "--enable-software-rendering", + "--no-enable-impeller", + "--verbose" + ], + "console": "terminal", + "cwd": "${workspaceFolder}/app" + }, + { + "name": "📱 HHA - Android Device (Debug)", + "type": "dart", + "request": "launch", + "program": "${workspaceFolder}/app/lib/main.dart", + "flutterMode": "debug", + "preLaunchTask": "prelaunch: check deps", + "console": "debugConsole", + "cwd": "${workspaceFolder}/app" + }, + { + "name": "🌐 HHA - Chrome (Debug)", + "type": "dart", + "request": "launch", + "program": "${workspaceFolder}/app/lib/main.dart", + "flutterMode": "debug", + "deviceId": "chrome", + "preLaunchTask": "prelaunch: check deps", + "console": "debugConsole", + "cwd": "${workspaceFolder}/app" + }, + { + "name": "📊 HHA - Profile Mode", + "type": "dart", + "request": "launch", + "program": "${workspaceFolder}/app/lib/main.dart", + "flutterMode": "profile", + "preLaunchTask": "prelaunch: check deps", + "console": "debugConsole", + "cwd": "${workspaceFolder}/app" + }, + { + "name": "⚡ HHA - Release Mode", + "type": "dart", + "request": "launch", + "program": "${workspaceFolder}/app/lib/main.dart", + "flutterMode": "release", + "preLaunchTask": "prelaunch: check deps", + "console": "debugConsole", + "cwd": "${workspaceFolder}/app" + }, + { + "name": "🔌 HHA - Attach to Running App", + "type": "dart", + "request": "attach", + "program": "${workspaceFolder}/app/lib/main.dart", + "console": "debugConsole", + "cwd": "${workspaceFolder}/app" + } + ] +} diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..39f0852 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,60 @@ +{ + // Dart & Flutter + "dart.flutterSdkPath": null, + "dart.openDevTools": "flutter", + "dart.previewFlutterUiGuides": true, + "dart.previewFlutterUiGuidesCustomTracking": true, + "dart.showInspectorNotificationsForWidgetErrors": true, + "dart.hotReloadOnSave": "always", + "dart.flutterHotReloadOnSave": "always", + "dart.debugExternalPackageLibraries": false, + "dart.debugSdkLibraries": false, + + // Formatierung + "editor.formatOnSave": true, + "editor.formatOnType": true, + "editor.rulers": [80, 120], + "editor.wordWrap": "wordWrapColumn", + "editor.wordWrapColumn": 120, + "editor.bracketPairColorization.enabled": true, + "editor.guides.bracketPairs": true, + + // Dart-spezifisch + "[dart]": { + "editor.formatOnSave": true, + "editor.formatOnType": true, + "editor.rulers": [80], + "editor.selectionHighlight": false, + "editor.suggest.snippetsPreventQuickSuggestions": false, + "editor.suggestSelection": "first", + "editor.tabCompletion": "onlySnippets", + "editor.wordBasedSuggestions": "off" + }, + + // File Explorer + "files.exclude": { + "**/.dart_tool": true, + "**/.packages": true, + "**/.pub": true, + "**/build": true, + "**/*.freezed.dart": true, + "**/*.g.dart": true + }, + + // Linting + "dart.analysisExcludedFolders": [ + "app/build", + "app/.dart_tool", + "backend/target" + ], + + // Emulator + "dart.flutterRunAdditionalArgs": [ + "--enable-software-rendering" + ], + + // Testing + "dart.testAdditionalArgs": [ + "--concurrency=4" + ] +} diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 0000000..3d1e646 --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,177 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "flutter: clean", + "type": "shell", + "command": "flutter", + "args": ["clean"], + "options": { + "cwd": "${workspaceFolder}/app" + }, + "group": "build", + "presentation": { + "echo": true, + "reveal": "always", + "focus": false, + "panel": "shared" + }, + "problemMatcher": [] + }, + { + "label": "flutter: pub get", + "type": "shell", + "command": "flutter", + "args": ["pub", "get"], + "options": { + "cwd": "${workspaceFolder}/app" + }, + "group": "build", + "presentation": { + "echo": true, + "reveal": "always", + "focus": false, + "panel": "shared" + }, + "problemMatcher": [] + }, + { + "label": "check: emulator", + "type": "shell", + "command": "${workspaceFolder}/.vscode/check_emulator.sh", + "group": "build", + "presentation": { + "echo": true, + "reveal": "always", + "focus": false, + "panel": "shared", + "clear": true + }, + "problemMatcher": [] + }, + { + "label": "flutter: build debug", + "type": "shell", + "command": "flutter", + "args": [ + "build", + "apk", + "--debug", + "-t", + "lib/main.dart" + ], + "options": { + "cwd": "${workspaceFolder}/app" + }, + "group": { + "kind": "build", + "isDefault": true + }, + "presentation": { + "echo": true, + "reveal": "always", + "focus": false, + "panel": "shared", + "showReuseMessage": false, + "clear": true + }, + "problemMatcher": { + "pattern": { + "regexp": "." + } + } + }, + { + "label": "flutter: run (terminal)", + "type": "shell", + "command": "flutter", + "args": [ + "run", + "-d", + "emulator-5554", + "--debug" + ], + "options": { + "cwd": "${workspaceFolder}/app" + }, + "group": "build", + "isBackground": true, + "dependsOn": ["check: emulator", "flutter: pub get"], + "presentation": { + "echo": true, + "reveal": "always", + "focus": true, + "panel": "shared", + "showReuseMessage": false, + "clear": true + }, + "problemMatcher": { + "pattern": [ + { + "regexp": ".", + "file": 1, + "location": 2, + "message": 3 + } + ], + "background": { + "activeOnStart": true, + "beginsPattern": "^\\[\\+\\]", + "endsPattern": "^\\[.*\\]\\s*Synced.*" + } + } + }, + { + "label": "flutter: devices", + "type": "shell", + "command": "flutter", + "args": ["devices"], + "options": { + "cwd": "${workspaceFolder}/app" + }, + "group": "build", + "presentation": { + "echo": true, + "reveal": "always", + "focus": false, + "panel": "shared", + "clear": true + }, + "problemMatcher": [] + }, + { + "label": "flutter: doctor", + "type": "shell", + "command": "flutter", + "args": ["doctor", "-v"], + "options": { + "cwd": "${workspaceFolder}/app" + }, + "group": "build", + "presentation": { + "echo": true, + "reveal": "always", + "focus": false, + "panel": "shared", + "clear": true + }, + "problemMatcher": [] + }, + { + "label": "prelaunch: check deps", + "type": "shell", + "command": "flutter", + "args": ["pub", "get"], + "options": { + "cwd": "${workspaceFolder}/app" + }, + "presentation": { + "echo": false, + "reveal": "silent", + "focus": false, + "panel": "shared" + }, + "problemMatcher": [] + } + ] +} diff --git a/README.md b/README.md new file mode 100644 index 0000000..19ce51a --- /dev/null +++ b/README.md @@ -0,0 +1,45 @@ +# HHA Repository + +Dieses Repository ist jetzt als Monorepo fuer zwei getrennte Anwendungen aufgebaut: + +- `app/` enthaelt die Flutter-App +- `backend/` enthaelt das Spring Boot + Vaadin Backoffice + +## Struktur + +```text +HHA/ +|- app/ +| |- lib/ +| |- android/ +| |- pubspec.yaml +| `- README.md +`- backend/ + |- src/main/java/ + |- src/main/resources/ + |- pom.xml + `- mvnw +``` + +## Start + +Flutter-App: + +```bash +cd app +flutter pub get +flutter run +``` + +Backend: + +```bash +cd backend +./mvnw spring-boot:run +``` + +## Hinweise + +- Flutter-spezifische Quellen, Build-Dateien und Artefakte liegen unter `app/`. +- Das Backend bleibt als eigenstaendiges Maven-Modul unter `backend/`. +- Weitere Details zur mobilen App stehen in `app/README.md`. diff --git a/app/.metadata b/app/.metadata new file mode 100644 index 0000000..a30adde --- /dev/null +++ b/app/.metadata @@ -0,0 +1,30 @@ +# This file tracks properties of this Flutter project. +# Used by Flutter tool to assess capabilities and perform upgrades etc. +# +# This file should be version controlled and should not be manually edited. + +version: + revision: "8b872868494e429d94fa06dca855c306438b22c0" + channel: "stable" + +project_type: app + +# Tracks metadata for the flutter migrate command +migration: + platforms: + - platform: root + create_revision: 8b872868494e429d94fa06dca855c306438b22c0 + base_revision: 8b872868494e429d94fa06dca855c306438b22c0 + - platform: android + create_revision: 8b872868494e429d94fa06dca855c306438b22c0 + base_revision: 8b872868494e429d94fa06dca855c306438b22c0 + + # User provided section + + # List of Local paths (relative to this file) that should be + # ignored by the migrate tool. + # + # Files that are not part of the templates will be ignored by default. + unmanaged_files: + - 'lib/main.dart' + - 'ios/Runner.xcodeproj/project.pbxproj' diff --git a/app/.vscode/launch.json b/app/.vscode/launch.json new file mode 100644 index 0000000..fef93ab --- /dev/null +++ b/app/.vscode/launch.json @@ -0,0 +1,89 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "name": "🚀 HHA - Android Emulator (Debug)", + "type": "dart", + "request": "launch", + "program": "lib/main.dart", + "flutterMode": "debug", + "deviceId": "emulator-5554", + "preLaunchTask": "prelaunch: check deps", + "args": [ + "--enable-software-rendering", + "--no-enable-impeller" + ], + "console": "debugConsole", + "toolArgs": [ + "--hot" + ], + "cwd": "${workspaceFolder}", + "internalConsoleOptions": "openOnSessionStart" + }, + { + "name": "🚀 HHA - Android Emulator (Verbose)", + "type": "dart", + "request": "launch", + "program": "lib/main.dart", + "flutterMode": "debug", + "deviceId": "emulator-5554", + "preLaunchTask": "flutter: pub get", + "args": [ + "--enable-software-rendering", + "--no-enable-impeller", + "--verbose" + ], + "console": "terminal", + "cwd": "${workspaceFolder}" + }, + { + "name": "📱 HHA - Android Device (Debug)", + "type": "dart", + "request": "launch", + "program": "lib/main.dart", + "flutterMode": "debug", + "preLaunchTask": "prelaunch: check deps", + "console": "debugConsole", + "cwd": "${workspaceFolder}" + }, + { + "name": "🌐 HHA - Chrome (Debug)", + "type": "dart", + "request": "launch", + "program": "lib/main.dart", + "flutterMode": "debug", + "deviceId": "chrome", + "preLaunchTask": "prelaunch: check deps", + "console": "debugConsole", + "cwd": "${workspaceFolder}" + }, + { + "name": "📊 HHA - Profile Mode", + "type": "dart", + "request": "launch", + "program": "lib/main.dart", + "flutterMode": "profile", + "preLaunchTask": "prelaunch: check deps", + "console": "debugConsole", + "cwd": "${workspaceFolder}" + }, + { + "name": "⚡ HHA - Release Mode", + "type": "dart", + "request": "launch", + "program": "lib/main.dart", + "flutterMode": "release", + "preLaunchTask": "prelaunch: check deps", + "console": "debugConsole", + "cwd": "${workspaceFolder}" + }, + { + "name": "🔌 HHA - Attach to Running App", + "type": "dart", + "request": "attach", + "program": "lib/main.dart", + "console": "debugConsole", + "cwd": "${workspaceFolder}" + } + ] +} diff --git a/app/.vscode/tasks.json b/app/.vscode/tasks.json new file mode 100644 index 0000000..6a1c5a8 --- /dev/null +++ b/app/.vscode/tasks.json @@ -0,0 +1,38 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "flutter: pub get", + "type": "shell", + "command": "flutter", + "args": ["pub", "get"], + "options": { + "cwd": "${workspaceFolder}" + }, + "group": "build", + "presentation": { + "echo": true, + "reveal": "always", + "focus": false, + "panel": "shared" + }, + "problemMatcher": [] + }, + { + "label": "prelaunch: check deps", + "type": "shell", + "command": "flutter", + "args": ["pub", "get"], + "options": { + "cwd": "${workspaceFolder}" + }, + "presentation": { + "echo": false, + "reveal": "silent", + "focus": false, + "panel": "shared" + }, + "problemMatcher": [] + } + ] +} diff --git a/app/ANALYSE.md b/app/ANALYSE.md new file mode 100644 index 0000000..2ed33bb --- /dev/null +++ b/app/ANALYSE.md @@ -0,0 +1,381 @@ +# HHA Lua Workflow Analyse + +## Überblick + +Die analysierten Lua-Skripte implementieren einen umfangreichen Logistik-Workflow für die Hamburger Hochbahn (HHA). Die App verwaltet den Transport und die Zustandsänderungen verschiedener Objekte zwischen verschiedenen Stationen. + +## Architektur der Lua-App + +### Dateistruktur +- `hha_mainscript.lua` - Initialisierung und Barcode-Handling +- `hha_main.lua` - Hauptlogik mit UI und State-Machine +- `hha_db_migration_V0_initial.lua` - Datenbank-Schema + +### UI-Framework +Die App verwendet ein proprietäres UI-Framework (ASUI) mit folgenden Komponenten: +- ASUIStackLayout - Layout-Container +- ASUILabel - Textanzeige +- ASUIButton - Schaltflächen +- ASUIScrollView - Scrollbare Bereiche +- ASUIPerfListViewM - Performante Listen +- ASUIBoxView / ASUIRelativeLayout - Container + +## Objekt-Typen + +### 1. Geldkassetten (GK) +- **Typ-ID**: 3 +- **Codes**: MEKxxx, BEKxxx +- **Subtypen**: meka, mekb, mekc, mekd, beka, bekb, bekc, bekd +- **Workflow**: Lager → Fahrzeug → Station → Fahrscheinautomat → Geldinstitut + +### 2. HP Patronen (HP) +- **Typ-ID**: 4 +- **Codes**: HOPxxx, H1Pxxx, H2Pxxx, H3Pxxx +- **Subtypen**: hp1a, hp1b, hp1c, hp2a, hp2b, hp2c, hp3a, hp3b, hp3c +- **Workflow**: Lager → Fahrzeug → Fahrscheinautomat + +### 3. Fahrkartenrollen (FR) +- **Typ-ID**: 7 +- **Codes**: FRxxx +- **Subtypen**: fra +- **Workflow**: Lager → Fahrzeug → Fahrscheinautomat + +### 4. Safebags (SB) +- **Typ-ID**: 5 +- **Workflow**: Versorgungsstelle → Geldinstitut + +### 5. Abfallbehälter (ABS) +- **Typ-ID**: 9 +- **Workflow**: Versorgungsstelle → Dienststelle + +### 6. Container (CNTR) +- **Typ-ID**: ? +- **Subtypen**: cntra (Geldinstitut), cntrb (Dienststelle) +- **Workflow**: Sammlung mehrerer Objekte + +## Zustände (States) + +### Hauptzustände +``` +unknown → to_delivery → delivery → station → in_fa + ↓ + ┌───────────────────────┼───────────────────────┐ + ↓ ↓ ↓ + ret_gi ret_fail ret_ds + ↓ ↓ ↓ + ret_gi_fzg ret_fail_fzg ret_ds_fzg + ↓ ↓ ↓ + fin_gi ret_fail_stk ret_ds_stk + ↓ ↓ + fin_ds_fail fin_ds +``` + +### Zustandsbeschreibungen + +| State | Beschreibung | Farbe | +|-------|-------------|-------| +| `unknown` | Unbekannt/Neu | Weiß | +| `to_delivery` | Zum Fahrzeug | Grau | +| `delivery` | Im Fahrzeug | Grau | +| `station` | An Station | Gelb | +| `in_fa` | Im Fahrscheinautomat | Grün | +| `in_vs` | In Versorgungsstelle | Gelb | +| `ret_fail` | Fehlerhaft zur Dienststelle | Rot | +| `ret_fail_fzg` | Fehlerhaft im Fahrzeug | Rot | +| `ret_fail_stk` | Fehlerhaft in Dienststelle | Rot | +| `ret_gi` | Zum Geldinstitut | Hellblau | +| `ret_gi_fzg` | Zum Geldinstitut (Fzg) | Hellblau | +| `ret_gi_stk` | Zum Geldinstitut (Stk) | Hellblau | +| `fin_gi` | Abgeschlossen im Geldinstitut | Blau | +| `ret_ds` | Zur Dienststelle | Hellblau | +| `ret_ds_fzg` | Zur Dienststelle (Fzg) | Hellblau | +| `ret_ds_stk` | Zur Dienststelle (Stk) | Hellblau | +| `ret_ds_err` | Fehlerhaft zur Dienststelle | Hellblau | +| `fin_ds` | Abgeschlossen in Dienststelle | Blau | +| `fin_ds_fail` | Fehlerhaft abgeschlossen | Blau | +| `fin_ds_err` | Fehlerhaft abgeschlossen | Blau | +| `hdl` | Handel | Grau | +| `ret_ds_empty` | Leer zur Dienststelle | Hellblau | + +## Tour-Stationen + +### Stationstypen + +| Type | Beschreibung | Icon | +|------|-------------|------| +| `stock_start` | Lager - Beladung | Lager | +| `stock` | Lager | Lager | +| `stock_end` | Lager - Rückgabe | Lager | +| `start` | Dienststelle - Start | Dienststelle | +| `end` | Dienststelle - Ende | Dienststelle | +| `st` | Haltestelle | Haltestelle | +| `hls` | Hochbahnstation | HLS | +| `fsa` | Fahrscheinautomat | FSA | +| `vs` | Versorgungsstelle | VS | +| `gi` | Geldinstitut | Bank | +| `veh_start` | Fahrzeug - Beladung | Fahrzeug | +| `veh` | Fahrzeug | Fahrzeug | +| `veh_bulk` | Fahrzeug - Massenladung | Fahrzeug | +| `veh_vs` | Fahrzeug - Versorgung | Fahrzeug | +| `veh_end` | Fahrzeug - Entladung | Fahrzeug | + +### Seiten (Pages) +Jede Tour hat mehrere Seiten, die bestimmte Aktionen definieren: +- **Page-ID**: Eindeutige Identifikation +- **Code**: Barcode zum Aktivieren der Seite +- **Label**: Anzeigename +- **Pickup**: Objekte, die aufgenommen werden sollen +- **Swap**: Objekte, die ausgetauscht werden sollen + +## State Machines + +### 1. Stock Start State Machine +``` +unknown → to_delivery (Auf Fahrzeug laden) +fin_gi_tmp → ret_gi (Rückgabe an Geldinstitut) +``` + +### 2. Vehicle Start State Machine +``` +to_delivery → delivery (Bestätigung Ladung) +ret_gi → ret_gi_fzg (Übernahme vom Geldinstitut) +``` + +### 3. Vehicle State Machine +``` +delivery → station (An Haltestelle ausgeben) +ret_fail → ret_fail_fzg (Fehlerhafte übernehmen) +ret_gi → ret_gi_fzg (Geldinstitut-Objekte übernehmen) +ret_ds → ret_ds_fzg (Dienststellen-Objekte übernehmen) +station → delivery (Rücknahme) +in_fa → hdl (Handel) +``` + +### 4. FSA (Fahrscheinautomat) State Machine + +#### Geldkassette (GK) +``` +station → in_fa (Einbau) +in_fa → ret_fail (Fehlerhaft ausbauen) +unknown → ret_gi (Neue unbekannte Kassette) +``` + +#### HP Patrone +``` +station → in_fa (Einbau) +in_fa → station (Ausbau) +unknown → ret_ds (Neue unbekannte Patrone) +``` + +#### Fahrkartenrolle +``` +station → in_fa (Einbau) +in_fa → station (Ausbau) +``` + +### 5. Versorgungsstelle (VS) State Machine +``` +Container Type A (cntra): + - SB (Safebag) in_vs → ret_gi + +Container Type B (cntrb): + - ABS (Abfall) in_vs → ret_ds + +Container Barcode: + - cntra → Container A aktivieren + - cntrb → Container B aktivieren +``` + +### 6. Geldinstitut (GI) State Machine +``` +ret_gi_fzg → fin_gi (Übergabe an Bank) +unknown → ret_ds_empty (Leere Kassette) +``` + +### 7. Vehicle End State Machine +``` +ret_fail_fzg → ret_fail_stk +ret_ds_fzg → ret_ds_stk +delivery → ret_ds_stk +ret_ds_empty → ret_ds_stk +ret_gi_fzg → ret_gi_stk +``` + +### 8. Stock End State Machine +``` +ret_fail_stk → fin_ds_fail +ret_ds_stk → fin_ds +ret_ds_err → fin_ds_err +ret_gi_stk → fin_gi_tmp +``` + +## API-Endpunkte + +### Initialisierung +``` +GET /hha?init={"update":, "imei":} +``` + +### Status-Update +``` +GET /hha?set_obj_state={"obj":[...], "imei":} +``` + +### Tour abschließen +``` +GET /hha?fin_tour={"id":, "time":, "imei":} +``` + +### Neues Objekt +``` +GET /hha?new_obj={"type":, "man":true, "code":, ...} +``` + +### Quittung +``` +GET /hha?new_receipt={"data":, "time":, ...} +``` + +### Neuer Safebag +``` +GET /hha?new_safebag={"code":, "time":, ...} +``` + +## Datenbank-Schema + +### Tabellen + +#### tour +- id, job_id, tour_id, version, state, type, sort +- loc_id, loc_code, loc_code2, rem, menu, modified, del_code + +#### object +- id, object_id, type, version, loc_id, code, rem, state, subtype +- origin, manual, last_modified + +#### location +- id, location_id, version, name, street, num, zip, city, lat, long, rem + +#### page +- id, tour_id, page_number, page_id, type, code, label + +#### page_swap_count / page_pickup_count +- id, tour_id, page_id, object_type, object_count + +#### sendqueue +- id, url (Base64-kodiert) + +#### receipt +- id, code + +#### container_objects +- id, container_id, type, object_id + +## Besonderheiten + +### Counter-Labels +Die App zeigt Zähler für verschiedene Objekttypen an: +- **MEK**: Münzgeldkassette +- **BEK**: Bargeldentnahmekassette +- **H1, H2, H3**: HP Patronen +- **P**: Fahrkartenrolle +- **SB**: Safebag +- **ABS**: Abfallbehälter + +### Beladezähler +- SST: Sonder-Sonder-Tour +- CR: Collection-Route +- HADAG: Fährverbindung + +### Quittungen +Für Geldkassetten müssen Quittungen gescannt werden: +- 2D-Barcode enthält: FA-#, GK-#, Betrag, Datum, Zeit +- Keine Quittung = Warnhinweis + +### Manueller Modus +- Neue Objekte können manuell angelegt werden +- Server-Validierung des Barcodes +- Automatische Typ-Erkennung über Präfix + +### Container-Logik +- Container werden über Barcode aktiviert +- Mehrere Objekte können einem Container zugeordnet werden +- Container-Abschluss überträgt Status auf alle enthaltenen Objekte + +## Offline-Verhalten + +1. **Daten werden lokal gespeichert** (SQLite) +2. **API-Aufrufe werden in Queue eingereiht** +3. **Automatische Synchronisation** bei Verbindung +4. **Konfliktauflösung** über Versionsnummern + +## Synchronisation + +### Trigger +- App-Start +- Manueller Refresh +- Intervall (60 Sekunden) +- Tour-Abschluss + +### Daten +- Metadaten (Objekttypen) +- Standorte +- Objekte +- Jobs & Touren +- Page-Counts + +## Sicherheit + +- Geräte-Authentifizierung über IMEI +- Keine Passwörter im Code +- HTTPS für API-Kommunikation +- Lokale Daten verschlüsselt (SQLite) + +## Flutter-Implementierung + +### Architektur-Mapping + +| Lua | Flutter | +|-----|---------| +| ASUIStackLayout | Column/Row | +| ASUILabel | Text | +| ASUIButton | ElevatedButton | +| ASUIScrollView | SingleChildScrollView | +| database:Query | Repository Pattern | +| BarcodeScanned | MobileScanner | +| State Machine | BLoC Pattern | + +### UI-Vergleich + +| Lua-UI | Flutter-UI | +|--------|-----------| +| Hintergrund #220220220 | Colors.grey.shade200 | +| HHA Rot | Color(0xFFE3001B) | +| Grüner Header #188230165 | Color(0xFFBCA6A5) | +| Status-Farben | ObjectStateInfo.getColorForState | + +### State-Management + +Die komplexen Lua-State-Machines wurden in BLoC-Pattern überführt: +- `ScanBloc` verwaltet Barcode-Scanning +- `TourBloc` verwaltet Touren und Synchronisation +- Zustandsübergänge sind explizit und testbar + +### Vorteile der Flutter-Implementierung + +1. **Type Safety**: Dart's Typisierung verhindert Laufzeitfehler +2. **Hot Reload**: Schnellere Entwicklung +3. **Moderne UI**: Material Design 3, Animationen +4. **Wartbarkeit**: Klare Architektur, Trennung von Concerns +5. **Testbarkeit**: Unit-Tests für Business-Logik +6. **Offline-First**: SQFlite mit Repository-Pattern +7. **State Management**: BLoC für vorhersagbare Zustände + +## Fazit + +Die Lua-App implementiert einen ausgereiften, komplexen Workflow für die Logistik der Hamburger Hochbahn. Die Flutter-Neuimplementierung behält die komplette fachliche Logik bei, verbessert jedoch: +- Architektur und Wartbarkeit +- UI/UX mit modernem Design +- Offline-Fähigkeiten +- Testbarkeit und Qualität +- Zukunftssicherheit und Erweiterbarkeit diff --git a/app/README.md b/app/README.md new file mode 100644 index 0000000..acc30ce --- /dev/null +++ b/app/README.md @@ -0,0 +1,196 @@ +# HHA Logistics - Flutter App + +Diese Flutter-Anwendung liegt im Monorepo unter `app/`. + +Das zugehoerige Spring Boot + Vaadin Backend liegt daneben unter `../backend/`. + +Eine moderne, optisch ansprechende Flutter-App für die Hamburger Hochbahn (HHA) zur Verwaltung von Logistik-Prozessen. + +## Features + +### Kernfunktionen +- **Tour-Management**: Übersichtliche Darstellung aller Touren und Stationen +- **Barcode-Scanning**: Schnelles Erfassen von Objekten per Kamera +- **State-Management**: Automatische Zustandsübergänge für Objekte +- **Offline-Unterstützung**: Lokale Datenspeicherung mit Synchronisation +- **Echtzeit-Sync**: Automatische Aktualisierung der Daten + +### Objekttypen +- **Geldkassetten** (MEK, BEK) +- **HP Patronen** (H1, H2, H3) +- **Fahrkartenrollen** +- **Safebags** (Wertsachenbehälter) +- **Container** + +### Stationstypen +- Lager (Beladung/Rückgabe) +- Dienststellen +- Haltestellen +- Fahrscheinautomaten +- Versorgungsstellen +- Geldinstitute + +## Technischer Stack + +### Architektur +- **Clean Architecture**: Trennung von Domain, Data und Presentation Layer +- **BLoC Pattern**: State Management mit flutter_bloc +- **Repository Pattern**: Abstraktion der Datenquellen + +### UI/UX +- **Material Design 3**: Modernes, konsistentes Design +- **Flutter Animate**: Flüssige Animationen +- **Phosphor Icons**: Hochwertige Icons +- **Google Fonts**: Inter als Hausschrift + +### Technologien +- **Mobile Scanner**: Barcode-Scanning +- **SQFlite**: Lokale Datenbank +- **Dio**: HTTP-Client für API-Kommunikation +- **Shared Preferences**: Lokale Einstellungen + +## Projektstruktur + +``` +app/ +├── lib/ +│ ├── core/ +│ ├── data/ +│ ├── domain/ +│ └── presentation/ +├── android/ +├── build/ +├── pubspec.yaml +└── run_app.sh +``` + +## Installation + +### Voraussetzungen +- Flutter SDK >= 3.0.0 +- Dart SDK >= 3.0.0 +- Android Studio / Xcode + +### Setup + +1. Repository klonen: +```bash +git clone +cd hha_logistics +cd app +``` + +2. Dependencies installieren: +```bash +flutter pub get +``` + +3. Code-Generierung ausführen: +```bash +flutter pub run build_runner build +``` + +4. App starten: +```bash +flutter run +``` + +## Konfiguration + +### API-Endpunkt +Die API-URL wird in `lib/core/constants/app_constants.dart` konfiguriert: +```dart +static const String baseUrl = 'https://hha-app1.assecutor.de/hha'; +``` + +### Berechtigungen + +#### Android (android/app/src/main/AndroidManifest.xml) +```xml + + + +``` + +#### iOS (ios/Runner/Info.plist) +```xml +NSCameraUsageDescription +Kamera wird für Barcode-Scanning benötigt +``` + +## Fachlicher Workflow + +### 1. Login & Datensynchronisation +- Anmeldung mit Geräte-IMEI +- Automatischer Datenabgleich mit Server +- Lokale Speicherung für Offline-Nutzung + +### 2. Tour-Übersicht +- Liste aller Stationen der aktuellen Tour +- Fortschrittsanzeige +- Unterscheidung zwischen offenen und erledigten Stationen + +### 3. Station-Arbeit +- Barcode-Scanning zur Identifikation +- Automatische State-Machine für Zustandsübergänge +- Manuelle Barcode-Eingabe möglich + +### 4. State-Machine +Die App implementiert folgende Zustandsübergänge: +- `unknown` → `to_delivery` → `delivery` → `station` → `in_fa` → `ret_gi` → `fin_gi` +- Fehlerfälle: `ret_fail` → `ret_fail_fzg` → `ret_fail_stk` +- Dienststelle: `ret_ds` → `ret_ds_fzg` → `fin_ds` + +### 5. Bestandsführung +- Echtzeit-Anzeige aller Objekte +- Filterung nach Status und Typ +- Quittungsverwaltung für Geldkassetten + +## Design-System + +### Farben +- **Primary**: HHA Rot (#E3001B) +- **Success**: Grün (#4CAF50) +- **Warning**: Orange (#FF9800) +- **Error**: Rot (#E3001B) + +### State Colors +- `delivery`: Grau (#B3B3B3) +- `station`: Gelb (#FFDD00) +- `in_fa`: Grün (#9CDA7A) +- `ret_fail`: Rot (#FF9081) +- `ret_ds`: Hellblau (#AFE0ED) +- `fin_ds`: Blau (#29B7FB) + +## Entwicklung + +### Code-Generierung +Nach Änderungen an Modellen: +```bash +flutter pub run build_runner build --delete-conflicting-outputs +``` + +### Tests ausführen +```bash +flutter test +``` + +### Release Build +```bash +# Android +flutter build apk --release +flutter build appbundle --release + +# iOS +flutter build ios --release +``` + +## Lizenz + +Copyright © 2024 Hamburger Hochbahn AG + +## Support + +Bei Fragen oder Problemen wenden Sie sich an: +- IT-Support: support@hha.de +- Entwicklung: dev@hha.de diff --git a/app/analysis_options.yaml b/app/analysis_options.yaml new file mode 100644 index 0000000..44d1b64 --- /dev/null +++ b/app/analysis_options.yaml @@ -0,0 +1,22 @@ +include: package:flutter_lints/flutter.yaml + +linter: + rules: + avoid_print: true + prefer_single_quotes: true + prefer_const_constructors: true + prefer_const_literals_to_create_immutables: true + prefer_final_fields: true + prefer_final_locals: true + avoid_unnecessary_containers: true + avoid_redundant_argument_values: true + use_super_parameters: true + use_build_context_synchronously: true + +analyzer: + exclude: + - "**/*.g.dart" + - "**/*.freezed.dart" + - "**/generated_plugin_registrant.dart" + errors: + invalid_annotation_target: ignore diff --git a/app/android/.gitignore b/app/android/.gitignore new file mode 100644 index 0000000..be3943c --- /dev/null +++ b/app/android/.gitignore @@ -0,0 +1,14 @@ +gradle-wrapper.jar +/.gradle +/captures/ +/gradlew +/gradlew.bat +/local.properties +GeneratedPluginRegistrant.java +.cxx/ + +# Remember to never publicly share your keystore. +# See https://flutter.dev/to/reference-keystore +key.properties +**/*.keystore +**/*.jks diff --git a/app/android/app/build.gradle.kts b/app/android/app/build.gradle.kts new file mode 100644 index 0000000..9d3fc3f --- /dev/null +++ b/app/android/app/build.gradle.kts @@ -0,0 +1,44 @@ +plugins { + id("com.android.application") + id("kotlin-android") + // The Flutter Gradle Plugin must be applied after the Android and Kotlin Gradle plugins. + id("dev.flutter.flutter-gradle-plugin") +} + +android { + namespace = "com.example.hha_logistics" + compileSdk = flutter.compileSdkVersion + ndkVersion = flutter.ndkVersion + + compileOptions { + sourceCompatibility = JavaVersion.VERSION_17 + targetCompatibility = JavaVersion.VERSION_17 + } + + kotlinOptions { + jvmTarget = JavaVersion.VERSION_17.toString() + } + + defaultConfig { + // TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html). + applicationId = "com.example.hha_logistics" + // You can update the following values to match your application needs. + // For more information, see: https://flutter.dev/to/review-gradle-config. + minSdk = flutter.minSdkVersion + targetSdk = flutter.targetSdkVersion + versionCode = flutter.versionCode + versionName = flutter.versionName + } + + buildTypes { + release { + // TODO: Add your own signing config for the release build. + // Signing with the debug keys for now, so `flutter run --release` works. + signingConfig = signingConfigs.getByName("debug") + } + } +} + +flutter { + source = "../.." +} diff --git a/app/android/app/src/debug/AndroidManifest.xml b/app/android/app/src/debug/AndroidManifest.xml new file mode 100644 index 0000000..399f698 --- /dev/null +++ b/app/android/app/src/debug/AndroidManifest.xml @@ -0,0 +1,7 @@ + + + + diff --git a/app/android/app/src/main/AndroidManifest.xml b/app/android/app/src/main/AndroidManifest.xml new file mode 100644 index 0000000..8cfbe1f --- /dev/null +++ b/app/android/app/src/main/AndroidManifest.xml @@ -0,0 +1,45 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/app/android/app/src/main/kotlin/com/example/hha_logistics/MainActivity.kt b/app/android/app/src/main/kotlin/com/example/hha_logistics/MainActivity.kt new file mode 100644 index 0000000..0f4baf9 --- /dev/null +++ b/app/android/app/src/main/kotlin/com/example/hha_logistics/MainActivity.kt @@ -0,0 +1,5 @@ +package com.example.hha_logistics + +import io.flutter.embedding.android.FlutterActivity + +class MainActivity : FlutterActivity() diff --git a/app/android/app/src/main/res/drawable-v21/launch_background.xml b/app/android/app/src/main/res/drawable-v21/launch_background.xml new file mode 100644 index 0000000..f74085f --- /dev/null +++ b/app/android/app/src/main/res/drawable-v21/launch_background.xml @@ -0,0 +1,12 @@ + + + + + + + + diff --git a/app/android/app/src/main/res/drawable/launch_background.xml b/app/android/app/src/main/res/drawable/launch_background.xml new file mode 100644 index 0000000..304732f --- /dev/null +++ b/app/android/app/src/main/res/drawable/launch_background.xml @@ -0,0 +1,12 @@ + + + + + + + + diff --git a/app/android/app/src/main/res/mipmap-hdpi/ic_launcher.png b/app/android/app/src/main/res/mipmap-hdpi/ic_launcher.png new file mode 100644 index 0000000..db77bb4 Binary files /dev/null and b/app/android/app/src/main/res/mipmap-hdpi/ic_launcher.png differ diff --git a/app/android/app/src/main/res/mipmap-mdpi/ic_launcher.png b/app/android/app/src/main/res/mipmap-mdpi/ic_launcher.png new file mode 100644 index 0000000..17987b7 Binary files /dev/null and b/app/android/app/src/main/res/mipmap-mdpi/ic_launcher.png differ diff --git a/app/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/app/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png new file mode 100644 index 0000000..09d4391 Binary files /dev/null and b/app/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png differ diff --git a/app/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/app/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png new file mode 100644 index 0000000..d5f1c8d Binary files /dev/null and b/app/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png differ diff --git a/app/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/app/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png new file mode 100644 index 0000000..4d6372e Binary files /dev/null and b/app/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png differ diff --git a/app/android/app/src/main/res/values-night/styles.xml b/app/android/app/src/main/res/values-night/styles.xml new file mode 100644 index 0000000..06952be --- /dev/null +++ b/app/android/app/src/main/res/values-night/styles.xml @@ -0,0 +1,18 @@ + + + + + + + diff --git a/app/android/app/src/main/res/values/styles.xml b/app/android/app/src/main/res/values/styles.xml new file mode 100644 index 0000000..cb1ef88 --- /dev/null +++ b/app/android/app/src/main/res/values/styles.xml @@ -0,0 +1,18 @@ + + + + + + + diff --git a/app/android/app/src/profile/AndroidManifest.xml b/app/android/app/src/profile/AndroidManifest.xml new file mode 100644 index 0000000..399f698 --- /dev/null +++ b/app/android/app/src/profile/AndroidManifest.xml @@ -0,0 +1,7 @@ + + + + diff --git a/app/android/build.gradle.kts b/app/android/build.gradle.kts new file mode 100644 index 0000000..dbee657 --- /dev/null +++ b/app/android/build.gradle.kts @@ -0,0 +1,24 @@ +allprojects { + repositories { + google() + mavenCentral() + } +} + +val newBuildDir: Directory = + rootProject.layout.buildDirectory + .dir("../../build") + .get() +rootProject.layout.buildDirectory.value(newBuildDir) + +subprojects { + val newSubprojectBuildDir: Directory = newBuildDir.dir(project.name) + project.layout.buildDirectory.value(newSubprojectBuildDir) +} +subprojects { + project.evaluationDependsOn(":app") +} + +tasks.register("clean") { + delete(rootProject.layout.buildDirectory) +} diff --git a/app/android/gradle.properties b/app/android/gradle.properties new file mode 100644 index 0000000..fbee1d8 --- /dev/null +++ b/app/android/gradle.properties @@ -0,0 +1,2 @@ +org.gradle.jvmargs=-Xmx8G -XX:MaxMetaspaceSize=4G -XX:ReservedCodeCacheSize=512m -XX:+HeapDumpOnOutOfMemoryError +android.useAndroidX=true diff --git a/app/android/gradle/wrapper/gradle-wrapper.properties b/app/android/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..e4ef43f --- /dev/null +++ b/app/android/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-all.zip diff --git a/app/android/settings.gradle.kts b/app/android/settings.gradle.kts new file mode 100644 index 0000000..ca7fe06 --- /dev/null +++ b/app/android/settings.gradle.kts @@ -0,0 +1,26 @@ +pluginManagement { + val flutterSdkPath = + run { + val properties = java.util.Properties() + file("local.properties").inputStream().use { properties.load(it) } + val flutterSdkPath = properties.getProperty("flutter.sdk") + require(flutterSdkPath != null) { "flutter.sdk not set in local.properties" } + flutterSdkPath + } + + includeBuild("$flutterSdkPath/packages/flutter_tools/gradle") + + repositories { + google() + mavenCentral() + gradlePluginPortal() + } +} + +plugins { + id("dev.flutter.flutter-plugin-loader") version "1.0.0" + id("com.android.application") version "8.11.1" apply false + id("org.jetbrains.kotlin.android") version "2.2.20" apply false +} + +include(":app") diff --git a/app/devtools_options.yaml b/app/devtools_options.yaml new file mode 100644 index 0000000..fa0b357 --- /dev/null +++ b/app/devtools_options.yaml @@ -0,0 +1,3 @@ +description: This file stores settings for Dart & Flutter DevTools. +documentation: https://docs.flutter.dev/tools/devtools/extensions#configure-extension-enablement-states +extensions: diff --git a/app/lib/core/constants/app_constants.dart b/app/lib/core/constants/app_constants.dart new file mode 100644 index 0000000..33b3a52 --- /dev/null +++ b/app/lib/core/constants/app_constants.dart @@ -0,0 +1,132 @@ +class AppConstants { + // API + static const String baseUrl = 'https://hha-app1.assecutor.de/hha'; + static const int connectionTimeout = 30000; + static const int receiveTimeout = 30000; + + // Database + static const String databaseName = 'hha_logistics.db'; + static const int databaseVersion = 1; + + // App Info + static const String appName = 'HHA Logistics'; + static const String appVersion = '2.0.0'; + + // Sync + static const Duration syncInterval = Duration(minutes: 1); + static const Duration locationUpdateInterval = Duration(seconds: 30); +} + +class ObjectStates { + static const String unknown = 'unknown'; + static const String toDelivery = 'to_delivery'; + static const String delivery = 'delivery'; + static const String station = 'station'; + static const String inFA = 'in_fa'; + static const String inVS = 'in_vs'; + static const String retFail = 'ret_fail'; + static const String retFailFzg = 'ret_fail_fzg'; + static const String retFailStk = 'ret_fail_stk'; + static const String retGI = 'ret_gi'; + static const String retGIFzg = 'ret_gi_fzg'; + static const String retGIStk = 'ret_gi_stk'; + static const String retDS = 'ret_ds'; + static const String retDSFzg = 'ret_ds_fzg'; + static const String retDSStk = 'ret_ds_stk'; + static const String retDSErr = 'ret_ds_err'; + static const String retDSEmpty = 'ret_ds_empty'; + static const String finDS = 'fin_ds'; + static const String finGI = 'fin_gi'; + static const String finDSFail = 'fin_ds_fail'; + static const String finDSErr = 'fin_ds_err'; + static const String hdl = 'hdl'; + static const String stkHadag = 'stk_hadag'; + static const String finGITmp = 'fin_gi_tmp'; + static const String retcGI = 'retc_gi'; + static const String retcDS = 'retc_ds'; + static const String retDSFix = 'ret_ds_fix'; + static const String retFixStk = 'ret_fix_stk'; + static const String finFix = 'fin_fix'; + static const String trig = 'trig'; +} + +class TourTypes { + static const String stockStart = 'stock_start'; + static const String stock = 'stock'; + static const String start = 'start'; + static const String station = 'st'; + static const String hls = 'hls'; + static const String vs = 'vs'; + static const String stockEnd = 'stock_end'; + static const String end = 'end'; + static const String fsa = 'fsa'; + static const String gi = 'gi'; + static const String veh = 'veh'; + static const String vehStart = 'veh_start'; + static const String vehBulk = 'veh_bulk'; + static const String vehVs = 'veh_vs'; + static const String vehEnd = 'veh_end'; + static const String menu = 'me'; +} + +class ObjectTypes { + static const String gk = 'gk'; // Geldkassette + static const String hp = 'hp'; // HP Patronen + static const String fr = 'fr'; // Fahrkartenrolle + static const String sb = 'sb'; // Safebag + static const String abs = 'abs'; // Abfallbehälter + static const String cntr = 'cntr'; // Container +} + +class ObjectSubtypes { + // Geldkassetten + static const String meka = 'meka'; + static const String mekb = 'mekb'; + static const String mekc = 'mekc'; + static const String mekd = 'mekd'; + static const String beka = 'beka'; + static const String bekb = 'bekb'; + static const String bekc = 'bekc'; + static const String bekd = 'bekd'; + + // HP Patronen + static const String hp1a = 'hp1a'; + static const String hp1b = 'hp1b'; + static const String hp1c = 'hp1c'; + static const String hp2a = 'hp2a'; + static const String hp2b = 'hp2b'; + static const String hp2c = 'hp2c'; + static const String hp3a = 'hp3a'; + static const String hp3b = 'hp3b'; + static const String hp3c = 'hp3c'; + + // Fahrkartenrollen + static const String fra = 'fra'; + + // Container + static const String cntra = 'cntra'; + static const String cntrb = 'cntrb'; +} + +class CounterLabels { + static const Map labels = { + 'meka': 'MEK', + 'beka': 'BEK', + 'hp1a': 'H1', + 'hp2a': 'H2', + 'hp3a': 'H3', + 'fra': 'P', + 'sb': 'SB', + 'abs': 'ABS', + 'mekb': 'MEK-B', + 'bekb': 'BEK-B', + 'hp1b': 'H1-B', + 'hp2b': 'H2-B', + 'mekc': 'MEK-SST', + 'bekc': 'BEK-SST', + 'hp1c': 'H1-SST', + 'hp2c': 'H2-SST', + 'mekd': 'MEK-CR', + 'bekd': 'BEK-CR', + }; +} diff --git a/app/lib/core/errors/failures.dart b/app/lib/core/errors/failures.dart new file mode 100644 index 0000000..ed6b063 --- /dev/null +++ b/app/lib/core/errors/failures.dart @@ -0,0 +1,70 @@ +import 'package:equatable/equatable.dart'; + +abstract class Failure extends Equatable { + final String message; + final String? code; + + const Failure({ + required this.message, + this.code, + }); + + @override + List get props => [message, code]; +} + +class ServerFailure extends Failure { + const ServerFailure({ + required super.message, + super.code, + }); +} + +class CacheFailure extends Failure { + const CacheFailure({ + required super.message, + super.code, + }); +} + +class NetworkFailure extends Failure { + const NetworkFailure({ + required super.message, + super.code, + }); +} + +class ValidationFailure extends Failure { + const ValidationFailure({ + required super.message, + super.code, + }); +} + +class NotFoundFailure extends Failure { + const NotFoundFailure({ + required super.message, + super.code, + }); +} + +class UnauthorizedFailure extends Failure { + const UnauthorizedFailure({ + required super.message, + super.code, + }); +} + +class BarcodeFailure extends Failure { + const BarcodeFailure({ + required super.message, + super.code, + }); +} + +class SyncFailure extends Failure { + const SyncFailure({ + required super.message, + super.code, + }); +} diff --git a/app/lib/core/theme/app_theme.dart b/app/lib/core/theme/app_theme.dart new file mode 100644 index 0000000..2f8dd21 --- /dev/null +++ b/app/lib/core/theme/app_theme.dart @@ -0,0 +1,273 @@ +import 'package:flutter/material.dart'; +import 'package:flutter/services.dart'; +import 'package:google_fonts/google_fonts.dart'; + +class AppTheme { + // Brand Colors - HHA Corporate Colors + static const Color hhaRed = Color(0xFFE3001B); + static const Color hhaDarkRed = Color(0xFFB30015); + static const Color hhaLightRed = Color(0xFFFF4D5E); + + // State Colors + static const Color stateDelivery = Color(0xFFB3B3B3); + static const Color stateStation = Color(0xFFFFDD00); + static const Color stateInFA = Color(0xFF9CDA7A); + static const Color stateRetFail = Color(0xFFFF9081); + static const Color stateRetDS = Color(0xFFAFE0ED); + static const Color stateRetGI = Color(0xFFAFE0ED); + static const Color stateFinDS = Color(0xFF29B7FB); + static const Color stateFinGI = Color(0xFF25BAFC); + static const Color stateInVS = Color(0xFFFAE14B); + + // Functional Colors + static const Color success = Color(0xFF4CAF50); + static const Color warning = Color(0xFFFF9800); + static const Color error = Color(0xFFE3001B); + static const Color info = Color(0xFF2196F3); + + // Neutral Colors + static const Color white = Color(0xFFFFFFFF); + static const Color background = Color(0xFFF5F5F5); + static const Color surface = Color(0xFFFFFFFF); + static const Color cardBackground = Color(0xFFFAFAFA); + static const Color divider = Color(0xFFE0E0E0); + + // Text Colors + static const Color textPrimary = Color(0xFF212121); + static const Color textSecondary = Color(0xFF757575); + static const Color textTertiary = Color(0xFF9E9E9E); + static const Color textOnDark = Color(0xFFFFFFFF); + + static ThemeData get lightTheme { + return ThemeData( + useMaterial3: true, + colorScheme: const ColorScheme.light( + primary: hhaRed, + primaryContainer: hhaLightRed, + onPrimaryContainer: white, + secondary: Color(0xFF2196F3), + onSurface: textPrimary, + surfaceContainerHighest: background, + error: error, + ), + scaffoldBackgroundColor: background, + appBarTheme: AppBarTheme( + elevation: 0, + centerTitle: true, + backgroundColor: hhaRed, + foregroundColor: white, + titleTextStyle: GoogleFonts.inter( + fontSize: 20, + fontWeight: FontWeight.w600, + color: white, + ), + systemOverlayStyle: const SystemUiOverlayStyle( + statusBarColor: Colors.transparent, + statusBarIconBrightness: Brightness.light, + ), + ), + cardTheme: CardThemeData( + elevation: 2, + shadowColor: Colors.black.withValues(alpha: 26), + shape: RoundedRectangleBorder( + borderRadius: BorderRadius.circular(16), + ), + color: surface, + ), + elevatedButtonTheme: ElevatedButtonThemeData( + style: ElevatedButton.styleFrom( + elevation: 0, + backgroundColor: hhaRed, + foregroundColor: white, + padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 16), + shape: RoundedRectangleBorder( + borderRadius: BorderRadius.circular(12), + ), + textStyle: GoogleFonts.inter( + fontSize: 16, + fontWeight: FontWeight.w600, + ), + ), + ), + outlinedButtonTheme: OutlinedButtonThemeData( + style: OutlinedButton.styleFrom( + foregroundColor: hhaRed, + side: const BorderSide(color: hhaRed, width: 2), + padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 16), + shape: RoundedRectangleBorder( + borderRadius: BorderRadius.circular(12), + ), + textStyle: GoogleFonts.inter( + fontSize: 16, + fontWeight: FontWeight.w600, + ), + ), + ), + textButtonTheme: TextButtonThemeData( + style: TextButton.styleFrom( + foregroundColor: hhaRed, + padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12), + textStyle: GoogleFonts.inter( + fontSize: 14, + fontWeight: FontWeight.w600, + ), + ), + ), + floatingActionButtonTheme: const FloatingActionButtonThemeData( + backgroundColor: hhaRed, + foregroundColor: white, + elevation: 4, + ), + inputDecorationTheme: InputDecorationTheme( + filled: true, + fillColor: surface, + contentPadding: const EdgeInsets.symmetric(horizontal: 16, vertical: 16), + border: OutlineInputBorder( + borderRadius: BorderRadius.circular(12), + borderSide: const BorderSide(color: divider), + ), + enabledBorder: OutlineInputBorder( + borderRadius: BorderRadius.circular(12), + borderSide: const BorderSide(color: divider), + ), + focusedBorder: OutlineInputBorder( + borderRadius: BorderRadius.circular(12), + borderSide: const BorderSide(color: hhaRed, width: 2), + ), + errorBorder: OutlineInputBorder( + borderRadius: BorderRadius.circular(12), + borderSide: const BorderSide(color: error, width: 2), + ), + labelStyle: GoogleFonts.inter( + fontSize: 14, + color: textSecondary, + ), + hintStyle: GoogleFonts.inter( + fontSize: 14, + color: textTertiary, + ), + ), + chipTheme: ChipThemeData( + backgroundColor: background, + selectedColor: hhaRed.withValues(alpha: 26), + labelStyle: GoogleFonts.inter(fontSize: 12), + secondaryLabelStyle: GoogleFonts.inter( + fontSize: 12, + color: hhaRed, + ), + shape: RoundedRectangleBorder( + borderRadius: BorderRadius.circular(8), + ), + ), + listTileTheme: ListTileThemeData( + contentPadding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8), + shape: RoundedRectangleBorder( + borderRadius: BorderRadius.circular(12), + ), + ), + dividerTheme: const DividerThemeData( + color: divider, + thickness: 1, + space: 1, + ), + textTheme: _textTheme, + fontFamily: GoogleFonts.inter().fontFamily, + ); + } + + static TextTheme get _textTheme { + return TextTheme( + displayLarge: GoogleFonts.inter( + fontSize: 32, + fontWeight: FontWeight.bold, + color: textPrimary, + ), + displayMedium: GoogleFonts.inter( + fontSize: 28, + fontWeight: FontWeight.bold, + color: textPrimary, + ), + displaySmall: GoogleFonts.inter( + fontSize: 24, + fontWeight: FontWeight.bold, + color: textPrimary, + ), + headlineLarge: GoogleFonts.inter( + fontSize: 22, + fontWeight: FontWeight.w600, + color: textPrimary, + ), + headlineMedium: GoogleFonts.inter( + fontSize: 20, + fontWeight: FontWeight.w600, + color: textPrimary, + ), + headlineSmall: GoogleFonts.inter( + fontSize: 18, + fontWeight: FontWeight.w600, + color: textPrimary, + ), + titleLarge: GoogleFonts.inter( + fontSize: 16, + fontWeight: FontWeight.w600, + color: textPrimary, + ), + titleMedium: GoogleFonts.inter( + fontSize: 14, + fontWeight: FontWeight.w600, + color: textPrimary, + ), + titleSmall: GoogleFonts.inter( + fontSize: 12, + fontWeight: FontWeight.w600, + color: textSecondary, + ), + bodyLarge: GoogleFonts.inter( + fontSize: 16, + fontWeight: FontWeight.normal, + color: textPrimary, + ), + bodyMedium: GoogleFonts.inter( + fontSize: 14, + fontWeight: FontWeight.normal, + color: textPrimary, + ), + bodySmall: GoogleFonts.inter( + fontSize: 12, + fontWeight: FontWeight.normal, + color: textSecondary, + ), + labelLarge: GoogleFonts.inter( + fontSize: 14, + fontWeight: FontWeight.w500, + color: textPrimary, + ), + labelMedium: GoogleFonts.inter( + fontSize: 12, + fontWeight: FontWeight.w500, + color: textSecondary, + ), + labelSmall: GoogleFonts.inter( + fontSize: 10, + fontWeight: FontWeight.w500, + color: textTertiary, + ), + ); + } +} + +extension ColorExtension on Color { + Color darken([double amount = .1]) { + assert(amount >= 0 && amount <= 1); + final hsl = HSLColor.fromColor(this); + final hslDark = hsl.withLightness((hsl.lightness - amount).clamp(0.0, 1.0)); + return hslDark.toColor(); + } + + Color lighten([double amount = .1]) { + assert(amount >= 0 && amount <= 1); + final hsl = HSLColor.fromColor(this); + final hslLight = hsl.withLightness((hsl.lightness + amount).clamp(0.0, 1.0)); + return hslLight.toColor(); + } +} diff --git a/app/lib/data/models/logistic_object_model.dart b/app/lib/data/models/logistic_object_model.dart new file mode 100644 index 0000000..a69c5df --- /dev/null +++ b/app/lib/data/models/logistic_object_model.dart @@ -0,0 +1,163 @@ +import '../../domain/entities/logistic_object.dart'; + +class LogisticObjectModel extends LogisticObject { + const LogisticObjectModel({ + required super.id, + required super.objectId, + required super.type, + required super.version, + super.locationId, + required super.code, + super.remark, + required super.state, + required super.subtype, + super.origin, + super.isManual, + super.lastModified, + super.typeName, + super.typeMnemonic, + }); + + factory LogisticObjectModel.fromJson(Map json) { + return LogisticObjectModel( + id: json['id'] ?? 0, + objectId: json['object_id'] ?? json['id'] ?? 0, + type: json['type'] ?? 0, + version: json['version'] ?? json['ver'] ?? 0, + locationId: json['loc_id'], + code: json['code'] ?? '', + remark: json['rem'], + state: json['state'] ?? 'unknown', + subtype: json['subtype'] ?? json['type']?.toString() ?? '', + origin: json['origin'], + isManual: json['manual'] == '1' || json['manual'] == true, + lastModified: json['last_modified'] != null + ? DateTime.parse(json['last_modified']) + : null, + ); + } + + factory LogisticObjectModel.fromMap(Map map) { + return LogisticObjectModel( + id: map['id'] ?? 0, + objectId: map['object_id'] ?? 0, + type: map['type'] ?? 0, + version: map['version'] ?? 0, + locationId: map['loc_id'], + code: map['code'] ?? '', + remark: map['rem'], + state: map['state'] ?? 'unknown', + subtype: map['subtype'] ?? '', + origin: map['origin'], + isManual: map['manual'] == '1' || map['manual'] == 1, + lastModified: map['last_modified'] != null + ? DateTime.tryParse(map['last_modified']) + : null, + typeName: map['type_name'], + typeMnemonic: map['type_mnemonic'], + ); + } + + Map toMap() { + return { + 'id': id, + 'object_id': objectId, + 'type': type, + 'version': version, + 'loc_id': locationId, + 'code': code, + 'rem': remark, + 'state': state, + 'subtype': subtype, + 'origin': origin, + 'manual': isManual ? 1 : 0, + 'last_modified': lastModified?.toIso8601String(), + }; + } + + LogisticObjectModel copyWithModel({ + int? id, + int? objectId, + int? type, + int? version, + int? locationId, + String? code, + String? remark, + String? state, + String? subtype, + String? origin, + bool? isManual, + DateTime? lastModified, + String? typeName, + String? typeMnemonic, + }) { + return LogisticObjectModel( + id: id ?? this.id, + objectId: objectId ?? this.objectId, + type: type ?? this.type, + version: version ?? this.version, + locationId: locationId ?? this.locationId, + code: code ?? this.code, + remark: remark ?? this.remark, + state: state ?? this.state, + subtype: subtype ?? this.subtype, + origin: origin ?? this.origin, + isManual: isManual ?? this.isManual, + lastModified: lastModified ?? this.lastModified, + typeName: typeName ?? this.typeName, + typeMnemonic: typeMnemonic ?? this.typeMnemonic, + ); + } +} + +class ObjectMetadataModel extends ObjectMetadata { + const ObjectMetadataModel({ + required super.id, + required super.type, + required super.version, + required super.mnemonic, + required super.name, + required super.prefix, + required super.subtype, + required super.counterText, + }); + + factory ObjectMetadataModel.fromJson(Map json) { + return ObjectMetadataModel( + id: json['id'] ?? 0, + type: json['type'] ?? 0, + version: json['version'] ?? json['ver'] ?? 0, + mnemonic: json['mnemonic'] ?? '', + name: json['name'] ?? '', + prefix: json['pre'] ?? '', + subtype: json['subtype'] ?? '', + counterText: json['counter_text'] ?? '', + ); + } + + factory ObjectMetadataModel.fromMap(Map map) { + return ObjectMetadataModel( + id: map['id'] ?? 0, + type: map['type'] ?? 0, + version: map['version'] ?? 0, + mnemonic: map['mnemonic'] ?? '', + name: map['name'] ?? '', + prefix: map['prefix'] ?? '', + subtype: map['subtype'] ?? '', + counterText: map['counter_text'] ?? '', + ); + } + + Map toMap() { + return { + 'id': id, + 'type': type, + 'version': version, + 'mnemonic': mnemonic, + 'name': name, + 'prefix': prefix, + 'subtype': subtype, + 'counter_text': counterText, + }; + } +} diff --git a/app/lib/data/models/tour_model.dart b/app/lib/data/models/tour_model.dart new file mode 100644 index 0000000..dde0714 --- /dev/null +++ b/app/lib/data/models/tour_model.dart @@ -0,0 +1,194 @@ +import '../../domain/entities/tour.dart'; + +class TourModel extends Tour { + const TourModel({ + required super.id, + required super.jobId, + required super.tourId, + required super.version, + required super.state, + required super.type, + required super.sort, + required super.locationId, + required super.locationCode, + super.locationCode2, + super.remark, + super.menuText, + required super.modified, + super.deliveryCode, + super.locationName, + super.isCompleted, + super.pages, + }); + + factory TourModel.fromJson(Map json) { + return TourModel( + id: json['id'] ?? 0, + jobId: json['job_id'] ?? 0, + tourId: json['tour_id'] ?? 0, + version: json['version'] ?? 0, + state: json['state'] ?? 0, + type: json['type'] ?? '', + sort: json['sort'] ?? 0, + locationId: json['loc_id'] ?? 0, + locationCode: json['loc_code'] ?? '', + locationCode2: json['loc_code_2'], + remark: json['rem'], + menuText: json['menu'], + modified: json['modified'] ?? 0, + deliveryCode: json['del_code'], + locationName: json['location_name'], + isCompleted: json['state'] == 1, + pages: (json['pages'] as List?) + ?.map((p) => TourPageModel.fromJson(p)) + .toList() ?? + [], + ); + } + + factory TourModel.fromMap(Map map) { + return TourModel( + id: map['id'] ?? 0, + jobId: map['job_id'] ?? 0, + tourId: map['tour_id'] ?? 0, + version: map['version'] ?? 0, + state: map['state'] ?? 0, + type: map['type'] ?? '', + sort: map['sort'] ?? 0, + locationId: map['loc_id'] ?? 0, + locationCode: map['loc_code'] ?? '', + locationCode2: map['loc_code2'], + remark: map['rem'], + menuText: map['menu'], + modified: map['modified'] ?? 0, + deliveryCode: map['del_code'], + locationName: map['location_name'], + isCompleted: map['state'] == 1, + ); + } + + Map toMap() { + return { + 'id': id, + 'job_id': jobId, + 'tour_id': tourId, + 'version': version, + 'state': state, + 'type': type, + 'sort': sort, + 'loc_id': locationId, + 'loc_code': locationCode, + 'loc_code2': locationCode2, + 'rem': remark, + 'menu': menuText, + 'modified': modified, + 'del_code': deliveryCode, + }; + } + + TourModel copyWithModel({ + int? id, + int? jobId, + int? tourId, + int? version, + int? state, + String? type, + int? sort, + int? locationId, + String? locationCode, + String? locationCode2, + String? remark, + String? menuText, + int? modified, + String? deliveryCode, + String? locationName, + bool? isCompleted, + List? pages, + }) { + return TourModel( + id: id ?? this.id, + jobId: jobId ?? this.jobId, + tourId: tourId ?? this.tourId, + version: version ?? this.version, + state: state ?? this.state, + type: type ?? this.type, + sort: sort ?? this.sort, + locationId: locationId ?? this.locationId, + locationCode: locationCode ?? this.locationCode, + locationCode2: locationCode2 ?? this.locationCode2, + remark: remark ?? this.remark, + menuText: menuText ?? this.menuText, + modified: modified ?? this.modified, + deliveryCode: deliveryCode ?? this.deliveryCode, + locationName: locationName ?? this.locationName, + isCompleted: isCompleted ?? this.isCompleted, + pages: pages ?? this.pages, + ); + } +} + +class TourPageModel extends TourPage { + const TourPageModel({ + required super.id, + required super.tourId, + required super.pageNumber, + required super.pageId, + required super.type, + super.code, + super.label, + super.pickupCounts, + super.swapCounts, + }); + + factory TourPageModel.fromJson(Map json) { + Map pickupCounts = {}; + Map swapCounts = {}; + + if (json['pickup'] != null && json['pickup']['cnt'] != null) { + final cnt = json['pickup']['cnt'] as Map; + pickupCounts = cnt.map((key, value) => MapEntry(key, value as int)); + } + + if (json['swap'] != null && json['swap']['cnt'] != null) { + final cnt = json['swap']['cnt'] as Map; + swapCounts = cnt.map((key, value) => MapEntry(key, value as int)); + } + + return TourPageModel( + id: json['id'] ?? 0, + tourId: json['tour_id'] ?? 0, + pageNumber: json['page_number'] ?? 0, + pageId: json['page_id'] ?? '', + type: json['type'] ?? '', + code: json['code'], + label: json['lbl'], + pickupCounts: pickupCounts, + swapCounts: swapCounts, + ); + } + + factory TourPageModel.fromMap(Map map) { + return TourPageModel( + id: map['id'] ?? 0, + tourId: map['tour_id'] ?? 0, + pageNumber: map['page_number'] ?? 0, + pageId: map['page_id'] ?? '', + type: map['type'] ?? '', + code: map['code'], + label: map['label'], + + ); + } + + Map toMap() { + return { + 'id': id, + 'tour_id': tourId, + 'page_number': pageNumber, + 'page_id': pageId, + 'type': type, + 'code': code, + 'label': label, + }; + } +} diff --git a/app/lib/domain/entities/counter.dart b/app/lib/domain/entities/counter.dart new file mode 100644 index 0000000..bdced9f --- /dev/null +++ b/app/lib/domain/entities/counter.dart @@ -0,0 +1,199 @@ +import 'package:equatable/equatable.dart'; + +/// Repräsentiert einen Zählerstand für einen Objekttyp +/// Entspricht der Lua-Logik in CreateLoadingStockStartView etc. +class ObjectCounter extends Equatable { + final String objectType; // z.B. 'meka', 'beka', 'hp1a', etc. + final String label; // z.B. 'MEK', 'BEK', 'H1' + final int currentCount; // Aktueller Bestand (z.B. im Fahrzeug) + final int targetCount; // Soll-Zahl (z.B. Beladezähler) + final int? alternateCount; // Alternative Zählung (z.B. HADAG, CR, SST) + + const ObjectCounter({ + required this.objectType, + required this.label, + required this.currentCount, + required this.targetCount, + this.alternateCount, + }); + + bool get isComplete => currentCount >= targetCount; + bool get isOver => currentCount > targetCount; + int get difference => targetCount - currentCount; + + @override + List get props => [objectType, label, currentCount, targetCount, alternateCount]; +} + +/// Gruppen von Zählern für verschiedene Ansichten +class CounterGroup extends Equatable { + final String title; + final List counters; + + const CounterGroup({ + required this.title, + required this.counters, + }); + + @override + List get props => [title, counters]; +} + +/// Zähler-Übersicht für eine komplette Tour/Page +class CounterOverview extends Equatable { + final int tourId; + final String? pageId; + final List groups; + final DateTime? lastUpdated; + + const CounterOverview({ + required this.tourId, + this.pageId, + required this.groups, + this.lastUpdated, + }); + + /// Standard-Gruppen für StockStart (Lager Beladung) + /// Entspricht Lua: CreateLoadingStockStartView + factory CounterOverview.stockStart({ + required int tourId, + required List vehicleStock, // Bestand Fzg + required List loadingCounters, // Beladezähler + required List hadagCounters, // HADAG + required List sstCounters, // SST + required List crCounters, // CR + }) { + return CounterOverview( + tourId: tourId, + groups: [ + CounterGroup(title: 'Bestand Fzg', counters: vehicleStock), + CounterGroup(title: 'Beladezähler', counters: loadingCounters), + CounterGroup(title: 'HADAG', counters: hadagCounters), + CounterGroup(title: 'SST', counters: sstCounters), + CounterGroup(title: 'CR', counters: crCounters), + ], + ); + } + + /// Standard-Gruppen für VehStart + /// Entspricht Lua: CreateLoadingVehStartView + factory CounterOverview.vehStart({ + required int tourId, + required List loadingCounters, + }) { + return CounterOverview( + tourId: tourId, + groups: [ + CounterGroup(title: 'Beladezähler', counters: loadingCounters), + ], + ); + } + + /// Standard-Gruppen für Veh (Station) + /// Entspricht Lua: CreateLoadingVehView + factory CounterOverview.veh({ + required int tourId, + String? pageId, + required List swapCounters, // Wechselzähler + required List pickupCounters, // Abholzähler + }) { + return CounterOverview( + tourId: tourId, + pageId: pageId, + groups: [ + CounterGroup(title: 'Wechsel', counters: swapCounters), + CounterGroup(title: 'Abholung', counters: pickupCounters), + ], + ); + } + + @override + List get props => [tourId, pageId, groups, lastUpdated]; +} + +/// Pickup/Abhol-Zähler aus der Datenbank +/// Entspricht Lua: page_pickup_count Tabelle +class PickupCount extends Equatable { + final int tourId; + final String pageId; + final String objectType; + final int count; + + const PickupCount({ + required this.tourId, + required this.pageId, + required this.objectType, + required this.count, + }); + + @override + List get props => [tourId, pageId, objectType, count]; +} + +/// Swap/Wechsel-Zähler aus der Datenbank +/// Entspricht Lua: page_swap_count Tabelle +class SwapCount extends Equatable { + final int tourId; + final String pageId; + final String objectType; + final int count; + + const SwapCount({ + required this.tourId, + required this.pageId, + required this.objectType, + required this.count, + }); + + @override + List get props => [tourId, pageId, objectType, count]; +} + +/// Container-Information für VS/Verwahrungsstelle +/// Entspricht Lua: ContainerId, ContainerType in vsStateMachine +class ContainerInfo extends Equatable { + final String containerId; + final String containerType; // 'a' = Geldinstitut, 'b' = Dienststelle + final String? subtype; // 'cntra' oder 'cntrb' + final int? objectCount; // Anzahl Objekte im Container + + const ContainerInfo({ + required this.containerId, + required this.containerType, + this.subtype, + this.objectCount, + }); + + bool get isForGI => containerType == 'a'; + bool get isForDS => containerType == 'b'; + + String get displayName { + if (isForGI) return 'Container Geldinstitut'; + if (isForDS) return 'Container Dienststelle'; + return 'Container $containerId'; + } + + @override + List get props => [containerId, containerType, subtype, objectCount]; +} + +/// Letzte gescannte Objekte für die Anzeige +/// Entspricht Lua: Die Liste in ShowStockStartScreen etc. +class RecentScan extends Equatable { + final String objectCode; + final String objectName; + final String state; + final DateTime scanTime; + final String? imageName; + + const RecentScan({ + required this.objectCode, + required this.objectName, + required this.state, + required this.scanTime, + this.imageName, + }); + + @override + List get props => [objectCode, objectName, state, scanTime, imageName]; +} diff --git a/app/lib/domain/entities/location.dart b/app/lib/domain/entities/location.dart new file mode 100644 index 0000000..a58b964 --- /dev/null +++ b/app/lib/domain/entities/location.dart @@ -0,0 +1,89 @@ +import 'package:equatable/equatable.dart'; + +class Location extends Equatable { + final int id; + final int locationId; + final int version; + final String name; + final String? street; + final String? number; + final String? zip; + final String? city; + final double? latitude; + final double? longitude; + final String? remark; + + const Location({ + required this.id, + required this.locationId, + required this.version, + required this.name, + this.street, + this.number, + this.zip, + this.city, + this.latitude, + this.longitude, + this.remark, + }); + + Location copyWith({ + int? id, + int? locationId, + int? version, + String? name, + String? street, + String? number, + String? zip, + String? city, + double? latitude, + double? longitude, + String? remark, + }) { + return Location( + id: id ?? this.id, + locationId: locationId ?? this.locationId, + version: version ?? this.version, + name: name ?? this.name, + street: street ?? this.street, + number: number ?? this.number, + zip: zip ?? this.zip, + city: city ?? this.city, + latitude: latitude ?? this.latitude, + longitude: longitude ?? this.longitude, + remark: remark ?? this.remark, + ); + } + + String get fullAddress { + final parts = []; + if (street != null && street!.isNotEmpty) { + parts.add(street!); + if (number != null && number!.isNotEmpty) { + parts.add(number!); + } + } + if (zip != null && zip!.isNotEmpty) { + parts.add(zip!); + } + if (city != null && city!.isNotEmpty) { + parts.add(city!); + } + return parts.join(', '); + } + + @override + List get props => [ + id, + locationId, + version, + name, + street, + number, + zip, + city, + latitude, + longitude, + remark, + ]; +} diff --git a/app/lib/domain/entities/logistic_object.dart b/app/lib/domain/entities/logistic_object.dart new file mode 100644 index 0000000..893d987 --- /dev/null +++ b/app/lib/domain/entities/logistic_object.dart @@ -0,0 +1,250 @@ +import 'package:equatable/equatable.dart'; +import 'package:flutter/material.dart'; + +class LogisticObject extends Equatable { + final int id; + final int objectId; + final int type; + final int version; + final int? locationId; + final String code; + final String? remark; + final String state; + final String subtype; + final String? origin; + final bool isManual; + final DateTime? lastModified; + final String? typeName; + final String? typeMnemonic; + + const LogisticObject({ + required this.id, + required this.objectId, + required this.type, + required this.version, + this.locationId, + required this.code, + this.remark, + required this.state, + required this.subtype, + this.origin, + this.isManual = false, + this.lastModified, + this.typeName, + this.typeMnemonic, + }); + + LogisticObject copyWith({ + int? id, + int? objectId, + int? type, + int? version, + int? locationId, + String? code, + String? remark, + String? state, + String? subtype, + String? origin, + bool? isManual, + DateTime? lastModified, + String? typeName, + String? typeMnemonic, + }) { + return LogisticObject( + id: id ?? this.id, + objectId: objectId ?? this.objectId, + type: type ?? this.type, + version: version ?? this.version, + locationId: locationId ?? this.locationId, + code: code ?? this.code, + remark: remark ?? this.remark, + state: state ?? this.state, + subtype: subtype ?? this.subtype, + origin: origin ?? this.origin, + isManual: isManual ?? this.isManual, + lastModified: lastModified ?? this.lastModified, + typeName: typeName ?? this.typeName, + typeMnemonic: typeMnemonic ?? this.typeMnemonic, + ); + } + + @override + List get props => [ + id, + objectId, + type, + version, + locationId, + code, + remark, + state, + subtype, + origin, + isManual, + lastModified, + typeName, + typeMnemonic, + ]; +} + +class ObjectMetadata extends Equatable { + final int id; + final int type; + final int version; + final String mnemonic; + final String name; + final String prefix; + final String subtype; + final String counterText; + + const ObjectMetadata({ + required this.id, + required this.type, + required this.version, + required this.mnemonic, + required this.name, + required this.prefix, + required this.subtype, + required this.counterText, + }); + + @override + List get props => [ + id, + type, + version, + mnemonic, + name, + prefix, + subtype, + counterText, + ]; +} + +class ObjectStateInfo { + final String state; + final String displayName; + final int colorValue; + final String iconName; + + const ObjectStateInfo({ + required this.state, + required this.displayName, + required this.colorValue, + required this.iconName, + }); + + static const Map stateInfos = { + 'unknown': ObjectStateInfo( + state: 'unknown', + displayName: 'Unbekannt', + colorValue: 0xFFFFFFFF, + iconName: 'help', + ), + 'delivery': ObjectStateInfo( + state: 'delivery', + displayName: 'Im Fahrzeug', + colorValue: 0xFFB3B3B3, + iconName: 'local_shipping', + ), + 'to_delivery': ObjectStateInfo( + state: 'to_delivery', + displayName: 'Zum Fahrzeug', + colorValue: 0xFFB3B3B3, + iconName: 'local_shipping_outlined', + ), + 'station': ObjectStateInfo( + state: 'station', + displayName: 'An Station', + colorValue: 0xFFFFDD00, + iconName: 'location_on', + ), + 'in_fa': ObjectStateInfo( + state: 'in_fa', + displayName: 'Im Fahrscheinautomat', + colorValue: 0xFF9CDA7A, + iconName: 'confirmation_number', + ), + 'in_vs': ObjectStateInfo( + state: 'in_vs', + displayName: 'In Versorgungsstelle', + colorValue: 0xFFFAE14B, + iconName: 'inventory', + ), + 'ret_fail': ObjectStateInfo( + state: 'ret_fail', + displayName: 'Fehler - zur Dienststelle', + colorValue: 0xFFFF9081, + iconName: 'error', + ), + 'ret_fail_fzg': ObjectStateInfo( + state: 'ret_fail_fzg', + displayName: 'Fehler - im Fahrzeug', + colorValue: 0xFFFF9081, + iconName: 'error_outline', + ), + 'ret_ds': ObjectStateInfo( + state: 'ret_ds', + displayName: 'Zur Dienststelle', + colorValue: 0xFFAFE0ED, + iconName: 'account_balance', + ), + 'ret_ds_fzg': ObjectStateInfo( + state: 'ret_ds_fzg', + displayName: 'Zur Dienststelle (Fzg)', + colorValue: 0xFFAFE0ED, + iconName: 'account_balance_outlined', + ), + 'ret_gi': ObjectStateInfo( + state: 'ret_gi', + displayName: 'Zum Geldinstitut', + colorValue: 0xFFAFE0ED, + iconName: 'account_balance_wallet', + ), + 'ret_gi_fzg': ObjectStateInfo( + state: 'ret_gi_fzg', + displayName: 'Zum Geldinstitut (Fzg)', + colorValue: 0xFFAFE0ED, + iconName: 'account_balance_wallet_outlined', + ), + 'fin_ds': ObjectStateInfo( + state: 'fin_ds', + displayName: 'In Dienststelle', + colorValue: 0xFF29B7FB, + iconName: 'check_circle', + ), + 'fin_gi': ObjectStateInfo( + state: 'fin_gi', + displayName: 'In Geldinstitut', + colorValue: 0xFF25BAFC, + iconName: 'check_circle_outline', + ), + 'hdl': ObjectStateInfo( + state: 'hdl', + displayName: 'Handel', + colorValue: 0xFF9E9E9E, + iconName: 'shopping_cart', + ), + 'ret_ds_empty': ObjectStateInfo( + state: 'ret_ds_empty', + displayName: 'Leer - zur Dienststelle', + colorValue: 0xFFAFE0ED, + iconName: 'remove_circle_outline', + ), + }; + + static Color getColorForState(String state) { + final info = stateInfos[state]; + return info != null ? Color(info.colorValue) : const Color(0xFFFFFFFF); + } + + static String getDisplayName(String state) { + final info = stateInfos[state]; + return info?.displayName ?? 'Unbekannt'; + } + + static String getIconName(String state) { + final info = stateInfos[state]; + return info?.iconName ?? 'help'; + } +} diff --git a/app/lib/domain/entities/tour.dart b/app/lib/domain/entities/tour.dart new file mode 100644 index 0000000..f15971c --- /dev/null +++ b/app/lib/domain/entities/tour.dart @@ -0,0 +1,163 @@ +import 'package:equatable/equatable.dart'; + +class Tour extends Equatable { + final int id; + final int jobId; + final int tourId; + final int version; + final int state; // 0 = offen, 1 = erledigt, 2 = abgeschlossen + final String type; + final int sort; + final int locationId; + final String locationCode; + final String? locationCode2; + final String? remark; + final String? menuText; + final int modified; + final String? deliveryCode; + final String? locationName; + final bool isCompleted; + final List pages; + + const Tour({ + required this.id, + required this.jobId, + required this.tourId, + required this.version, + required this.state, + required this.type, + required this.sort, + required this.locationId, + required this.locationCode, + this.locationCode2, + this.remark, + this.menuText, + required this.modified, + this.deliveryCode, + this.locationName, + this.isCompleted = false, + this.pages = const [], + }); + + Tour copyWith({ + int? id, + int? jobId, + int? tourId, + int? version, + int? state, + String? type, + int? sort, + int? locationId, + String? locationCode, + String? locationCode2, + String? remark, + String? menuText, + int? modified, + String? deliveryCode, + String? locationName, + bool? isCompleted, + List? pages, + }) { + return Tour( + id: id ?? this.id, + jobId: jobId ?? this.jobId, + tourId: tourId ?? this.tourId, + version: version ?? this.version, + state: state ?? this.state, + type: type ?? this.type, + sort: sort ?? this.sort, + locationId: locationId ?? this.locationId, + locationCode: locationCode ?? this.locationCode, + locationCode2: locationCode2 ?? this.locationCode2, + remark: remark ?? this.remark, + menuText: menuText ?? this.menuText, + modified: modified ?? this.modified, + deliveryCode: deliveryCode ?? this.deliveryCode, + locationName: locationName ?? this.locationName, + isCompleted: isCompleted ?? this.isCompleted, + pages: pages ?? this.pages, + ); + } + + @override + List get props => [ + id, + jobId, + tourId, + version, + state, + type, + sort, + locationId, + locationCode, + locationCode2, + remark, + menuText, + modified, + deliveryCode, + locationName, + isCompleted, + pages, + ]; +} + +class TourPage extends Equatable { + final int id; + final int tourId; + final int pageNumber; + final String pageId; + final String type; + final String? code; + final String? label; + final Map pickupCounts; + final Map swapCounts; + + const TourPage({ + required this.id, + required this.tourId, + required this.pageNumber, + required this.pageId, + required this.type, + this.code, + this.label, + this.pickupCounts = const {}, + this.swapCounts = const {}, + }); + + TourPage copyWith({ + int? id, + int? tourId, + int? pageNumber, + String? pageId, + String? type, + String? code, + String? label, + Map? pickupCounts, + Map? swapCounts, + }) { + return TourPage( + id: id ?? this.id, + tourId: tourId ?? this.tourId, + pageNumber: pageNumber ?? this.pageNumber, + pageId: pageId ?? this.pageId, + type: type ?? this.type, + code: code ?? this.code, + label: label ?? this.label, + pickupCounts: pickupCounts ?? this.pickupCounts, + swapCounts: swapCounts ?? this.swapCounts, + ); + } + + @override + List get props => [ + id, + tourId, + pageNumber, + pageId, + type, + code, + label, + pickupCounts, + swapCounts, + ]; +} diff --git a/app/lib/domain/repositories/tour_repository.dart b/app/lib/domain/repositories/tour_repository.dart new file mode 100644 index 0000000..be060fc --- /dev/null +++ b/app/lib/domain/repositories/tour_repository.dart @@ -0,0 +1,109 @@ +import 'package:dartz/dartz.dart'; +import '../entities/tour.dart'; +import '../entities/logistic_object.dart'; +import '../entities/location.dart'; +import '../entities/counter.dart'; +import '../../core/errors/failures.dart'; + +abstract class TourRepository { + // Touren + Future>> getTours(); + Future> getTourById(int tourId); + Future> updateTourState(int tourId, int state); + Future> completeTour(int tourId); + + // Sync + Future> syncData(); + Future> checkForUpdates(); + + // Objects + Future>> getObjectsByTour(int tourId); + Future>> getObjectsByState(String state); + Future> getObjectByBarcode(String barcode); + Future> updateObjectState( + int objectId, + String newState, { + int? locationId, + int? refType, + int? refId, + String? containerCode, + }); + Future> createObject({ + required int type, + required String code, + bool isManual = true, + }); + + // Locations + Future>> getLocations(); + Future> getLocationById(int locationId); + + // Metadata + Future>> getObjectMetadata(); + + // Statistics + Future> getTourStatistics(int tourId); + Future> getObjectStatistics(); + + // Counter operations (spezifisch für Lua-kompatible Ansichten) + Future> getCounterOverview( + int tourId, + String tourType, { + String? pageId, + }); + + Future>> getPickupCounts(int tourId, String pageId); + Future>> getSwapCounts(int tourId, String pageId); + + // Container operations + Future>> getOpenContainers(); + Future> addObjectToContainer( + String containerId, + String containerType, + int objectId, + ); + Future> closeContainer( + String containerId, + String containerType, + ); + + // Recent scans + Future>> getRecentScans( + int tourId, { + int limit = 10, + }); +} + +class TourStatistics { + final int totalObjects; + final int completedObjects; + final int pendingObjects; + final Map objectsByState; + final Map objectsByType; + final double completionPercentage; + + const TourStatistics({ + required this.totalObjects, + required this.completedObjects, + required this.pendingObjects, + required this.objectsByState, + required this.objectsByType, + required this.completionPercentage, + }); +} + +class ObjectStatistics { + final Map byState; + final Map byType; + final Map byLocation; + final List recentObjects; + final int totalCount; + + const ObjectStatistics({ + required this.byState, + required this.byType, + required this.byLocation, + required this.recentObjects, + required this.totalCount, + }); +} diff --git a/app/lib/main.dart b/app/lib/main.dart new file mode 100644 index 0000000..2c7ae85 --- /dev/null +++ b/app/lib/main.dart @@ -0,0 +1,424 @@ +import 'package:dartz/dartz.dart' hide State; +import 'package:flutter/material.dart'; +import 'package:flutter/services.dart'; +import 'package:flutter_bloc/flutter_bloc.dart'; +import 'core/theme/app_theme.dart'; +import 'domain/entities/tour.dart'; +import 'domain/entities/logistic_object.dart'; +import 'domain/entities/location.dart'; +import 'domain/entities/counter.dart'; +import 'domain/repositories/tour_repository.dart'; +import 'core/errors/failures.dart'; +import 'presentation/blocs/tour/tour_bloc.dart'; +import 'presentation/blocs/scan/scan_bloc.dart'; +import 'presentation/pages/tours/tours_page.dart'; +import 'presentation/pages/tours/dashboard_page.dart'; + +void main() { + WidgetsFlutterBinding.ensureInitialized(); + + // Set preferred orientations + SystemChrome.setPreferredOrientations([ + DeviceOrientation.portraitUp, + DeviceOrientation.portraitDown, + ]); + + // Set system UI overlay style + SystemChrome.setSystemUIOverlayStyle( + const SystemUiOverlayStyle( + statusBarColor: Colors.transparent, + statusBarIconBrightness: Brightness.light, + systemNavigationBarColor: Colors.white, + systemNavigationBarIconBrightness: Brightness.dark, + ), + ); + + runApp(const HHAApp()); +} + +class HHAApp extends StatelessWidget { + const HHAApp({super.key}); + + @override + Widget build(BuildContext context) { + final repository = MockTourRepository(); + + return MultiBlocProvider( + providers: [ + BlocProvider( + create: (context) => TourBloc( + repository: repository, + )..add(const LoadTours()), + ), + BlocProvider( + create: (context) => ScanBloc( + repository: repository, + ), + ), + ], + child: MaterialApp( + title: 'HHA Logistics', + debugShowCheckedModeBanner: false, + theme: AppTheme.lightTheme, + home: const MainNavigationPage(), + ), + ); + } +} + +class MainNavigationPage extends StatefulWidget { + const MainNavigationPage({super.key}); + + @override + State createState() => _MainNavigationPageState(); +} + +class _MainNavigationPageState extends State { + int _currentIndex = 0; + + final List _pages = const [ + DashboardPage(), + ToursPage(), + InventoryPage(), + SettingsPage(), + ]; + + @override + Widget build(BuildContext context) { + return Scaffold( + body: IndexedStack( + index: _currentIndex, + children: _pages, + ), + bottomNavigationBar: NavigationBar( + selectedIndex: _currentIndex, + onDestinationSelected: (index) { + setState(() { + _currentIndex = index; + }); + }, + destinations: const [ + NavigationDestination( + icon: Icon(Icons.dashboard_outlined), + selectedIcon: Icon(Icons.dashboard), + label: 'Dashboard', + ), + NavigationDestination( + icon: Icon(Icons.map_outlined), + selectedIcon: Icon(Icons.map), + label: 'Touren', + ), + NavigationDestination( + icon: Icon(Icons.inventory_2_outlined), + selectedIcon: Icon(Icons.inventory_2), + label: 'Bestand', + ), + NavigationDestination( + icon: Icon(Icons.settings_outlined), + selectedIcon: Icon(Icons.settings), + label: 'Einstellungen', + ), + ], + ), + ); + } +} + +// Mock Repository for demonstration +class MockTourRepository implements TourRepository { + @override + Future>> getTours() async { + await Future.delayed(const Duration(seconds: 1)); + return const Right([ + Tour( + id: 1, + jobId: 1, + tourId: 1, + version: 1, + state: 0, + type: 'stock_start', + sort: 1, + locationId: 1, + locationCode: 'LAGER001', + locationName: 'Hauptlager Wandsbek', + modified: 0, + ), + Tour( + id: 2, + jobId: 1, + tourId: 2, + version: 1, + state: 0, + type: 'veh_start', + sort: 2, + locationId: 2, + locationCode: 'DST001', + locationName: 'Dienststelle Hammerbrook', + modified: 0, + ), + Tour( + id: 3, + jobId: 1, + tourId: 3, + version: 1, + state: 0, + type: 'st', + sort: 3, + locationId: 3, + locationCode: 'HALT001', + locationName: 'Hauptbahnhof Nord', + remark: '4 Fahrscheinautomaten', + modified: 0, + ), + Tour( + id: 4, + jobId: 1, + tourId: 4, + version: 1, + state: 1, + type: 'st', + sort: 4, + locationId: 4, + locationCode: 'HALT002', + locationName: 'Jungfernstieg', + remark: '2 Fahrscheinautomaten', + modified: 0, + ), + Tour( + id: 5, + jobId: 1, + tourId: 5, + version: 1, + state: 0, + type: 'gi', + sort: 5, + locationId: 5, + locationCode: 'BANK001', + locationName: 'Geldinstitut Mitte', + modified: 0, + ), + ]); + } + + @override + Future> getTourById(int tourId) async { + final tours = await getTours(); + return tours.fold( + (failure) => Left(failure), + (tourList) { + final tour = tourList.firstWhere( + (t) => t.tourId == tourId, + orElse: () => throw Exception('Tour not found'), + ); + return Right(tour); + }, + ); + } + + @override + Future> updateTourState(int tourId, int state) async { + return const Right(null); + } + + @override + Future> completeTour(int tourId) async { + return const Right(null); + } + + @override + Future> syncData() async { + await Future.delayed(const Duration(seconds: 1)); + return const Right(null); + } + + @override + Future> checkForUpdates() async => const Right(false); + + @override + Future>> getObjectsByTour(int tourId) async => const Right([]); + + @override + Future>> getObjectsByState(String state) async => const Right([]); + + @override + Future> getObjectByBarcode(String barcode) async => const Right(null); + + @override + Future> updateObjectState( + int objectId, + String newState, { + int? locationId, + int? refType, + int? refId, + String? containerCode, + }) async => const Right(null); + + @override + Future> createObject({ + required int type, + required String code, + bool isManual = true, + }) async => const Right(null); + + @override + Future>> getLocations() async => const Right([]); + + @override + Future> getLocationById(int locationId) async { + return const Left(NotFoundFailure(message: 'Location not found')); + } + + @override + Future>> getObjectMetadata() async => const Right([]); + + @override + Future> getTourStatistics(int tourId) async { + return const Right(TourStatistics( + totalObjects: 10, + completedObjects: 5, + pendingObjects: 5, + objectsByState: {'delivery': 3, 'station': 2}, + objectsByType: {'meka': 3, 'beka': 2}, + completionPercentage: 50.0, + )); + } + + @override + Future> getObjectStatistics() async { + return const Right(ObjectStatistics( + byState: {}, + byType: {}, + byLocation: {}, + recentObjects: [], + totalCount: 0, + )); + } + + @override + Future> getCounterOverview( + int tourId, + String tourType, { + String? pageId, + }) async { + return Right(CounterOverview( + tourId: tourId, + pageId: pageId, + groups: [], + )); + } + + @override + Future>> getPickupCounts( + int tourId, + String pageId, + ) async => const Right([]); + + @override + Future>> getSwapCounts( + int tourId, + String pageId, + ) async => const Right([]); + + @override + Future>> getOpenContainers() async => const Right([]); + + @override + Future> addObjectToContainer( + String containerId, + String containerType, + int objectId, + ) async => const Right(null); + + @override + Future> closeContainer( + String containerId, + String containerType, + ) async => const Right(null); + + @override + Future>> getRecentScans( + int tourId, { + int limit = 10, + }) async => const Right([]); +} + +// Placeholder pages +class InventoryPage extends StatelessWidget { + const InventoryPage({super.key}); + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: const Text('Bestand'), + ), + body: Center( + child: Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + Icon( + Icons.inventory_2, + size: 80, + color: Colors.grey.shade400, + ), + const SizedBox(height: 16), + Text( + 'Bestandsübersicht', + style: Theme.of(context).textTheme.headlineSmall, + ), + const SizedBox(height: 8), + Text( + 'Hier wird der aktuelle Bestand angezeigt', + style: Theme.of(context).textTheme.bodyMedium?.copyWith( + color: Colors.grey.shade600, + ), + ), + ], + ), + ), + ); + } +} + +class SettingsPage extends StatelessWidget { + const SettingsPage({super.key}); + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: const Text('Einstellungen'), + ), + body: ListView( + children: [ + ListTile( + leading: const Icon(Icons.sync), + title: const Text('Daten synchronisieren'), + subtitle: const Text('Letzte Synchronisation: Gerade eben'), + trailing: const Icon(Icons.chevron_right), + onTap: () { + // Trigger sync + }, + ), + const Divider(), + ListTile( + leading: const Icon(Icons.visibility), + title: const Text('Erledigte Stationen anzeigen'), + trailing: Switch( + value: true, + onChanged: (value) {}, + ), + ), + const Divider(), + ListTile( + leading: const Icon(Icons.info), + title: const Text('Über'), + subtitle: const Text('Version 2.0.0'), + trailing: const Icon(Icons.chevron_right), + onTap: () {}, + ), + ], + ), + ); + } +} diff --git a/app/lib/presentation/blocs/scan/scan_bloc.dart b/app/lib/presentation/blocs/scan/scan_bloc.dart new file mode 100644 index 0000000..5ac23dd --- /dev/null +++ b/app/lib/presentation/blocs/scan/scan_bloc.dart @@ -0,0 +1,916 @@ +import 'package:flutter_bloc/flutter_bloc.dart'; +import 'package:equatable/equatable.dart'; +import '../../../domain/entities/logistic_object.dart'; +import '../../../domain/entities/tour.dart'; +import '../../../domain/repositories/tour_repository.dart'; +import '../../../core/constants/app_constants.dart'; +import '../../../core/errors/failures.dart'; + +part 'scan_event.dart'; +part 'scan_state.dart'; + +class ScanBloc extends Bloc { + final TourRepository repository; + Tour? currentTour; + String? currentPageId; + String? scannedFsaId; + + // Container handling for VS state machine + String? containerId; + String? containerType; // 'a' or 'b' + + ScanBloc({required this.repository}) : super(ScanInitial()) { + on(_onInitializeScan); + on(_onProcessBarcode); + on(_onValidateBarcode); + on(_onUpdateObjectState); + on(_onResetScan); + on(_onCreateUnknownObject); + } + + Future _onInitializeScan(InitializeScan event, Emitter emit) async { + currentTour = event.tour; + containerId = null; + containerType = null; + emit(ScanReady(tour: event.tour)); + } + + Future _onProcessBarcode(ProcessBarcode event, Emitter emit) async { + emit(ScanProcessing(barcode: event.barcode)); + + final barcode = event.barcode.trim(); + + // Prüfe auf spezielle Barcodes (Seiten-Codes) + if (currentTour != null) { + final pageInfo = _findPageForBarcode(barcode); + if (pageInfo != null) { + emit(ScanPageDetected( + pageId: pageInfo['pageId']!, + label: pageInfo['label']!, + tour: currentTour!, + )); + return; + } + } + + // Suche Objekt nach Barcode + final result = await repository.getObjectByBarcode(barcode); + + result.fold( + (failure) => emit(ScanError(message: _mapFailureToMessage(failure))), + (object) { + if (object != null) { + _processScannedObject(object, barcode, emit); + } else { + // Unbekanntes Objekt - prüfe auf gültiges Präfix + final prefix = barcode.length >= 3 ? barcode.substring(0, 3) : ''; + if (_isValidPrefix(prefix)) { + emit(ScanUnknownObject( + barcode: barcode, + prefix: prefix, + tour: currentTour, + )); + } else { + emit(ScanError(message: 'Unbekannter Barcode: $barcode')); + } + } + }, + ); + } + + void _processScannedObject(LogisticObject object, String barcode, Emitter emit) { + if (currentTour == null) { + emit(const ScanError(message: 'Keine Tour ausgewählt')); + return; + } + + final tourType = currentTour!.type; + + // Dispatch to appropriate state machine based on tour type + switch (tourType) { + case TourTypes.stockStart: + _stockStartStateMachine(object, emit); + break; + case TourTypes.vehStart: + _vehStartStateMachine(object, emit); + break; + case TourTypes.vehBulk: + _vehBulkStateMachine(object, emit); + break; + case TourTypes.veh: + _vehStateMachine(object, emit); + break; + case TourTypes.fsa: + _fsaStateMachine(object, emit); + break; + case TourTypes.vs: + _vsStateMachine(object, emit); + break; + case TourTypes.vehVs: + _vehVsStateMachine(object, emit); + break; + case TourTypes.gi: + _giStateMachine(object, emit); + break; + case TourTypes.vehEnd: + _vehEndStateMachine(object, emit); + break; + case TourTypes.stockEnd: + _stockEndStateMachine(object, emit); + break; + case TourTypes.stock: + _stockStateMachine(object, emit); + break; + default: + // Fallback to simple state machine for unknown tour types + final nextState = _determineNextState(object); + emit(ScanObjectDetected( + object: object, + suggestedState: nextState, + tour: currentTour, + )); + } + } + + // ============================================================================ + // STATE MACHINE: stockStart (Lager Beladung) + // ============================================================================ + void _stockStartStateMachine(LogisticObject object, Emitter emit) { + final currentState = object.state; + + if (currentState == ObjectStates.unknown) { + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.toDelivery, + tour: currentTour, + )); + } else if (currentState == ObjectStates.finGITmp) { + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retGI, + tour: currentTour, + )); + } else { + emit(ScanError( + message: 'Fehler: Ungültiger Barcode für Lager Beladung', + )); + } + } + + // ============================================================================ + // STATE MACHINE: vehStart (Fahrzeug Start) + // ============================================================================ + void _vehStartStateMachine(LogisticObject object, Emitter emit) { + final currentState = object.state; + + if (currentState == ObjectStates.toDelivery) { + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.delivery, + tour: currentTour, + )); + } else if (currentState == ObjectStates.retGI) { + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retGIFzg, + tour: currentTour, + )); + } else { + emit(const ScanError(message: 'Fehler: Ungültiger Barcode')); + } + } + + // ============================================================================ + // STATE MACHINE: vehBulk (Fahrzeug Bulk) + // ============================================================================ + void _vehBulkStateMachine(LogisticObject object, Emitter emit) { + final objectType = object.type; + final currentState = object.state; + + // Type 9 = special bulk handling + if (objectType == 9) { + // Bulk update all objects with state to_delivery + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.delivery, + tour: currentTour, + )); + } else { + if (currentState == ObjectStates.toDelivery) { + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.delivery, + tour: currentTour, + )); + } else if (currentState == ObjectStates.retGI) { + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retGIFzg, + tour: currentTour, + )); + } else { + emit(const ScanError(message: 'Fehler: Ungültiger Barcode')); + } + } + } + + // ============================================================================ + // STATE MACHINE: veh (Fahrzeug - Stationen) + // ============================================================================ + void _vehStateMachine(LogisticObject object, Emitter emit) { + final currentState = object.state; + + switch (currentState) { + case ObjectStates.delivery: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.station, + tour: currentTour, + )); + break; + case ObjectStates.retFail: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retFailFzg, + tour: currentTour, + )); + break; + case ObjectStates.retGI: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retGIFzg, + tour: currentTour, + )); + break; + case ObjectStates.retDS: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retDSFzg, + tour: currentTour, + )); + break; + case ObjectStates.station: + // Reverse transition: back to delivery + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.delivery, + tour: currentTour, + )); + break; + case ObjectStates.inFA: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.hdl, + tour: currentTour, + )); + break; + default: + emit(const ScanError(message: 'Fehler: Falscher Status')); + } + } + + // ============================================================================ + // STATE MACHINE: fsa (Fahrscheinautomat) + // ============================================================================ + void _fsaStateMachine(LogisticObject object, Emitter emit) { + final objectType = object.type; + final currentState = object.state; + final subtype = object.subtype.toLowerCase(); + + // GK = Geldkassette (type 1) + if (_isTypeGK(objectType, subtype)) { + _fsaGKStateMachine(object, currentState, emit); + } + // HP = Hauptkasse/Druckerpatronen (type 2) + else if (_isTypeHP(objectType, subtype)) { + _fsaHPStateMachine(object, currentState, emit); + } + // FR = Fahrkartenrolle (type 5) + else if (_isTypeFR(objectType, subtype)) { + _fsaFRStateMachine(object, currentState, emit); + } + else { + emit(const ScanError(message: 'Fehler: Falscher Typ für FSA')); + } + } + + void _fsaGKStateMachine(LogisticObject object, String currentState, Emitter emit) { + switch (currentState) { + case ObjectStates.station: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.inFA, + tour: currentTour, + )); + break; + case ObjectStates.inFA: + // Special handling: Fehlkassette logic + emit(ScanFehlKassetteDetected( + object: object, + suggestedState: ObjectStates.retFail, + tour: currentTour, + )); + break; + case ObjectStates.unknown: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retGI, + tour: currentTour, + originBarcode: object.code, + )); + break; + default: + emit(const ScanError(message: 'Fehler: Falscher Status')); + } + } + + void _fsaHPStateMachine(LogisticObject object, String currentState, Emitter emit) { + switch (currentState) { + case ObjectStates.station: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.inFA, + tour: currentTour, + )); + break; + case ObjectStates.inFA: + // Bidirectional: back to station + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.station, + tour: currentTour, + )); + break; + case ObjectStates.unknown: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retDS, + tour: currentTour, + originBarcode: object.code, + )); + break; + default: + emit(const ScanError(message: 'Fehler: Falscher Status')); + } + } + + void _fsaFRStateMachine(LogisticObject object, String currentState, Emitter emit) { + switch (currentState) { + case ObjectStates.station: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.inFA, + tour: currentTour, + )); + break; + case ObjectStates.inFA: + // Bidirectional: back to station + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.station, + tour: currentTour, + )); + break; + default: + emit(const ScanError(message: 'Fehler: Falscher Status')); + } + } + + // ============================================================================ + // STATE MACHINE: vs (Versorgungsstelle) + // ============================================================================ + void _vsStateMachine(LogisticObject object, Emitter emit) { + final objectType = object.type; + final currentState = object.state; + final subtype = object.subtype.toLowerCase(); + + // SB = Safebag + if (_isTypeSB(objectType, subtype)) { + _vsSBStateMachine(object, currentState, emit); + } + // ABS = Abfallbehälter + else if (_isTypeABS(objectType, subtype)) { + _vsABSStateMachine(object, currentState, emit); + } + // CNTR = Container + else if (_isTypeCNTR(objectType, subtype)) { + _vsCNTRStateMachine(object, currentState, subtype, emit); + } + else { + emit(const ScanError(message: 'Fehler: Falscher Status')); + } + } + + void _vsSBStateMachine(LogisticObject object, String currentState, Emitter emit) { + if (containerId == null) { + emit(const ScanError(message: 'Fehler: Falscher Zustand - Container nicht ausgewählt')); + return; + } + + if (containerType == 'a') { + if (currentState == ObjectStates.inVS) { + emit(ScanContainerObjectDetected( + object: object, + suggestedState: ObjectStates.retGI, + tour: currentTour, + containerId: containerId!, + containerType: containerType!, + )); + } else { + emit(const ScanError(message: 'Fehler: Falscher Zustand')); + } + } else { + emit(const ScanError(message: 'Fehler: Falscher Zustand')); + } + } + + void _vsABSStateMachine(LogisticObject object, String currentState, Emitter emit) { + if (containerId == null) { + emit(const ScanError(message: 'Fehler: Falscher Zustand - Container nicht ausgewählt')); + return; + } + + if (containerType == 'a') { + emit(const ScanError(message: 'Fehler: Falscher Zustand')); + } else { + if (currentState == ObjectStates.inVS) { + emit(ScanContainerObjectDetected( + object: object, + suggestedState: ObjectStates.retDS, + tour: currentTour, + containerId: containerId!, + containerType: containerType!, + )); + } else { + emit(const ScanError(message: 'Fehler: Falscher Zustand')); + } + } + } + + void _vsCNTRStateMachine(LogisticObject object, String currentState, String subtype, Emitter emit) { + containerId = object.code; + + if (subtype == 'cntra') { + containerType = 'a'; + emit(ScanContainerDetected( + object: object, + suggestedState: ObjectStates.retcGI, + tour: currentTour, + containerId: containerId!, + containerType: containerType!, + )); + } else if (subtype == 'cntrb') { + containerType = 'b'; + emit(ScanContainerDetected( + object: object, + suggestedState: ObjectStates.retcDS, + tour: currentTour, + containerId: containerId!, + containerType: containerType!, + )); + } else { + emit(const ScanError(message: 'Fehler: Unbekannter Container-Typ')); + } + } + + // ============================================================================ + // STATE MACHINE: vehVs (Fahrzeug VS) + // ============================================================================ + void _vehVsStateMachine(LogisticObject object, Emitter emit) { + final objectType = object.type; + final currentState = object.state; + final subtype = object.subtype.toLowerCase(); + + // SB and ABS not allowed in vehVs + if (_isTypeSB(objectType, subtype) || _isTypeABS(objectType, subtype)) { + emit(const ScanError(message: 'Fehler: Falscher Status')); + return; + } + + // CNTR = Container + if (_isTypeCNTR(objectType, subtype)) { + _vehVsCNTRStateMachine(object, currentState, subtype, emit); + } else { + emit(const ScanError(message: 'Fehler: Falscher Typ')); + } + } + + void _vehVsCNTRStateMachine(LogisticObject object, String currentState, String subtype, Emitter emit) { + if (subtype == 'cntra') { + if (currentState == ObjectStates.retcGI) { + // Update all container objects and clear container + emit(ScanContainerCloseDetected( + object: object, + suggestedState: ObjectStates.unknown, + targetStateForObjects: ObjectStates.retGIFzg, + tour: currentTour, + containerType: 'a', + )); + containerId = null; + containerType = null; + } else { + emit(const ScanError(message: 'Fehler: Falscher Status')); + } + } else if (subtype == 'cntrb') { + if (currentState == ObjectStates.retcDS) { + // Update all container objects and clear container + emit(ScanContainerCloseDetected( + object: object, + suggestedState: ObjectStates.unknown, + targetStateForObjects: ObjectStates.retDSFzg, + tour: currentTour, + containerType: 'b', + )); + containerId = null; + containerType = null; + } else { + emit(const ScanError(message: 'Fehler: Falscher Status')); + } + } + } + + // ============================================================================ + // STATE MACHINE: gi (Geldinstitut) + // ============================================================================ + void _giStateMachine(LogisticObject object, Emitter emit) { + final objectType = object.type; + final currentState = object.state; + final subtype = object.subtype.toLowerCase(); + + // GK = Geldkassette + if (_isTypeGK(objectType, subtype)) { + _giGKStateMachine(object, currentState, emit); + } + // SB = Safebag + else if (_isTypeSB(objectType, subtype)) { + _giSBStateMachine(object, currentState, emit); + } + else { + emit(const ScanError(message: 'Fehler: Falscher Typ')); + } + } + + void _giGKStateMachine(LogisticObject object, String currentState, Emitter emit) { + switch (currentState) { + case ObjectStates.retGIFzg: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.finGI, + tour: currentTour, + )); + break; + case ObjectStates.unknown: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retDSEmpty, + tour: currentTour, + )); + break; + case ObjectStates.delivery: + emit(const ScanError(message: 'Fehler: Falscher Status')); + break; + default: + emit(const ScanError(message: 'Fehler: Falscher Status')); + } + } + + void _giSBStateMachine(LogisticObject object, String currentState, Emitter emit) { + if (currentState == ObjectStates.retGIFzg) { + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.finGI, + tour: currentTour, + )); + } else { + emit(const ScanError(message: 'Fehler: Falscher Status')); + } + } + + // ============================================================================ + // STATE MACHINE: vehEnd (Fahrzeug Ende) + // ============================================================================ + void _vehEndStateMachine(LogisticObject object, Emitter emit) { + final currentState = object.state; + + switch (currentState) { + case ObjectStates.retFailFzg: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retFailStk, + tour: currentTour, + )); + break; + case ObjectStates.retDSFzg: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retDSStk, + tour: currentTour, + )); + break; + case ObjectStates.delivery: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retDSStk, + tour: currentTour, + )); + break; + case ObjectStates.retDSEmpty: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retDSStk, + tour: currentTour, + )); + break; + case ObjectStates.retGIFzg: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retGIStk, + tour: currentTour, + )); + break; + default: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.retDSErr, + tour: currentTour, + )); + } + } + + // ============================================================================ + // STATE MACHINE: stockEnd (Lager Ende) + // ============================================================================ + void _stockEndStateMachine(LogisticObject object, Emitter emit) { + final currentState = object.state; + + switch (currentState) { + case ObjectStates.retFailStk: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.finDSFail, + tour: currentTour, + )); + break; + case ObjectStates.retDSStk: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.finDS, + tour: currentTour, + )); + break; + case ObjectStates.retDSErr: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.finDSErr, + tour: currentTour, + )); + break; + case ObjectStates.retGIStk: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.finGITmp, + tour: currentTour, + )); + break; + default: + emit(const ScanError(message: 'Fehler: Falscher Status')); + } + } + + // ============================================================================ + // STATE MACHINE: stock (Lager - HADAG) + // ============================================================================ + void _stockStateMachine(LogisticObject object, Emitter emit) { + final objectType = object.type; + final currentState = object.state; + final subtype = object.subtype.toLowerCase(); + + // Only HP and GK allowed + if (!_isTypeHP(objectType, subtype) && !_isTypeGK(objectType, subtype)) { + emit(const ScanError(message: 'Fehler: Falscher Typ')); + return; + } + + switch (currentState) { + case ObjectStates.unknown: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.station, + tour: currentTour, + )); + break; + case ObjectStates.stkHadag: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.station, + tour: currentTour, + )); + break; + case ObjectStates.station: + emit(ScanObjectDetected( + object: object, + suggestedState: ObjectStates.stkHadag, + tour: currentTour, + )); + break; + default: + emit(ScanUnknownObject( + barcode: object.code, + prefix: object.code.length >= 3 ? object.code.substring(0, 3) : '', + tour: currentTour, + )); + } + } + + // ============================================================================ + // Helper methods for type checking + // ============================================================================ + bool _isTypeGK(int type, String subtype) { + // GK = Geldkassette (type 1, subtypes meka, mekb, mekc, mekd, beka, bekb, bekc, bekd) + return type == 1 || subtype.startsWith('mek') || subtype.startsWith('bek'); + } + + bool _isTypeHP(int type, String subtype) { + // HP = Hauptkasse/Druckerpatronen (type 2, subtypes hp1a, hp1b, etc.) + return type == 2 || subtype.startsWith('hp'); + } + + bool _isTypeFR(int type, String subtype) { + // FR = Fahrkartenrolle (type 5, subtype fra) + return type == 5 || subtype.startsWith('fr'); + } + + bool _isTypeSB(int type, String subtype) { + // SB = Safebag (type 6) + return type == 6 || subtype == 'sb'; + } + + bool _isTypeABS(int type, String subtype) { + // ABS = Abfallbehälter (type 7) + return type == 7 || subtype == 'abs'; + } + + bool _isTypeCNTR(int type, String subtype) { + // CNTR = Container (type 8) + return type == 8 || subtype.startsWith('cntr'); + } + + // ============================================================================ + // Legacy simple state machine (fallback) + // ============================================================================ + String _determineNextState(LogisticObject object) { + switch (object.state) { + case ObjectStates.unknown: + return ObjectStates.toDelivery; + case ObjectStates.toDelivery: + return ObjectStates.delivery; + case ObjectStates.delivery: + return ObjectStates.station; + case ObjectStates.station: + return ObjectStates.inFA; + case ObjectStates.inFA: + return ObjectStates.retGI; + case ObjectStates.retGI: + return ObjectStates.retGIFzg; + case ObjectStates.retGIFzg: + return ObjectStates.finGI; + case ObjectStates.retFail: + return ObjectStates.retFailFzg; + case ObjectStates.retFailFzg: + return ObjectStates.retFailStk; + case ObjectStates.retDS: + return ObjectStates.retDSFzg; + case ObjectStates.retDSFzg: + return ObjectStates.finDS; + default: + return object.state; + } + } + + // ============================================================================ + // Event handlers + // ============================================================================ + Future _onValidateBarcode(ValidateBarcode event, Emitter emit) async { + if (event.barcode.isEmpty) { + emit(const ScanValidationError(message: 'Barcode darf nicht leer sein')); + return; + } + + if (event.barcode.length < 6) { + emit(const ScanValidationError(message: 'Barcode zu kurz')); + return; + } + + add(ProcessBarcode(barcode: event.barcode)); + } + + Future _onUpdateObjectState(UpdateObjectState event, Emitter emit) async { + emit(ScanProcessing(barcode: event.object.code)); + + final result = await repository.updateObjectState( + event.object.objectId, + event.newState, + locationId: currentTour?.locationId, + refType: currentTour != null ? _getTourTypeCode(currentTour!.type) : null, + refId: currentTour?.tourId, + containerCode: event.containerCode, + ); + + result.fold( + (failure) => emit(ScanError(message: _mapFailureToMessage(failure))), + (_) { + emit(ScanObjectUpdated( + object: event.object.copyWith(state: event.newState), + previousState: event.object.state, + newState: event.newState, + tour: currentTour, + )); + }, + ); + } + + Future _onCreateUnknownObject(CreateUnknownObject event, Emitter emit) async { + emit(ScanProcessing(barcode: event.barcode)); + + final result = await repository.createObject( + type: event.type, + code: event.barcode, + isManual: true, + ); + + result.fold( + (failure) => emit(ScanError(message: _mapFailureToMessage(failure))), + (_) { + emit(ScanObjectCreated(barcode: event.barcode)); + }, + ); + } + + void _onResetScan(ResetScan event, Emitter emit) { + if (currentTour != null) { + emit(ScanReady(tour: currentTour!)); + } else { + emit(ScanInitial()); + } + } + + // ============================================================================ + // Helper methods + // ============================================================================ + Map? _findPageForBarcode(String barcode) { + if (currentTour == null) return null; + + for (final page in currentTour!.pages) { + if (page.code == barcode) { + return { + 'pageId': page.pageId, + 'label': page.label ?? page.pageId, + }; + } + + if (page.pageId.toLowerCase().startsWith('fsa') && page.type.isNotEmpty) { + // FSA page detected + } + } + + return null; + } + + bool _isValidPrefix(String prefix) { + final validPrefixes = ['MEK', 'BEK', 'HOP', 'H1P', 'H2P', 'H3P', 'FR', 'SB', 'ABS', 'FZG']; + return validPrefixes.any((p) => prefix.toUpperCase().startsWith(p)); + } + + int? _getTourTypeCode(String type) { + switch (type) { + case TourTypes.stockStart: + return 1; + case TourTypes.vehStart: + return 2; + case TourTypes.veh: + return 3; + case TourTypes.fsa: + return 4; + case TourTypes.vs: + return 5; + case TourTypes.gi: + return 6; + case TourTypes.vehEnd: + return 7; + case TourTypes.stockEnd: + return 8; + default: + return null; + } + } + + String _mapFailureToMessage(Failure failure) { + return switch (failure) { + ServerFailure _ => 'Serverfehler: ${failure.message}', + NetworkFailure _ => 'Netzwerkfehler. Bitte überprüfen Sie Ihre Internetverbindung.', + NotFoundFailure _ => 'Objekt nicht gefunden', + BarcodeFailure _ => 'Barcode-Fehler: ${failure.message}', + _ => 'Ein Fehler ist aufgetreten: ${failure.message}', + }; + } +} diff --git a/app/lib/presentation/blocs/scan/scan_event.dart b/app/lib/presentation/blocs/scan/scan_event.dart new file mode 100644 index 0000000..8b9d6b2 --- /dev/null +++ b/app/lib/presentation/blocs/scan/scan_event.dart @@ -0,0 +1,69 @@ +part of 'scan_bloc.dart'; + +abstract class ScanEvent extends Equatable { + const ScanEvent(); + + @override + List get props => []; +} + +class InitializeScan extends ScanEvent { + final Tour tour; + + const InitializeScan(this.tour); + + @override + List get props => [tour]; +} + +class ProcessBarcode extends ScanEvent { + final String barcode; + + const ProcessBarcode({required this.barcode}); + + @override + List get props => [barcode]; +} + +class ValidateBarcode extends ScanEvent { + final String barcode; + + const ValidateBarcode({required this.barcode}); + + @override + List get props => [barcode]; +} + +class UpdateObjectState extends ScanEvent { + final LogisticObject object; + final String newState; + final int? locationId; + final String? containerCode; + + const UpdateObjectState({ + required this.object, + required this.newState, + this.locationId, + this.containerCode, + }); + + @override + List get props => [object, newState, locationId, containerCode]; +} + +class ResetScan extends ScanEvent { + const ResetScan(); +} + +class CreateUnknownObject extends ScanEvent { + final String barcode; + final int type; + + const CreateUnknownObject({ + required this.barcode, + required this.type, + }); + + @override + List get props => [barcode, type]; +} diff --git a/app/lib/presentation/blocs/scan/scan_state.dart b/app/lib/presentation/blocs/scan/scan_state.dart new file mode 100644 index 0000000..d559d95 --- /dev/null +++ b/app/lib/presentation/blocs/scan/scan_state.dart @@ -0,0 +1,195 @@ +part of 'scan_bloc.dart'; + +abstract class ScanState extends Equatable { + const ScanState(); + + @override + List get props => []; +} + +class ScanInitial extends ScanState {} + +class ScanReady extends ScanState { + final Tour tour; + + const ScanReady({required this.tour}); + + @override + List get props => [tour]; +} + +class ScanProcessing extends ScanState { + final String barcode; + + const ScanProcessing({required this.barcode}); + + @override + List get props => [barcode]; +} + +class ScanObjectDetected extends ScanState { + final LogisticObject object; + final String suggestedState; + final Tour? tour; + final String? originBarcode; + + const ScanObjectDetected({ + required this.object, + required this.suggestedState, + this.tour, + this.originBarcode, + }); + + @override + List get props => [object, suggestedState, tour, originBarcode]; +} + +// Special state for Fehlkassette (error cassette) detection +class ScanFehlKassetteDetected extends ScanState { + final LogisticObject object; + final String suggestedState; + final Tour? tour; + + const ScanFehlKassetteDetected({ + required this.object, + required this.suggestedState, + this.tour, + }); + + @override + List get props => [object, suggestedState, tour]; +} + +// Special state for container object detection (VS state machine) +class ScanContainerObjectDetected extends ScanState { + final LogisticObject object; + final String suggestedState; + final Tour? tour; + final String containerId; + final String containerType; + + const ScanContainerObjectDetected({ + required this.object, + required this.suggestedState, + this.tour, + required this.containerId, + required this.containerType, + }); + + @override + List get props => [object, suggestedState, tour, containerId, containerType]; +} + +// Special state for container detection +class ScanContainerDetected extends ScanState { + final LogisticObject object; + final String suggestedState; + final Tour? tour; + final String containerId; + final String containerType; + + const ScanContainerDetected({ + required this.object, + required this.suggestedState, + this.tour, + required this.containerId, + required this.containerType, + }); + + @override + List get props => [object, suggestedState, tour, containerId, containerType]; +} + +// Special state for container close detection (vehVs state machine) +class ScanContainerCloseDetected extends ScanState { + final LogisticObject object; + final String suggestedState; + final String targetStateForObjects; + final Tour? tour; + final String containerType; + + const ScanContainerCloseDetected({ + required this.object, + required this.suggestedState, + required this.targetStateForObjects, + this.tour, + required this.containerType, + }); + + @override + List get props => [object, suggestedState, targetStateForObjects, tour, containerType]; +} + +class ScanUnknownObject extends ScanState { + final String barcode; + final String prefix; + final Tour? tour; + + const ScanUnknownObject({ + required this.barcode, + required this.prefix, + this.tour, + }); + + @override + List get props => [barcode, prefix, tour]; +} + +class ScanPageDetected extends ScanState { + final String pageId; + final String label; + final Tour tour; + + const ScanPageDetected({ + required this.pageId, + required this.label, + required this.tour, + }); + + @override + List get props => [pageId, label, tour]; +} + +class ScanObjectUpdated extends ScanState { + final LogisticObject object; + final String previousState; + final String newState; + final Tour? tour; + + const ScanObjectUpdated({ + required this.object, + required this.previousState, + required this.newState, + this.tour, + }); + + @override + List get props => [object, previousState, newState, tour]; +} + +class ScanObjectCreated extends ScanState { + final String barcode; + + const ScanObjectCreated({required this.barcode}); + + @override + List get props => [barcode]; +} + +class ScanError extends ScanState { + final String message; + + const ScanError({required this.message}); + + @override + List get props => [message]; +} + +class ScanValidationError extends ScanState { + final String message; + + const ScanValidationError({required this.message}); + + @override + List get props => [message]; +} diff --git a/app/lib/presentation/blocs/tour/tour_bloc.dart b/app/lib/presentation/blocs/tour/tour_bloc.dart new file mode 100644 index 0000000..f82891c --- /dev/null +++ b/app/lib/presentation/blocs/tour/tour_bloc.dart @@ -0,0 +1,124 @@ +import 'package:flutter_bloc/flutter_bloc.dart'; +import 'package:equatable/equatable.dart'; +import '../../../domain/entities/tour.dart'; +import '../../../domain/entities/logistic_object.dart'; +import '../../../domain/repositories/tour_repository.dart'; +import '../../../core/errors/failures.dart'; + +part 'tour_event.dart'; +part 'tour_state.dart'; + +class TourBloc extends Bloc { + final TourRepository repository; + + TourBloc({required this.repository}) : super(TourInitial()) { + on(_onLoadTours); + on(_onSelectTour); + on(_onCompleteTour); + on(_onSyncData); + on(_onRefreshTours); + on(_onLoadTourDetails); + } + + Future _onLoadTours(LoadTours event, Emitter emit) async { + emit(TourLoading()); + + final result = await repository.getTours(); + + result.fold( + (failure) => emit(TourError(message: _mapFailureToMessage(failure))), + (tours) { + final openTours = tours.where((t) => t.state < 2).toList(); + final completedTours = tours.where((t) => t.state == 1).toList(); + + emit(ToursLoaded( + tours: openTours, + completedTours: completedTours, + allTours: tours, + )); + }, + ); + } + + Future _onSelectTour(SelectTour event, Emitter emit) async { + final currentState = state; + if (currentState is ToursLoaded) { + emit(currentState.copyWith(selectedTour: event.tour)); + } + } + + Future _onCompleteTour(CompleteTour event, Emitter emit) async { + final currentState = state; + if (currentState is ToursLoaded) { + emit(TourLoading()); + + final result = await repository.completeTour(event.tourId); + + result.fold( + (failure) => emit(TourError(message: _mapFailureToMessage(failure))), + (_) => add(const LoadTours()), + ); + } + } + + Future _onSyncData(SyncData event, Emitter emit) async { + final currentState = state; + if (currentState is ToursLoaded) { + emit(currentState.copyWith(isSyncing: true)); + + final result = await repository.syncData(); + + result.fold( + (failure) { + emit(currentState.copyWith(isSyncing: false)); + emit(SyncError(message: _mapFailureToMessage(failure))); + }, + (_) { + emit(currentState.copyWith(isSyncing: false)); + add(const LoadTours()); + }, + ); + } + } + + Future _onRefreshTours(RefreshTours event, Emitter emit) async { + add(const LoadTours()); + } + + Future _onLoadTourDetails(LoadTourDetails event, Emitter emit) async { + final currentState = state; + if (currentState is ToursLoaded) { + emit(currentState.copyWith(isLoadingDetails: true)); + + final objectsResult = await repository.getObjectsByTour(event.tourId); + final statsResult = await repository.getTourStatistics(event.tourId); + + objectsResult.fold( + (failure) => emit(TourError(message: _mapFailureToMessage(failure))), + (objects) { + statsResult.fold( + (failure) => emit(TourError(message: _mapFailureToMessage(failure))), + (statistics) { + emit(currentState.copyWith( + selectedTourObjects: objects, + selectedTourStats: statistics, + isLoadingDetails: false, + )); + }, + ); + }, + ); + } + } + + String _mapFailureToMessage(Failure failure) { + return switch (failure) { + ServerFailure _ => 'Serverfehler: ${failure.message}', + NetworkFailure _ => 'Netzwerkfehler. Bitte überprüfen Sie Ihre Internetverbindung.', + CacheFailure _ => 'Cachefehler: ${failure.message}', + NotFoundFailure _ => 'Daten nicht gefunden', + UnauthorizedFailure _ => 'Nicht autorisiert. Bitte melden Sie sich erneut an.', + _ => 'Ein unerwarteter Fehler ist aufgetreten', + }; + } +} diff --git a/app/lib/presentation/blocs/tour/tour_event.dart b/app/lib/presentation/blocs/tour/tour_event.dart new file mode 100644 index 0000000..b8fe866 --- /dev/null +++ b/app/lib/presentation/blocs/tour/tour_event.dart @@ -0,0 +1,56 @@ +part of 'tour_bloc.dart'; + +abstract class TourEvent extends Equatable { + const TourEvent(); + + @override + List get props => []; +} + +class LoadTours extends TourEvent { + const LoadTours(); +} + +class SelectTour extends TourEvent { + final Tour tour; + + const SelectTour(this.tour); + + @override + List get props => [tour]; +} + +class CompleteTour extends TourEvent { + final int tourId; + + const CompleteTour(this.tourId); + + @override + List get props => [tourId]; +} + +class SyncData extends TourEvent { + const SyncData(); +} + +class RefreshTours extends TourEvent { + const RefreshTours(); +} + +class LoadTourDetails extends TourEvent { + final int tourId; + + const LoadTourDetails(this.tourId); + + @override + List get props => [tourId]; +} + +class UpdateShowCompleted extends TourEvent { + final bool showCompleted; + + const UpdateShowCompleted(this.showCompleted); + + @override + List get props => [showCompleted]; +} diff --git a/app/lib/presentation/blocs/tour/tour_state.dart b/app/lib/presentation/blocs/tour/tour_state.dart new file mode 100644 index 0000000..f145b78 --- /dev/null +++ b/app/lib/presentation/blocs/tour/tour_state.dart @@ -0,0 +1,95 @@ +part of 'tour_bloc.dart'; + +abstract class TourState extends Equatable { + const TourState(); + + @override + List get props => []; +} + +class TourInitial extends TourState {} + +class TourLoading extends TourState {} + +class ToursLoaded extends TourState { + final List tours; + final List completedTours; + final List allTours; + final Tour? selectedTour; + final List? selectedTourObjects; + final TourStatistics? selectedTourStats; + final bool isSyncing; + final bool isLoadingDetails; + final bool showCompleted; + + const ToursLoaded({ + required this.tours, + this.completedTours = const [], + required this.allTours, + this.selectedTour, + this.selectedTourObjects, + this.selectedTourStats, + this.isSyncing = false, + this.isLoadingDetails = false, + this.showCompleted = true, + }); + + ToursLoaded copyWith({ + List? tours, + List? completedTours, + List? allTours, + Tour? selectedTour, + List? selectedTourObjects, + TourStatistics? selectedTourStats, + bool? isSyncing, + bool? isLoadingDetails, + bool? showCompleted, + }) { + return ToursLoaded( + tours: tours ?? this.tours, + completedTours: completedTours ?? this.completedTours, + allTours: allTours ?? this.allTours, + selectedTour: selectedTour ?? this.selectedTour, + selectedTourObjects: selectedTourObjects ?? this.selectedTourObjects, + selectedTourStats: selectedTourStats ?? this.selectedTourStats, + isSyncing: isSyncing ?? this.isSyncing, + isLoadingDetails: isLoadingDetails ?? this.isLoadingDetails, + showCompleted: showCompleted ?? this.showCompleted, + ); + } + + int get completedCount => completedTours.length; + int get totalCount => allTours.length; + double get completionPercentage => totalCount > 0 ? (completedCount / totalCount) * 100 : 0; + + @override + List get props => [ + tours, + completedTours, + allTours, + selectedTour, + selectedTourObjects, + selectedTourStats, + isSyncing, + isLoadingDetails, + showCompleted, + ]; +} + +class TourError extends TourState { + final String message; + + const TourError({required this.message}); + + @override + List get props => [message]; +} + +class SyncError extends TourState { + final String message; + + const SyncError({required this.message}); + + @override + List get props => [message]; +} diff --git a/app/lib/presentation/pages/scan/scan_page.dart b/app/lib/presentation/pages/scan/scan_page.dart new file mode 100644 index 0000000..ecc9af5 --- /dev/null +++ b/app/lib/presentation/pages/scan/scan_page.dart @@ -0,0 +1,626 @@ +import 'package:flutter/material.dart'; +import 'package:flutter/services.dart'; +import 'package:flutter_bloc/flutter_bloc.dart'; +import 'package:mobile_scanner/mobile_scanner.dart'; +import '../../../domain/entities/tour.dart'; +import '../../blocs/scan/scan_bloc.dart'; +import 'scan_result_sheet.dart'; + +class ScanPage extends StatefulWidget { + final Tour tour; + + const ScanPage({ + super.key, + required this.tour, + }); + + @override + State createState() => _ScanPageState(); +} + +class _ScanPageState extends State with SingleTickerProviderStateMixin { + late MobileScannerController controller; + bool isFlashOn = false; + bool isManualEntry = false; + final TextEditingController barcodeController = TextEditingController(); + + @override + void initState() { + super.initState(); + controller = MobileScannerController(); + + // Initialize scan bloc with tour + context.read().add(InitializeScan(widget.tour)); + } + + @override + void dispose() { + controller.dispose(); + barcodeController.dispose(); + super.dispose(); + } + + @override + Widget build(BuildContext context) { + final theme = Theme.of(context); + + return Scaffold( + backgroundColor: Colors.black, + appBar: AppBar( + backgroundColor: Colors.black.withValues(alpha: 128), + elevation: 0, + title: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + widget.tour.locationName ?? 'Station', + style: theme.textTheme.titleMedium?.copyWith( + color: Colors.white, + fontWeight: FontWeight.w600, + ), + ), + Text( + _getTypeLabel(widget.tour.type), + style: theme.textTheme.bodySmall?.copyWith( + color: Colors.white70, + ), + ), + ], + ), + actions: [ + IconButton( + onPressed: () { + setState(() { + isFlashOn = !isFlashOn; + controller.toggleTorch(); + }); + }, + icon: Icon( + isFlashOn + ? Icons.flashlight_on + : Icons.flashlight_off, + color: Colors.white, + ), + ), + IconButton( + onPressed: () { + controller.switchCamera(); + }, + icon: const Icon( + Icons.flip_camera_android, + color: Colors.white, + ), + ), + ], + ), + body: BlocListener( + listener: (context, state) { + if (state is ScanObjectDetected) { + _showScanResult(context, state); + } else if (state is ScanFehlKassetteDetected) { + _showFehlKassetteDialog(context, state); + } else if (state is ScanContainerObjectDetected) { + _showContainerObjectResult(context, state); + } else if (state is ScanContainerDetected) { + _showContainerDetectedSnackBar(context, state); + } else if (state is ScanContainerCloseDetected) { + _showContainerCloseDialog(context, state); + } else if (state is ScanUnknownObject) { + _showUnknownObjectDialog(context, state); + } else if (state is ScanPageDetected) { + _showPageDetectedSnackBar(context, state); + } else if (state is ScanObjectUpdated) { + _showSuccessSnackBar(context, state); + } else if (state is ScanObjectCreated) { + _showObjectCreatedSnackBar(context, state); + } else if (state is ScanError) { + _showErrorSnackBar(context, state.message); + } + }, + child: Stack( + fit: StackFit.expand, + children: [ + // Camera Preview + MobileScanner( + controller: controller, + onDetect: (capture) { + final barcodes = capture.barcodes; + if (barcodes.isNotEmpty && barcodes.first.rawValue != null) { + HapticFeedback.mediumImpact(); + context.read().add( + ProcessBarcode(barcode: barcodes.first.rawValue!), + ); + } + }, + ), + + // Scan Overlay + CustomPaint( + size: Size.infinite, + painter: ScanOverlayPainter(), + ), + + // Bottom Controls + Positioned( + bottom: 0, + left: 0, + right: 0, + child: Container( + padding: const EdgeInsets.all(24), + decoration: BoxDecoration( + gradient: LinearGradient( + begin: Alignment.bottomCenter, + end: Alignment.topCenter, + colors: [ + Colors.black.withValues(alpha: 230), + Colors.transparent, + ], + ), + ), + child: Column( + mainAxisSize: MainAxisSize.min, + children: [ + Text( + 'Barcode in den Rahmen halten', + style: theme.textTheme.bodyMedium?.copyWith( + color: Colors.white70, + ), + ), + const SizedBox(height: 24), + Row( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + // Manual Entry Button + ElevatedButton.icon( + onPressed: _showManualEntryDialog, + style: ElevatedButton.styleFrom( + backgroundColor: Colors.white, + foregroundColor: Colors.black, + padding: const EdgeInsets.symmetric( + horizontal: 24, + vertical: 12, + ), + ), + icon: const Icon(Icons.keyboard), + label: const Text('Manuelle Eingabe'), + ), + ], + ), + ], + ), + ), + ), + + // Loading Overlay + BlocBuilder( + builder: (context, state) { + if (state is ScanProcessing) { + return Container( + color: Colors.black54, + child: const Center( + child: CircularProgressIndicator(color: Colors.white), + ), + ); + } + return const SizedBox.shrink(); + }, + ), + ], + ), + ), + ); + } + + void _showScanResult(BuildContext context, ScanObjectDetected state) { + showModalBottomSheet( + context: context, + isScrollControlled: true, + backgroundColor: Colors.transparent, + builder: (context) => ScanResultSheet( + object: state.object, + suggestedState: state.suggestedState, + tour: state.tour, + onConfirm: () { + context.read().add(UpdateObjectState( + object: state.object, + newState: state.suggestedState, + )); + Navigator.pop(context); + }, + onCancel: () { + Navigator.pop(context); + }, + ), + ); + } + + void _showUnknownObjectDialog(BuildContext context, ScanUnknownObject state) { + showDialog( + context: context, + builder: (context) => AlertDialog( + title: const Text('Unbekanntes Objekt'), + content: Column( + mainAxisSize: MainAxisSize.min, + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text('Barcode: ${state.barcode}'), + const SizedBox(height: 8), + const Text( + 'Dieses Objekt ist nicht im System vorhanden. ' + 'Möchten Sie es neu anlegen?', + ), + ], + ), + actions: [ + TextButton( + onPressed: () => Navigator.pop(context), + child: const Text('Abbrechen'), + ), + ElevatedButton( + onPressed: () { + Navigator.pop(context); + // TODO: Navigate to create object page + }, + child: const Text('Anlegen'), + ), + ], + ), + ); + } + + void _showPageDetectedSnackBar(BuildContext context, ScanPageDetected state) { + ScaffoldMessenger.of(context).showSnackBar( + SnackBar( + content: Text('Seite erkannt: ${state.label}'), + backgroundColor: Colors.green, + behavior: SnackBarBehavior.floating, + action: SnackBarAction( + label: 'OK', + textColor: Colors.white, + onPressed: () {}, + ), + ), + ); + } + + void _showSuccessSnackBar(BuildContext context, ScanObjectUpdated state) { + ScaffoldMessenger.of(context).showSnackBar( + SnackBar( + content: Text('Status aktualisiert: ${state.object.code}'), + backgroundColor: Colors.green, + behavior: SnackBarBehavior.floating, + duration: const Duration(seconds: 2), + ), + ); + } + + void _showFehlKassetteDialog(BuildContext context, ScanFehlKassetteDetected state) { + showDialog( + context: context, + builder: (context) => AlertDialog( + title: const Text('Fehlkassette'), + content: Text( + 'Die Kassette ${state.object.code} wird als Fehlkassette markiert. ' + 'Der Status wird auf "Fehler - zur Dienststelle" geändert.', + ), + actions: [ + TextButton( + onPressed: () => Navigator.pop(context), + child: const Text('Abbrechen'), + ), + ElevatedButton( + onPressed: () { + context.read().add(UpdateObjectState( + object: state.object, + newState: state.suggestedState, + )); + Navigator.pop(context); + }, + style: ElevatedButton.styleFrom( + backgroundColor: Colors.red, + foregroundColor: Colors.white, + ), + child: const Text('Bestätigen'), + ), + ], + ), + ); + } + + void _showContainerObjectResult(BuildContext context, ScanContainerObjectDetected state) { + showModalBottomSheet( + context: context, + isScrollControlled: true, + backgroundColor: Colors.transparent, + builder: (context) => ScanResultSheet( + object: state.object, + suggestedState: state.suggestedState, + tour: state.tour, + containerInfo: 'Container: ${state.containerId} (${state.containerType == 'a' ? 'Geldinstitut' : 'Dienststelle'})', + onConfirm: () { + context.read().add(UpdateObjectState( + object: state.object, + newState: state.suggestedState, + containerCode: state.containerId, + )); + Navigator.pop(context); + }, + onCancel: () { + Navigator.pop(context); + }, + ), + ); + } + + void _showContainerDetectedSnackBar(BuildContext context, ScanContainerDetected state) { + final containerTypeLabel = state.containerType == 'a' ? 'Geldinstitut' : 'Dienststelle'; + ScaffoldMessenger.of(context).showSnackBar( + SnackBar( + content: Text('Container erkannt: ${state.containerId} ($containerTypeLabel)'), + backgroundColor: Colors.blue, + behavior: SnackBarBehavior.floating, + duration: const Duration(seconds: 3), + action: SnackBarAction( + label: 'OK', + textColor: Colors.white, + onPressed: () { + context.read().add(UpdateObjectState( + object: state.object, + newState: state.suggestedState, + )); + }, + ), + ), + ); + } + + void _showContainerCloseDialog(BuildContext context, ScanContainerCloseDetected state) { + final containerTypeLabel = state.containerType == 'a' ? 'Geldinstitut' : 'Dienststelle'; + showDialog( + context: context, + builder: (context) => AlertDialog( + title: const Text('Container schließen'), + content: Text( + 'Container ${state.object.code} ($containerTypeLabel) wird geschlossen. ' + 'Alle enthaltenen Objekte werden auf den entsprechenden Status aktualisiert.', + ), + actions: [ + TextButton( + onPressed: () => Navigator.pop(context), + child: const Text('Abbrechen'), + ), + ElevatedButton( + onPressed: () { + context.read().add(UpdateObjectState( + object: state.object, + newState: state.suggestedState, + )); + Navigator.pop(context); + }, + child: const Text('Schließen'), + ), + ], + ), + ); + } + + void _showObjectCreatedSnackBar(BuildContext context, ScanObjectCreated state) { + ScaffoldMessenger.of(context).showSnackBar( + SnackBar( + content: Text('Objekt erstellt: ${state.barcode}'), + backgroundColor: Colors.green, + behavior: SnackBarBehavior.floating, + duration: const Duration(seconds: 2), + ), + ); + } + + void _showErrorSnackBar(BuildContext context, String message) { + ScaffoldMessenger.of(context).showSnackBar( + SnackBar( + content: Text(message), + backgroundColor: Colors.red, + behavior: SnackBarBehavior.floating, + ), + ); + } + + void _showManualEntryDialog() { + showDialog( + context: context, + builder: (context) => AlertDialog( + title: const Text('Barcode manuell eingeben'), + content: TextField( + controller: barcodeController, + autofocus: true, + decoration: const InputDecoration( + hintText: 'Barcode eingeben', + border: OutlineInputBorder(), + ), + textCapitalization: TextCapitalization.characters, + ), + actions: [ + TextButton( + onPressed: () { + barcodeController.clear(); + Navigator.pop(context); + }, + child: const Text('Abbrechen'), + ), + ElevatedButton( + onPressed: () { + if (barcodeController.text.isNotEmpty) { + context.read().add( + ProcessBarcode(barcode: barcodeController.text), + ); + barcodeController.clear(); + Navigator.pop(context); + } + }, + child: const Text('Suchen'), + ), + ], + ), + ); + } + + String _getTypeLabel(String type) { + switch (type) { + case 'stock_start': + return 'Lager - Beladung'; + case 'stock_end': + return 'Lager - Rückgabe'; + case 'start': + return 'Dienststelle'; + case 'st': + return 'Haltestelle'; + case 'hls': + return 'Hochbahnstation'; + case 'fsa': + return 'Fahrscheinautomat'; + case 'vs': + return 'Versorgungsstelle'; + case 'gi': + return 'Geldinstitut'; + default: + return type; + } + } +} + +class ScanOverlayPainter extends CustomPainter { + @override + void paint(Canvas canvas, Size size) { + final paint = Paint() + ..color = Colors.black.withValues(alpha: 128) + ..style = PaintingStyle.fill; + + final scanAreaSize = size.width * 0.7; + final scanAreaLeft = (size.width - scanAreaSize) / 2; + final scanAreaTop = (size.height - scanAreaSize) / 2; + + // Draw dark overlay + final path = Path() + ..addRect(Rect.fromLTWH(0, 0, size.width, size.height)); + + final cutout = Path() + ..addRRect(RRect.fromRectAndRadius( + Rect.fromLTWH(scanAreaLeft, scanAreaTop, scanAreaSize, scanAreaSize), + const Radius.circular(20), + )); + + final overlayPath = Path.combine( + PathOperation.difference, + path, + cutout, + ); + + canvas.drawPath(overlayPath, paint); + + // Draw corner markers + final markerPaint = Paint() + ..color = Colors.white + ..style = PaintingStyle.stroke + ..strokeWidth = 4; + + final cornerLength = scanAreaSize * 0.15; + const cornerRadius = 20.0; + + // Top-left corner + _drawCorner( + canvas, + Offset(scanAreaLeft, scanAreaTop), + cornerLength, + markerPaint, + true, + true, + cornerRadius, + ); + + // Top-right corner + _drawCorner( + canvas, + Offset(scanAreaLeft + scanAreaSize, scanAreaTop), + cornerLength, + markerPaint, + false, + true, + cornerRadius, + ); + + // Bottom-left corner + _drawCorner( + canvas, + Offset(scanAreaLeft, scanAreaTop + scanAreaSize), + cornerLength, + markerPaint, + true, + false, + cornerRadius, + ); + + // Bottom-right corner + _drawCorner( + canvas, + Offset(scanAreaLeft + scanAreaSize, scanAreaTop + scanAreaSize), + cornerLength, + markerPaint, + false, + false, + cornerRadius, + ); + } + + void _drawCorner( + Canvas canvas, + Offset position, + double length, + Paint paint, + bool isLeft, + bool isTop, + double radius, + ) { + final path = Path(); + + if (isLeft && isTop) { + path.moveTo(position.dx + length, position.dy); + path.lineTo(position.dx + radius, position.dy); + path.arcToPoint( + Offset(position.dx, position.dy + radius), + radius: Radius.circular(radius), + clockwise: false, + ); + path.lineTo(position.dx, position.dy + length); + } else if (!isLeft && isTop) { + path.moveTo(position.dx - length, position.dy); + path.lineTo(position.dx - radius, position.dy); + path.arcToPoint( + Offset(position.dx, position.dy + radius), + radius: Radius.circular(radius), + ); + path.lineTo(position.dx, position.dy + length); + } else if (isLeft && !isTop) { + path.moveTo(position.dx + length, position.dy); + path.lineTo(position.dx + radius, position.dy); + path.arcToPoint( + Offset(position.dx, position.dy - radius), + radius: Radius.circular(radius), + ); + path.lineTo(position.dx, position.dy - length); + } else { + path.moveTo(position.dx - length, position.dy); + path.lineTo(position.dx - radius, position.dy); + path.arcToPoint( + Offset(position.dx, position.dy - radius), + radius: Radius.circular(radius), + clockwise: false, + ); + path.lineTo(position.dx, position.dy - length); + } + + canvas.drawPath(path, paint); + } + + @override + bool shouldRepaint(covariant CustomPainter oldDelegate) => false; +} diff --git a/app/lib/presentation/pages/scan/scan_result_sheet.dart b/app/lib/presentation/pages/scan/scan_result_sheet.dart new file mode 100644 index 0000000..38f9337 --- /dev/null +++ b/app/lib/presentation/pages/scan/scan_result_sheet.dart @@ -0,0 +1,317 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_animate/flutter_animate.dart'; +import '../../../domain/entities/logistic_object.dart'; +import '../../../domain/entities/tour.dart'; + +class ScanResultSheet extends StatelessWidget { + final LogisticObject object; + final String suggestedState; + final Tour? tour; + final String? containerInfo; + final VoidCallback onConfirm; + final VoidCallback onCancel; + + const ScanResultSheet({ + super.key, + required this.object, + required this.suggestedState, + this.tour, + this.containerInfo, + required this.onConfirm, + required this.onCancel, + }); + + @override + Widget build(BuildContext context) { + final theme = Theme.of(context); + final currentStateColor = ObjectStateInfo.getColorForState(object.state); + final suggestedStateColor = ObjectStateInfo.getColorForState(suggestedState); + + return Container( + decoration: const BoxDecoration( + color: Colors.white, + borderRadius: BorderRadius.vertical(top: Radius.circular(24)), + ), + child: Column( + mainAxisSize: MainAxisSize.min, + children: [ + // Handle + Container( + margin: const EdgeInsets.only(top: 12), + width: 40, + height: 4, + decoration: BoxDecoration( + color: Colors.grey.shade300, + borderRadius: BorderRadius.circular(2), + ), + ), + + const SizedBox(height: 24), + + // Success Icon + Container( + width: 80, + height: 80, + decoration: BoxDecoration( + gradient: LinearGradient( + colors: [ + Colors.green.shade400, + Colors.green.shade600, + ], + ), + shape: BoxShape.circle, + boxShadow: [ + BoxShadow( + color: Colors.green.withValues(alpha: 77), + blurRadius: 20, + offset: const Offset(0, 8), + ), + ], + ), + child: const Icon( + Icons.check, + color: Colors.white, + size: 40, + ), + ).animate().scale(duration: 300.ms, curve: Curves.elasticOut), + + const SizedBox(height: 24), + + // Title + Text( + 'Objekt gefunden', + style: theme.textTheme.headlineSmall?.copyWith( + fontWeight: FontWeight.bold, + ), + ), + + const SizedBox(height: 24), + + // Object Info Card + Padding( + padding: const EdgeInsets.symmetric(horizontal: 24), + child: Card( + elevation: 0, + color: Colors.grey.shade50, + shape: RoundedRectangleBorder( + borderRadius: BorderRadius.circular(16), + side: BorderSide(color: Colors.grey.shade200), + ), + child: Padding( + padding: const EdgeInsets.all(20), + child: Column( + children: [ + _buildInfoRow( + context, + 'Code', + object.code, + Icons.qr_code, + ), + const Divider(height: 24), + _buildInfoRow( + context, + 'Typ', + object.typeName ?? object.subtype.toUpperCase(), + Icons.inventory_2, + ), + const Divider(height: 24), + _buildStateRow( + context, + 'Aktueller Status', + object.state, + currentStateColor, + ), + if (containerInfo != null) ...[ + const Divider(height: 24), + _buildInfoRow( + context, + 'Container', + containerInfo!, + Icons.inventory_2, + ), + ], + ], + ), + ), + ), + ), + + const SizedBox(height: 24), + + // State Transition + Container( + margin: const EdgeInsets.symmetric(horizontal: 24), + padding: const EdgeInsets.all(20), + decoration: BoxDecoration( + gradient: LinearGradient( + colors: [ + suggestedStateColor.withValues(alpha: 26), + suggestedStateColor.withValues(alpha: 13), + ], + ), + borderRadius: BorderRadius.circular(16), + border: Border.all(color: suggestedStateColor.withValues(alpha: 77)), + ), + child: Column( + children: [ + Text( + 'Status wird geändert zu:', + style: theme.textTheme.bodySmall?.copyWith( + color: Colors.grey.shade600, + ), + ), + const SizedBox(height: 8), + Row( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + Container( + width: 12, + height: 12, + decoration: BoxDecoration( + color: suggestedStateColor, + shape: BoxShape.circle, + ), + ), + const SizedBox(width: 8), + Text( + ObjectStateInfo.getDisplayName(suggestedState), + style: theme.textTheme.titleMedium?.copyWith( + fontWeight: FontWeight.w600, + color: suggestedStateColor, + ), + ), + ], + ), + ], + ), + ), + + const SizedBox(height: 32), + + // Action Buttons + Padding( + padding: const EdgeInsets.symmetric(horizontal: 24), + child: Row( + children: [ + Expanded( + child: OutlinedButton( + onPressed: onCancel, + style: OutlinedButton.styleFrom( + padding: const EdgeInsets.symmetric(vertical: 16), + ), + child: const Text('Abbrechen'), + ), + ), + const SizedBox(width: 16), + Expanded( + flex: 2, + child: ElevatedButton( + onPressed: onConfirm, + style: ElevatedButton.styleFrom( + padding: const EdgeInsets.symmetric(vertical: 16), + ), + child: const Text('Bestätigen'), + ), + ), + ], + ), + ), + + const SizedBox(height: 32), + ], + ), + ); + } + + Widget _buildInfoRow(BuildContext context, String label, String value, IconData icon) { + final theme = Theme.of(context); + + return Row( + children: [ + Container( + padding: const EdgeInsets.all(10), + decoration: BoxDecoration( + color: theme.colorScheme.primary.withValues(alpha: 26), + borderRadius: BorderRadius.circular(10), + ), + child: Icon( + icon, + size: 20, + color: theme.colorScheme.primary, + ), + ), + const SizedBox(width: 16), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + label, + style: theme.textTheme.bodySmall?.copyWith( + color: Colors.grey.shade600, + ), + ), + const SizedBox(height: 2), + Text( + value, + style: theme.textTheme.bodyLarge?.copyWith( + fontWeight: FontWeight.w600, + ), + ), + ], + ), + ), + ], + ); + } + + Widget _buildStateRow(BuildContext context, String label, String state, Color color) { + final theme = Theme.of(context); + + return Row( + children: [ + Container( + padding: const EdgeInsets.all(10), + decoration: BoxDecoration( + color: color.withValues(alpha: 26), + borderRadius: BorderRadius.circular(10), + ), + child: Icon( + Icons.info, + size: 20, + color: color, + ), + ), + const SizedBox(width: 16), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + label, + style: theme.textTheme.bodySmall?.copyWith( + color: Colors.grey.shade600, + ), + ), + const SizedBox(height: 2), + Container( + padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 4), + decoration: BoxDecoration( + color: color.withValues(alpha: 26), + borderRadius: BorderRadius.circular(20), + ), + child: Text( + ObjectStateInfo.getDisplayName(state), + style: theme.textTheme.bodyMedium?.copyWith( + fontWeight: FontWeight.w600, + color: color, + ), + ), + ), + ], + ), + ), + ], + ); + } +} diff --git a/app/lib/presentation/pages/tour_types/fsa_page.dart b/app/lib/presentation/pages/tour_types/fsa_page.dart new file mode 100644 index 0000000..cff0a3e --- /dev/null +++ b/app/lib/presentation/pages/tour_types/fsa_page.dart @@ -0,0 +1,252 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_bloc/flutter_bloc.dart'; +import '../../../domain/entities/tour.dart'; +import '../../blocs/scan/scan_bloc.dart'; +import '../scan/scan_page.dart'; + +/// FSA Page - Fahrscheinautomat +/// Entspricht Lua: ShowFsaScreen + CreateLoadingFsaView +class FsaPage extends StatefulWidget { + final Tour tour; + + const FsaPage({ + super.key, + required this.tour, + }); + + @override + State createState() => _FsaPageState(); +} + +class _FsaPageState extends State { + @override + void initState() { + super.initState(); + context.read().add(InitializeScan(widget.tour)); + } + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text(widget.tour.locationName ?? 'Fahrscheinautomat'), + const Text( + 'Objekt-Einbuchung', + style: TextStyle(fontSize: 14, color: Colors.white70), + ), + ], + ), + actions: [ + IconButton( + icon: const Icon(Icons.qr_code_scanner), + onPressed: () => _openScanner(context), + ), + ], + ), + body: Column( + children: [ + // Header + _buildHeader(context), + + // FSA-spezifische Info + Expanded( + child: SingleChildScrollView( + child: Column( + children: [ + _buildFsaInfo(context), + _buildObjectTypes(context), + ], + ), + ), + ), + + // Scan Button + _buildScanButton(context), + ], + ), + ); + } + + Widget _buildHeader(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + color: const Color(0xFFA4D4F0), + child: Row( + children: [ + Container( + width: 80, + height: 80, + decoration: BoxDecoration( + color: Colors.white, + borderRadius: BorderRadius.circular(8), + ), + child: const Icon( + Icons.confirmation_number, + size: 48, + color: Colors.blue, + ), + ), + const SizedBox(width: 16), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + 'Fahrscheinautomat', + style: Theme.of(context).textTheme.titleLarge?.copyWith( + fontWeight: FontWeight.bold, + ), + ), + Text( + widget.tour.locationName ?? 'FSA', + style: Theme.of(context).textTheme.bodyMedium, + ), + if (widget.tour.remark != null) + Text( + widget.tour.remark!, + style: Theme.of(context).textTheme.bodySmall, + ), + ], + ), + ), + ], + ), + ); + } + + Widget _buildFsaInfo(BuildContext context) { + return Container( + margin: const EdgeInsets.all(16), + padding: const EdgeInsets.all(16), + decoration: BoxDecoration( + color: Colors.blue.shade50, + borderRadius: BorderRadius.circular(12), + border: Border.all(color: Colors.blue.shade200), + ), + child: const Column( + children: [ + Text( + 'Gültige Objekte:', + style: TextStyle( + fontWeight: FontWeight.bold, + fontSize: 16, + ), + ), + SizedBox(height: 8), + Text( + '• GK (Geldkassette): station → in_fa → ret_fail\n' + '• HP (Hauptkasse): station ↔ in_fa (Wechsel)\n' + '• FR (Fahrkartenrolle): station ↔ in_fa', + style: TextStyle(fontSize: 14), + ), + ], + ), + ); + } + + Widget _buildObjectTypes(BuildContext context) { + final objectTypes = [ + _ObjectTypeInfo('Geldkassette (GK)', 'MEK, BEK', Icons.money, Colors.green), + _ObjectTypeInfo('Hauptkasse (HP)', 'H1, H2, H3', Icons.print, Colors.blue), + _ObjectTypeInfo('Fahrkartenrolle (FR)', 'P', Icons.receipt, Colors.orange), + ]; + + return Padding( + padding: const EdgeInsets.symmetric(horizontal: 16), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + const Text( + 'Objekttypen', + style: TextStyle( + fontSize: 16, + fontWeight: FontWeight.bold, + ), + ), + const SizedBox(height: 12), + ...objectTypes.map((type) => _buildObjectTypeCard(context, type)), + ], + ), + ); + } + + Widget _buildObjectTypeCard(BuildContext context, _ObjectTypeInfo type) { + return Container( + margin: const EdgeInsets.only(bottom: 8), + padding: const EdgeInsets.all(12), + decoration: BoxDecoration( + color: Colors.grey.shade100, + borderRadius: BorderRadius.circular(8), + ), + child: Row( + children: [ + Container( + padding: const EdgeInsets.all(8), + decoration: BoxDecoration( + color: type.color.withValues(alpha: 26), + borderRadius: BorderRadius.circular(8), + ), + child: Icon(type.icon, color: type.color), + ), + const SizedBox(width: 12), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + type.name, + style: const TextStyle( + fontWeight: FontWeight.bold, + fontSize: 15, + ), + ), + Text( + type.subtypes, + style: TextStyle( + fontSize: 13, + color: Colors.grey.shade600, + ), + ), + ], + ), + ), + ], + ), + ); + } + + Widget _buildScanButton(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + child: ElevatedButton.icon( + onPressed: () => _openScanner(context), + icon: const Icon(Icons.qr_code_scanner), + label: const Text('Barcode scannen'), + style: ElevatedButton.styleFrom( + minimumSize: const Size(double.infinity, 56), + ), + ), + ); + } + + void _openScanner(BuildContext context) { + Navigator.push( + context, + MaterialPageRoute( + builder: (_) => ScanPage(tour: widget.tour), + ), + ); + } +} + +class _ObjectTypeInfo { + final String name; + final String subtypes; + final IconData icon; + final Color color; + + _ObjectTypeInfo(this.name, this.subtypes, this.icon, this.color); +} diff --git a/app/lib/presentation/pages/tour_types/gi_page.dart b/app/lib/presentation/pages/tour_types/gi_page.dart new file mode 100644 index 0000000..c61989c --- /dev/null +++ b/app/lib/presentation/pages/tour_types/gi_page.dart @@ -0,0 +1,264 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_bloc/flutter_bloc.dart'; +import '../../../domain/entities/tour.dart'; +import '../../blocs/scan/scan_bloc.dart'; +import '../scan/scan_page.dart'; + +/// GI Page - Geldinstitut +/// Entspricht Lua: ShowGiScreen + CreateLoadingGiView +class GiPage extends StatefulWidget { + final Tour tour; + + const GiPage({ + super.key, + required this.tour, + }); + + @override + State createState() => _GiPageState(); +} + +class _GiPageState extends State { + @override + void initState() { + super.initState(); + context.read().add(InitializeScan(widget.tour)); + } + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text(widget.tour.locationName ?? 'Geldinstitut'), + const Text( + 'Übergabe', + style: TextStyle(fontSize: 14, color: Colors.white70), + ), + ], + ), + actions: [ + IconButton( + icon: const Icon(Icons.qr_code_scanner), + onPressed: () => _openScanner(context), + ), + ], + ), + body: Column( + children: [ + // Header + _buildHeader(context), + + // GI-spezifische Info + Expanded( + child: SingleChildScrollView( + child: Column( + children: [ + _buildGiInfo(context), + _buildExpectedObjects(context), + ], + ), + ), + ), + + // Scan Button + _buildScanButton(context), + ], + ), + ); + } + + Widget _buildHeader(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + color: const Color(0xFFA4D4F0), + child: Row( + children: [ + Container( + width: 80, + height: 80, + decoration: BoxDecoration( + color: Colors.white, + borderRadius: BorderRadius.circular(8), + ), + child: const Icon( + Icons.account_balance, + size: 48, + color: Colors.blue, + ), + ), + const SizedBox(width: 16), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + 'Geldinstitut', + style: Theme.of(context).textTheme.titleLarge?.copyWith( + fontWeight: FontWeight.bold, + ), + ), + Text( + widget.tour.locationName ?? 'Bank', + style: Theme.of(context).textTheme.bodyMedium, + ), + ], + ), + ), + ], + ), + ); + } + + Widget _buildGiInfo(BuildContext context) { + return Container( + margin: const EdgeInsets.all(16), + padding: const EdgeInsets.all(16), + decoration: BoxDecoration( + color: Colors.green.shade50, + borderRadius: BorderRadius.circular(12), + border: Border.all(color: Colors.green.shade200), + ), + child: const Column( + children: [ + Text( + 'Erwartete Objekte:', + style: TextStyle( + fontWeight: FontWeight.bold, + fontSize: 16, + ), + ), + SizedBox(height: 8), + Text( + '• GK mit Status "ret_gi_fzg" → "fin_gi"\n' + '• SB (Safebag) mit Status "ret_gi_fzg" → "fin_gi"\n' + '• Leere Kassetten: "unknown" → "ret_ds_empty"', + style: TextStyle(fontSize: 14), + ), + ], + ), + ); + } + + Widget _buildExpectedObjects(BuildContext context) { + return Padding( + padding: const EdgeInsets.symmetric(horizontal: 16), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + const Text( + 'Zu übergebende Objekte', + style: TextStyle( + fontSize: 16, + fontWeight: FontWeight.bold, + ), + ), + const SizedBox(height: 12), + + // Geldkassetten + _buildObjectStatusCard( + context, + 'Geldkassetten (GK)', + 'ret_gi_fzg → fin_gi', + Icons.money, + Colors.green, + ), + + // Safebags + _buildObjectStatusCard( + context, + 'Safebags (SB)', + 'ret_gi_fzg → fin_gi', + Icons.shopping_bag, + Colors.blue, + ), + + // Leere Kassetten + _buildObjectStatusCard( + context, + 'Leere Kassetten', + 'unknown → ret_ds_empty', + Icons.remove_circle_outline, + Colors.orange, + ), + ], + ), + ); + } + + Widget _buildObjectStatusCard( + BuildContext context, + String title, + String transition, + IconData icon, + Color color, + ) { + return Container( + margin: const EdgeInsets.only(bottom: 8), + padding: const EdgeInsets.all(12), + decoration: BoxDecoration( + color: Colors.grey.shade100, + borderRadius: BorderRadius.circular(8), + ), + child: Row( + children: [ + Container( + padding: const EdgeInsets.all(8), + decoration: BoxDecoration( + color: color.withValues(alpha: 26), + borderRadius: BorderRadius.circular(8), + ), + child: Icon(icon, color: color), + ), + const SizedBox(width: 12), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + title, + style: const TextStyle( + fontWeight: FontWeight.bold, + fontSize: 15, + ), + ), + Text( + transition, + style: TextStyle( + fontSize: 13, + color: Colors.grey.shade600, + ), + ), + ], + ), + ), + ], + ), + ); + } + + Widget _buildScanButton(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + child: ElevatedButton.icon( + onPressed: () => _openScanner(context), + icon: const Icon(Icons.qr_code_scanner), + label: const Text('Barcode scannen'), + style: ElevatedButton.styleFrom( + minimumSize: const Size(double.infinity, 56), + ), + ), + ); + } + + void _openScanner(BuildContext context) { + Navigator.push( + context, + MaterialPageRoute( + builder: (_) => ScanPage(tour: widget.tour), + ), + ); + } +} diff --git a/app/lib/presentation/pages/tour_types/stock_end_page.dart b/app/lib/presentation/pages/tour_types/stock_end_page.dart new file mode 100644 index 0000000..3e56424 --- /dev/null +++ b/app/lib/presentation/pages/tour_types/stock_end_page.dart @@ -0,0 +1,274 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_bloc/flutter_bloc.dart'; +import '../../../domain/entities/tour.dart'; +import '../../blocs/scan/scan_bloc.dart'; +import '../scan/scan_page.dart'; + +/// Stock End Page - Lager Rückgabe +/// Entspricht Lua: ShowStockEndScreen + CreateLoadingStockEndView +class StockEndPage extends StatefulWidget { + final Tour tour; + + const StockEndPage({ + super.key, + required this.tour, + }); + + @override + State createState() => _StockEndPageState(); +} + +class _StockEndPageState extends State { + @override + void initState() { + super.initState(); + context.read().add(InitializeScan(widget.tour)); + } + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text(widget.tour.locationName ?? 'Lager'), + const Text( + 'Rückgabe', + style: TextStyle(fontSize: 14, color: Colors.white70), + ), + ], + ), + actions: [ + IconButton( + icon: const Icon(Icons.qr_code_scanner), + onPressed: () => _openScanner(context), + ), + ], + ), + body: Column( + children: [ + // Header + _buildHeader(context), + + // Rückgabe-Übersicht + Expanded( + child: SingleChildScrollView( + child: Column( + children: [ + _buildReturnInfo(context), + _buildObjectSummary(context), + ], + ), + ), + ), + + // Scan Button + _buildScanButton(context), + ], + ), + ); + } + + Widget _buildHeader(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + color: const Color(0xFFA4D4F0), + child: Row( + children: [ + Container( + width: 80, + height: 80, + decoration: BoxDecoration( + color: Colors.white, + borderRadius: BorderRadius.circular(8), + ), + child: const Icon( + Icons.warehouse, + size: 48, + color: Colors.blue, + ), + ), + const SizedBox(width: 16), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + 'Lager Rückgabe', + style: Theme.of(context).textTheme.titleLarge?.copyWith( + fontWeight: FontWeight.bold, + ), + ), + Text( + widget.tour.locationName ?? 'Hauptlager', + style: Theme.of(context).textTheme.bodyMedium, + ), + ], + ), + ), + ], + ), + ); + } + + Widget _buildReturnInfo(BuildContext context) { + return Container( + margin: const EdgeInsets.all(16), + padding: const EdgeInsets.all(16), + decoration: BoxDecoration( + color: Colors.green.shade50, + borderRadius: BorderRadius.circular(12), + border: Border.all(color: Colors.green.shade200), + ), + child: const Column( + children: [ + Text( + 'Rückgabe-Status:', + style: TextStyle( + fontWeight: FontWeight.bold, + fontSize: 16, + ), + ), + SizedBox(height: 8), + Text( + 'Abschluss der Tour - Objekte werden finalisiert:\n' + '• ret_fail_stk → fin_ds_fail\n' + '• ret_ds_stk → fin_ds\n' + '• ret_gi_stk → fin_gi_tmp', + style: TextStyle(fontSize: 14), + ), + ], + ), + ); + } + + Widget _buildObjectSummary(BuildContext context) { + return Padding( + padding: const EdgeInsets.symmetric(horizontal: 16), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + const Text( + 'Objekte zur Rückgabe', + style: TextStyle( + fontSize: 16, + fontWeight: FontWeight.bold, + ), + ), + const SizedBox(height: 12), + + // Fehlkassetten + _buildObjectStatusCard( + context, + 'Fehlkassetten', + 'ret_fail_stk → fin_ds_fail', + Icons.error, + Colors.red, + ), + + // DS-Normal + _buildObjectStatusCard( + context, + 'Zur Dienststelle', + 'ret_ds_stk → fin_ds', + Icons.account_balance, + Colors.blue, + ), + + // DS-Fehler + _buildObjectStatusCard( + context, + 'Fehlerhafte DS', + 'ret_ds_err → fin_ds_err', + Icons.warning, + Colors.orange, + ), + + // GI + _buildObjectStatusCard( + context, + 'Zum Geldinstitut', + 'ret_gi_stk → fin_gi_tmp', + Icons.account_balance_wallet, + Colors.green, + ), + ], + ), + ); + } + + Widget _buildObjectStatusCard( + BuildContext context, + String title, + String transition, + IconData icon, + Color color, + ) { + return Container( + margin: const EdgeInsets.only(bottom: 8), + padding: const EdgeInsets.all(12), + decoration: BoxDecoration( + color: Colors.grey.shade100, + borderRadius: BorderRadius.circular(8), + ), + child: Row( + children: [ + Container( + padding: const EdgeInsets.all(8), + decoration: BoxDecoration( + color: color.withValues(alpha: 26), + borderRadius: BorderRadius.circular(8), + ), + child: Icon(icon, color: color), + ), + const SizedBox(width: 12), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + title, + style: const TextStyle( + fontWeight: FontWeight.bold, + fontSize: 15, + ), + ), + Text( + transition, + style: TextStyle( + fontSize: 13, + color: Colors.grey.shade600, + ), + ), + ], + ), + ), + ], + ), + ); + } + + Widget _buildScanButton(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + child: ElevatedButton.icon( + onPressed: () => _openScanner(context), + icon: const Icon(Icons.qr_code_scanner), + label: const Text('Barcode scannen'), + style: ElevatedButton.styleFrom( + minimumSize: const Size(double.infinity, 56), + ), + ), + ); + } + + void _openScanner(BuildContext context) { + Navigator.push( + context, + MaterialPageRoute( + builder: (_) => ScanPage(tour: widget.tour), + ), + ); + } +} diff --git a/app/lib/presentation/pages/tour_types/stock_start_page.dart b/app/lib/presentation/pages/tour_types/stock_start_page.dart new file mode 100644 index 0000000..0a978ed --- /dev/null +++ b/app/lib/presentation/pages/tour_types/stock_start_page.dart @@ -0,0 +1,323 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_bloc/flutter_bloc.dart'; +import '../../../domain/entities/tour.dart'; +import '../../../domain/entities/counter.dart'; +import '../../../core/constants/app_constants.dart'; +import '../../blocs/scan/scan_bloc.dart'; +import '../../widgets/counter_grid.dart'; +import '../../widgets/recent_scans_list.dart'; +import '../scan/scan_page.dart'; + +/// Stock Start Page - Lager Beladung +/// Entspricht Lua: ShowStockStartScreen + CreateLoadingStockStartView +class StockStartPage extends StatefulWidget { + final Tour tour; + + const StockStartPage({ + super.key, + required this.tour, + }); + + @override + State createState() => _StockStartPageState(); +} + +class _StockStartPageState extends State { + @override + void initState() { + super.initState(); + // Initialize scan bloc with tour + context.read().add(InitializeScan(widget.tour)); + } + + @override + Widget build(BuildContext context) { + final theme = Theme.of(context); + + return Scaffold( + appBar: AppBar( + title: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text(widget.tour.locationName ?? 'Lager'), + Text( + 'Beladung', + style: theme.textTheme.bodySmall?.copyWith( + color: Colors.white70, + ), + ), + ], + ), + actions: [ + IconButton( + icon: const Icon(Icons.qr_code_scanner), + onPressed: () => _openScanner(context), + ), + ], + ), + body: Column( + children: [ + // Header mit Lager-Icon + _buildHeader(context), + + // Zähler-Übersicht (wie in Lua CreateLoadingStockStartView) + Expanded( + child: SingleChildScrollView( + child: Column( + children: [ + // Bestand Fzg (aktueller Bestand im Fahrzeug) + _buildCounterSection( + context, + title: 'Bestand Fzg', + counters: const [ + CounterItem('MEK', 0), + CounterItem('BEK', 0), + CounterItem('H1', 0), + CounterItem('H2', 0), + CounterItem('H3', 0), + CounterItem('P', 0), + ], + backgroundColor: const Color(0xFFA4D4F0), // Lua-Farbe + ), + + // Beladezähler (Soll-Zahlen) + _buildCounterSection( + context, + title: 'Beladezähler', + counters: const [ + CounterItem('MEK', 0), + CounterItem('BEK', 0), + CounterItem('H1', 0), + CounterItem('H2', 0), + CounterItem('H3', 0), + CounterItem('P', 0), + ], + backgroundColor: Colors.grey.shade200, + ), + + // HADAG + _buildCounterSection( + context, + title: 'HADAG', + counters: const [ + CounterItem('', null), + CounterItem('BEK-B', 0), + CounterItem('H1-B', 0), + CounterItem('H2-B', 0), + CounterItem('', null), + CounterItem('', null), + ], + backgroundColor: Colors.grey.shade200, + ), + + // SST (Schnellbahn) + _buildCounterSection( + context, + title: 'SST', + counters: const [ + CounterItem('MEK-SST', 0), + CounterItem('BEK-SST', 0), + CounterItem('H1-SST', 0), + CounterItem('H2-SST', 0), + CounterItem('', null), + CounterItem('', null), + ], + backgroundColor: Colors.grey.shade200, + ), + + // CR (CityRail) + _buildCounterSection( + context, + title: 'CR', + counters: const [ + CounterItem('MEK-CR', 0), + CounterItem('BEK-CR', 0), + CounterItem('', null), + CounterItem('', null), + CounterItem('', null), + CounterItem('', null), + ], + backgroundColor: Colors.grey.shade200, + ), + + // Zuletzt gescannte Objekte + const Padding( + padding: EdgeInsets.all(16), + child: RecentScansList(), + ), + ], + ), + ), + ), + + // Scan Button + _buildScanButton(context), + ], + ), + ); + } + + Widget _buildHeader(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + color: const Color(0xFFA4D4F0), // Hellblau wie in Lua + child: Row( + children: [ + Container( + width: 80, + height: 80, + decoration: BoxDecoration( + color: Colors.white, + borderRadius: BorderRadius.circular(8), + ), + child: const Icon( + Icons.warehouse, + size: 48, + color: Colors.blue, + ), + ), + const SizedBox(width: 16), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + 'Lager Beladung', + style: Theme.of(context).textTheme.titleLarge?.copyWith( + fontWeight: FontWeight.bold, + ), + ), + Text( + widget.tour.locationName ?? 'Hauptlager', + style: Theme.of(context).textTheme.bodyMedium, + ), + ], + ), + ), + ], + ), + ); + } + + Widget _buildCounterSection( + BuildContext context, { + required String title, + required List counters, + required Color backgroundColor, + }) { + return Container( + margin: const EdgeInsets.symmetric(horizontal: 8, vertical: 4), + decoration: BoxDecoration( + color: backgroundColor, + borderRadius: BorderRadius.circular(8), + ), + child: Column( + children: [ + // Titel + Container( + width: double.infinity, + padding: const EdgeInsets.symmetric(vertical: 8), + child: Text( + title, + textAlign: TextAlign.center, + style: const TextStyle( + fontWeight: FontWeight.bold, + fontSize: 16, + ), + ), + ), + + // Zähler-Grid + Container( + padding: const EdgeInsets.all(8), + child: Row( + children: counters.map((counter) { + return Expanded( + child: Container( + margin: const EdgeInsets.symmetric(horizontal: 2), + padding: const EdgeInsets.symmetric(vertical: 8), + decoration: BoxDecoration( + color: counter.value == null ? Colors.transparent : Colors.white, + borderRadius: BorderRadius.circular(4), + ), + child: Column( + children: [ + Text( + counter.label, + style: TextStyle( + fontSize: 11, + fontWeight: FontWeight.w500, + color: counter.value == null ? Colors.transparent : Colors.black87, + ), + textAlign: TextAlign.center, + maxLines: 1, + overflow: TextOverflow.ellipsis, + ), + if (counter.value != null) ...[ + const SizedBox(height: 4), + Text( + '${counter.value}', + style: const TextStyle( + fontSize: 18, + fontWeight: FontWeight.bold, + ), + ), + ], + ], + ), + ), + ); + }).toList(), + ), + ), + ], + ), + ); + } + + Widget _buildScanButton(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + decoration: BoxDecoration( + color: Colors.white, + boxShadow: [ + BoxShadow( + color: Colors.black.withValues(alpha: 10), + blurRadius: 4, + offset: const Offset(0, -2), + ), + ], + ), + child: SafeArea( + child: ElevatedButton.icon( + onPressed: () => _openScanner(context), + icon: const Icon(Icons.qr_code_scanner), + label: const Text( + 'Barcode scannen', + style: TextStyle(fontSize: 16), + ), + style: ElevatedButton.styleFrom( + minimumSize: const Size(double.infinity, 56), + ), + ), + ), + ); + } + + void _openScanner(BuildContext context) { + Navigator.push( + context, + MaterialPageRoute( + builder: (_) => ScanPage(tour: widget.tour), + ), + ); + } +} + +/// Hilfsklasse für Zähler-Darstellung +class CounterItem { + final String label; + final int? value; + + const CounterItem(this.label, this.value); +} diff --git a/app/lib/presentation/pages/tour_types/veh_end_page.dart b/app/lib/presentation/pages/tour_types/veh_end_page.dart new file mode 100644 index 0000000..c80a277 --- /dev/null +++ b/app/lib/presentation/pages/tour_types/veh_end_page.dart @@ -0,0 +1,274 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_bloc/flutter_bloc.dart'; +import '../../../domain/entities/tour.dart'; +import '../../blocs/scan/scan_bloc.dart'; +import '../scan/scan_page.dart'; + +/// Veh End Page - Fahrzeug Rückgabe +/// Entspricht Lua: ShowVehEndScreen + CreateLoadingVehEndView +class VehEndPage extends StatefulWidget { + final Tour tour; + + const VehEndPage({ + super.key, + required this.tour, + }); + + @override + State createState() => _VehEndPageState(); +} + +class _VehEndPageState extends State { + @override + void initState() { + super.initState(); + context.read().add(InitializeScan(widget.tour)); + } + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text(widget.tour.locationName ?? 'Fahrzeugende'), + const Text( + 'Rückgabe', + style: TextStyle(fontSize: 14, color: Colors.white70), + ), + ], + ), + actions: [ + IconButton( + icon: const Icon(Icons.qr_code_scanner), + onPressed: () => _openScanner(context), + ), + ], + ), + body: Column( + children: [ + // Header + _buildHeader(context), + + // Rückgabe-Übersicht + Expanded( + child: SingleChildScrollView( + child: Column( + children: [ + _buildReturnInfo(context), + _buildObjectSummary(context), + ], + ), + ), + ), + + // Scan Button + _buildScanButton(context), + ], + ), + ); + } + + Widget _buildHeader(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + color: const Color(0xFFA4D4F0), + child: Row( + children: [ + Container( + width: 80, + height: 80, + decoration: BoxDecoration( + color: Colors.white, + borderRadius: BorderRadius.circular(8), + ), + child: const Icon( + Icons.local_shipping, + size: 48, + color: Colors.blue, + ), + ), + const SizedBox(width: 16), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + 'Fahrzeug Rückgabe', + style: Theme.of(context).textTheme.titleLarge?.copyWith( + fontWeight: FontWeight.bold, + ), + ), + Text( + widget.tour.locationName ?? 'Dienststelle', + style: Theme.of(context).textTheme.bodyMedium, + ), + ], + ), + ), + ], + ), + ); + } + + Widget _buildReturnInfo(BuildContext context) { + return Container( + margin: const EdgeInsets.all(16), + padding: const EdgeInsets.all(16), + decoration: BoxDecoration( + color: Colors.orange.shade50, + borderRadius: BorderRadius.circular(12), + border: Border.all(color: Colors.orange.shade200), + ), + child: const Column( + children: [ + Text( + 'Rückgabe-Status:', + style: TextStyle( + fontWeight: FontWeight.bold, + fontSize: 16, + ), + ), + SizedBox(height: 8), + Text( + 'Alle Objekte im Fahrzeug werden zurückgebucht:\n' + '• ret_fail_fzg → ret_fail_stk\n' + '• ret_ds_fzg → ret_ds_stk\n' + '• ret_gi_fzg → ret_gi_stk', + style: TextStyle(fontSize: 14), + ), + ], + ), + ); + } + + Widget _buildObjectSummary(BuildContext context) { + return Padding( + padding: const EdgeInsets.symmetric(horizontal: 16), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + const Text( + 'Objekte im Fahrzeug', + style: TextStyle( + fontSize: 16, + fontWeight: FontWeight.bold, + ), + ), + const SizedBox(height: 12), + + // Fehlkassetten + _buildObjectStatusCard( + context, + 'Fehlkassetten', + 'ret_fail_fzg → ret_fail_stk', + Icons.error, + Colors.red, + ), + + // DS-Objekte + _buildObjectStatusCard( + context, + 'Zur Dienststelle', + 'ret_ds_fzg → ret_ds_stk', + Icons.account_balance, + Colors.blue, + ), + + // GI-Objekte + _buildObjectStatusCard( + context, + 'Zum Geldinstitut', + 'ret_gi_fzg → ret_gi_stk', + Icons.account_balance_wallet, + Colors.green, + ), + + // Noch im Fahrzeug + _buildObjectStatusCard( + context, + 'Noch im Fahrzeug (Rest)', + 'delivery → ret_ds_stk', + Icons.local_shipping, + Colors.orange, + ), + ], + ), + ); + } + + Widget _buildObjectStatusCard( + BuildContext context, + String title, + String transition, + IconData icon, + Color color, + ) { + return Container( + margin: const EdgeInsets.only(bottom: 8), + padding: const EdgeInsets.all(12), + decoration: BoxDecoration( + color: Colors.grey.shade100, + borderRadius: BorderRadius.circular(8), + ), + child: Row( + children: [ + Container( + padding: const EdgeInsets.all(8), + decoration: BoxDecoration( + color: color.withValues(alpha: 26), + borderRadius: BorderRadius.circular(8), + ), + child: Icon(icon, color: color), + ), + const SizedBox(width: 12), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + title, + style: const TextStyle( + fontWeight: FontWeight.bold, + fontSize: 15, + ), + ), + Text( + transition, + style: TextStyle( + fontSize: 13, + color: Colors.grey.shade600, + ), + ), + ], + ), + ), + ], + ), + ); + } + + Widget _buildScanButton(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + child: ElevatedButton.icon( + onPressed: () => _openScanner(context), + icon: const Icon(Icons.qr_code_scanner), + label: const Text('Barcode scannen'), + style: ElevatedButton.styleFrom( + minimumSize: const Size(double.infinity, 56), + ), + ), + ); + } + + void _openScanner(BuildContext context) { + Navigator.push( + context, + MaterialPageRoute( + builder: (_) => ScanPage(tour: widget.tour), + ), + ); + } +} diff --git a/app/lib/presentation/pages/tour_types/veh_page.dart b/app/lib/presentation/pages/tour_types/veh_page.dart new file mode 100644 index 0000000..0e99420 --- /dev/null +++ b/app/lib/presentation/pages/tour_types/veh_page.dart @@ -0,0 +1,256 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_bloc/flutter_bloc.dart'; +import '../../../domain/entities/tour.dart'; +import '../../blocs/scan/scan_bloc.dart'; +import '../scan/scan_page.dart'; + +/// Veh Page - Station (Haltestelle) +/// Entspricht Lua: ShowVehScreen + CreateLoadingVehView +class VehPage extends StatefulWidget { + final Tour tour; + + const VehPage({ + super.key, + required this.tour, + }); + + @override + State createState() => _VehPageState(); +} + +class _VehPageState extends State { + @override + void initState() { + super.initState(); + context.read().add(InitializeScan(widget.tour)); + } + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text(widget.tour.locationName ?? 'Station'), + const Text( + 'Objekt-Wechsel', + style: TextStyle(fontSize: 14, color: Colors.white70), + ), + ], + ), + actions: [ + IconButton( + icon: const Icon(Icons.qr_code_scanner), + onPressed: () => _openScanner(context), + ), + ], + ), + body: Column( + children: [ + // Header mit Stations-Info + _buildHeader(context), + + // Zähler-Bereiche + Expanded( + child: SingleChildScrollView( + child: Column( + children: [ + // Wechselzähler (Leer/Voll) + _buildSwapCounters(context), + + // Abholzähler + _buildPickupCounters(context), + + const SizedBox(height: 16), + ], + ), + ), + ), + + // Scan Button + _buildScanButton(context), + ], + ), + ); + } + + Widget _buildHeader(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + color: const Color(0xFFA4D4F0), + child: Row( + children: [ + Container( + width: 80, + height: 80, + decoration: BoxDecoration( + color: Colors.white, + borderRadius: BorderRadius.circular(8), + ), + child: const Icon( + Icons.train, + size: 48, + color: Colors.blue, + ), + ), + const SizedBox(width: 16), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + widget.tour.locationName ?? 'Haltestelle', + style: Theme.of(context).textTheme.titleLarge?.copyWith( + fontWeight: FontWeight.bold, + ), + ), + if (widget.tour.remark != null) + Text( + widget.tour.remark!, + style: Theme.of(context).textTheme.bodyMedium?.copyWith( + color: Colors.black87, + ), + ), + ], + ), + ), + ], + ), + ); + } + + Widget _buildSwapCounters(BuildContext context) { + return Container( + margin: const EdgeInsets.all(8), + decoration: BoxDecoration( + color: Colors.grey.shade200, + borderRadius: BorderRadius.circular(8), + ), + child: Column( + children: [ + Container( + width: double.infinity, + padding: const EdgeInsets.symmetric(vertical: 8), + decoration: BoxDecoration( + color: Colors.blue.shade100, + borderRadius: const BorderRadius.vertical(top: Radius.circular(8)), + ), + child: const Text( + 'Wechselzähler', + textAlign: TextAlign.center, + style: TextStyle( + fontWeight: FontWeight.bold, + fontSize: 16, + ), + ), + ), + + // Leer/Voll/HADAG Reihen + _buildCounterRow('Leer', [0, 0, 0, 0, 0, 0]), + const Divider(height: 1), + _buildCounterRow('Voll', [0, 0, 0, 0, 0, 0]), + const Divider(height: 1), + _buildCounterRow('HADAG', [null, 0, 0, 0, null, null]), + ], + ), + ); + } + + Widget _buildPickupCounters(BuildContext context) { + return Container( + margin: const EdgeInsets.all(8), + decoration: BoxDecoration( + color: Colors.grey.shade200, + borderRadius: BorderRadius.circular(8), + ), + child: Column( + children: [ + Container( + width: double.infinity, + padding: const EdgeInsets.symmetric(vertical: 8), + decoration: BoxDecoration( + color: Colors.green.shade100, + borderRadius: const BorderRadius.vertical(top: Radius.circular(8)), + ), + child: const Text( + 'Abholzähler', + textAlign: TextAlign.center, + style: TextStyle( + fontWeight: FontWeight.bold, + fontSize: 16, + ), + ), + ), + + _buildCounterRow('Abholung', [0, 0, 0, 0, 0, 0]), + ], + ), + ); + } + + Widget _buildCounterRow(String label, List values) { + return Padding( + padding: const EdgeInsets.symmetric(vertical: 8), + child: Column( + children: [ + Text( + label, + style: const TextStyle( + fontSize: 12, + fontWeight: FontWeight.w500, + ), + ), + const SizedBox(height: 4), + Row( + children: values.map((value) { + return Expanded( + child: Container( + margin: const EdgeInsets.symmetric(horizontal: 2), + padding: const EdgeInsets.symmetric(vertical: 8), + decoration: BoxDecoration( + color: value == null ? Colors.transparent : Colors.white, + borderRadius: BorderRadius.circular(4), + ), + child: value != null + ? Text( + '$value', + textAlign: TextAlign.center, + style: const TextStyle( + fontSize: 16, + fontWeight: FontWeight.bold, + ), + ) + : null, + ), + ); + }).toList(), + ), + ], + ), + ); + } + + Widget _buildScanButton(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + child: ElevatedButton.icon( + onPressed: () => _openScanner(context), + icon: const Icon(Icons.qr_code_scanner), + label: const Text('Barcode scannen'), + style: ElevatedButton.styleFrom( + minimumSize: const Size(double.infinity, 56), + ), + ), + ); + } + + void _openScanner(BuildContext context) { + Navigator.push( + context, + MaterialPageRoute( + builder: (_) => ScanPage(tour: widget.tour), + ), + ); + } +} diff --git a/app/lib/presentation/pages/tour_types/veh_start_page.dart b/app/lib/presentation/pages/tour_types/veh_start_page.dart new file mode 100644 index 0000000..4987629 --- /dev/null +++ b/app/lib/presentation/pages/tour_types/veh_start_page.dart @@ -0,0 +1,233 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_bloc/flutter_bloc.dart'; +import '../../../domain/entities/tour.dart'; +import '../../blocs/scan/scan_bloc.dart'; +import '../scan/scan_page.dart'; + +/// Veh Start Page - Fahrzeug Beladung +/// Entspricht Lua: ShowVehStartScreen + CreateLoadingVehStartView +class VehStartPage extends StatefulWidget { + final Tour tour; + + const VehStartPage({ + super.key, + required this.tour, + }); + + @override + State createState() => _VehStartPageState(); +} + +class _VehStartPageState extends State { + @override + void initState() { + super.initState(); + context.read().add(InitializeScan(widget.tour)); + } + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text(widget.tour.locationName ?? 'Dienststelle'), + const Text( + 'Fahrzeug Beladung', + style: TextStyle(fontSize: 14, color: Colors.white70), + ), + ], + ), + actions: [ + IconButton( + icon: const Icon(Icons.qr_code_scanner), + onPressed: () => _openScanner(context), + ), + ], + ), + body: Column( + children: [ + // Header + _buildHeader(context), + + // Beladezähler (wie in Lua CreateLoadingVehStartView) + Expanded( + child: SingleChildScrollView( + child: Column( + children: [ + _buildCounterSection( + context, + title: 'Beladezähler', + counters: const [ + CounterItem('MEK', 0), + CounterItem('BEK', 0), + CounterItem('H1', 0), + CounterItem('H2', 0), + CounterItem('H3', 0), + CounterItem('P', 0), + ], + ), + + // Zuletzt gescannt + const Padding( + padding: EdgeInsets.all(16), + child: Text( + 'Scanne Objekte zum Beladen', + style: TextStyle( + color: Colors.grey, + fontStyle: FontStyle.italic, + ), + ), + ), + ], + ), + ), + ), + + // Scan Button + _buildScanButton(context), + ], + ), + ); + } + + Widget _buildHeader(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + color: const Color(0xFFA4D4F0), + child: Row( + children: [ + Container( + width: 80, + height: 80, + decoration: BoxDecoration( + color: Colors.white, + borderRadius: BorderRadius.circular(8), + ), + child: const Icon( + Icons.local_shipping, + size: 48, + color: Colors.blue, + ), + ), + const SizedBox(width: 16), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + 'Fahrzeug Beladung', + style: Theme.of(context).textTheme.titleLarge?.copyWith( + fontWeight: FontWeight.bold, + ), + ), + Text( + widget.tour.locationName ?? 'Dienststelle', + style: Theme.of(context).textTheme.bodyMedium, + ), + ], + ), + ), + ], + ), + ); + } + + Widget _buildCounterSection( + BuildContext context, { + required String title, + required List counters, + }) { + return Container( + margin: const EdgeInsets.all(8), + decoration: BoxDecoration( + color: Colors.grey.shade200, + borderRadius: BorderRadius.circular(8), + ), + child: Column( + children: [ + Container( + width: double.infinity, + padding: const EdgeInsets.symmetric(vertical: 8), + child: Text( + title, + textAlign: TextAlign.center, + style: const TextStyle( + fontWeight: FontWeight.bold, + fontSize: 16, + ), + ), + ), + Container( + padding: const EdgeInsets.all(8), + child: Row( + children: counters.map((counter) { + return Expanded( + child: Container( + margin: const EdgeInsets.symmetric(horizontal: 2), + padding: const EdgeInsets.symmetric(vertical: 8), + decoration: BoxDecoration( + color: Colors.white, + borderRadius: BorderRadius.circular(4), + ), + child: Column( + children: [ + Text( + counter.label, + style: const TextStyle( + fontSize: 11, + fontWeight: FontWeight.w500, + ), + textAlign: TextAlign.center, + ), + const SizedBox(height: 4), + Text( + '${counter.value}', + style: const TextStyle( + fontSize: 18, + fontWeight: FontWeight.bold, + ), + ), + ], + ), + ), + ); + }).toList(), + ), + ), + ], + ), + ); + } + + Widget _buildScanButton(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + child: ElevatedButton.icon( + onPressed: () => _openScanner(context), + icon: const Icon(Icons.qr_code_scanner), + label: const Text('Barcode scannen'), + style: ElevatedButton.styleFrom( + minimumSize: const Size(double.infinity, 56), + ), + ), + ); + } + + void _openScanner(BuildContext context) { + Navigator.push( + context, + MaterialPageRoute( + builder: (_) => ScanPage(tour: widget.tour), + ), + ); + } +} + +class CounterItem { + final String label; + final int value; + + const CounterItem(this.label, this.value); +} diff --git a/app/lib/presentation/pages/tour_types/vs_page.dart b/app/lib/presentation/pages/tour_types/vs_page.dart new file mode 100644 index 0000000..298af9f --- /dev/null +++ b/app/lib/presentation/pages/tour_types/vs_page.dart @@ -0,0 +1,309 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_bloc/flutter_bloc.dart'; +import '../../../domain/entities/tour.dart'; +import '../../blocs/scan/scan_bloc.dart'; +import '../scan/scan_page.dart'; + +/// VS Page - Verwahrungsstelle +/// Entspricht Lua: ShowVsScreen + CreateLoadingVsView +/// Spezial: Container-Handling für SB (Safebag) und ABS (Abfallbehälter) +class VsPage extends StatefulWidget { + final Tour tour; + + const VsPage({ + super.key, + required this.tour, + }); + + @override + State createState() => _VsPageState(); +} + +class _VsPageState extends State { + String? selectedContainerId; + String? selectedContainerType; // 'a' = GI, 'b' = DS + + @override + void initState() { + super.initState(); + context.read().add(InitializeScan(widget.tour)); + } + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text(widget.tour.locationName ?? 'Verwahrungsstelle'), + const Text( + 'Container-Annahme', + style: TextStyle(fontSize: 14, color: Colors.white70), + ), + ], + ), + actions: [ + IconButton( + icon: const Icon(Icons.qr_code_scanner), + onPressed: () => _openScanner(context), + ), + ], + ), + body: Column( + children: [ + // Header + _buildHeader(context), + + // Container-Auswahl + _buildContainerSelection(context), + + // Aktueller Container Status + if (selectedContainerId != null) + _buildContainerStatus(context), + + const Spacer(), + + // Scan Button + _buildScanButton(context), + ], + ), + ); + } + + Widget _buildHeader(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + color: const Color(0xFFA4D4F0), + child: Row( + children: [ + Container( + width: 80, + height: 80, + decoration: BoxDecoration( + color: Colors.white, + borderRadius: BorderRadius.circular(8), + ), + child: const Icon( + Icons.inventory_2, + size: 48, + color: Colors.blue, + ), + ), + const SizedBox(width: 16), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + 'Verwahrungsstelle', + style: Theme.of(context).textTheme.titleLarge?.copyWith( + fontWeight: FontWeight.bold, + ), + ), + Text( + widget.tour.locationName ?? 'VS', + style: Theme.of(context).textTheme.bodyMedium, + ), + ], + ), + ), + ], + ), + ); + } + + Widget _buildContainerSelection(BuildContext context) { + return Container( + margin: const EdgeInsets.all(16), + padding: const EdgeInsets.all(16), + decoration: BoxDecoration( + color: Colors.grey.shade100, + borderRadius: BorderRadius.circular(12), + border: Border.all(color: Colors.grey.shade300), + ), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + const Text( + 'Container auswählen', + style: TextStyle( + fontSize: 16, + fontWeight: FontWeight.bold, + ), + ), + const SizedBox(height: 12), + + // Container A - Geldinstitut + _buildContainerOption( + context, + id: 'CONT_A', + type: 'a', + title: 'Container A', + subtitle: 'Für Geldinstitut (GI)', + icon: Icons.account_balance, + color: Colors.blue, + ), + + const SizedBox(height: 8), + + // Container B - Dienststelle + _buildContainerOption( + context, + id: 'CONT_B', + type: 'b', + title: 'Container B', + subtitle: 'Für Dienststelle (DS)', + icon: Icons.business, + color: Colors.orange, + ), + ], + ), + ); + } + + Widget _buildContainerOption( + BuildContext context, { + required String id, + required String type, + required String title, + required String subtitle, + required IconData icon, + required Color color, + }) { + final isSelected = selectedContainerId == id; + + return InkWell( + onTap: () { + setState(() { + selectedContainerId = id; + selectedContainerType = type; + }); + }, + child: Container( + padding: const EdgeInsets.all(12), + decoration: BoxDecoration( + color: isSelected ? color.withValues(alpha: 20) : Colors.white, + borderRadius: BorderRadius.circular(8), + border: Border.all( + color: isSelected ? color : Colors.grey.shade300, + width: isSelected ? 2 : 1, + ), + ), + child: Row( + children: [ + Container( + padding: const EdgeInsets.all(8), + decoration: BoxDecoration( + color: color.withValues(alpha: 26), + borderRadius: BorderRadius.circular(8), + ), + child: Icon(icon, color: color), + ), + const SizedBox(width: 12), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + title, + style: const TextStyle( + fontWeight: FontWeight.bold, + fontSize: 15, + ), + ), + Text( + subtitle, + style: TextStyle( + fontSize: 13, + color: Colors.grey.shade600, + ), + ), + ], + ), + ), + if (isSelected) + Icon(Icons.check_circle, color: color), + ], + ), + ), + ); + } + + Widget _buildContainerStatus(BuildContext context) { + return Container( + margin: const EdgeInsets.symmetric(horizontal: 16), + padding: const EdgeInsets.all(16), + decoration: BoxDecoration( + color: selectedContainerType == 'a' + ? Colors.blue.shade50 + : Colors.orange.shade50, + borderRadius: BorderRadius.circular(12), + border: Border.all( + color: selectedContainerType == 'a' + ? Colors.blue + : Colors.orange, + ), + ), + child: Column( + children: [ + Text( + 'Ausgewählt: ${selectedContainerType == 'a' ? 'Container A (GI)' : 'Container B (DS)'}', + style: TextStyle( + fontWeight: FontWeight.bold, + color: selectedContainerType == 'a' + ? Colors.blue + : Colors.orange, + ), + ), + const SizedBox(height: 8), + const Text( + 'Scannen Sie jetzt SB (Safebag) oder ABS (Abfallbehälter)', + textAlign: TextAlign.center, + style: TextStyle(fontSize: 13), + ), + ], + ), + ); + } + + Widget _buildScanButton(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + child: Column( + children: [ + if (selectedContainerId == null) + const Padding( + padding: EdgeInsets.only(bottom: 8), + child: Text( + 'Bitte zuerst einen Container auswählen', + style: TextStyle( + color: Colors.orange, + fontSize: 13, + ), + ), + ), + ElevatedButton.icon( + onPressed: selectedContainerId != null + ? () => _openScanner(context) + : null, + icon: const Icon(Icons.qr_code_scanner), + label: const Text('Barcode scannen'), + style: ElevatedButton.styleFrom( + minimumSize: const Size(double.infinity, 56), + ), + ), + ], + ), + ); + } + + void _openScanner(BuildContext context) { + Navigator.push( + context, + MaterialPageRoute( + builder: (_) => ScanPage(tour: widget.tour), + ), + ); + } +} diff --git a/app/lib/presentation/pages/tours/dashboard_page.dart b/app/lib/presentation/pages/tours/dashboard_page.dart new file mode 100644 index 0000000..9c19635 --- /dev/null +++ b/app/lib/presentation/pages/tours/dashboard_page.dart @@ -0,0 +1,423 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_bloc/flutter_bloc.dart'; +import '../../blocs/tour/tour_bloc.dart'; +import '../../widgets/loading_indicator.dart'; + +class DashboardPage extends StatelessWidget { + const DashboardPage({super.key}); + + @override + Widget build(BuildContext context) { + final theme = Theme.of(context); + + return Scaffold( + body: SafeArea( + child: BlocBuilder( + builder: (context, state) { + if (state is TourLoading) { + return const LoadingIndicator(); + } + + if (state is ToursLoaded) { + return CustomScrollView( + slivers: [ + // App Bar + SliverToBoxAdapter( + child: Padding( + padding: const EdgeInsets.all(24), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Row( + mainAxisAlignment: MainAxisAlignment.spaceBetween, + children: [ + Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + 'Guten Morgen,', + style: theme.textTheme.bodyLarge?.copyWith( + color: Colors.grey.shade600, + ), + ), + const SizedBox(height: 4), + Text( + 'Fahrer', + style: theme.textTheme.headlineMedium?.copyWith( + fontWeight: FontWeight.bold, + ), + ), + ], + ), + Container( + padding: const EdgeInsets.all(12), + decoration: BoxDecoration( + color: theme.colorScheme.primary.withValues(alpha: 26), + borderRadius: BorderRadius.circular(16), + ), + child: Icon( + Icons.person, + color: theme.colorScheme.primary, + ), + ), + ], + ), + const SizedBox(height: 8), + Text( + 'Tour vom ${DateTime.now().day}.${DateTime.now().month}.${DateTime.now().year}', + style: theme.textTheme.bodyMedium?.copyWith( + color: Colors.grey.shade600, + ), + ), + ], + ), + ), + ), + + // Quick Stats + SliverToBoxAdapter( + child: _buildQuickStats(context, state), + ), + + // Section Title + SliverToBoxAdapter( + child: Padding( + padding: const EdgeInsets.fromLTRB(24, 32, 24, 16), + child: Row( + mainAxisAlignment: MainAxisAlignment.spaceBetween, + children: [ + Text( + 'Schnellzugriff', + style: theme.textTheme.titleLarge?.copyWith( + fontWeight: FontWeight.w600, + ), + ), + TextButton( + onPressed: () { + // Navigate to full tours list + }, + child: const Text('Alle anzeigen'), + ), + ], + ), + ), + ), + + // Quick Actions Grid + SliverPadding( + padding: const EdgeInsets.symmetric(horizontal: 24), + sliver: SliverGrid.count( + crossAxisCount: 2, + mainAxisSpacing: 16, + crossAxisSpacing: 16, + children: [ + _buildQuickActionCard( + context, + 'Nächste Station', + Icons.location_on, + Colors.orange, + '${state.tours.where((t) => t.state == 0).length} offen', + () {}, + ), + _buildQuickActionCard( + context, + 'Scan', + Icons.qr_code_scanner, + Colors.green, + 'Barcode scannen', + () {}, + ), + _buildQuickActionCard( + context, + 'Bestand', + Icons.warehouse, + Colors.blue, + 'Objekte anzeigen', + () {}, + ), + _buildQuickActionCard( + context, + 'Sync', + Icons.sync, + Colors.purple, + state.isSyncing ? 'Synchronisiert...' : 'Daten aktualisieren', + () { + context.read().add(const SyncData()); + }, + ), + ], + ), + ), + + // Recent Activity + SliverToBoxAdapter( + child: Padding( + padding: const EdgeInsets.fromLTRB(24, 32, 24, 16), + child: Text( + 'Letzte Aktivitäten', + style: theme.textTheme.titleLarge?.copyWith( + fontWeight: FontWeight.w600, + ), + ), + ), + ), + + SliverPadding( + padding: const EdgeInsets.symmetric(horizontal: 24), + sliver: SliverList( + delegate: SliverChildBuilderDelegate( + (context, index) { + return _buildActivityItem( + context, + 'Geldkassette gescannt', + 'Station: Hauptbahnhof Nord', + '10:23 Uhr', + Icons.qr_code_scanner, + Colors.green, + ); + }, + childCount: 3, + ), + ), + ), + + const SliverPadding(padding: EdgeInsets.only(bottom: 100)), + ], + ); + } + + return const Center(child: Text('Willkommen bei HHA Logistics')); + }, + ), + ), + ); + } + + Widget _buildQuickStats(BuildContext context, ToursLoaded state) { + final theme = Theme.of(context); + final completionPercentage = state.completionPercentage; + + return Container( + margin: const EdgeInsets.symmetric(horizontal: 24), + padding: const EdgeInsets.all(24), + decoration: BoxDecoration( + gradient: LinearGradient( + colors: [ + theme.colorScheme.primary, + theme.colorScheme.primary.withValues(alpha: 204), + ], + begin: Alignment.topLeft, + end: Alignment.bottomRight, + ), + borderRadius: BorderRadius.circular(24), + boxShadow: [ + BoxShadow( + color: theme.colorScheme.primary.withValues(alpha: 77), + blurRadius: 20, + offset: const Offset(0, 8), + ), + ], + ), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Row( + children: [ + Container( + padding: const EdgeInsets.all(12), + decoration: BoxDecoration( + color: Colors.white.withValues(alpha: 51), + borderRadius: BorderRadius.circular(12), + ), + child: const Icon( + Icons.route, + color: Colors.white, + size: 24, + ), + ), + const SizedBox(width: 16), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + 'Tour-Fortschritt', + style: theme.textTheme.titleSmall?.copyWith( + color: Colors.white.withValues(alpha: 204), + ), + ), + const SizedBox(height: 4), + Text( + '${state.completedCount} / ${state.totalCount} Stationen', + style: theme.textTheme.titleLarge?.copyWith( + color: Colors.white, + fontWeight: FontWeight.bold, + ), + ), + ], + ), + ), + ], + ), + const SizedBox(height: 24), + ClipRRect( + borderRadius: BorderRadius.circular(8), + child: LinearProgressIndicator( + value: completionPercentage / 100, + backgroundColor: Colors.white.withValues(alpha: 51), + valueColor: const AlwaysStoppedAnimation(Colors.white), + minHeight: 10, + ), + ), + const SizedBox(height: 16), + Row( + mainAxisAlignment: MainAxisAlignment.spaceBetween, + children: [ + Text( + '${completionPercentage.toStringAsFixed(0)}% abgeschlossen', + style: theme.textTheme.bodyMedium?.copyWith( + color: Colors.white.withValues(alpha: 230), + ), + ), + if (state.isSyncing) + Row( + children: [ + SizedBox( + width: 14, + height: 14, + child: CircularProgressIndicator( + strokeWidth: 2, + valueColor: AlwaysStoppedAnimation( + Colors.white.withValues(alpha: 204), + ), + ), + ), + const SizedBox(width: 8), + Text( + 'Sync...', + style: theme.textTheme.bodyMedium?.copyWith( + color: Colors.white.withValues(alpha: 230), + ), + ), + ], + ), + ], + ), + ], + ), + ); + } + + Widget _buildQuickActionCard( + BuildContext context, + String title, + IconData icon, + Color color, + String subtitle, + VoidCallback onTap, + ) { + final theme = Theme.of(context); + + return Card( + elevation: 0, + shape: RoundedRectangleBorder( + borderRadius: BorderRadius.circular(20), + side: BorderSide(color: Colors.grey.shade200), + ), + child: InkWell( + onTap: onTap, + borderRadius: BorderRadius.circular(20), + child: Padding( + padding: const EdgeInsets.all(20), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + mainAxisAlignment: MainAxisAlignment.center, + children: [ + Container( + padding: const EdgeInsets.all(12), + decoration: BoxDecoration( + color: color.withValues(alpha: 26), + borderRadius: BorderRadius.circular(14), + ), + child: Icon( + icon, + color: color, + size: 28, + ), + ), + const SizedBox(height: 16), + Text( + title, + style: theme.textTheme.titleMedium?.copyWith( + fontWeight: FontWeight.w600, + ), + ), + const SizedBox(height: 4), + Text( + subtitle, + style: theme.textTheme.bodySmall?.copyWith( + color: Colors.grey.shade600, + ), + ), + ], + ), + ), + ), + ); + } + + Widget _buildActivityItem( + BuildContext context, + String title, + String subtitle, + String time, + IconData icon, + Color color, + ) { + final theme = Theme.of(context); + + return Padding( + padding: const EdgeInsets.only(bottom: 12), + child: Card( + elevation: 0, + shape: RoundedRectangleBorder( + borderRadius: BorderRadius.circular(16), + side: BorderSide(color: Colors.grey.shade200), + ), + child: ListTile( + contentPadding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8), + leading: Container( + padding: const EdgeInsets.all(10), + decoration: BoxDecoration( + color: color.withValues(alpha: 26), + borderRadius: BorderRadius.circular(12), + ), + child: Icon( + icon, + color: color, + size: 22, + ), + ), + title: Text( + title, + style: theme.textTheme.bodyMedium?.copyWith( + fontWeight: FontWeight.w600, + ), + ), + subtitle: Text( + subtitle, + style: theme.textTheme.bodySmall?.copyWith( + color: Colors.grey.shade600, + ), + ), + trailing: Text( + time, + style: theme.textTheme.bodySmall?.copyWith( + color: Colors.grey.shade500, + ), + ), + ), + ), + ); + } +} diff --git a/app/lib/presentation/pages/tours/tours_page.dart b/app/lib/presentation/pages/tours/tours_page.dart new file mode 100644 index 0000000..b67fb5c --- /dev/null +++ b/app/lib/presentation/pages/tours/tours_page.dart @@ -0,0 +1,327 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_bloc/flutter_bloc.dart'; +import '../../../domain/entities/tour.dart'; +import '../../../core/constants/app_constants.dart'; +import '../../blocs/tour/tour_bloc.dart'; +import '../../widgets/tour_list_item.dart'; +import '../../widgets/loading_indicator.dart'; +import '../../widgets/error_view.dart'; +import '../tour_types/stock_start_page.dart'; +import '../tour_types/veh_start_page.dart'; +import '../tour_types/veh_page.dart'; +import '../tour_types/fsa_page.dart'; +import '../tour_types/vs_page.dart'; +import '../tour_types/gi_page.dart'; +import '../tour_types/veh_end_page.dart'; +import '../tour_types/stock_end_page.dart'; +import '../scan/scan_page.dart'; + +class ToursPage extends StatelessWidget { + const ToursPage({super.key}); + + @override + Widget build(BuildContext context) { + return Scaffold( + body: BlocBuilder( + builder: (context, state) { + if (state is TourLoading) { + return const LoadingIndicator(message: 'Touren werden geladen...'); + } + + if (state is TourError) { + return ErrorView( + message: state.message, + onRetry: () => context.read().add(const RefreshTours()), + ); + } + + if (state is ToursLoaded) { + return _ToursListView(state: state); + } + + return const LoadingIndicator(); + }, + ), + ); + } +} + +class _ToursListView extends StatelessWidget { + final ToursLoaded state; + + const _ToursListView({required this.state}); + + @override + Widget build(BuildContext context) { + final theme = Theme.of(context); + + return CustomScrollView( + slivers: [ + // Header mit Fortschritt + SliverToBoxAdapter( + child: _buildHeader(context), + ), + + // Offene Touren + SliverToBoxAdapter( + child: Padding( + padding: const EdgeInsets.fromLTRB(16, 16, 16, 8), + child: Row( + children: [ + Icon( + Icons.location_on, + color: theme.colorScheme.primary, + size: 20, + ), + const SizedBox(width: 8), + Text( + 'Offene Stationen', + style: theme.textTheme.titleMedium?.copyWith( + fontWeight: FontWeight.w600, + ), + ), + const Spacer(), + Container( + padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 4), + decoration: BoxDecoration( + color: theme.colorScheme.primary.withValues(alpha: 26), + borderRadius: BorderRadius.circular(12), + ), + child: Text( + '${state.tours.length}', + style: theme.textTheme.labelMedium?.copyWith( + color: theme.colorScheme.primary, + fontWeight: FontWeight.w600, + ), + ), + ), + ], + ), + ), + ), + + SliverList( + delegate: SliverChildBuilderDelegate( + (context, index) { + final tour = state.tours[index]; + return TourListItem( + tour: tour, + onTap: () => _onTourSelected(context, tour), + ); + }, + childCount: state.tours.length, + ), + ), + + // Erledigte Touren (falls aktiviert) + if (state.showCompleted && state.completedTours.isNotEmpty) ...[ + SliverToBoxAdapter( + child: Padding( + padding: const EdgeInsets.fromLTRB(16, 24, 16, 8), + child: Row( + children: [ + const Icon( + Icons.check_circle, + color: Colors.green, + size: 20, + ), + const SizedBox(width: 8), + Text( + 'Erledigte Stationen', + style: theme.textTheme.titleMedium?.copyWith( + fontWeight: FontWeight.w600, + ), + ), + const Spacer(), + Container( + padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 4), + decoration: BoxDecoration( + color: Colors.green.withValues(alpha: 26), + borderRadius: BorderRadius.circular(12), + ), + child: Text( + '${state.completedTours.length}', + style: theme.textTheme.labelMedium?.copyWith( + color: Colors.green, + fontWeight: FontWeight.w600, + ), + ), + ), + ], + ), + ), + ), + SliverList( + delegate: SliverChildBuilderDelegate( + (context, index) { + final tour = state.completedTours[index]; + return TourListItem( + tour: tour, + onTap: () => _onTourSelected(context, tour), + isCompleted: true, + ); + }, + childCount: state.completedTours.length, + ), + ), + ], + + const SliverPadding(padding: EdgeInsets.only(bottom: 100)), + ], + ); + } + + Widget _buildHeader(BuildContext context) { + final theme = Theme.of(context); + final completionPercentage = state.completionPercentage; + + return Container( + margin: const EdgeInsets.all(16), + padding: const EdgeInsets.all(20), + decoration: BoxDecoration( + gradient: LinearGradient( + colors: [ + theme.colorScheme.primary, + theme.colorScheme.primary.withValues(alpha: 204), + ], + begin: Alignment.topLeft, + end: Alignment.bottomRight, + ), + borderRadius: BorderRadius.circular(20), + boxShadow: [ + BoxShadow( + color: theme.colorScheme.primary.withValues(alpha: 77), + blurRadius: 20, + offset: const Offset(0, 8), + ), + ], + ), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Row( + children: [ + Container( + padding: const EdgeInsets.all(12), + decoration: BoxDecoration( + color: Colors.white.withValues(alpha: 51), + borderRadius: BorderRadius.circular(12), + ), + child: const Icon( + Icons.route, + color: Colors.white, + size: 24, + ), + ), + const SizedBox(width: 16), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + 'Tagesübersicht', + style: theme.textTheme.titleSmall?.copyWith( + color: Colors.white.withValues(alpha: 204), + ), + ), + const SizedBox(height: 4), + Text( + '${state.completedCount} / ${state.totalCount} Stationen', + style: theme.textTheme.titleLarge?.copyWith( + color: Colors.white, + fontWeight: FontWeight.bold, + ), + ), + ], + ), + ), + ], + ), + const SizedBox(height: 20), + ClipRRect( + borderRadius: BorderRadius.circular(8), + child: LinearProgressIndicator( + value: completionPercentage / 100, + backgroundColor: Colors.white.withValues(alpha: 51), + valueColor: const AlwaysStoppedAnimation(Colors.white), + minHeight: 8, + ), + ), + const SizedBox(height: 12), + Row( + mainAxisAlignment: MainAxisAlignment.spaceBetween, + children: [ + Text( + '${completionPercentage.toStringAsFixed(0)}% abgeschlossen', + style: theme.textTheme.bodySmall?.copyWith( + color: Colors.white.withValues(alpha: 230), + ), + ), + if (state.isSyncing) + Row( + children: [ + SizedBox( + width: 12, + height: 12, + child: CircularProgressIndicator( + strokeWidth: 2, + valueColor: AlwaysStoppedAnimation( + Colors.white.withValues(alpha: 204), + ), + ), + ), + const SizedBox(width: 6), + Text( + 'Sync...', + style: theme.textTheme.bodySmall?.copyWith( + color: Colors.white.withValues(alpha: 230), + ), + ), + ], + ), + ], + ), + ], + ), + ); + } + + void _onTourSelected(BuildContext context, Tour tour) { + context.read().add(SelectTour(tour)); + + // Navigation zur tour-spezifischen Page + final page = _getPageForTourType(tour); + + Navigator.push( + context, + MaterialPageRoute(builder: (_) => page), + ); + } + + Widget _getPageForTourType(Tour tour) { + switch (tour.type) { + case TourTypes.stockStart: + return StockStartPage(tour: tour); + case TourTypes.vehStart: + return VehStartPage(tour: tour); + case TourTypes.veh: + return VehPage(tour: tour); + case TourTypes.fsa: + return FsaPage(tour: tour); + case TourTypes.vs: + return VsPage(tour: tour); + case TourTypes.gi: + return GiPage(tour: tour); + case TourTypes.vehEnd: + return VehEndPage(tour: tour); + case TourTypes.stockEnd: + return StockEndPage(tour: tour); + case TourTypes.stock: + // Stock (HADAG) uses similar UI to stock_start + return StockStartPage(tour: tour); + default: + // Fallback to generic scan page for unknown types + return ScanPage(tour: tour); + } + } +} diff --git a/app/lib/presentation/widgets/counter_grid.dart b/app/lib/presentation/widgets/counter_grid.dart new file mode 100644 index 0000000..0dafc07 --- /dev/null +++ b/app/lib/presentation/widgets/counter_grid.dart @@ -0,0 +1,186 @@ +import 'package:flutter/material.dart'; +import '../../domain/entities/counter.dart'; + +/// Zähler-Grid wie in Lua CreateLoadingStockStartView etc. +class CounterGrid extends StatelessWidget { + final List groups; + final bool showDifferences; + + const CounterGrid({ + super.key, + required this.groups, + this.showDifferences = false, + }); + + @override + Widget build(BuildContext context) { + return Column( + children: groups.map((group) => _buildGroup(context, group)).toList(), + ); + } + + Widget _buildGroup(BuildContext context, CounterGroup group) { + return Container( + margin: const EdgeInsets.symmetric(horizontal: 8, vertical: 4), + decoration: BoxDecoration( + color: _getGroupColor(group.title), + borderRadius: BorderRadius.circular(8), + ), + child: Column( + children: [ + // Titel + Container( + width: double.infinity, + padding: const EdgeInsets.symmetric(vertical: 8), + child: Text( + group.title, + textAlign: TextAlign.center, + style: const TextStyle( + fontWeight: FontWeight.bold, + fontSize: 16, + ), + ), + ), + + // Zähler + Container( + padding: const EdgeInsets.all(8), + child: Row( + children: group.counters.map((counter) { + return Expanded( + child: _buildCounterCell(context, counter), + ); + }).toList(), + ), + ), + ], + ), + ); + } + + Widget _buildCounterCell(BuildContext context, ObjectCounter counter) { + final color = counter.isOver + ? Colors.red.shade100 + : counter.isComplete + ? Colors.green.shade100 + : Colors.white; + + return Container( + margin: const EdgeInsets.symmetric(horizontal: 2), + padding: const EdgeInsets.symmetric(vertical: 8), + decoration: BoxDecoration( + color: color, + borderRadius: BorderRadius.circular(4), + ), + child: Column( + children: [ + Text( + counter.label, + style: const TextStyle( + fontSize: 11, + fontWeight: FontWeight.w500, + ), + textAlign: TextAlign.center, + maxLines: 1, + overflow: TextOverflow.ellipsis, + ), + const SizedBox(height: 4), + Text( + '${counter.currentCount}', + style: TextStyle( + fontSize: 18, + fontWeight: FontWeight.bold, + color: counter.isOver ? Colors.red : Colors.black87, + ), + ), + if (showDifferences && counter.targetCount > 0) ...[ + const SizedBox(height: 2), + Text( + '${counter.difference > 0 ? "+" : ""}${counter.difference}', + style: TextStyle( + fontSize: 12, + color: counter.difference == 0 + ? Colors.green + : counter.difference > 0 + ? Colors.orange + : Colors.red, + ), + ), + ], + ], + ), + ); + } + + Color _getGroupColor(String title) { + switch (title.toLowerCase()) { + case 'bestand fzg': + return const Color(0xFFA4D4F0); // Hellblau wie in Lua + case 'beladezähler': + case 'hadag': + case 'sst': + case 'cr': + return Colors.grey.shade200; + default: + return Colors.grey.shade200; + } + } +} + +/// Vereinfachte Zähler-Anzeige für eine Zeile +class CounterRow extends StatelessWidget { + final String label; + final int count; + final Color? backgroundColor; + final VoidCallback? onTap; + + const CounterRow({ + super.key, + required this.label, + required this.count, + this.backgroundColor, + this.onTap, + }); + + @override + Widget build(BuildContext context) { + return InkWell( + onTap: onTap, + child: Container( + padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12), + decoration: BoxDecoration( + color: backgroundColor ?? Colors.grey.shade100, + borderRadius: BorderRadius.circular(8), + ), + child: Row( + children: [ + Expanded( + child: Text( + label, + style: const TextStyle( + fontSize: 16, + fontWeight: FontWeight.w500, + ), + ), + ), + Container( + padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8), + decoration: BoxDecoration( + color: Colors.white, + borderRadius: BorderRadius.circular(20), + border: Border.all(color: Colors.grey.shade300), + ), + child: Text( + '$count', + style: const TextStyle( + fontSize: 18, + fontWeight: FontWeight.bold, + ), + ), + ), + ], + ), + ), + ); + } +} diff --git a/app/lib/presentation/widgets/error_view.dart b/app/lib/presentation/widgets/error_view.dart new file mode 100644 index 0000000..6f4e652 --- /dev/null +++ b/app/lib/presentation/widgets/error_view.dart @@ -0,0 +1,141 @@ +import 'package:flutter/material.dart'; + +class ErrorView extends StatelessWidget { + final String message; + final VoidCallback? onRetry; + final String? retryText; + final IconData? icon; + + const ErrorView({ + super.key, + required this.message, + this.onRetry, + this.retryText, + this.icon, + }); + + @override + Widget build(BuildContext context) { + final theme = Theme.of(context); + + return Center( + child: Padding( + padding: const EdgeInsets.all(32), + child: Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + Container( + width: 100, + height: 100, + decoration: BoxDecoration( + color: theme.colorScheme.error.withValues(alpha: 26), + shape: BoxShape.circle, + ), + child: Icon( + icon ?? Icons.error_outline, + size: 48, + color: theme.colorScheme.error, + ), + ), + const SizedBox(height: 24), + Text( + 'Oops!', + style: theme.textTheme.headlineMedium?.copyWith( + fontWeight: FontWeight.bold, + color: theme.colorScheme.onSurface, + ), + ), + const SizedBox(height: 12), + Text( + message, + style: theme.textTheme.bodyMedium?.copyWith( + color: theme.colorScheme.onSurface.withValues(alpha: 179), + ), + textAlign: TextAlign.center, + ), + if (onRetry != null) ...[ + const SizedBox(height: 32), + ElevatedButton.icon( + onPressed: onRetry, + icon: const Icon(Icons.refresh), + label: Text(retryText ?? 'Erneut versuchen'), + ), + ], + ], + ), + ), + ); + } +} + +class EmptyStateView extends StatelessWidget { + final String title; + final String? subtitle; + final IconData icon; + final VoidCallback? onAction; + final String? actionText; + + const EmptyStateView({ + super.key, + required this.title, + this.subtitle, + this.icon = Icons.inbox, + this.onAction, + this.actionText, + }); + + @override + Widget build(BuildContext context) { + final theme = Theme.of(context); + + return Center( + child: Padding( + padding: const EdgeInsets.all(32), + child: Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + Container( + width: 100, + height: 100, + decoration: BoxDecoration( + color: Colors.grey.shade200, + shape: BoxShape.circle, + ), + child: Icon( + icon, + size: 48, + color: Colors.grey.shade500, + ), + ), + const SizedBox(height: 24), + Text( + title, + style: theme.textTheme.titleLarge?.copyWith( + fontWeight: FontWeight.w600, + color: theme.colorScheme.onSurface, + ), + textAlign: TextAlign.center, + ), + if (subtitle != null) ...[ + const SizedBox(height: 8), + Text( + subtitle!, + style: theme.textTheme.bodyMedium?.copyWith( + color: theme.colorScheme.onSurface.withValues(alpha: 153), + ), + textAlign: TextAlign.center, + ), + ], + if (onAction != null && actionText != null) ...[ + const SizedBox(height: 24), + ElevatedButton( + onPressed: onAction, + child: Text(actionText!), + ), + ], + ], + ), + ), + ); + } +} diff --git a/app/lib/presentation/widgets/loading_indicator.dart b/app/lib/presentation/widgets/loading_indicator.dart new file mode 100644 index 0000000..f95cdc4 --- /dev/null +++ b/app/lib/presentation/widgets/loading_indicator.dart @@ -0,0 +1,134 @@ +import 'package:flutter/material.dart'; + +class LoadingIndicator extends StatelessWidget { + final String? message; + final bool showAnimation; + + const LoadingIndicator({ + super.key, + this.message, + this.showAnimation = false, + }); + + @override + Widget build(BuildContext context) { + final theme = Theme.of(context); + + return Center( + child: Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + if (showAnimation) ...[ + // Optional: Lottie Animation für Loading + SizedBox( + width: 120, + height: 120, + child: CircularProgressIndicator( + strokeWidth: 3, + valueColor: AlwaysStoppedAnimation( + theme.colorScheme.primary, + ), + ), + ), + ] else ...[ + SizedBox( + width: 48, + height: 48, + child: CircularProgressIndicator( + strokeWidth: 3, + valueColor: AlwaysStoppedAnimation( + theme.colorScheme.primary, + ), + ), + ), + ], + if (message != null) ...[ + const SizedBox(height: 24), + Text( + message!, + style: theme.textTheme.bodyMedium?.copyWith( + color: theme.colorScheme.onSurface.withValues(alpha: 179), + ), + textAlign: TextAlign.center, + ), + ], + ], + ), + ); + } +} + +class SkeletonLoading extends StatelessWidget { + final int itemCount; + final EdgeInsets padding; + + const SkeletonLoading({ + super.key, + this.itemCount = 5, + this.padding = const EdgeInsets.symmetric(horizontal: 16, vertical: 8), + }); + + @override + Widget build(BuildContext context) { + return ListView.builder( + padding: padding, + itemCount: itemCount, + itemBuilder: (context, index) { + return Padding( + padding: const EdgeInsets.only(bottom: 12), + child: _SkeletonCard(), + ); + }, + ); + } +} + +class _SkeletonCard extends StatelessWidget { + @override + Widget build(BuildContext context) { + return Container( + padding: const EdgeInsets.all(16), + decoration: BoxDecoration( + color: Colors.grey.shade200, + borderRadius: BorderRadius.circular(16), + ), + child: Row( + children: [ + Container( + width: 56, + height: 56, + decoration: BoxDecoration( + color: Colors.grey.shade300, + borderRadius: BorderRadius.circular(14), + ), + ), + const SizedBox(width: 16), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Container( + width: double.infinity, + height: 16, + decoration: BoxDecoration( + color: Colors.grey.shade300, + borderRadius: BorderRadius.circular(4), + ), + ), + const SizedBox(height: 8), + Container( + width: 120, + height: 12, + decoration: BoxDecoration( + color: Colors.grey.shade300, + borderRadius: BorderRadius.circular(4), + ), + ), + ], + ), + ), + ], + ), + ); + } +} diff --git a/app/lib/presentation/widgets/recent_scans_list.dart b/app/lib/presentation/widgets/recent_scans_list.dart new file mode 100644 index 0000000..bc3c222 --- /dev/null +++ b/app/lib/presentation/widgets/recent_scans_list.dart @@ -0,0 +1,173 @@ +import 'package:flutter/material.dart'; +import '../../domain/entities/counter.dart'; + +/// Zeigt zuletzt gescannte Objekte an +/// Entspricht Lua: Die Liste in ShowStockStartScreen etc. +class RecentScansList extends StatelessWidget { + final List? scans; + + const RecentScansList({ + super.key, + this.scans, + }); + + @override + Widget build(BuildContext context) { + // Demo-Daten falls keine vorhanden + final demoScans = scans ?? const [ + // RecentScan( + // objectCode: 'MEKA123456', + // objectName: 'MEK A', + // state: 'to_delivery', + // scanTime: '', + // ), + ]; + + if (demoScans.isEmpty) { + return Container( + padding: const EdgeInsets.all(16), + decoration: BoxDecoration( + color: Colors.grey.shade100, + borderRadius: BorderRadius.circular(8), + ), + child: const Center( + child: Text( + 'Noch keine Objekte gescannt', + style: TextStyle( + color: Colors.grey, + fontStyle: FontStyle.italic, + ), + ), + ), + ); + } + + return Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + const Text( + 'Zuletzt gescannt', + style: TextStyle( + fontSize: 16, + fontWeight: FontWeight.bold, + ), + ), + const SizedBox(height: 8), + ...demoScans.map((scan) => _buildScanItem(context, scan)), + ], + ); + } + + Widget _buildScanItem(BuildContext context, RecentScan scan) { + return Container( + margin: const EdgeInsets.only(bottom: 8), + padding: const EdgeInsets.all(12), + decoration: BoxDecoration( + color: Colors.grey.shade200, + borderRadius: BorderRadius.circular(8), + ), + child: Row( + children: [ + // Objekt-Icon + Container( + width: 48, + height: 48, + decoration: BoxDecoration( + color: Colors.white, + borderRadius: BorderRadius.circular(8), + ), + child: Icon( + _getIconForObject(scan.objectName), + color: Colors.blue, + ), + ), + const SizedBox(width: 12), + + // Objekt-Info + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + scan.objectName, + style: const TextStyle( + fontSize: 15, + fontWeight: FontWeight.w600, + ), + ), + Text( + '#${scan.objectCode}', + style: TextStyle( + fontSize: 13, + color: Colors.grey.shade600, + ), + ), + ], + ), + ), + + // Status + Container( + padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4), + decoration: BoxDecoration( + color: _getColorForState(scan.state), + borderRadius: BorderRadius.circular(12), + ), + child: Text( + _getShortStateName(scan.state), + style: const TextStyle( + fontSize: 12, + fontWeight: FontWeight.w500, + ), + ), + ), + ], + ), + ); + } + + IconData _getIconForObject(String objectName) { + final name = objectName.toLowerCase(); + if (name.contains('mek')) return Icons.money; + if (name.contains('bek')) return Icons.money_off; + if (name.contains('hp')) return Icons.print; + if (name.contains('fr')) return Icons.receipt; + if (name.contains('sb')) return Icons.shopping_bag; + if (name.contains('abs')) return Icons.delete; + return Icons.inventory_2; + } + + Color _getColorForState(String state) { + switch (state) { + case 'to_delivery': + return Colors.grey.shade300; + case 'delivery': + return Colors.grey.shade400; + case 'station': + return const Color(0xFFFFDD00); + case 'in_fa': + return const Color(0xFF9CDA7A); + case 'ret_fail': + return const Color(0xFFFF9081); + default: + return Colors.grey.shade200; + } + } + + String _getShortStateName(String state) { + switch (state) { + case 'to_delivery': + return 'Zum Fzg'; + case 'delivery': + return 'Im Fzg'; + case 'station': + return 'Station'; + case 'in_fa': + return 'Im FA'; + case 'ret_fail': + return 'Fehler'; + default: + return state; + } + } +} diff --git a/app/lib/presentation/widgets/tour_list_item.dart b/app/lib/presentation/widgets/tour_list_item.dart new file mode 100644 index 0000000..74d979d --- /dev/null +++ b/app/lib/presentation/widgets/tour_list_item.dart @@ -0,0 +1,231 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_animate/flutter_animate.dart'; +import '../../domain/entities/tour.dart'; +import '../../core/constants/app_constants.dart'; + +class TourListItem extends StatelessWidget { + final Tour tour; + final VoidCallback onTap; + final bool isCompleted; + + const TourListItem({ + super.key, + required this.tour, + required this.onTap, + this.isCompleted = false, + }); + + @override + Widget build(BuildContext context) { + final theme = Theme.of(context); + final iconData = _getIconForTourType(tour.type); + final color = _getColorForTourType(tour.type); + + return Padding( + padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 6), + child: Card( + elevation: isCompleted ? 0 : 2, + shadowColor: Colors.black.withValues(alpha: 26), + shape: RoundedRectangleBorder( + borderRadius: BorderRadius.circular(16), + side: isCompleted + ? BorderSide(color: Colors.grey.shade300) + : BorderSide.none, + ), + child: InkWell( + onTap: isCompleted ? null : onTap, + borderRadius: BorderRadius.circular(16), + child: Padding( + padding: const EdgeInsets.all(16), + child: Row( + children: [ + // Icon Container + Container( + width: 56, + height: 56, + decoration: BoxDecoration( + gradient: LinearGradient( + colors: [ + color, + color.withValues(alpha: 204), + ], + begin: Alignment.topLeft, + end: Alignment.bottomRight, + ), + borderRadius: BorderRadius.circular(14), + boxShadow: [ + BoxShadow( + color: color.withValues(alpha: 77), + blurRadius: 8, + offset: const Offset(0, 4), + ), + ], + ), + child: Icon( + iconData, + color: Colors.white, + size: 28, + ), + ), + const SizedBox(width: 16), + + // Content + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + tour.locationName ?? 'Station ${tour.locationId}', + style: theme.textTheme.titleMedium?.copyWith( + fontWeight: FontWeight.w600, + color: isCompleted ? Colors.grey : null, + decoration: isCompleted ? TextDecoration.lineThrough : null, + ), + maxLines: 1, + overflow: TextOverflow.ellipsis, + ), + const SizedBox(height: 4), + Text( + _getTypeLabel(tour.type), + style: theme.textTheme.bodySmall?.copyWith( + color: color, + fontWeight: FontWeight.w500, + ), + ), + if (tour.remark != null && tour.remark!.isNotEmpty) ...[ + const SizedBox(height: 4), + Text( + tour.remark!, + style: theme.textTheme.bodySmall?.copyWith( + color: Colors.grey.shade600, + ), + maxLines: 1, + overflow: TextOverflow.ellipsis, + ), + ], + ], + ), + ), + + // Status Indicator + if (isCompleted) + Container( + padding: const EdgeInsets.all(8), + decoration: BoxDecoration( + color: Colors.green.withValues(alpha: 26), + shape: BoxShape.circle, + ), + child: const Icon( + Icons.check, + color: Colors.green, + size: 20, + ), + ) + else + Container( + padding: const EdgeInsets.all(8), + decoration: BoxDecoration( + color: Colors.grey.shade100, + shape: BoxShape.circle, + ), + child: Icon( + Icons.chevron_right, + color: Colors.grey.shade600, + size: 24, + ), + ), + ], + ), + ), + ), + ), + ).animate().fadeIn(duration: 300.ms).slideX(begin: 0.1, end: 0); + } + + IconData _getIconForTourType(String type) { + switch (type) { + case TourTypes.stockStart: + return Icons.warehouse; + case TourTypes.stockEnd: + return Icons.archive; + case TourTypes.start: + return Icons.business; + case TourTypes.end: + return Icons.flag; + case TourTypes.station: + return Icons.directions_bus; + case TourTypes.hls: + return Icons.train; + case TourTypes.fsa: + return Icons.confirmation_number; + case TourTypes.vs: + return Icons.store; + case TourTypes.gi: + return Icons.account_balance; + case TourTypes.veh: + case TourTypes.vehStart: + case TourTypes.vehEnd: + return Icons.local_shipping; + default: + return Icons.location_on; + } + } + + Color _getColorForTourType(String type) { + switch (type) { + case TourTypes.stockStart: + case TourTypes.stockEnd: + return const Color(0xFF2196F3); + case TourTypes.start: + case TourTypes.end: + return const Color(0xFF4CAF50); + case TourTypes.station: + return const Color(0xFFFF9800); + case TourTypes.hls: + return const Color(0xFF9C27B0); + case TourTypes.fsa: + return const Color(0xFFE91E63); + case TourTypes.vs: + return const Color(0xFF00BCD4); + case TourTypes.gi: + return const Color(0xFF3F51B5); + case TourTypes.veh: + case TourTypes.vehStart: + case TourTypes.vehEnd: + return const Color(0xFF795548); + default: + return const Color(0xFF607D8B); + } + } + + String _getTypeLabel(String type) { + switch (type) { + case TourTypes.stockStart: + return 'Lager - Beladung'; + case TourTypes.stockEnd: + return 'Lager - Rückgabe'; + case TourTypes.start: + return 'Dienststelle'; + case TourTypes.end: + return 'Tour Ende'; + case TourTypes.station: + return 'Haltestelle'; + case TourTypes.hls: + return 'Hochbahnstation'; + case TourTypes.fsa: + return 'Fahrscheinautomat'; + case TourTypes.vs: + return 'Versorgungsstelle'; + case TourTypes.gi: + return 'Geldinstitut'; + case TourTypes.veh: + return 'Fahrzeug'; + case TourTypes.vehStart: + return 'Fahrzeug - Beladung'; + case TourTypes.vehEnd: + return 'Fahrzeug - Entladung'; + default: + return type; + } + } +} diff --git a/app/pubspec.lock b/app/pubspec.lock new file mode 100644 index 0000000..170ac6e --- /dev/null +++ b/app/pubspec.lock @@ -0,0 +1,1111 @@ +# Generated by pub +# See https://dart.dev/tools/pub/glossary#lockfile +packages: + _fe_analyzer_shared: + dependency: transitive + description: + name: _fe_analyzer_shared + sha256: da0d9209ca76bde579f2da330aeb9df62b6319c834fa7baae052021b0462401f + url: "https://pub.dev" + source: hosted + version: "85.0.0" + analyzer: + dependency: transitive + description: + name: analyzer + sha256: "974859dc0ff5f37bc4313244b3218c791810d03ab3470a579580279ba971a48d" + url: "https://pub.dev" + source: hosted + version: "7.7.1" + archive: + dependency: transitive + description: + name: archive + sha256: cb6a278ef2dbb298455e1a713bda08524a175630ec643a242c399c932a0a1f7d + url: "https://pub.dev" + source: hosted + version: "3.6.1" + args: + dependency: transitive + description: + name: args + sha256: d0481093c50b1da8910eb0bb301626d4d8eb7284aa739614d2b394ee09e3ea04 + url: "https://pub.dev" + source: hosted + version: "2.7.0" + async: + dependency: transitive + description: + name: async + sha256: "758e6d74e971c3e5aceb4110bfd6698efc7f501675bcfe0c775459a8140750eb" + url: "https://pub.dev" + source: hosted + version: "2.13.0" + badges: + dependency: "direct main" + description: + name: badges + sha256: a7b6bbd60dce418df0db3058b53f9d083c22cdb5132a052145dc267494df0b84 + url: "https://pub.dev" + source: hosted + version: "3.1.2" + bloc: + dependency: transitive + description: + name: bloc + sha256: "106842ad6569f0b60297619e9e0b1885c2fb9bf84812935490e6c5275777804e" + url: "https://pub.dev" + source: hosted + version: "8.1.4" + boolean_selector: + dependency: transitive + description: + name: boolean_selector + sha256: "8aab1771e1243a5063b8b0ff68042d67334e3feab9e95b9490f9a6ebf73b42ea" + url: "https://pub.dev" + source: hosted + version: "2.1.2" + build: + dependency: transitive + description: + name: build + sha256: "51dc711996cbf609b90cbe5b335bbce83143875a9d58e4b5c6d3c4f684d3dda7" + url: "https://pub.dev" + source: hosted + version: "2.5.4" + build_config: + dependency: transitive + description: + name: build_config + sha256: "4ae2de3e1e67ea270081eaee972e1bd8f027d459f249e0f1186730784c2e7e33" + url: "https://pub.dev" + source: hosted + version: "1.1.2" + build_daemon: + dependency: transitive + description: + name: build_daemon + sha256: bf05f6e12cfea92d3c09308d7bcdab1906cd8a179b023269eed00c071004b957 + url: "https://pub.dev" + source: hosted + version: "4.1.1" + build_resolvers: + dependency: transitive + description: + name: build_resolvers + sha256: ee4257b3f20c0c90e72ed2b57ad637f694ccba48839a821e87db762548c22a62 + url: "https://pub.dev" + source: hosted + version: "2.5.4" + build_runner: + dependency: "direct dev" + description: + name: build_runner + sha256: "382a4d649addbfb7ba71a3631df0ec6a45d5ab9b098638144faf27f02778eb53" + url: "https://pub.dev" + source: hosted + version: "2.5.4" + build_runner_core: + dependency: transitive + description: + name: build_runner_core + sha256: "85fbbb1036d576d966332a3f5ce83f2ce66a40bea1a94ad2d5fc29a19a0d3792" + url: "https://pub.dev" + source: hosted + version: "9.1.2" + built_collection: + dependency: transitive + description: + name: built_collection + sha256: "376e3dd27b51ea877c28d525560790aee2e6fbb5f20e2f85d5081027d94e2100" + url: "https://pub.dev" + source: hosted + version: "5.1.1" + built_value: + dependency: transitive + description: + name: built_value + sha256: "6ae8a6435a8c6520c7077b107e77f1fb4ba7009633259a4d49a8afd8e7efc5e9" + url: "https://pub.dev" + source: hosted + version: "8.12.4" + characters: + dependency: transitive + description: + name: characters + sha256: f71061c654a3380576a52b451dd5532377954cf9dbd272a78fc8479606670803 + url: "https://pub.dev" + source: hosted + version: "1.4.0" + checked_yaml: + dependency: transitive + description: + name: checked_yaml + sha256: "959525d3162f249993882720d52b7e0c833978df229be20702b33d48d91de70f" + url: "https://pub.dev" + source: hosted + version: "2.0.4" + cli_util: + dependency: transitive + description: + name: cli_util + sha256: ff6785f7e9e3c38ac98b2fb035701789de90154024a75b6cb926445e83197d1c + url: "https://pub.dev" + source: hosted + version: "0.4.2" + clock: + dependency: transitive + description: + name: clock + sha256: fddb70d9b5277016c77a80201021d40a2247104d9f4aa7bab7157b7e3f05b84b + url: "https://pub.dev" + source: hosted + version: "1.1.2" + code_assets: + dependency: transitive + description: + name: code_assets + sha256: "83ccdaa064c980b5596c35dd64a8d3ecc68620174ab9b90b6343b753aa721687" + url: "https://pub.dev" + source: hosted + version: "1.0.0" + code_builder: + dependency: transitive + description: + name: code_builder + sha256: "6a6cab2ba4680d6423f34a9b972a4c9a94ebe1b62ecec4e1a1f2cba91fd1319d" + url: "https://pub.dev" + source: hosted + version: "4.11.1" + collection: + dependency: transitive + description: + name: collection + sha256: "2f5709ae4d3d59dd8f7cd309b4e023046b57d8a6c82130785d2b0e5868084e76" + url: "https://pub.dev" + source: hosted + version: "1.19.1" + connectivity_plus: + dependency: "direct main" + description: + name: connectivity_plus + sha256: "224a77051d52a11fbad53dd57827594d3bd24f945af28bd70bab376d68d437f0" + url: "https://pub.dev" + source: hosted + version: "5.0.2" + connectivity_plus_platform_interface: + dependency: transitive + description: + name: connectivity_plus_platform_interface + sha256: cf1d1c28f4416f8c654d7dc3cd638ec586076255d407cef3ddbdaf178272a71a + url: "https://pub.dev" + source: hosted + version: "1.2.4" + convert: + dependency: transitive + description: + name: convert + sha256: b30acd5944035672bc15c6b7a8b47d773e41e2f17de064350988c5d02adb1c68 + url: "https://pub.dev" + source: hosted + version: "3.1.2" + crypto: + dependency: transitive + description: + name: crypto + sha256: c8ea0233063ba03258fbcf2ca4d6dadfefe14f02fab57702265467a19f27fadf + url: "https://pub.dev" + source: hosted + version: "3.0.7" + cupertino_icons: + dependency: "direct main" + description: + name: cupertino_icons + sha256: ba631d1c7f7bef6b729a622b7b752645a2d076dba9976925b8f25725a30e1ee6 + url: "https://pub.dev" + source: hosted + version: "1.0.8" + dart_style: + dependency: transitive + description: + name: dart_style + sha256: "8a0e5fba27e8ee025d2ffb4ee820b4e6e2cf5e4246a6b1a477eb66866947e0bb" + url: "https://pub.dev" + source: hosted + version: "3.1.1" + dartz: + dependency: "direct main" + description: + name: dartz + sha256: e6acf34ad2e31b1eb00948692468c30ab48ac8250e0f0df661e29f12dd252168 + url: "https://pub.dev" + source: hosted + version: "0.10.1" + dbus: + dependency: transitive + description: + name: dbus + sha256: d0c98dcd4f5169878b6cf8f6e0a52403a9dff371a3e2f019697accbf6f44a270 + url: "https://pub.dev" + source: hosted + version: "0.7.12" + dio: + dependency: "direct main" + description: + name: dio + sha256: aff32c08f92787a557dd5c0145ac91536481831a01b4648136373cddb0e64f8c + url: "https://pub.dev" + source: hosted + version: "5.9.2" + dio_web_adapter: + dependency: transitive + description: + name: dio_web_adapter + sha256: "2f9e64323a7c3c7ef69567d5c800424a11f8337b8b228bad02524c9fb3c1f340" + url: "https://pub.dev" + source: hosted + version: "2.1.2" + equatable: + dependency: "direct main" + description: + name: equatable + sha256: "3e0141505477fd8ad55d6eb4e7776d3fe8430be8e497ccb1521370c3f21a3e2b" + url: "https://pub.dev" + source: hosted + version: "2.0.8" + fake_async: + dependency: transitive + description: + name: fake_async + sha256: "5368f224a74523e8d2e7399ea1638b37aecfca824a3cc4dfdf77bf1fa905ac44" + url: "https://pub.dev" + source: hosted + version: "1.3.3" + ffi: + dependency: transitive + description: + name: ffi + sha256: "6d7fd89431262d8f3125e81b50d3847a091d846eafcd4fdb88dd06f36d705a45" + url: "https://pub.dev" + source: hosted + version: "2.2.0" + file: + dependency: transitive + description: + name: file + sha256: a3b4f84adafef897088c160faf7dfffb7696046cb13ae90b508c2cbc95d3b8d4 + url: "https://pub.dev" + source: hosted + version: "7.0.1" + fixnum: + dependency: transitive + description: + name: fixnum + sha256: b6dc7065e46c974bc7c5f143080a6764ec7a4be6da1285ececdc37be96de53be + url: "https://pub.dev" + source: hosted + version: "1.1.1" + flutter: + dependency: "direct main" + description: flutter + source: sdk + version: "0.0.0" + flutter_animate: + dependency: "direct main" + description: + name: flutter_animate + sha256: "7befe2d3252728afb77aecaaea1dec88a89d35b9b1d2eea6d04479e8af9117b5" + url: "https://pub.dev" + source: hosted + version: "4.5.2" + flutter_bloc: + dependency: "direct main" + description: + name: flutter_bloc + sha256: b594505eac31a0518bdcb4b5b79573b8d9117b193cc80cc12e17d639b10aa27a + url: "https://pub.dev" + source: hosted + version: "8.1.6" + flutter_launcher_icons: + dependency: "direct dev" + description: + name: flutter_launcher_icons + sha256: "526faf84284b86a4cb36d20a5e45147747b7563d921373d4ee0559c54fcdbcea" + url: "https://pub.dev" + source: hosted + version: "0.13.1" + flutter_lints: + dependency: "direct dev" + description: + name: flutter_lints + sha256: "9e8c3858111da373efc5aa341de011d9bd23e2c5c5e0c62bccf32438e192d7b1" + url: "https://pub.dev" + source: hosted + version: "3.0.2" + flutter_localizations: + dependency: "direct main" + description: flutter + source: sdk + version: "0.0.0" + flutter_shaders: + dependency: transitive + description: + name: flutter_shaders + sha256: "34794acadd8275d971e02df03afee3dee0f98dbfb8c4837082ad0034f612a3e2" + url: "https://pub.dev" + source: hosted + version: "0.1.3" + flutter_slidable: + dependency: "direct main" + description: + name: flutter_slidable + sha256: a857de7ea701f276fd6a6c4c67ae885b60729a3449e42766bb0e655171042801 + url: "https://pub.dev" + source: hosted + version: "3.1.2" + flutter_svg: + dependency: "direct main" + description: + name: flutter_svg + sha256: "1ded017b39c8e15c8948ea855070a5ff8ff8b3d5e83f3446e02d6bb12add7ad9" + url: "https://pub.dev" + source: hosted + version: "2.2.4" + flutter_test: + dependency: "direct dev" + description: flutter + source: sdk + version: "0.0.0" + flutter_web_plugins: + dependency: transitive + description: flutter + source: sdk + version: "0.0.0" + freezed: + dependency: "direct dev" + description: + name: freezed + sha256: "59a584c24b3acdc5250bb856d0d3e9c0b798ed14a4af1ddb7dc1c7b41df91c9c" + url: "https://pub.dev" + source: hosted + version: "2.5.8" + freezed_annotation: + dependency: "direct main" + description: + name: freezed_annotation + sha256: c2e2d632dd9b8a2b7751117abcfc2b4888ecfe181bd9fca7170d9ef02e595fe2 + url: "https://pub.dev" + source: hosted + version: "2.4.4" + frontend_server_client: + dependency: transitive + description: + name: frontend_server_client + sha256: f64a0333a82f30b0cca061bc3d143813a486dc086b574bfb233b7c1372427694 + url: "https://pub.dev" + source: hosted + version: "4.0.0" + glob: + dependency: transitive + description: + name: glob + sha256: c3f1ee72c96f8f78935e18aa8cecced9ab132419e8625dc187e1c2408efc20de + url: "https://pub.dev" + source: hosted + version: "2.1.3" + go_router: + dependency: "direct main" + description: + name: go_router + sha256: c5fa45fa502ee880839e3b2152d987c44abae26d064a2376d4aad434cf0f7b15 + url: "https://pub.dev" + source: hosted + version: "12.1.3" + google_fonts: + dependency: "direct main" + description: + name: google_fonts + sha256: ba03d03bcaa2f6cb7bd920e3b5027181db75ab524f8891c8bc3aa603885b8055 + url: "https://pub.dev" + source: hosted + version: "6.3.3" + graphs: + dependency: transitive + description: + name: graphs + sha256: "741bbf84165310a68ff28fe9e727332eef1407342fca52759cb21ad8177bb8d0" + url: "https://pub.dev" + source: hosted + version: "2.3.2" + hooks: + dependency: transitive + description: + name: hooks + sha256: e79ed1e8e1929bc6ecb6ec85f0cb519c887aa5b423705ded0d0f2d9226def388 + url: "https://pub.dev" + source: hosted + version: "1.0.2" + http: + dependency: transitive + description: + name: http + sha256: "87721a4a50b19c7f1d49001e51409bddc46303966ce89a65af4f4e6004896412" + url: "https://pub.dev" + source: hosted + version: "1.6.0" + http_multi_server: + dependency: transitive + description: + name: http_multi_server + sha256: aa6199f908078bb1c5efb8d8638d4ae191aac11b311132c3ef48ce352fb52ef8 + url: "https://pub.dev" + source: hosted + version: "3.2.2" + http_parser: + dependency: transitive + description: + name: http_parser + sha256: "178d74305e7866013777bab2c3d8726205dc5a4dd935297175b19a23a2e66571" + url: "https://pub.dev" + source: hosted + version: "4.1.2" + image: + dependency: transitive + description: + name: image + sha256: f31d52537dc417fdcde36088fdf11d191026fd5e4fae742491ebd40e5a8bea7d + url: "https://pub.dev" + source: hosted + version: "4.3.0" + intl: + dependency: "direct main" + description: + name: intl + sha256: "3df61194eb431efc39c4ceba583b95633a403f46c9fd341e550ce0bfa50e9aa5" + url: "https://pub.dev" + source: hosted + version: "0.20.2" + io: + dependency: transitive + description: + name: io + sha256: dfd5a80599cf0165756e3181807ed3e77daf6dd4137caaad72d0b7931597650b + url: "https://pub.dev" + source: hosted + version: "1.0.5" + js: + dependency: transitive + description: + name: js + sha256: f2c445dce49627136094980615a031419f7f3eb393237e4ecd97ac15dea343f3 + url: "https://pub.dev" + source: hosted + version: "0.6.7" + json_annotation: + dependency: "direct main" + description: + name: json_annotation + sha256: "1ce844379ca14835a50d2f019a3099f419082cfdd231cd86a142af94dd5c6bb1" + url: "https://pub.dev" + source: hosted + version: "4.9.0" + json_serializable: + dependency: "direct dev" + description: + name: json_serializable + sha256: c50ef5fc083d5b5e12eef489503ba3bf5ccc899e487d691584699b4bdefeea8c + url: "https://pub.dev" + source: hosted + version: "6.9.5" + leak_tracker: + dependency: transitive + description: + name: leak_tracker + sha256: "33e2e26bdd85a0112ec15400c8cbffea70d0f9c3407491f672a2fad47915e2de" + url: "https://pub.dev" + source: hosted + version: "11.0.2" + leak_tracker_flutter_testing: + dependency: transitive + description: + name: leak_tracker_flutter_testing + sha256: "1dbc140bb5a23c75ea9c4811222756104fbcd1a27173f0c34ca01e16bea473c1" + url: "https://pub.dev" + source: hosted + version: "3.0.10" + leak_tracker_testing: + dependency: transitive + description: + name: leak_tracker_testing + sha256: "8d5a2d49f4a66b49744b23b018848400d23e54caf9463f4eb20df3eb8acb2eb1" + url: "https://pub.dev" + source: hosted + version: "3.0.2" + lints: + dependency: transitive + description: + name: lints + sha256: cbf8d4b858bb0134ef3ef87841abdf8d63bfc255c266b7bf6b39daa1085c4290 + url: "https://pub.dev" + source: hosted + version: "3.0.0" + logger: + dependency: "direct main" + description: + name: logger + sha256: "25aee487596a6257655a1e091ec2ae66bc30e7af663592cc3a27e6591e05035c" + url: "https://pub.dev" + source: hosted + version: "2.7.0" + logging: + dependency: transitive + description: + name: logging + sha256: c8245ada5f1717ed44271ed1c26b8ce85ca3228fd2ffdb75468ab01979309d61 + url: "https://pub.dev" + source: hosted + version: "1.3.0" + lottie: + dependency: "direct main" + description: + name: lottie + sha256: a93542cc2d60a7057255405f62252533f8e8956e7e06754955669fd32fb4b216 + url: "https://pub.dev" + source: hosted + version: "2.7.0" + matcher: + dependency: transitive + description: + name: matcher + sha256: dc58c723c3c24bf8d3e2d3ad3f2f9d7bd9cf43ec6feaa64181775e60190153f2 + url: "https://pub.dev" + source: hosted + version: "0.12.17" + material_color_utilities: + dependency: transitive + description: + name: material_color_utilities + sha256: f7142bb1154231d7ea5f96bc7bde4bda2a0945d2806bb11670e30b850d56bdec + url: "https://pub.dev" + source: hosted + version: "0.11.1" + meta: + dependency: transitive + description: + name: meta + sha256: "23f08335362185a5ea2ad3a4e597f1375e78bce8a040df5c600c8d3552ef2394" + url: "https://pub.dev" + source: hosted + version: "1.17.0" + mime: + dependency: transitive + description: + name: mime + sha256: "41a20518f0cb1256669420fdba0cd90d21561e560ac240f26ef8322e45bb7ed6" + url: "https://pub.dev" + source: hosted + version: "2.0.0" + mobile_scanner: + dependency: "direct main" + description: + name: mobile_scanner + sha256: "1b60b8f9d4ce0cb0e7d7bc223c955d083a0737bee66fa1fcfe5de48225e0d5b3" + url: "https://pub.dev" + source: hosted + version: "3.5.7" + native_toolchain_c: + dependency: transitive + description: + name: native_toolchain_c + sha256: "6ba77bb18063eebe9de401f5e6437e95e1438af0a87a3a39084fbd37c90df572" + url: "https://pub.dev" + source: hosted + version: "0.17.6" + nested: + dependency: transitive + description: + name: nested + sha256: "03bac4c528c64c95c722ec99280375a6f2fc708eec17c7b3f07253b626cd2a20" + url: "https://pub.dev" + source: hosted + version: "1.0.0" + nm: + dependency: transitive + description: + name: nm + sha256: "2c9aae4127bdc8993206464fcc063611e0e36e72018696cd9631023a31b24254" + url: "https://pub.dev" + source: hosted + version: "0.5.0" + objective_c: + dependency: transitive + description: + name: objective_c + sha256: "100a1c87616ab6ed41ec263b083c0ef3261ee6cd1dc3b0f35f8ddfa4f996fe52" + url: "https://pub.dev" + source: hosted + version: "9.3.0" + package_config: + dependency: transitive + description: + name: package_config + sha256: f096c55ebb7deb7e384101542bfba8c52696c1b56fca2eb62827989ef2353bbc + url: "https://pub.dev" + source: hosted + version: "2.2.0" + path: + dependency: transitive + description: + name: path + sha256: "75cca69d1490965be98c73ceaea117e8a04dd21217b37b292c9ddbec0d955bc5" + url: "https://pub.dev" + source: hosted + version: "1.9.1" + path_parsing: + dependency: transitive + description: + name: path_parsing + sha256: "883402936929eac138ee0a45da5b0f2c80f89913e6dc3bf77eb65b84b409c6ca" + url: "https://pub.dev" + source: hosted + version: "1.1.0" + path_provider: + dependency: "direct main" + description: + name: path_provider + sha256: "50c5dd5b6e1aaf6fb3a78b33f6aa3afca52bf903a8a5298f53101fdaee55bbcd" + url: "https://pub.dev" + source: hosted + version: "2.1.5" + path_provider_android: + dependency: transitive + description: + name: path_provider_android + sha256: f2c65e21139ce2c3dad46922be8272bb5963516045659e71bb16e151c93b580e + url: "https://pub.dev" + source: hosted + version: "2.2.22" + path_provider_foundation: + dependency: transitive + description: + name: path_provider_foundation + sha256: "2a376b7d6392d80cd3705782d2caa734ca4727776db0b6ec36ef3f1855197699" + url: "https://pub.dev" + source: hosted + version: "2.6.0" + path_provider_linux: + dependency: transitive + description: + name: path_provider_linux + sha256: f7a1fe3a634fe7734c8d3f2766ad746ae2a2884abe22e241a8b301bf5cac3279 + url: "https://pub.dev" + source: hosted + version: "2.2.1" + path_provider_platform_interface: + dependency: transitive + description: + name: path_provider_platform_interface + sha256: "88f5779f72ba699763fa3a3b06aa4bf6de76c8e5de842cf6f29e2e06476c2334" + url: "https://pub.dev" + source: hosted + version: "2.1.2" + path_provider_windows: + dependency: transitive + description: + name: path_provider_windows + sha256: bd6f00dbd873bfb70d0761682da2b3a2c2fccc2b9e84c495821639601d81afe7 + url: "https://pub.dev" + source: hosted + version: "2.3.0" + petitparser: + dependency: transitive + description: + name: petitparser + sha256: "91bd59303e9f769f108f8df05e371341b15d59e995e6806aefab827b58336675" + url: "https://pub.dev" + source: hosted + version: "7.0.2" + phosphor_flutter: + dependency: "direct main" + description: + name: phosphor_flutter + sha256: "8a14f238f28a0b54842c5a4dc20676598dd4811fcba284ed828bd5a262c11fde" + url: "https://pub.dev" + source: hosted + version: "2.1.0" + platform: + dependency: transitive + description: + name: platform + sha256: "5d6b1b0036a5f331ebc77c850ebc8506cbc1e9416c27e59b439f917a902a4984" + url: "https://pub.dev" + source: hosted + version: "3.1.6" + plugin_platform_interface: + dependency: transitive + description: + name: plugin_platform_interface + sha256: "4820fbfdb9478b1ebae27888254d445073732dae3d6ea81f0b7e06d5dedc3f02" + url: "https://pub.dev" + source: hosted + version: "2.1.8" + pool: + dependency: transitive + description: + name: pool + sha256: "978783255c543aa3586a1b3c21f6e9d720eb315376a915872c61ef8b5c20177d" + url: "https://pub.dev" + source: hosted + version: "1.5.2" + provider: + dependency: transitive + description: + name: provider + sha256: "4e82183fa20e5ca25703ead7e05de9e4cceed1fbd1eadc1ac3cb6f565a09f272" + url: "https://pub.dev" + source: hosted + version: "6.1.5+1" + pub_semver: + dependency: transitive + description: + name: pub_semver + sha256: "5bfcf68ca79ef689f8990d1160781b4bad40a3bd5e5218ad4076ddb7f4081585" + url: "https://pub.dev" + source: hosted + version: "2.2.0" + pubspec_parse: + dependency: transitive + description: + name: pubspec_parse + sha256: "0560ba233314abbed0a48a2956f7f022cce7c3e1e73df540277da7544cad4082" + url: "https://pub.dev" + source: hosted + version: "1.5.0" + shared_preferences: + dependency: "direct main" + description: + name: shared_preferences + sha256: "2939ae520c9024cb197fc20dee269cd8cdbf564c8b5746374ec6cacdc5169e64" + url: "https://pub.dev" + source: hosted + version: "2.5.4" + shared_preferences_android: + dependency: transitive + description: + name: shared_preferences_android + sha256: "8374d6200ab33ac99031a852eba4c8eb2170c4bf20778b3e2c9eccb45384fb41" + url: "https://pub.dev" + source: hosted + version: "2.4.21" + shared_preferences_foundation: + dependency: transitive + description: + name: shared_preferences_foundation + sha256: "4e7eaffc2b17ba398759f1151415869a34771ba11ebbccd1b0145472a619a64f" + url: "https://pub.dev" + source: hosted + version: "2.5.6" + shared_preferences_linux: + dependency: transitive + description: + name: shared_preferences_linux + sha256: "580abfd40f415611503cae30adf626e6656dfb2f0cee8f465ece7b6defb40f2f" + url: "https://pub.dev" + source: hosted + version: "2.4.1" + shared_preferences_platform_interface: + dependency: transitive + description: + name: shared_preferences_platform_interface + sha256: "57cbf196c486bc2cf1f02b85784932c6094376284b3ad5779d1b1c6c6a816b80" + url: "https://pub.dev" + source: hosted + version: "2.4.1" + shared_preferences_web: + dependency: transitive + description: + name: shared_preferences_web + sha256: c49bd060261c9a3f0ff445892695d6212ff603ef3115edbb448509d407600019 + url: "https://pub.dev" + source: hosted + version: "2.4.3" + shared_preferences_windows: + dependency: transitive + description: + name: shared_preferences_windows + sha256: "94ef0f72b2d71bc3e700e025db3710911bd51a71cefb65cc609dd0d9a982e3c1" + url: "https://pub.dev" + source: hosted + version: "2.4.1" + shelf: + dependency: transitive + description: + name: shelf + sha256: e7dd780a7ffb623c57850b33f43309312fc863fb6aa3d276a754bb299839ef12 + url: "https://pub.dev" + source: hosted + version: "1.4.2" + shelf_web_socket: + dependency: transitive + description: + name: shelf_web_socket + sha256: "3632775c8e90d6c9712f883e633716432a27758216dfb61bd86a8321c0580925" + url: "https://pub.dev" + source: hosted + version: "3.0.0" + shimmer: + dependency: "direct main" + description: + name: shimmer + sha256: "5f88c883a22e9f9f299e5ba0e4f7e6054857224976a5d9f839d4ebdc94a14ac9" + url: "https://pub.dev" + source: hosted + version: "3.0.0" + sky_engine: + dependency: transitive + description: flutter + source: sdk + version: "0.0.0" + source_gen: + dependency: transitive + description: + name: source_gen + sha256: "35c8150ece9e8c8d263337a265153c3329667640850b9304861faea59fc98f6b" + url: "https://pub.dev" + source: hosted + version: "2.0.0" + source_helper: + dependency: transitive + description: + name: source_helper + sha256: a447acb083d3a5ef17f983dd36201aeea33fedadb3228fa831f2f0c92f0f3aca + url: "https://pub.dev" + source: hosted + version: "1.3.7" + source_span: + dependency: transitive + description: + name: source_span + sha256: "56a02f1f4cd1a2d96303c0144c93bd6d909eea6bee6bf5a0e0b685edbd4c47ab" + url: "https://pub.dev" + source: hosted + version: "1.10.2" + sqflite: + dependency: "direct main" + description: + name: sqflite + sha256: e2297b1da52f127bc7a3da11439985d9b536f75070f3325e62ada69a5c585d03 + url: "https://pub.dev" + source: hosted + version: "2.4.2" + sqflite_android: + dependency: transitive + description: + name: sqflite_android + sha256: "881e28efdcc9950fd8e9bb42713dcf1103e62a2e7168f23c9338d82db13dec40" + url: "https://pub.dev" + source: hosted + version: "2.4.2+3" + sqflite_common: + dependency: transitive + description: + name: sqflite_common + sha256: "6ef422a4525ecc601db6c0a2233ff448c731307906e92cabc9ba292afaae16a6" + url: "https://pub.dev" + source: hosted + version: "2.5.6" + sqflite_darwin: + dependency: transitive + description: + name: sqflite_darwin + sha256: "279832e5cde3fe99e8571879498c9211f3ca6391b0d818df4e17d9fff5c6ccb3" + url: "https://pub.dev" + source: hosted + version: "2.4.2" + sqflite_platform_interface: + dependency: transitive + description: + name: sqflite_platform_interface + sha256: "8dd4515c7bdcae0a785b0062859336de775e8c65db81ae33dd5445f35be61920" + url: "https://pub.dev" + source: hosted + version: "2.4.0" + stack_trace: + dependency: transitive + description: + name: stack_trace + sha256: "8b27215b45d22309b5cddda1aa2b19bdfec9df0e765f2de506401c071d38d1b1" + url: "https://pub.dev" + source: hosted + version: "1.12.1" + stream_channel: + dependency: transitive + description: + name: stream_channel + sha256: "969e04c80b8bcdf826f8f16579c7b14d780458bd97f56d107d3950fdbeef059d" + url: "https://pub.dev" + source: hosted + version: "2.1.4" + stream_transform: + dependency: transitive + description: + name: stream_transform + sha256: ad47125e588cfd37a9a7f86c7d6356dde8dfe89d071d293f80ca9e9273a33871 + url: "https://pub.dev" + source: hosted + version: "2.1.1" + string_scanner: + dependency: transitive + description: + name: string_scanner + sha256: "921cd31725b72fe181906c6a94d987c78e3b98c2e205b397ea399d4054872b43" + url: "https://pub.dev" + source: hosted + version: "1.4.1" + synchronized: + dependency: transitive + description: + name: synchronized + sha256: c254ade258ec8282947a0acbbc90b9575b4f19673533ee46f2f6e9b3aeefd7c0 + url: "https://pub.dev" + source: hosted + version: "3.4.0" + term_glyph: + dependency: transitive + description: + name: term_glyph + sha256: "7f554798625ea768a7518313e58f83891c7f5024f88e46e7182a4558850a4b8e" + url: "https://pub.dev" + source: hosted + version: "1.2.2" + test_api: + dependency: transitive + description: + name: test_api + sha256: ab2726c1a94d3176a45960b6234466ec367179b87dd74f1611adb1f3b5fb9d55 + url: "https://pub.dev" + source: hosted + version: "0.7.7" + timing: + dependency: transitive + description: + name: timing + sha256: "62ee18aca144e4a9f29d212f5a4c6a053be252b895ab14b5821996cff4ed90fe" + url: "https://pub.dev" + source: hosted + version: "1.0.2" + typed_data: + dependency: transitive + description: + name: typed_data + sha256: f9049c039ebfeb4cf7a7104a675823cd72dba8297f264b6637062516699fa006 + url: "https://pub.dev" + source: hosted + version: "1.4.0" + uuid: + dependency: "direct main" + description: + name: uuid + sha256: "1fef9e8e11e2991bb773070d4656b7bd5d850967a2456cfc83cf47925ba79489" + url: "https://pub.dev" + source: hosted + version: "4.5.3" + vector_graphics: + dependency: transitive + description: + name: vector_graphics + sha256: "7076216a10d5c390315fbe536a30f1254c341e7543e6c4c8a815e591307772b1" + url: "https://pub.dev" + source: hosted + version: "1.1.20" + vector_graphics_codec: + dependency: transitive + description: + name: vector_graphics_codec + sha256: "99fd9fbd34d9f9a32efd7b6a6aae14125d8237b10403b422a6a6dfeac2806146" + url: "https://pub.dev" + source: hosted + version: "1.1.13" + vector_graphics_compiler: + dependency: transitive + description: + name: vector_graphics_compiler + sha256: "5a88dd14c0954a5398af544651c7fb51b457a2a556949bfb25369b210ef73a74" + url: "https://pub.dev" + source: hosted + version: "1.2.0" + vector_math: + dependency: transitive + description: + name: vector_math + sha256: d530bd74fea330e6e364cda7a85019c434070188383e1cd8d9777ee586914c5b + url: "https://pub.dev" + source: hosted + version: "2.2.0" + vm_service: + dependency: transitive + description: + name: vm_service + sha256: "45caa6c5917fa127b5dbcfbd1fa60b14e583afdc08bfc96dda38886ca252eb60" + url: "https://pub.dev" + source: hosted + version: "15.0.2" + watcher: + dependency: transitive + description: + name: watcher + sha256: "1398c9f081a753f9226febe8900fce8f7d0a67163334e1c94a2438339d79d635" + url: "https://pub.dev" + source: hosted + version: "1.2.1" + web: + dependency: transitive + description: + name: web + sha256: "868d88a33d8a87b18ffc05f9f030ba328ffefba92d6c127917a2ba740f9cfe4a" + url: "https://pub.dev" + source: hosted + version: "1.1.1" + web_socket: + dependency: transitive + description: + name: web_socket + sha256: "34d64019aa8e36bf9842ac014bb5d2f5586ca73df5e4d9bf5c936975cae6982c" + url: "https://pub.dev" + source: hosted + version: "1.0.1" + web_socket_channel: + dependency: transitive + description: + name: web_socket_channel + sha256: d645757fb0f4773d602444000a8131ff5d48c9e47adfe9772652dd1a4f2d45c8 + url: "https://pub.dev" + source: hosted + version: "3.0.3" + xdg_directories: + dependency: transitive + description: + name: xdg_directories + sha256: "7a3f37b05d989967cdddcbb571f1ea834867ae2faa29725fd085180e0883aa15" + url: "https://pub.dev" + source: hosted + version: "1.1.0" + xml: + dependency: transitive + description: + name: xml + sha256: "971043b3a0d3da28727e40ed3e0b5d18b742fa5a68665cca88e74b7876d5e025" + url: "https://pub.dev" + source: hosted + version: "6.6.1" + yaml: + dependency: transitive + description: + name: yaml + sha256: b9da305ac7c39faa3f030eccd175340f968459dae4af175130b3fc47e40d76ce + url: "https://pub.dev" + source: hosted + version: "3.1.3" +sdks: + dart: ">=3.10.3 <4.0.0" + flutter: ">=3.38.4" diff --git a/app/pubspec.yaml b/app/pubspec.yaml new file mode 100644 index 0000000..60c43d1 --- /dev/null +++ b/app/pubspec.yaml @@ -0,0 +1,75 @@ +name: hha_logistics +version: 1.0.0+1 +publish_to: none +description: HHA Logistics - Moderne Flutter App für die Hamburger Hochbahn +environment: + sdk: '>=3.0.0 <4.0.0' + +dependencies: + flutter: + sdk: flutter + flutter_localizations: + sdk: flutter + + # State Management + flutter_bloc: ^8.1.3 + equatable: ^2.0.5 + + # Navigation + go_router: ^12.1.1 + + # Local Storage + sqflite: ^2.3.0 + path_provider: ^2.1.1 + shared_preferences: ^2.2.2 + + # Networking + dio: ^5.4.0 + connectivity_plus: ^5.0.2 + + # Barcode Scanning + mobile_scanner: ^3.5.5 + + # UI Components + shimmer: ^3.0.0 + flutter_slidable: ^3.0.1 + badges: ^3.1.2 + flutter_animate: ^4.3.0 + lottie: ^2.7.0 + + # Icons & Fonts + cupertino_icons: ^1.0.6 + google_fonts: ^6.1.0 + flutter_svg: ^2.0.9 + phosphor_flutter: ^2.0.1 + + # Utils + intl: ^0.20.2 + uuid: ^4.2.1 + logger: ^2.0.2 + freezed_annotation: ^2.4.1 + json_annotation: ^4.8.1 + dartz: ^0.10.1 + +dev_dependencies: + flutter_test: + sdk: flutter + flutter_lints: ^3.0.1 + build_runner: ^2.4.7 + freezed: ^2.4.5 + json_serializable: ^6.7.1 + flutter_launcher_icons: ^0.13.1 + +flutter: + uses-material-design: true + + # assets: + # - assets/icons/ + # - assets/animations/ + # - assets/images/ + +flutter_launcher_icons: + android: "launcher_icon" + ios: true + image_path: "assets/icons/app_icon.png" + min_sdk_android: 21 diff --git a/app/run_app.sh b/app/run_app.sh new file mode 100755 index 0000000..8cfed45 --- /dev/null +++ b/app/run_app.sh @@ -0,0 +1,91 @@ +#!/bin/bash + +# Flutter App Start-Skript mit sichtbarem Build-Status +# Usage: ./run_app.sh [device_id] + +set -e + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +# Farben für Output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' # No Color + +echo -e "${BLUE}========================================${NC}" +echo -e "${BLUE} HHA Logistics - Flutter App Start ${NC}" +echo -e "${BLUE}========================================${NC}" +echo "" + +# Device ID aus Parameter oder Default +DEVICE_ID=${1:-"emulator-5554"} + +# Prüfe ob Flutter installiert ist +if ! command -v flutter &> /dev/null; then + echo -e "${RED}❌ Flutter wurde nicht gefunden!${NC}" + echo "Bitte Flutter installieren: https://flutter.dev/docs/get-started/install" + exit 1 +fi + +echo -e "${BLUE}📱 Verfügbare Geräte:${NC}" +flutter devices +echo "" + +# Prüfe ob gewähltes Gerät existiert +echo -e "${BLUE}🔍 Prüfe Gerät: $DEVICE_ID${NC}" +if ! flutter devices | grep -q "$DEVICE_ID"; then + echo -e "${YELLOW}⚠️ Gerät '$DEVICE_ID' nicht gefunden!${NC}" + echo -e "${YELLOW} Versuche verfügbare Geräte zu finden...${NC}" + echo "" + + # Suche nach Android Emulator + AVAILABLE_EMULATOR=$(flutter devices | grep "emulator" | head -1 | awk '{print $2}') + + if [ -n "$AVAILABLE_EMULATOR" ]; then + echo -e "${GREEN}✅ Emulator gefunden: $AVAILABLE_EMULATOR${NC}" + DEVICE_ID=$AVAILABLE_EMULATOR + else + echo -e "${RED}❌ Kein Emulator gefunden!${NC}" + echo "" + echo "Verfügbare Emulatoren:" + flutter emulators + echo "" + echo -e "${YELLOW}Starte Emulator...${NC}" + flutter emulators --launch Pixel_8_Pro_API_29 2>/dev/null || true + sleep 5 + fi +fi + +echo "" +echo -e "${BLUE}📦 Installiere Dependencies...${NC}" +flutter pub get + +echo "" +echo -e "${BLUE}🔨 Starte Build...${NC}" +echo -e "${YELLOW} Das kann einige Minuten dauern beim ersten Mal!${NC}" +echo "" + +# Zeige Build-Fortschritt mit verbose +flutter run -d "$DEVICE_ID" --debug --verbose 2>&1 | while IFS= read -r line; do + # Filtere wichtige Build-Schritte + if [[ $line == *"Building APK"* ]] || [[ $line == *"Compiling"* ]] || [[ $line == *"Installing"* ]] || [[ $line == *"Launching"* ]]; then + echo -e "${GREEN}🔄 $line${NC}" + elif [[ $line == *"error"* ]] || [[ $line == *"Error"* ]] || [[ $line == *"FAILED"* ]]; then + echo -e "${RED}❌ $line${NC}" + elif [[ $line == *"Syncing"* ]] || [[ $line == *"Reloaded"* ]]; then + echo -e "${BLUE}💫 $line${NC}" + else + # Normale Ausgabe nur bei verbose-Modus relevant + if [[ $line == *"[+"* ]] || [[ $line == *"lib/"* ]]; then + echo "$line" + fi + fi +done + +echo "" +echo -e "${GREEN}========================================${NC}" +echo -e "${GREEN} App beendet ${NC}" +echo -e "${GREEN}========================================${NC}" diff --git a/backend/.gitignore b/backend/.gitignore new file mode 100644 index 0000000..bc9caa6 --- /dev/null +++ b/backend/.gitignore @@ -0,0 +1,34 @@ +node_modules +HELP.md +target/ +.mvn/wrapper/maven-wrapper.jar +!**/src/main/**/target/ +!**/src/test/**/target/ + +### STS ### +.apt_generated +.classpath +.factorypath +.project +.settings +.springBeans +.sts4-cache + +### IntelliJ IDEA ### +.idea +*.iws +*.iml +*.ipr + +### NetBeans ### +/nbproject/private/ +/nbbuild/ +/dist/ +/nbdist/ +/.nb-gradle/ +build/ +!**/src/main/**/build/ +!**/src/test/**/build/ + +### VS Code ### +.vscode/ diff --git a/backend/.mvn/wrapper/maven-wrapper.properties b/backend/.mvn/wrapper/maven-wrapper.properties new file mode 100644 index 0000000..c595b00 --- /dev/null +++ b/backend/.mvn/wrapper/maven-wrapper.properties @@ -0,0 +1,3 @@ +wrapperVersion=3.3.4 +distributionType=only-script +distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.14/apache-maven-3.9.14-bin.zip diff --git a/backend/mvnw b/backend/mvnw new file mode 100755 index 0000000..bd8896b --- /dev/null +++ b/backend/mvnw @@ -0,0 +1,295 @@ +#!/bin/sh +# ---------------------------------------------------------------------------- +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# ---------------------------------------------------------------------------- + +# ---------------------------------------------------------------------------- +# Apache Maven Wrapper startup batch script, version 3.3.4 +# +# Optional ENV vars +# ----------------- +# JAVA_HOME - location of a JDK home dir, required when download maven via java source +# MVNW_REPOURL - repo url base for downloading maven distribution +# MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven +# MVNW_VERBOSE - true: enable verbose log; debug: trace the mvnw script; others: silence the output +# ---------------------------------------------------------------------------- + +set -euf +[ "${MVNW_VERBOSE-}" != debug ] || set -x + +# OS specific support. +native_path() { printf %s\\n "$1"; } +case "$(uname)" in +CYGWIN* | MINGW*) + [ -z "${JAVA_HOME-}" ] || JAVA_HOME="$(cygpath --unix "$JAVA_HOME")" + native_path() { cygpath --path --windows "$1"; } + ;; +esac + +# set JAVACMD and JAVACCMD +set_java_home() { + # For Cygwin and MinGW, ensure paths are in Unix format before anything is touched + if [ -n "${JAVA_HOME-}" ]; then + if [ -x "$JAVA_HOME/jre/sh/java" ]; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + JAVACCMD="$JAVA_HOME/jre/sh/javac" + else + JAVACMD="$JAVA_HOME/bin/java" + JAVACCMD="$JAVA_HOME/bin/javac" + + if [ ! -x "$JAVACMD" ] || [ ! -x "$JAVACCMD" ]; then + echo "The JAVA_HOME environment variable is not defined correctly, so mvnw cannot run." >&2 + echo "JAVA_HOME is set to \"$JAVA_HOME\", but \"\$JAVA_HOME/bin/java\" or \"\$JAVA_HOME/bin/javac\" does not exist." >&2 + return 1 + fi + fi + else + JAVACMD="$( + 'set' +e + 'unset' -f command 2>/dev/null + 'command' -v java + )" || : + JAVACCMD="$( + 'set' +e + 'unset' -f command 2>/dev/null + 'command' -v javac + )" || : + + if [ ! -x "${JAVACMD-}" ] || [ ! -x "${JAVACCMD-}" ]; then + echo "The java/javac command does not exist in PATH nor is JAVA_HOME set, so mvnw cannot run." >&2 + return 1 + fi + fi +} + +# hash string like Java String::hashCode +hash_string() { + str="${1:-}" h=0 + while [ -n "$str" ]; do + char="${str%"${str#?}"}" + h=$(((h * 31 + $(LC_CTYPE=C printf %d "'$char")) % 4294967296)) + str="${str#?}" + done + printf %x\\n $h +} + +verbose() { :; } +[ "${MVNW_VERBOSE-}" != true ] || verbose() { printf %s\\n "${1-}"; } + +die() { + printf %s\\n "$1" >&2 + exit 1 +} + +trim() { + # MWRAPPER-139: + # Trims trailing and leading whitespace, carriage returns, tabs, and linefeeds. + # Needed for removing poorly interpreted newline sequences when running in more + # exotic environments such as mingw bash on Windows. + printf "%s" "${1}" | tr -d '[:space:]' +} + +scriptDir="$(dirname "$0")" +scriptName="$(basename "$0")" + +# parse distributionUrl and optional distributionSha256Sum, requires .mvn/wrapper/maven-wrapper.properties +while IFS="=" read -r key value; do + case "${key-}" in + distributionUrl) distributionUrl=$(trim "${value-}") ;; + distributionSha256Sum) distributionSha256Sum=$(trim "${value-}") ;; + esac +done <"$scriptDir/.mvn/wrapper/maven-wrapper.properties" +[ -n "${distributionUrl-}" ] || die "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties" + +case "${distributionUrl##*/}" in +maven-mvnd-*bin.*) + MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ + case "${PROCESSOR_ARCHITECTURE-}${PROCESSOR_ARCHITEW6432-}:$(uname -a)" in + *AMD64:CYGWIN* | *AMD64:MINGW*) distributionPlatform=windows-amd64 ;; + :Darwin*x86_64) distributionPlatform=darwin-amd64 ;; + :Darwin*arm64) distributionPlatform=darwin-aarch64 ;; + :Linux*x86_64*) distributionPlatform=linux-amd64 ;; + *) + echo "Cannot detect native platform for mvnd on $(uname)-$(uname -m), use pure java version" >&2 + distributionPlatform=linux-amd64 + ;; + esac + distributionUrl="${distributionUrl%-bin.*}-$distributionPlatform.zip" + ;; +maven-mvnd-*) MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ ;; +*) MVN_CMD="mvn${scriptName#mvnw}" _MVNW_REPO_PATTERN=/org/apache/maven/ ;; +esac + +# apply MVNW_REPOURL and calculate MAVEN_HOME +# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-,maven-mvnd--}/ +[ -z "${MVNW_REPOURL-}" ] || distributionUrl="$MVNW_REPOURL$_MVNW_REPO_PATTERN${distributionUrl#*"$_MVNW_REPO_PATTERN"}" +distributionUrlName="${distributionUrl##*/}" +distributionUrlNameMain="${distributionUrlName%.*}" +distributionUrlNameMain="${distributionUrlNameMain%-bin}" +MAVEN_USER_HOME="${MAVEN_USER_HOME:-${HOME}/.m2}" +MAVEN_HOME="${MAVEN_USER_HOME}/wrapper/dists/${distributionUrlNameMain-}/$(hash_string "$distributionUrl")" + +exec_maven() { + unset MVNW_VERBOSE MVNW_USERNAME MVNW_PASSWORD MVNW_REPOURL || : + exec "$MAVEN_HOME/bin/$MVN_CMD" "$@" || die "cannot exec $MAVEN_HOME/bin/$MVN_CMD" +} + +if [ -d "$MAVEN_HOME" ]; then + verbose "found existing MAVEN_HOME at $MAVEN_HOME" + exec_maven "$@" +fi + +case "${distributionUrl-}" in +*?-bin.zip | *?maven-mvnd-?*-?*.zip) ;; +*) die "distributionUrl is not valid, must match *-bin.zip or maven-mvnd-*.zip, but found '${distributionUrl-}'" ;; +esac + +# prepare tmp dir +if TMP_DOWNLOAD_DIR="$(mktemp -d)" && [ -d "$TMP_DOWNLOAD_DIR" ]; then + clean() { rm -rf -- "$TMP_DOWNLOAD_DIR"; } + trap clean HUP INT TERM EXIT +else + die "cannot create temp dir" +fi + +mkdir -p -- "${MAVEN_HOME%/*}" + +# Download and Install Apache Maven +verbose "Couldn't find MAVEN_HOME, downloading and installing it ..." +verbose "Downloading from: $distributionUrl" +verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName" + +# select .zip or .tar.gz +if ! command -v unzip >/dev/null; then + distributionUrl="${distributionUrl%.zip}.tar.gz" + distributionUrlName="${distributionUrl##*/}" +fi + +# verbose opt +__MVNW_QUIET_WGET=--quiet __MVNW_QUIET_CURL=--silent __MVNW_QUIET_UNZIP=-q __MVNW_QUIET_TAR='' +[ "${MVNW_VERBOSE-}" != true ] || __MVNW_QUIET_WGET='' __MVNW_QUIET_CURL='' __MVNW_QUIET_UNZIP='' __MVNW_QUIET_TAR=v + +# normalize http auth +case "${MVNW_PASSWORD:+has-password}" in +'') MVNW_USERNAME='' MVNW_PASSWORD='' ;; +has-password) [ -n "${MVNW_USERNAME-}" ] || MVNW_USERNAME='' MVNW_PASSWORD='' ;; +esac + +if [ -z "${MVNW_USERNAME-}" ] && command -v wget >/dev/null; then + verbose "Found wget ... using wget" + wget ${__MVNW_QUIET_WGET:+"$__MVNW_QUIET_WGET"} "$distributionUrl" -O "$TMP_DOWNLOAD_DIR/$distributionUrlName" || die "wget: Failed to fetch $distributionUrl" +elif [ -z "${MVNW_USERNAME-}" ] && command -v curl >/dev/null; then + verbose "Found curl ... using curl" + curl ${__MVNW_QUIET_CURL:+"$__MVNW_QUIET_CURL"} -f -L -o "$TMP_DOWNLOAD_DIR/$distributionUrlName" "$distributionUrl" || die "curl: Failed to fetch $distributionUrl" +elif set_java_home; then + verbose "Falling back to use Java to download" + javaSource="$TMP_DOWNLOAD_DIR/Downloader.java" + targetZip="$TMP_DOWNLOAD_DIR/$distributionUrlName" + cat >"$javaSource" <<-END + public class Downloader extends java.net.Authenticator + { + protected java.net.PasswordAuthentication getPasswordAuthentication() + { + return new java.net.PasswordAuthentication( System.getenv( "MVNW_USERNAME" ), System.getenv( "MVNW_PASSWORD" ).toCharArray() ); + } + public static void main( String[] args ) throws Exception + { + setDefault( new Downloader() ); + java.nio.file.Files.copy( java.net.URI.create( args[0] ).toURL().openStream(), java.nio.file.Paths.get( args[1] ).toAbsolutePath().normalize() ); + } + } + END + # For Cygwin/MinGW, switch paths to Windows format before running javac and java + verbose " - Compiling Downloader.java ..." + "$(native_path "$JAVACCMD")" "$(native_path "$javaSource")" || die "Failed to compile Downloader.java" + verbose " - Running Downloader.java ..." + "$(native_path "$JAVACMD")" -cp "$(native_path "$TMP_DOWNLOAD_DIR")" Downloader "$distributionUrl" "$(native_path "$targetZip")" +fi + +# If specified, validate the SHA-256 sum of the Maven distribution zip file +if [ -n "${distributionSha256Sum-}" ]; then + distributionSha256Result=false + if [ "$MVN_CMD" = mvnd.sh ]; then + echo "Checksum validation is not supported for maven-mvnd." >&2 + echo "Please disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2 + exit 1 + elif command -v sha256sum >/dev/null; then + if echo "$distributionSha256Sum $TMP_DOWNLOAD_DIR/$distributionUrlName" | sha256sum -c - >/dev/null 2>&1; then + distributionSha256Result=true + fi + elif command -v shasum >/dev/null; then + if echo "$distributionSha256Sum $TMP_DOWNLOAD_DIR/$distributionUrlName" | shasum -a 256 -c >/dev/null 2>&1; then + distributionSha256Result=true + fi + else + echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2 + echo "Please install either command, or disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2 + exit 1 + fi + if [ $distributionSha256Result = false ]; then + echo "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised." >&2 + echo "If you updated your Maven version, you need to update the specified distributionSha256Sum property." >&2 + exit 1 + fi +fi + +# unzip and move +if command -v unzip >/dev/null; then + unzip ${__MVNW_QUIET_UNZIP:+"$__MVNW_QUIET_UNZIP"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -d "$TMP_DOWNLOAD_DIR" || die "failed to unzip" +else + tar xzf${__MVNW_QUIET_TAR:+"$__MVNW_QUIET_TAR"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -C "$TMP_DOWNLOAD_DIR" || die "failed to untar" +fi + +# Find the actual extracted directory name (handles snapshots where filename != directory name) +actualDistributionDir="" + +# First try the expected directory name (for regular distributions) +if [ -d "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" ]; then + if [ -f "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain/bin/$MVN_CMD" ]; then + actualDistributionDir="$distributionUrlNameMain" + fi +fi + +# If not found, search for any directory with the Maven executable (for snapshots) +if [ -z "$actualDistributionDir" ]; then + # enable globbing to iterate over items + set +f + for dir in "$TMP_DOWNLOAD_DIR"/*; do + if [ -d "$dir" ]; then + if [ -f "$dir/bin/$MVN_CMD" ]; then + actualDistributionDir="$(basename "$dir")" + break + fi + fi + done + set -f +fi + +if [ -z "$actualDistributionDir" ]; then + verbose "Contents of $TMP_DOWNLOAD_DIR:" + verbose "$(ls -la "$TMP_DOWNLOAD_DIR")" + die "Could not find Maven distribution directory in extracted archive" +fi + +verbose "Found extracted Maven distribution directory: $actualDistributionDir" +printf %s\\n "$distributionUrl" >"$TMP_DOWNLOAD_DIR/$actualDistributionDir/mvnw.url" +mv -- "$TMP_DOWNLOAD_DIR/$actualDistributionDir" "$MAVEN_HOME" || [ -d "$MAVEN_HOME" ] || die "fail to move MAVEN_HOME" + +clean || : +exec_maven "$@" diff --git a/backend/mvnw.cmd b/backend/mvnw.cmd new file mode 100644 index 0000000..92450f9 --- /dev/null +++ b/backend/mvnw.cmd @@ -0,0 +1,189 @@ +<# : batch portion +@REM ---------------------------------------------------------------------------- +@REM Licensed to the Apache Software Foundation (ASF) under one +@REM or more contributor license agreements. See the NOTICE file +@REM distributed with this work for additional information +@REM regarding copyright ownership. The ASF licenses this file +@REM to you under the Apache License, Version 2.0 (the +@REM "License"); you may not use this file except in compliance +@REM with the License. You may obtain a copy of the License at +@REM +@REM http://www.apache.org/licenses/LICENSE-2.0 +@REM +@REM Unless required by applicable law or agreed to in writing, +@REM software distributed under the License is distributed on an +@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +@REM KIND, either express or implied. See the License for the +@REM specific language governing permissions and limitations +@REM under the License. +@REM ---------------------------------------------------------------------------- + +@REM ---------------------------------------------------------------------------- +@REM Apache Maven Wrapper startup batch script, version 3.3.4 +@REM +@REM Optional ENV vars +@REM MVNW_REPOURL - repo url base for downloading maven distribution +@REM MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven +@REM MVNW_VERBOSE - true: enable verbose log; others: silence the output +@REM ---------------------------------------------------------------------------- + +@IF "%__MVNW_ARG0_NAME__%"=="" (SET __MVNW_ARG0_NAME__=%~nx0) +@SET __MVNW_CMD__= +@SET __MVNW_ERROR__= +@SET __MVNW_PSMODULEP_SAVE=%PSModulePath% +@SET PSModulePath= +@FOR /F "usebackq tokens=1* delims==" %%A IN (`powershell -noprofile "& {$scriptDir='%~dp0'; $script='%__MVNW_ARG0_NAME__%'; icm -ScriptBlock ([Scriptblock]::Create((Get-Content -Raw '%~f0'))) -NoNewScope}"`) DO @( + IF "%%A"=="MVN_CMD" (set __MVNW_CMD__=%%B) ELSE IF "%%B"=="" (echo %%A) ELSE (echo %%A=%%B) +) +@SET PSModulePath=%__MVNW_PSMODULEP_SAVE% +@SET __MVNW_PSMODULEP_SAVE= +@SET __MVNW_ARG0_NAME__= +@SET MVNW_USERNAME= +@SET MVNW_PASSWORD= +@IF NOT "%__MVNW_CMD__%"=="" ("%__MVNW_CMD__%" %*) +@echo Cannot start maven from wrapper >&2 && exit /b 1 +@GOTO :EOF +: end batch / begin powershell #> + +$ErrorActionPreference = "Stop" +if ($env:MVNW_VERBOSE -eq "true") { + $VerbosePreference = "Continue" +} + +# calculate distributionUrl, requires .mvn/wrapper/maven-wrapper.properties +$distributionUrl = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionUrl +if (!$distributionUrl) { + Write-Error "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties" +} + +switch -wildcard -casesensitive ( $($distributionUrl -replace '^.*/','') ) { + "maven-mvnd-*" { + $USE_MVND = $true + $distributionUrl = $distributionUrl -replace '-bin\.[^.]*$',"-windows-amd64.zip" + $MVN_CMD = "mvnd.cmd" + break + } + default { + $USE_MVND = $false + $MVN_CMD = $script -replace '^mvnw','mvn' + break + } +} + +# apply MVNW_REPOURL and calculate MAVEN_HOME +# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-,maven-mvnd--}/ +if ($env:MVNW_REPOURL) { + $MVNW_REPO_PATTERN = if ($USE_MVND -eq $False) { "/org/apache/maven/" } else { "/maven/mvnd/" } + $distributionUrl = "$env:MVNW_REPOURL$MVNW_REPO_PATTERN$($distributionUrl -replace "^.*$MVNW_REPO_PATTERN",'')" +} +$distributionUrlName = $distributionUrl -replace '^.*/','' +$distributionUrlNameMain = $distributionUrlName -replace '\.[^.]*$','' -replace '-bin$','' + +$MAVEN_M2_PATH = "$HOME/.m2" +if ($env:MAVEN_USER_HOME) { + $MAVEN_M2_PATH = "$env:MAVEN_USER_HOME" +} + +if (-not (Test-Path -Path $MAVEN_M2_PATH)) { + New-Item -Path $MAVEN_M2_PATH -ItemType Directory | Out-Null +} + +$MAVEN_WRAPPER_DISTS = $null +if ((Get-Item $MAVEN_M2_PATH).Target[0] -eq $null) { + $MAVEN_WRAPPER_DISTS = "$MAVEN_M2_PATH/wrapper/dists" +} else { + $MAVEN_WRAPPER_DISTS = (Get-Item $MAVEN_M2_PATH).Target[0] + "/wrapper/dists" +} + +$MAVEN_HOME_PARENT = "$MAVEN_WRAPPER_DISTS/$distributionUrlNameMain" +$MAVEN_HOME_NAME = ([System.Security.Cryptography.SHA256]::Create().ComputeHash([byte[]][char[]]$distributionUrl) | ForEach-Object {$_.ToString("x2")}) -join '' +$MAVEN_HOME = "$MAVEN_HOME_PARENT/$MAVEN_HOME_NAME" + +if (Test-Path -Path "$MAVEN_HOME" -PathType Container) { + Write-Verbose "found existing MAVEN_HOME at $MAVEN_HOME" + Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD" + exit $? +} + +if (! $distributionUrlNameMain -or ($distributionUrlName -eq $distributionUrlNameMain)) { + Write-Error "distributionUrl is not valid, must end with *-bin.zip, but found $distributionUrl" +} + +# prepare tmp dir +$TMP_DOWNLOAD_DIR_HOLDER = New-TemporaryFile +$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir" +$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null +trap { + if ($TMP_DOWNLOAD_DIR.Exists) { + try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null } + catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" } + } +} + +New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null + +# Download and Install Apache Maven +Write-Verbose "Couldn't find MAVEN_HOME, downloading and installing it ..." +Write-Verbose "Downloading from: $distributionUrl" +Write-Verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName" + +$webclient = New-Object System.Net.WebClient +if ($env:MVNW_USERNAME -and $env:MVNW_PASSWORD) { + $webclient.Credentials = New-Object System.Net.NetworkCredential($env:MVNW_USERNAME, $env:MVNW_PASSWORD) +} +[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12 +$webclient.DownloadFile($distributionUrl, "$TMP_DOWNLOAD_DIR/$distributionUrlName") | Out-Null + +# If specified, validate the SHA-256 sum of the Maven distribution zip file +$distributionSha256Sum = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionSha256Sum +if ($distributionSha256Sum) { + if ($USE_MVND) { + Write-Error "Checksum validation is not supported for maven-mvnd. `nPlease disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." + } + Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash + if ((Get-FileHash "$TMP_DOWNLOAD_DIR/$distributionUrlName" -Algorithm SHA256).Hash.ToLower() -ne $distributionSha256Sum) { + Write-Error "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised. If you updated your Maven version, you need to update the specified distributionSha256Sum property." + } +} + +# unzip and move +Expand-Archive "$TMP_DOWNLOAD_DIR/$distributionUrlName" -DestinationPath "$TMP_DOWNLOAD_DIR" | Out-Null + +# Find the actual extracted directory name (handles snapshots where filename != directory name) +$actualDistributionDir = "" + +# First try the expected directory name (for regular distributions) +$expectedPath = Join-Path "$TMP_DOWNLOAD_DIR" "$distributionUrlNameMain" +$expectedMvnPath = Join-Path "$expectedPath" "bin/$MVN_CMD" +if ((Test-Path -Path $expectedPath -PathType Container) -and (Test-Path -Path $expectedMvnPath -PathType Leaf)) { + $actualDistributionDir = $distributionUrlNameMain +} + +# If not found, search for any directory with the Maven executable (for snapshots) +if (!$actualDistributionDir) { + Get-ChildItem -Path "$TMP_DOWNLOAD_DIR" -Directory | ForEach-Object { + $testPath = Join-Path $_.FullName "bin/$MVN_CMD" + if (Test-Path -Path $testPath -PathType Leaf) { + $actualDistributionDir = $_.Name + } + } +} + +if (!$actualDistributionDir) { + Write-Error "Could not find Maven distribution directory in extracted archive" +} + +Write-Verbose "Found extracted Maven distribution directory: $actualDistributionDir" +Rename-Item -Path "$TMP_DOWNLOAD_DIR/$actualDistributionDir" -NewName $MAVEN_HOME_NAME | Out-Null +try { + Move-Item -Path "$TMP_DOWNLOAD_DIR/$MAVEN_HOME_NAME" -Destination $MAVEN_HOME_PARENT | Out-Null +} catch { + if (! (Test-Path -Path "$MAVEN_HOME" -PathType Container)) { + Write-Error "fail to move MAVEN_HOME" + } +} finally { + try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null } + catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" } +} + +Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD" diff --git a/backend/pom.xml b/backend/pom.xml new file mode 100644 index 0000000..6c89ff0 --- /dev/null +++ b/backend/pom.xml @@ -0,0 +1,88 @@ + + + 4.0.0 + + + org.springframework.boot + spring-boot-starter-parent + 4.0.3 + + + + de.assecutor.hha + hha-backend + 0.0.1-SNAPSHOT + HHA Backend + Spring Boot and Vaadin backoffice module for the HHA repository. + + + 21 + 25.0.7 + + + + + + com.vaadin + vaadin-bom + ${vaadin.version} + pom + import + + + + + + + org.springframework.boot + spring-boot-starter-actuator + + + org.springframework.boot + spring-boot-starter-webmvc + + + com.vaadin + vaadin-dev + true + + + com.vaadin + vaadin-spring-boot-starter + + + + org.springframework.boot + spring-boot-starter-actuator-test + test + + + org.springframework.boot + spring-boot-starter-webmvc-test + test + + + + + + + com.vaadin + vaadin-maven-plugin + ${vaadin.version} + + + build-frontend + + build-frontend + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + + diff --git a/backend/src/main/frontend/generated/app-shell-imports.d.ts b/backend/src/main/frontend/generated/app-shell-imports.d.ts new file mode 100644 index 0000000..693da49 --- /dev/null +++ b/backend/src/main/frontend/generated/app-shell-imports.d.ts @@ -0,0 +1 @@ +export {} \ No newline at end of file diff --git a/backend/src/main/frontend/generated/app-shell-imports.js b/backend/src/main/frontend/generated/app-shell-imports.js new file mode 100644 index 0000000..e69de29 diff --git a/backend/src/main/frontend/generated/css.generated.d.ts b/backend/src/main/frontend/generated/css.generated.d.ts new file mode 100644 index 0000000..ba07dc0 --- /dev/null +++ b/backend/src/main/frontend/generated/css.generated.d.ts @@ -0,0 +1 @@ +export declare const applyCss: (target: Node) => void; \ No newline at end of file diff --git a/backend/src/main/frontend/generated/flow/Flow.tsx b/backend/src/main/frontend/generated/flow/Flow.tsx new file mode 100644 index 0000000..796e581 --- /dev/null +++ b/backend/src/main/frontend/generated/flow/Flow.tsx @@ -0,0 +1,706 @@ +/* + * Copyright 2000-2026 Vaadin Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +/// +import { Flow as _Flow } from 'Frontend/generated/jar-resources/Flow.js'; +import React, { useCallback, useEffect, useReducer, useRef, useState, type ReactNode } from 'react'; +import { matchRoutes, useBlocker, useLocation, useNavigate, type NavigateOptions, useHref } from 'react-router'; +import { createPortal } from 'react-dom'; + +const flow = new _Flow({ + imports: () => import('Frontend/generated/flow/generated-flow-imports.js') +}); + +const router = { + render() { + return Promise.resolve(); + } +}; + +const flowReact : { active: boolean } = { + active: false, +} + +// ClickHandler for vaadin-router-go event is copied from vaadin/router click.js +// @ts-ignore +function getAnchorOrigin(anchor) { + // IE11: on HTTP and HTTPS the default port is not included into + // window.location.origin, so won't include it here either. + const port = anchor.port; + const protocol = anchor.protocol; + const defaultHttp = protocol === 'http:' && port === '80'; + const defaultHttps = protocol === 'https:' && port === '443'; + const host = + defaultHttp || defaultHttps + ? anchor.hostname // does not include the port number (e.g. www.example.org) + : anchor.host; // does include the port number (e.g. www.example.org:80) + return `${protocol}//${host}`; +} + +function normalizeURL(url: URL): void | string { + // ignore click if baseURI does not match the document (external) + if (!url.href.startsWith(document.baseURI)) { + return; + } + + // Normalize path against baseURI + return '/' + url.href.slice(document.baseURI.length); +} + +function extractURL(event: MouseEvent): void | URL { + // ignore the click if the default action is prevented + if (event.defaultPrevented) { + return; + } + + // ignore the click if not with the primary mouse button + if (event.button !== 0) { + return; + } + + // ignore the click if a modifier key is pressed + if (event.shiftKey || event.ctrlKey || event.altKey || event.metaKey) { + return; + } + + // find the element that the click is at (or within) + let maybeAnchor = event.target; + const path = event.composedPath + ? event.composedPath() + : // @ts-ignore + event.path || []; + + // example to check: `for...of` loop here throws the "Not yet implemented" error + for (let i = 0; i < path.length; i++) { + const target = path[i]; + if (target.nodeName && target.nodeName.toLowerCase() === 'a') { + maybeAnchor = target; + break; + } + } + + // @ts-ignore + while (maybeAnchor && maybeAnchor.nodeName.toLowerCase() !== 'a') { + // @ts-ignore + maybeAnchor = maybeAnchor.parentNode; + } + + // ignore the click if not at an element + // @ts-ignore + if (!maybeAnchor || maybeAnchor.nodeName.toLowerCase() !== 'a') { + return; + } + + const anchor = maybeAnchor as HTMLAnchorElement; + + // ignore the click if the element has a non-default target + if (anchor.target && anchor.target.toLowerCase() !== '_self') { + return; + } + + // ignore the click if the element has the 'download' attribute + if (anchor.hasAttribute('download')) { + return; + } + + // ignore the click if the element has the 'router-ignore' attribute + if (anchor.hasAttribute('router-ignore')) { + return; + } + + // ignore the click if the target URL is a fragment on the current page + if (anchor.pathname === window.location.pathname && anchor.hash !== '') { + // @ts-ignore + window.location.hash = anchor.hash; + return; + } + + // ignore the click if the target is external to the app + // In IE11 HTMLAnchorElement does not have the `origin` property + // @ts-ignore + const origin = anchor.origin || getAnchorOrigin(anchor); + if (origin !== window.location.origin) { + return; + } + + return new URL(anchor.href, anchor.baseURI); +} + +function extractPath(event: MouseEvent): void | string { + const url = extractURL(event); + if (!url) { + return; + } + return normalizeURL(url); +} + +export const registerGlobalClickHandler = () => { + window.addEventListener('click', (event: MouseEvent) => { + if (flowReact.active) { + return; + } + const url = extractURL(event); + if (!url) { + return; + } + // ignore click if baseURI does not match the document (external) + if (!url.href.startsWith(document.baseURI)) { + return; + } + if (event && event.preventDefault) { + event.preventDefault(); + } + + // Normalize path against baseURI + const path = url.pathname + url.search + url.hash; + const state = {...window.history.state} + if (state.idx !== undefined) { + state.idx = state.idx + 1; + } + window.history.pushState(state, '', path); + window.dispatchEvent(new PopStateEvent('popstate')); + }, { capture: false }); +}; + +/** + * Fire 'vaadin-navigated' event to inform components of navigation. + * @param pathname pathname of navigation + * @param search search of navigation + */ +function fireNavigated(pathname: string, search: string) { + setTimeout(() => { + window.dispatchEvent( + new CustomEvent('vaadin-navigated', { + detail: { + pathname, + search + } + }) + ); + // @ts-ignore + delete window.Vaadin.Flow.navigation; + }); +} + +function postpone() {} + +const prevent = () => postpone; + +type RouterContainer = Awaited>; + +type PortalEntry = { + readonly children: ReactNode; + readonly domNode: HTMLElement; +}; + +type FlowPortalProps = React.PropsWithChildren< + Readonly<{ + domNode: HTMLElement; + onRemove(): void; + }> +>; + +function FlowPortal({ children, domNode, onRemove }: FlowPortalProps) { + useEffect(() => { + domNode.addEventListener( + 'flow-portal-remove', + (event: Event) => { + event.preventDefault(); + onRemove(); + }, + { once: true } + ); + }, []); + + return createPortal(children, domNode); +} + +const ADD_FLOW_PORTAL = 'ADD_FLOW_PORTAL'; + +type AddFlowPortalAction = Readonly<{ + type: typeof ADD_FLOW_PORTAL; + portal: React.ReactElement; +}>; + +function addFlowPortal(portal: React.ReactElement): AddFlowPortalAction { + return { + type: ADD_FLOW_PORTAL, + portal + }; +} + +const REMOVE_FLOW_PORTAL = 'REMOVE_FLOW_PORTAL'; + +type RemoveFlowPortalAction = Readonly<{ + type: typeof REMOVE_FLOW_PORTAL; + key: string; +}>; + +function removeFlowPortal(key: string): RemoveFlowPortalAction { + return { + type: REMOVE_FLOW_PORTAL, + key + }; +} + +function flowPortalsReducer( + portals: readonly React.ReactElement[], + action: AddFlowPortalAction | RemoveFlowPortalAction +) { + switch (action.type) { + case ADD_FLOW_PORTAL: + return [...portals, action.portal]; + case REMOVE_FLOW_PORTAL: + return portals.filter(({ key }) => key !== action.key); + default: + return portals; + } +} + +type NavigateOpts = { + to: string; + callback: boolean; + opts?: NavigateOptions; +}; + +type NavigateFn = (to: string, callback: boolean, opts?: NavigateOptions) => void; + +let navigateInProgress = false; +/** + * A hook providing the `navigate(path: string, opts?: NavigateOptions)` function + * with React Router API that has more consistent history updates. Uses internal + * queue for processing navigate calls. + */ +function useQueuedNavigate( + waitReference: React.MutableRefObject | undefined>, + navigated: React.MutableRefObject +): NavigateFn { + const navigate = useNavigate(); + const navigateQueue = useRef([]).current; + const [navigateQueueLength, setNavigateQueueLength] = useState(0); + + const dequeueNavigation = useCallback(() => { + if (navigateInProgress) { + dequeueNavigationAfterCurrentTask(); + return; + } + + const navigateArgs = navigateQueue.shift(); + if (navigateArgs === undefined) { + // Empty queue, do nothing. + return; + } + + const blockingNavigate = async () => { + if (waitReference.current) { + await waitReference.current; + waitReference.current = undefined; + } + navigated.current = !navigateArgs.callback; + navigateInProgress = true; + navigate(navigateArgs.to, navigateArgs.opts); + setNavigateQueueLength(navigateQueue.length); + }; + blockingNavigate(); + }, [navigate, setNavigateQueueLength]); + + const dequeueNavigationAfterCurrentTask = useCallback(() => { + setTimeout(dequeueNavigation, 0); + }, [dequeueNavigation]); + + const enqueueNavigation = useCallback( + (to: string, callback: boolean, opts?: NavigateOptions) => { + navigateQueue.push({ to: to, callback: callback, opts: opts }); + setNavigateQueueLength(navigateQueue.length); + if (navigateQueue.length === 1) { + // The first navigation can be started right after any pending sync + // jobs, which could add more navigations to the queue. + dequeueNavigationAfterCurrentTask(); + } + }, + [setNavigateQueueLength, dequeueNavigationAfterCurrentTask] + ); + + useEffect( + () => () => { + // The Flow component has rendered, but history might not be + // updated yet, as React Router does it asynchronously. + // Use microtask callback for history consistency. + dequeueNavigationAfterCurrentTask(); + }, + [navigateQueueLength, dequeueNavigationAfterCurrentTask] + ); + + return enqueueNavigation; +} + +const flowNavigation = () => { + // @ts-ignore + window.Vaadin.Flow.navigation = true; +}; + +function Flow() { + const ref = useRef(null); + const navigate = useNavigate(); + const blocker = useBlocker(({ currentLocation, nextLocation }) => { + navigated.current = + navigated.current || + (nextLocation.pathname === currentLocation.pathname && + nextLocation.search === currentLocation.search && + nextLocation.hash === currentLocation.hash); + return true; + }); + const location = useLocation(); + const navigated = useRef(false); + const blockerHandled = useRef(false); + const fromAnchor = useRef(false); + const containerRef = useRef(undefined); + const roundTrip = useRef | undefined>(undefined); + const queuedNavigate = useQueuedNavigate(roundTrip, navigated); + const basename = useHref('/'); + + // portalsReducer function is used as state outside the Flow component. + const [portals, dispatchPortalAction] = useReducer(flowPortalsReducer, []); + + const addPortalEventHandler = useCallback( + (event: CustomEvent) => { + event.preventDefault(); + + const key = Math.random().toString(36).slice(2); + dispatchPortalAction( + addFlowPortal( + dispatchPortalAction(removeFlowPortal(key))} + > + {event.detail.children} + + ) + ); + }, + [dispatchPortalAction] + ); + + const navigateEventHandler = useCallback( + (event: MouseEvent) => { + const path = extractPath(event); + if (!path) { + return; + } + + if (event && event.preventDefault) { + event.preventDefault(); + } + navigated.current = false; + // When navigation is triggered by click on a link, fromAnchor is set to true + // in order to get a server round-trip even when navigating to the same URL again + fromAnchor.current = true; + // @ts-ignore + window.Vaadin.Flow.navigation = true; + navigate(path); + // Dispatch close event for overlay drawer on click navigation. + window.dispatchEvent(new CustomEvent('close-overlay-drawer')); + }, + [navigate] + ); + + const vaadinRouterGoEventHandler = useCallback( + (event: CustomEvent) => { + const url = event.detail; + const path = normalizeURL(url); + if (!path) { + return; + } + + event.preventDefault(); + navigate(path); + }, + [navigate] + ); + + const vaadinNavigateEventHandler = useCallback( + (event: CustomEvent<{ state: unknown; url: string; replace?: boolean; callback: boolean }>) => { + // @ts-ignore + window.Vaadin.Flow.navigation = true; + // clean base uri away if for instance redirected to http://localhost/path/user?id=10 + // else the whole http... will be appended to the url see #19580 + const path = event.detail.url.startsWith(document.baseURI) + ? '/' + event.detail.url.slice(document.baseURI.length) + : '/' + event.detail.url; + fromAnchor.current = false; + queuedNavigate(path, event.detail.callback, { state: event.detail.state, replace: event.detail.replace }); + }, + [navigate] + ); + + const redirect = useCallback( + (path: string) => { + return () => { + navigate(path, { replace: true }); + }; + }, + [navigate] + ); + + useEffect(() => { + // @ts-ignore + window.addEventListener('vaadin-router-go', vaadinRouterGoEventHandler); + // @ts-ignore + window.addEventListener('vaadin-navigate', vaadinNavigateEventHandler); + + return () => { + // @ts-ignore + window.removeEventListener('vaadin-router-go', vaadinRouterGoEventHandler); + // @ts-ignore + window.removeEventListener('vaadin-navigate', vaadinNavigateEventHandler); + }; + }, [vaadinRouterGoEventHandler, vaadinNavigateEventHandler]); + + useEffect(() => { + // @ts-ignore + window.addEventListener("popstate", flowNavigation); + window.addEventListener('click', navigateEventHandler); + flowReact.active = true; + + return () => { + containerRef.current?.parentNode?.removeChild(containerRef.current); + containerRef.current?.removeEventListener('flow-portal-add', addPortalEventHandler as EventListener); + containerRef.current = undefined; + // @ts-ignore + window.removeEventListener("popstate", flowNavigation); + window.removeEventListener('click', navigateEventHandler); + flowReact.active = false; + }; + }, []); + + useEffect(() => { + if (blocker.state === 'blocked') { + if (blockerHandled.current) { + // Blocker is handled and the new navigation + // gets queued to be executed after the current handling ends. + const { pathname, state } = blocker.location; + // Clear base name to not get /baseName/basename/path + const pathNoBase = pathname.substring(basename.length); + // path should always start with / else react-router will append to current url + queuedNavigate(pathNoBase.startsWith('/') ? pathNoBase : '/' + pathNoBase, true, { + state: state, + replace: true + }); + return; + } + blockerHandled.current = true; + let blockingPromise: any; + roundTrip.current = new Promise( + (resolve, reject) => (blockingPromise = { resolve: resolve, reject: reject }) + ); + // Release blocker handling after promise is fulfilled + roundTrip.current.then( + () => (blockerHandled.current = false), + () => (blockerHandled.current = false) + ); + + // Proceed to the blocked location, unless the navigation originates from a click on a link. + // In that case continue with function execution and perform a server round-trip + if (navigated.current && !fromAnchor.current) { + blocker.proceed(); + blockingPromise.resolve(); + navigateInProgress = false; + return; + } + fromAnchor.current = false; + const { pathname, search } = blocker.location; + const routes = ((window as any)?.Vaadin?.routesConfig || []) as any[]; + let matched = matchRoutes(Array.from(routes), pathname); + + // Navigation between server routes + // @ts-ignore + if (matched && matched.filter((path) => path.route?.element?.type?.name === Flow.name).length != 0) { + containerRef.current?.onBeforeEnter?.call( + containerRef?.current, + { pathname, search }, + { + prevent() { + blocker.reset(); + blockingPromise.resolve(); + navigateInProgress = false; + navigated.current = false; + }, + redirect, + continue() { + blocker.proceed(); + blockingPromise.resolve(); + navigateInProgress = false; + } + }, + router + ); + navigated.current = true; + } else { + // For covering the 'server -> client' use case + Promise.resolve( + containerRef.current?.onBeforeLeave?.call( + containerRef?.current, + { + pathname, + search + }, + { prevent }, + router + ) + ).then((cmd: unknown) => { + if (cmd === postpone && containerRef.current) { + // postponed navigation: expose existing blocker to Flow + containerRef.current.serverConnected = (cancel) => { + if (cancel) { + blocker.reset(); + } else { + blocker.proceed(); + } + blockingPromise.resolve(); + navigateInProgress = false; + }; + } else { + // permitted navigation: proceed with the blocker + blocker.proceed(); + blockingPromise.resolve(); + navigateInProgress = false; + } + }); + } + } + }, [blocker.state, blocker.location]); + + useEffect(() => { + if (blocker.state === 'blocked') { + return; + } + if (navigated.current) { + navigated.current = false; + fireNavigated(location.pathname, location.search); + return; + } + flow.serverSideRoutes[0] + .action({ pathname: location.pathname, search: location.search }) + .then((container) => { + const outlet = ref.current?.parentNode; + if (outlet && outlet !== container.parentNode) { + outlet.append(container); + container.addEventListener('flow-portal-add', addPortalEventHandler as EventListener); + containerRef.current = container; + } + return container.onBeforeEnter?.call( + container, + { pathname: location.pathname, search: location.search }, + { + prevent, + redirect, + continue() { + fireNavigated(location.pathname, location.search); + } + }, + router + ); + }) + .then((result: unknown) => { + if (typeof result === 'function') { + result(); + } + }); + }, [location]); + + return ( + <> + + {portals} + + ); +} +Flow.type = 'FlowContainer'; // This is for copilot to recognize this + +export const serverSideRoutes = [{ path: '/*', element: }]; + +/** + * Load the script for an exported WebComponent with the given tag + * + * @param tag name of the exported web-component to load + * + * @returns Promise(resolve, reject) that is fulfilled on script load + */ +export const loadComponentScript = (tag: String): Promise => { + return new Promise((resolve, reject) => { + useEffect(() => { + const script = document.createElement('script'); + script.src = `/web-component/${tag}.js`; + script.onload = function () { + resolve(); + }; + script.onerror = function (err) { + reject(err); + }; + document.head.appendChild(script); + + return () => { + document.head.removeChild(script); + }; + }, []); + }); +}; + +interface Properties { + [key: string]: string; +} + +/** + * Load WebComponent script and create a React element for the WebComponent. + * + * @param tag custom web-component tag name. + * @param props optional Properties object to create element attributes with + * @param onload optional callback to be called for script onload + * @param onerror optional callback for error loading the script + */ +export const reactElement = (tag: string, props?: Properties, onload?: () => void, onerror?: (err: any) => void) => { + loadComponentScript(tag).then( + () => onload?.(), + (err) => { + if (onerror) { + onerror(err); + } else { + console.error(`Failed to load script for ${tag}.`, err); + } + } + ); + + if (props) { + return React.createElement(tag, props); + } + return React.createElement(tag); +}; + +export default Flow; + +// @ts-ignore +if (import.meta.hot) { + // @ts-ignore + import.meta.hot.accept((newModule) => { + // A hot module replace for Flow.tsx happens when any JS/TS imported through @JsModule + // or similar is updated because this updates generated-flow-imports.js and that in turn + // is imported by this file. We have no means of hot replacing those files, e.g. some + // custom lit element so we need to reload the page. */ + if (newModule) { + window.location.reload(); + } + }); +} diff --git a/backend/src/main/frontend/generated/flow/ReactAdapter.tsx b/backend/src/main/frontend/generated/flow/ReactAdapter.tsx new file mode 100644 index 0000000..f956aa2 --- /dev/null +++ b/backend/src/main/frontend/generated/flow/ReactAdapter.tsx @@ -0,0 +1,329 @@ +/* + * Copyright 2000-2026 Vaadin Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +import { createRoot, Root } from 'react-dom/client'; +import { createElement, type Dispatch, type ReactElement, type ReactNode, useEffect, useReducer } from 'react'; + +type FlowStateKeyChangedAction = Readonly<{ + type: 'stateKeyChanged'; + key: K; + value: V; +}>; + +type FlowStateReducerAction = FlowStateKeyChangedAction; + +function stateReducer>>(state: S, action: FlowStateReducerAction): S { + switch (action.type) { + case 'stateKeyChanged': + const { value } = action; + return { + ...state, + key: value + } as S; + default: + return state; + } +} + +type DispatchEvent = T extends undefined ? () => boolean : (value: T) => boolean; + +const emptyAction: Dispatch = () => {}; + +/** + * An object with APIs exposed for using in the {@link ReactAdapterElement#render} + * implementation. + */ +export type RenderHooks = { + /** + * A hook API for using stateful JS properties of the Web Component from + * the React `render()`. + * + * @typeParam T - Type of the state value + * + * @param key - Web Component property name, which is used for two-way + * value propagation from the server and back. + * @param initialValue - Fallback initial value (optional). Only applies if + * the Java component constructor does not invoke `setState`. + * @returns A tuple with two values: + * 1. The current state. + * 2. The `set` function for changing the state and triggering render + * @protected + */ + readonly useState: ReactAdapterElement['useState']; + + /** + * A hook helper to simplify dispatching a `CustomEvent` on the Web + * Component from React. + * + * @typeParam T - The type for `event.detail` value (optional). + * + * @param type - The `CustomEvent` type string. + * @param options - The settings for the `CustomEvent`. + * @returns The `dispatch` function. The function parameters change + * depending on the `T` generic type: + * - For `undefined` type (default), has no parameters. + * - For other types, has one parameter for the `event.detail` value of that type. + * @protected + */ + readonly useCustomEvent: ReactAdapterElement['useCustomEvent']; + + /** + * A hook helper to generate the content element with name attribute to bind + * the server-side Flow element for this component. + * + * This is used together with {@link ReactAdapterComponent::getContentElement} + * to have server-side component attach to the correct client element. + * + * Usage as follows: + * + * const content = hooks.useContent('content'); + * return <> + * {content} + * ; + * + * Note! Not adding the 'content' element into the dom will have the + * server throw a IllegalStateException for element with tag name not found. + * + * @param name - The name attribute of the element + */ + readonly useContent: ReactAdapterElement['useContent']; +}; + +interface ReadyCallbackFunction { + (): void; +} + +/** + * A base class for Web Components that render using React. Enables creating + * adapters for integrating React components with Flow. Intended for use with + * `ReactAdapterComponent` Flow Java class. + */ +export abstract class ReactAdapterElement extends HTMLElement { + #root: Root | undefined = undefined; + #rootRendered: boolean = false; + #rendering: ReactNode | undefined = undefined; + + #state: Record = Object.create(null); + #stateSetters = new Map>(); + #customEvents = new Map>(); + #dispatchFlowState: Dispatch = emptyAction; + + #readyCallback = new Map(); + + readonly #renderHooks: RenderHooks; + + readonly #Wrapper: () => ReactElement | null; + + #unmounting?: Promise; + + constructor() { + super(); + this.#renderHooks = { + useState: this.useState.bind(this), + useCustomEvent: this.useCustomEvent.bind(this), + useContent: this.useContent.bind(this) + }; + this.#Wrapper = this.#renderWrapper.bind(this); + this.#markAsUsed(); + } + + public async connectedCallback() { + this.#rendering = createElement(this.#Wrapper); + const createNewRoot = this.dispatchEvent( + new CustomEvent('flow-portal-add', { + bubbles: true, + cancelable: true, + composed: true, + detail: { + children: this.#rendering, + domNode: this + } + }) + ); + + if (!createNewRoot || this.#root) { + return; + } + + await this.#unmounting; + + this.#root = createRoot(this); + this.#maybeRenderRoot(); + this.#root.render(this.#rendering); + } + + /** + * Add a callback for specified element identifier to be called when + * react element is ready. + * + * @param panelTag + */ + getFloatingPanelZIndex(t) { + const r = this._floatingPanelsZIndexOrder.findIndex((n) => n === t); + return r === this._floatingPanelsZIndexOrder.length - 1 ? 50 : r === -1 ? 0 : r; + } + get floatingPanelsZIndexOrder() { + return this._floatingPanelsZIndexOrder; + } + get attentionRequiredPanelTag() { + return this._attentionRequiredPanelTag; + } + set attentionRequiredPanelTag(t) { + this._attentionRequiredPanelTag = t; + } + getAttentionRequiredPanelConfiguration() { + return this._panels.find((t) => t.tag === this._attentionRequiredPanelTag); + } + clearAttention() { + this._attentionRequiredPanelTag = null; + } + get panels() { + return this._panels; + } + addPanel(t) { + if (this.getPanelByTag(t.tag)) + return; + this._panels.push(t), this.restorePositions(); + const r = this.getPanelByTag(t.tag); + if (r) + (r.eager || r.expanded) && this.renderedPanels.add(t.tag); + else throw new Error(`Panel configuration not found for tag ${t.tag}`); + } + getPanelByTag(t) { + return this._panels.find((r) => r.tag === t); + } + updatePanel(t, r) { + const n = [...this._panels], i = n.find((a) => a.tag === t); + if (i) { + for (const a in r) + i[a] = r[a]; + i.expanded && this.renderedPanels.add(i.tag), r.floating === !1 && (this._floatingPanelsZIndexOrder = this._floatingPanelsZIndexOrder.filter((a) => a !== t)), this._panels = n, We.savePanelConfigurations(this._panels); + } + } + updateOrders(t) { + const r = [...this._panels]; + r.forEach((n) => { + const i = t.find((a) => a.tag === n.tag); + i && (n.panelOrder = i.order); + }), this._panels = r, We.savePanelConfigurations(r); + } + removePanel(t) { + const r = this._panels.findIndex((n) => n.tag === t); + r < 0 || (this._panels.splice(r, 1), We.savePanelConfigurations(this._panels)); + } + setCustomPanelHeader(t, r) { + this.customTags.set(t.tag, r); + } + getPanelHeader(t) { + return this.customTags.get(t.tag) ?? t.header; + } + clearCustomPanelHeader(t) { + this.customTags.delete(t.tag); + } +} +class Ll { + constructor() { + this.supportsHilla = !0, this.springSecurityEnabled = !1, this.springJpaDataEnabled = !1, this.springJpaDatasourceInitialization = !1, this.springApplication = !1, this.urlPrefix = "", this.serverVersions = [], this.clientVersions = [{ name: "Browser", version: navigator.userAgent }], $e(this); + } + setSupportsHilla(t) { + this.supportsHilla = t; + } + setSpringSecurityEnabled(t) { + this.springSecurityEnabled = t; + } + setSpringJpaDataEnabled(t) { + this.springJpaDataEnabled = t; + } + setSpringJpaDatasourceInitialization(t) { + this.springJpaDatasourceInitialization = t; + } + setSpringApplication(t) { + this.springApplication = t; + } + setUrlPrefix(t) { + this.urlPrefix = t; + } + setServerVersions(t) { + this.serverVersions = t; + } + setClientVersions(t) { + this.clientVersions = t; + } + setJdkInfo(t) { + this.jdkInfo = t; + } +} +class Ml { + constructor() { + this.palette = { components: [] }, $e(this), this.initializer = new ya(), this.initializer.promise.then(() => { + $r( + () => JSON.stringify(this), + () => { + te("copilot-set-project-state-configuration", { conf: JSON.stringify(qn(this)) }); + } + ); + }), window.Vaadin.copilot.eventbus.on("copilot-project-state-configuration", (t) => { + const r = t.detail.conf; + Object.assign(this, qn(r)), this.initializer.done(!0), t.preventDefault(); + }), this.loadData(); + } + loadData() { + te("copilot-get-project-state-configuration", {}); + } + addPaletteCustomComponent(t) { + return (this.palette?.components ?? []).find((i) => Sr(i, t)) ? !1 : (this.palette || (this.palette = { components: [] }), this.palette = JSON.parse(JSON.stringify(this.palette)), this.palette.components.push(t), !0); + } + removePaletteCustomComponent(t) { + if (this.palette) { + const r = this.palette.components.findIndex( + (n) => Sr(n, t) + ); + r > -1 && this.palette.components.splice(r, 1); + } + } + updatePaletteCustomComponent(t, r) { + if (!this.palette || !this.palette.components) + return; + const n = [...this.palette.components], i = n.findIndex((a) => Sr(a, t)); + i !== -1 && (n[i] = { ...t, ...r }), this.palette.components = n; + } + paletteCustomComponentExist(t, r) { + return !this.palette || !this.palette.components ? !1 : t ? this.palette.components.findIndex( + (n) => n.java && !n.react && n.javaClassName === t + ) !== -1 : r ? this.palette.components.findIndex((n) => !n.java && n.react && n.template === r) !== -1 : !1; + } + get paletteComponents() { + return this.palette?.components || []; + } +} +function qn(e) { + const t = { ...e }; + return delete t.initializer, t; +} +function Sr(e, t) { + return e.java ? t.java ? e.javaClassName === t.javaClassName : !1 : e.react && t.react ? e.template === t.template : !1; +} +window.Vaadin ??= {}; +window.Vaadin.copilot ??= {}; +window.Vaadin.copilot.plugins = []; +window.Vaadin.copilot._uiState = new wl(); +window.Vaadin.copilot.eventbus = new Xa(); +window.Vaadin.copilot.overlayManager = new Vl(); +window.Vaadin.copilot._machineState = new Il(); +window.Vaadin.copilot._storedProjectState = new Ml(); +window.Vaadin.copilot._previewState = new zl(); +window.Vaadin.copilot._sectionPanelUiState = new Ul(); +window.Vaadin.copilot._earlyProjectState = new Ll(); +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const jl = (e) => (t, r) => { + r !== void 0 ? r.addInitializer(() => { + customElements.define(e, t); + }) : customElements.define(e, t); +}; +/** + * @license + * Copyright 2019 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const Bt = globalThis, nn = Bt.ShadowRoot && (Bt.ShadyCSS === void 0 || Bt.ShadyCSS.nativeShadow) && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype, an = Symbol(), Kn = /* @__PURE__ */ new WeakMap(); +let wa = class { + constructor(t, r, n) { + if (this._$cssResult$ = !0, n !== an) throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead."); + this.cssText = t, this.t = r; + } + get styleSheet() { + let t = this.o; + const r = this.t; + if (nn && t === void 0) { + const n = r !== void 0 && r.length === 1; + n && (t = Kn.get(r)), t === void 0 && ((this.o = t = new CSSStyleSheet()).replaceSync(this.cssText), n && Kn.set(r, t)); + } + return t; + } + toString() { + return this.cssText; + } +}; +const L = (e) => new wa(typeof e == "string" ? e : e + "", void 0, an), Rl = (e, ...t) => { + const r = e.length === 1 ? e[0] : t.reduce((n, i, a) => n + ((o) => { + if (o._$cssResult$ === !0) return o.cssText; + if (typeof o == "number") return o; + throw Error("Value passed to 'css' function must be a 'css' function result: " + o + ". Use 'unsafeCSS' to pass non-literal values, but take care to ensure page security."); + })(i) + e[a + 1], e[0]); + return new wa(r, e, an); +}, ql = (e, t) => { + if (nn) e.adoptedStyleSheets = t.map((r) => r instanceof CSSStyleSheet ? r : r.styleSheet); + else for (const r of t) { + const n = document.createElement("style"), i = Bt.litNonce; + i !== void 0 && n.setAttribute("nonce", i), n.textContent = r.cssText, e.appendChild(n); + } +}, Bn = nn ? (e) => e : (e) => e instanceof CSSStyleSheet ? ((t) => { + let r = ""; + for (const n of t.cssRules) r += n.cssText; + return L(r); +})(e) : e; +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const { is: Kl, defineProperty: Bl, getOwnPropertyDescriptor: Fl, getOwnPropertyNames: Zl, getOwnPropertySymbols: Wl, getPrototypeOf: Hl } = Object, yr = globalThis, Fn = yr.trustedTypes, Xl = Fn ? Fn.emptyScript : "", Jl = yr.reactiveElementPolyfillSupport, vt = (e, t) => e, Fr = { toAttribute(e, t) { + switch (t) { + case Boolean: + e = e ? Xl : null; + break; + case Object: + case Array: + e = e == null ? e : JSON.stringify(e); + } + return e; +}, fromAttribute(e, t) { + let r = e; + switch (t) { + case Boolean: + r = e !== null; + break; + case Number: + r = e === null ? null : Number(e); + break; + case Object: + case Array: + try { + r = JSON.parse(e); + } catch { + r = null; + } + } + return r; +} }, xa = (e, t) => !Kl(e, t), Zn = { attribute: !0, type: String, converter: Fr, reflect: !1, useDefault: !1, hasChanged: xa }; +Symbol.metadata ??= Symbol("metadata"), yr.litPropertyMetadata ??= /* @__PURE__ */ new WeakMap(); +let Be = class extends HTMLElement { + static addInitializer(t) { + this._$Ei(), (this.l ??= []).push(t); + } + static get observedAttributes() { + return this.finalize(), this._$Eh && [...this._$Eh.keys()]; + } + static createProperty(t, r = Zn) { + if (r.state && (r.attribute = !1), this._$Ei(), this.prototype.hasOwnProperty(t) && ((r = Object.create(r)).wrapped = !0), this.elementProperties.set(t, r), !r.noAccessor) { + const n = Symbol(), i = this.getPropertyDescriptor(t, n, r); + i !== void 0 && Bl(this.prototype, t, i); + } + } + static getPropertyDescriptor(t, r, n) { + const { get: i, set: a } = Fl(this.prototype, t) ?? { get() { + return this[r]; + }, set(o) { + this[r] = o; + } }; + return { get: i, set(o) { + const s = i?.call(this); + a?.call(this, o), this.requestUpdate(t, s, n); + }, configurable: !0, enumerable: !0 }; + } + static getPropertyOptions(t) { + return this.elementProperties.get(t) ?? Zn; + } + static _$Ei() { + if (this.hasOwnProperty(vt("elementProperties"))) return; + const t = Hl(this); + t.finalize(), t.l !== void 0 && (this.l = [...t.l]), this.elementProperties = new Map(t.elementProperties); + } + static finalize() { + if (this.hasOwnProperty(vt("finalized"))) return; + if (this.finalized = !0, this._$Ei(), this.hasOwnProperty(vt("properties"))) { + const r = this.properties, n = [...Zl(r), ...Wl(r)]; + for (const i of n) this.createProperty(i, r[i]); + } + const t = this[Symbol.metadata]; + if (t !== null) { + const r = litPropertyMetadata.get(t); + if (r !== void 0) for (const [n, i] of r) this.elementProperties.set(n, i); + } + this._$Eh = /* @__PURE__ */ new Map(); + for (const [r, n] of this.elementProperties) { + const i = this._$Eu(r, n); + i !== void 0 && this._$Eh.set(i, r); + } + this.elementStyles = this.finalizeStyles(this.styles); + } + static finalizeStyles(t) { + const r = []; + if (Array.isArray(t)) { + const n = new Set(t.flat(1 / 0).reverse()); + for (const i of n) r.unshift(Bn(i)); + } else t !== void 0 && r.push(Bn(t)); + return r; + } + static _$Eu(t, r) { + const n = r.attribute; + return n === !1 ? void 0 : typeof n == "string" ? n : typeof t == "string" ? t.toLowerCase() : void 0; + } + constructor() { + super(), this._$Ep = void 0, this.isUpdatePending = !1, this.hasUpdated = !1, this._$Em = null, this._$Ev(); + } + _$Ev() { + this._$ES = new Promise((t) => this.enableUpdating = t), this._$AL = /* @__PURE__ */ new Map(), this._$E_(), this.requestUpdate(), this.constructor.l?.forEach((t) => t(this)); + } + addController(t) { + (this._$EO ??= /* @__PURE__ */ new Set()).add(t), this.renderRoot !== void 0 && this.isConnected && t.hostConnected?.(); + } + removeController(t) { + this._$EO?.delete(t); + } + _$E_() { + const t = /* @__PURE__ */ new Map(), r = this.constructor.elementProperties; + for (const n of r.keys()) this.hasOwnProperty(n) && (t.set(n, this[n]), delete this[n]); + t.size > 0 && (this._$Ep = t); + } + createRenderRoot() { + const t = this.shadowRoot ?? this.attachShadow(this.constructor.shadowRootOptions); + return ql(t, this.constructor.elementStyles), t; + } + connectedCallback() { + this.renderRoot ??= this.createRenderRoot(), this.enableUpdating(!0), this._$EO?.forEach((t) => t.hostConnected?.()); + } + enableUpdating(t) { + } + disconnectedCallback() { + this._$EO?.forEach((t) => t.hostDisconnected?.()); + } + attributeChangedCallback(t, r, n) { + this._$AK(t, n); + } + _$ET(t, r) { + const n = this.constructor.elementProperties.get(t), i = this.constructor._$Eu(t, n); + if (i !== void 0 && n.reflect === !0) { + const a = (n.converter?.toAttribute !== void 0 ? n.converter : Fr).toAttribute(r, n.type); + this._$Em = t, a == null ? this.removeAttribute(i) : this.setAttribute(i, a), this._$Em = null; + } + } + _$AK(t, r) { + const n = this.constructor, i = n._$Eh.get(t); + if (i !== void 0 && this._$Em !== i) { + const a = n.getPropertyOptions(i), o = typeof a.converter == "function" ? { fromAttribute: a.converter } : a.converter?.fromAttribute !== void 0 ? a.converter : Fr; + this._$Em = i, this[i] = o.fromAttribute(r, a.type) ?? this._$Ej?.get(i) ?? null, this._$Em = null; + } + } + requestUpdate(t, r, n) { + if (t !== void 0) { + const i = this.constructor, a = this[t]; + if (n ??= i.getPropertyOptions(t), !((n.hasChanged ?? xa)(a, r) || n.useDefault && n.reflect && a === this._$Ej?.get(t) && !this.hasAttribute(i._$Eu(t, n)))) return; + this.C(t, r, n); + } + this.isUpdatePending === !1 && (this._$ES = this._$EP()); + } + C(t, r, { useDefault: n, reflect: i, wrapped: a }, o) { + n && !(this._$Ej ??= /* @__PURE__ */ new Map()).has(t) && (this._$Ej.set(t, o ?? r ?? this[t]), a !== !0 || o !== void 0) || (this._$AL.has(t) || (this.hasUpdated || n || (r = void 0), this._$AL.set(t, r)), i === !0 && this._$Em !== t && (this._$Eq ??= /* @__PURE__ */ new Set()).add(t)); + } + async _$EP() { + this.isUpdatePending = !0; + try { + await this._$ES; + } catch (r) { + Promise.reject(r); + } + const t = this.scheduleUpdate(); + return t != null && await t, !this.isUpdatePending; + } + scheduleUpdate() { + return this.performUpdate(); + } + performUpdate() { + if (!this.isUpdatePending) return; + if (!this.hasUpdated) { + if (this.renderRoot ??= this.createRenderRoot(), this._$Ep) { + for (const [i, a] of this._$Ep) this[i] = a; + this._$Ep = void 0; + } + const n = this.constructor.elementProperties; + if (n.size > 0) for (const [i, a] of n) { + const { wrapped: o } = a, s = this[i]; + o !== !0 || this._$AL.has(i) || s === void 0 || this.C(i, void 0, a, s); + } + } + let t = !1; + const r = this._$AL; + try { + t = this.shouldUpdate(r), t ? (this.willUpdate(r), this._$EO?.forEach((n) => n.hostUpdate?.()), this.update(r)) : this._$EM(); + } catch (n) { + throw t = !1, this._$EM(), n; + } + t && this._$AE(r); + } + willUpdate(t) { + } + _$AE(t) { + this._$EO?.forEach((r) => r.hostUpdated?.()), this.hasUpdated || (this.hasUpdated = !0, this.firstUpdated(t)), this.updated(t); + } + _$EM() { + this._$AL = /* @__PURE__ */ new Map(), this.isUpdatePending = !1; + } + get updateComplete() { + return this.getUpdateComplete(); + } + getUpdateComplete() { + return this._$ES; + } + shouldUpdate(t) { + return !0; + } + update(t) { + this._$Eq &&= this._$Eq.forEach((r) => this._$ET(r, this[r])), this._$EM(); + } + updated(t) { + } + firstUpdated(t) { + } +}; +Be.elementStyles = [], Be.shadowRootOptions = { mode: "open" }, Be[vt("elementProperties")] = /* @__PURE__ */ new Map(), Be[vt("finalized")] = /* @__PURE__ */ new Map(), Jl?.({ ReactiveElement: Be }), (yr.reactiveElementVersions ??= []).push("2.1.0"); +const qe = Symbol("LitMobxRenderReaction"), Wn = Symbol("LitMobxRequestUpdate"); +function Gl(e, t) { + var r, n; + return n = class extends e { + constructor() { + super(...arguments), this[r] = () => { + this.requestUpdate(); + }; + } + connectedCallback() { + super.connectedCallback(); + const a = this.constructor.name || this.nodeName; + this[qe] = new t(`${a}.update()`, this[Wn]), this.hasUpdated && this.requestUpdate(); + } + disconnectedCallback() { + super.disconnectedCallback(), this[qe] && (this[qe].dispose(), this[qe] = void 0); + } + update(a) { + this[qe] ? this[qe].track(super.update.bind(this, a)) : super.update(a); + } + }, r = Wn, n; +} +function Yl(e) { + return Gl(e, ee); +} +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const on = globalThis, sr = on.trustedTypes, Hn = sr ? sr.createPolicy("lit-html", { createHTML: (e) => e }) : void 0, Oa = "$lit$", ue = `lit$${Math.random().toFixed(9).slice(2)}$`, Ea = "?" + ue, Ql = `<${Ea}>`, ze = document, Ot = () => ze.createComment(""), Et = (e) => e === null || typeof e != "object" && typeof e != "function", sn = Array.isArray, _l = (e) => sn(e) || typeof e?.[Symbol.iterator] == "function", Pr = `[ +\f\r]`, ot = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g, Xn = /-->/g, Jn = />/g, Oe = RegExp(`>|${Pr}(?:([^\\s"'>=/]+)(${Pr}*=${Pr}*(?:[^ +\f\r"'\`<>=]|("|')|))|$)`, "g"), Gn = /'/g, Yn = /"/g, ka = /^(?:script|style|textarea|title)$/i, Ca = (e) => (t, ...r) => ({ _$litType$: e, strings: t, values: r }), le = Ca(1), Yd = Ca(2), ge = Symbol.for("lit-noChange"), E = Symbol.for("lit-nothing"), Qn = /* @__PURE__ */ new WeakMap(), Ae = ze.createTreeWalker(ze, 129); +function Aa(e, t) { + if (!sn(e) || !e.hasOwnProperty("raw")) throw Error("invalid template strings array"); + return Hn !== void 0 ? Hn.createHTML(t) : t; +} +const $l = (e, t) => { + const r = e.length - 1, n = []; + let i, a = t === 2 ? "" : t === 3 ? "" : "", o = ot; + for (let s = 0; s < r; s++) { + const l = e[s]; + let c, d, u = -1, v = 0; + for (; v < l.length && (o.lastIndex = v, d = o.exec(l), d !== null); ) v = o.lastIndex, o === ot ? d[1] === "!--" ? o = Xn : d[1] !== void 0 ? o = Jn : d[2] !== void 0 ? (ka.test(d[2]) && (i = RegExp("" ? (o = i ?? ot, u = -1) : d[1] === void 0 ? u = -2 : (u = o.lastIndex - d[2].length, c = d[1], o = d[3] === void 0 ? Oe : d[3] === '"' ? Yn : Gn) : o === Yn || o === Gn ? o = Oe : o === Xn || o === Jn ? o = ot : (o = Oe, i = void 0); + const h = o === Oe && e[s + 1].startsWith("/>") ? " " : ""; + a += o === ot ? l + Ql : u >= 0 ? (n.push(c), l.slice(0, u) + Oa + l.slice(u) + ue + h) : l + ue + (u === -2 ? s : h); + } + return [Aa(e, a + (e[r] || "") + (t === 2 ? "" : t === 3 ? "" : "")), n]; +}; +class kt { + constructor({ strings: t, _$litType$: r }, n) { + let i; + this.parts = []; + let a = 0, o = 0; + const s = t.length - 1, l = this.parts, [c, d] = $l(t, r); + if (this.el = kt.createElement(c, n), Ae.currentNode = this.el.content, r === 2 || r === 3) { + const u = this.el.content.firstChild; + u.replaceWith(...u.childNodes); + } + for (; (i = Ae.nextNode()) !== null && l.length < s; ) { + if (i.nodeType === 1) { + if (i.hasAttributes()) for (const u of i.getAttributeNames()) if (u.endsWith(Oa)) { + const v = d[o++], h = i.getAttribute(u).split(ue), m = /([.?@])?(.*)/.exec(v); + l.push({ type: 1, index: a, name: m[2], strings: h, ctor: m[1] === "." ? tc : m[1] === "?" ? rc : m[1] === "@" ? nc : wr }), i.removeAttribute(u); + } else u.startsWith(ue) && (l.push({ type: 6, index: a }), i.removeAttribute(u)); + if (ka.test(i.tagName)) { + const u = i.textContent.split(ue), v = u.length - 1; + if (v > 0) { + i.textContent = sr ? sr.emptyScript : ""; + for (let h = 0; h < v; h++) i.append(u[h], Ot()), Ae.nextNode(), l.push({ type: 2, index: ++a }); + i.append(u[v], Ot()); + } + } + } else if (i.nodeType === 8) if (i.data === Ea) l.push({ type: 2, index: a }); + else { + let u = -1; + for (; (u = i.data.indexOf(ue, u + 1)) !== -1; ) l.push({ type: 7, index: a }), u += ue.length - 1; + } + a++; + } + } + static createElement(t, r) { + const n = ze.createElement("template"); + return n.innerHTML = t, n; + } +} +function Ye(e, t, r = e, n) { + if (t === ge) return t; + let i = n !== void 0 ? r._$Co?.[n] : r._$Cl; + const a = Et(t) ? void 0 : t._$litDirective$; + return i?.constructor !== a && (i?._$AO?.(!1), a === void 0 ? i = void 0 : (i = new a(e), i._$AT(e, r, n)), n !== void 0 ? (r._$Co ??= [])[n] = i : r._$Cl = i), i !== void 0 && (t = Ye(e, i._$AS(e, t.values), i, n)), t; +} +let ec = class { + constructor(t, r) { + this._$AV = [], this._$AN = void 0, this._$AD = t, this._$AM = r; + } + get parentNode() { + return this._$AM.parentNode; + } + get _$AU() { + return this._$AM._$AU; + } + u(t) { + const { el: { content: r }, parts: n } = this._$AD, i = (t?.creationScope ?? ze).importNode(r, !0); + Ae.currentNode = i; + let a = Ae.nextNode(), o = 0, s = 0, l = n[0]; + for (; l !== void 0; ) { + if (o === l.index) { + let c; + l.type === 2 ? c = new rt(a, a.nextSibling, this, t) : l.type === 1 ? c = new l.ctor(a, l.name, l.strings, this, t) : l.type === 6 && (c = new ic(a, this, t)), this._$AV.push(c), l = n[++s]; + } + o !== l?.index && (a = Ae.nextNode(), o++); + } + return Ae.currentNode = ze, i; + } + p(t) { + let r = 0; + for (const n of this._$AV) n !== void 0 && (n.strings !== void 0 ? (n._$AI(t, n, r), r += n.strings.length - 2) : n._$AI(t[r])), r++; + } +}; +class rt { + get _$AU() { + return this._$AM?._$AU ?? this._$Cv; + } + constructor(t, r, n, i) { + this.type = 2, this._$AH = E, this._$AN = void 0, this._$AA = t, this._$AB = r, this._$AM = n, this.options = i, this._$Cv = i?.isConnected ?? !0; + } + get parentNode() { + let t = this._$AA.parentNode; + const r = this._$AM; + return r !== void 0 && t?.nodeType === 11 && (t = r.parentNode), t; + } + get startNode() { + return this._$AA; + } + get endNode() { + return this._$AB; + } + _$AI(t, r = this) { + t = Ye(this, t, r), Et(t) ? t === E || t == null || t === "" ? (this._$AH !== E && this._$AR(), this._$AH = E) : t !== this._$AH && t !== ge && this._(t) : t._$litType$ !== void 0 ? this.$(t) : t.nodeType !== void 0 ? this.T(t) : _l(t) ? this.k(t) : this._(t); + } + O(t) { + return this._$AA.parentNode.insertBefore(t, this._$AB); + } + T(t) { + this._$AH !== t && (this._$AR(), this._$AH = this.O(t)); + } + _(t) { + this._$AH !== E && Et(this._$AH) ? this._$AA.nextSibling.data = t : this.T(ze.createTextNode(t)), this._$AH = t; + } + $(t) { + const { values: r, _$litType$: n } = t, i = typeof n == "number" ? this._$AC(t) : (n.el === void 0 && (n.el = kt.createElement(Aa(n.h, n.h[0]), this.options)), n); + if (this._$AH?._$AD === i) this._$AH.p(r); + else { + const a = new ec(i, this), o = a.u(this.options); + a.p(r), this.T(o), this._$AH = a; + } + } + _$AC(t) { + let r = Qn.get(t.strings); + return r === void 0 && Qn.set(t.strings, r = new kt(t)), r; + } + k(t) { + sn(this._$AH) || (this._$AH = [], this._$AR()); + const r = this._$AH; + let n, i = 0; + for (const a of t) i === r.length ? r.push(n = new rt(this.O(Ot()), this.O(Ot()), this, this.options)) : n = r[i], n._$AI(a), i++; + i < r.length && (this._$AR(n && n._$AB.nextSibling, i), r.length = i); + } + _$AR(t = this._$AA.nextSibling, r) { + for (this._$AP?.(!1, !0, r); t && t !== this._$AB; ) { + const n = t.nextSibling; + t.remove(), t = n; + } + } + setConnected(t) { + this._$AM === void 0 && (this._$Cv = t, this._$AP?.(t)); + } +} +class wr { + get tagName() { + return this.element.tagName; + } + get _$AU() { + return this._$AM._$AU; + } + constructor(t, r, n, i, a) { + this.type = 1, this._$AH = E, this._$AN = void 0, this.element = t, this.name = r, this._$AM = i, this.options = a, n.length > 2 || n[0] !== "" || n[1] !== "" ? (this._$AH = Array(n.length - 1).fill(new String()), this.strings = n) : this._$AH = E; + } + _$AI(t, r = this, n, i) { + const a = this.strings; + let o = !1; + if (a === void 0) t = Ye(this, t, r, 0), o = !Et(t) || t !== this._$AH && t !== ge, o && (this._$AH = t); + else { + const s = t; + let l, c; + for (t = a[0], l = 0; l < a.length - 1; l++) c = Ye(this, s[n + l], r, l), c === ge && (c = this._$AH[l]), o ||= !Et(c) || c !== this._$AH[l], c === E ? t = E : t !== E && (t += (c ?? "") + a[l + 1]), this._$AH[l] = c; + } + o && !i && this.j(t); + } + j(t) { + t === E ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, t ?? ""); + } +} +class tc extends wr { + constructor() { + super(...arguments), this.type = 3; + } + j(t) { + this.element[this.name] = t === E ? void 0 : t; + } +} +class rc extends wr { + constructor() { + super(...arguments), this.type = 4; + } + j(t) { + this.element.toggleAttribute(this.name, !!t && t !== E); + } +} +class nc extends wr { + constructor(t, r, n, i, a) { + super(t, r, n, i, a), this.type = 5; + } + _$AI(t, r = this) { + if ((t = Ye(this, t, r, 0) ?? E) === ge) return; + const n = this._$AH, i = t === E && n !== E || t.capture !== n.capture || t.once !== n.once || t.passive !== n.passive, a = t !== E && (n === E || i); + i && this.element.removeEventListener(this.name, this, n), a && this.element.addEventListener(this.name, this, t), this._$AH = t; + } + handleEvent(t) { + typeof this._$AH == "function" ? this._$AH.call(this.options?.host ?? this.element, t) : this._$AH.handleEvent(t); + } +} +class ic { + constructor(t, r, n) { + this.element = t, this.type = 6, this._$AN = void 0, this._$AM = r, this.options = n; + } + get _$AU() { + return this._$AM._$AU; + } + _$AI(t) { + Ye(this, t); + } +} +const ac = { I: rt }, oc = on.litHtmlPolyfillSupport; +oc?.(kt, rt), (on.litHtmlVersions ??= []).push("3.3.0"); +const sc = (e, t, r) => { + const n = r?.renderBefore ?? t; + let i = n._$litPart$; + if (i === void 0) { + const a = r?.renderBefore ?? null; + n._$litPart$ = i = new rt(t.insertBefore(Ot(), a), a, void 0, r ?? {}); + } + return i._$AI(e), i; +}; +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const ln = globalThis; +let ht = class extends Be { + constructor() { + super(...arguments), this.renderOptions = { host: this }, this._$Do = void 0; + } + createRenderRoot() { + const t = super.createRenderRoot(); + return this.renderOptions.renderBefore ??= t.firstChild, t; + } + update(t) { + const r = this.render(); + this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), super.update(t), this._$Do = sc(r, this.renderRoot, this.renderOptions); + } + connectedCallback() { + super.connectedCallback(), this._$Do?.setConnected(!0); + } + disconnectedCallback() { + super.disconnectedCallback(), this._$Do?.setConnected(!1); + } + render() { + return ge; + } +}; +ht._$litElement$ = !0, ht.finalized = !0, ln.litElementHydrateSupport?.({ LitElement: ht }); +const lc = ln.litElementPolyfillSupport; +lc?.({ LitElement: ht }); +(ln.litElementVersions ??= []).push("4.2.0"); +class cc extends Yl(ht) { +} +class dc extends cc { + constructor() { + super(...arguments), this.disposers = []; + } + /** + * Creates a MobX reaction using the given parameters and disposes it when this element is detached. + * + * This should be called from `connectedCallback` to ensure that the reaction is active also if the element is attached again later. + */ + reaction(t, r, n) { + this.disposers.push($r(t, r, n)); + } + /** + * Creates a MobX autorun using the given parameters and disposes it when this element is detached. + * + * This should be called from `connectedCallback` to ensure that the reaction is active also if the element is attached again later. + */ + autorun(t, r) { + this.disposers.push(Hi(t, r)); + } + disconnectedCallback() { + super.disconnectedCallback(), this.disposers.forEach((t) => { + t(); + }), this.disposers = []; + } +} +const se = window.Vaadin.copilot._sectionPanelUiState; +if (!se) + throw new Error("Tried to access copilot section panel ui state before it was initialized."); +let ke = []; +const _n = []; +function $n(e) { + e.init({ + addPanel: (t) => { + se.addPanel(t); + }, + send(t, r) { + te(t, r); + } + }); +} +function uc() { + ke.push(import("./copilot-log-plugin-k9jQ-PoP.js")), ke.push(import("./copilot-info-plugin-C03ukXfd.js")), ke.push(import("./copilot-features-plugin-C7i9ifZr.js")), ke.push(import("./copilot-feedback-plugin-DyqC4FEM.js")), ke.push(import("./copilot-shortcuts-plugin-C9BiTUJ_.js")); +} +function pc() { + { + const e = `https://cdn.vaadin.com/copilot/${cl}/copilot-plugins${dl}.js`; + import( + /* @vite-ignore */ + e + ).catch((t) => { + console.warn(`Unable to load plugins from ${e}. Some Copilot features are unavailable.`, t); + }); + } +} +function fc() { + Promise.all(ke).then(() => { + const e = window.Vaadin; + if (e.copilot.plugins) { + const t = e.copilot.plugins; + e.copilot.plugins.push = (r) => $n(r), Array.from(t).forEach((r) => { + _n.includes(r) || ($n(r), _n.push(r)); + }); + } + }), ke = []; +} +function $d(e) { + return Object.assign({ + expanded: !0, + expandable: !1, + panelOrder: 0, + floating: !1, + width: 500, + height: 500, + floatingPosition: { + top: 50, + left: 350 + } + }, e); +} +function st() { + return document.body.querySelector("copilot-main"); +} +class vc { + constructor() { + this.active = !1, this.activate = () => { + this.active = !0, st()?.focus(), st()?.addEventListener("focusout", this.keepFocusInCopilot); + }, this.deactivate = () => { + this.active = !1, st()?.removeEventListener("focusout", this.keepFocusInCopilot); + }, this.focusInEventListener = (t) => { + this.active && (t.preventDefault(), t.stopPropagation(), fe(t.target) || requestAnimationFrame(() => { + t.target.blur && t.target.blur(), st()?.focus(); + })); + }; + } + hostConnectedCallback() { + const t = this.getApplicationRootElement(); + t && t instanceof HTMLElement && t.addEventListener("focusin", this.focusInEventListener); + } + hostDisconnectedCallback() { + const t = this.getApplicationRootElement(); + t && t instanceof HTMLElement && t.removeEventListener("focusin", this.focusInEventListener); + } + getApplicationRootElement() { + return document.body.firstElementChild; + } + keepFocusInCopilot(t) { + t.preventDefault(), t.stopPropagation(), st()?.focus(); + } +} +const jt = new vc(), y = window.Vaadin.copilot.eventbus; +if (!y) + throw new Error("Tried to access copilot eventbus before it was initialized."); +const Ke = window.Vaadin.copilot.overlayManager, eu = { + DragAndDrop: "Drag and Drop", + RedoUndo: "Redo/Undo" +}, b = window.Vaadin.copilot._uiState; +if (!b) + throw new Error("Tried to access copilot ui state before it was initialized."); +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const Sa = { CHILD: 2, ELEMENT: 6 }, Pa = (e) => (...t) => ({ _$litDirective$: e, values: t }); +class Da { + constructor(t) { + } + get _$AU() { + return this._$AM._$AU; + } + _$AT(t, r, n) { + this._$Ct = t, this._$AM = r, this._$Ci = n; + } + _$AS(t, r) { + return this.update(t, r); + } + update(t, r) { + return this.render(...r); + } +} +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +class Zr extends Da { + constructor(t) { + if (super(t), this.it = E, t.type !== Sa.CHILD) throw Error(this.constructor.directiveName + "() can only be used in child bindings"); + } + render(t) { + if (t === E || t == null) return this._t = void 0, this.it = t; + if (t === ge) return t; + if (typeof t != "string") throw Error(this.constructor.directiveName + "() called with a non-string value"); + if (t === this.it) return this._t; + this.it = t; + const r = [t]; + return r.raw = r, this._t = { _$litType$: this.constructor.resultType, strings: r, values: [] }; + } +} +Zr.directiveName = "unsafeHTML", Zr.resultType = 1; +const hc = Pa(Zr), nt = window.Vaadin.copilot._machineState; +if (!nt) + throw new Error("Trying to use stored machine state before it was initialized"); +const gc = 5e3; +let ei = 1; +function Na(e) { + b.notifications.includes(e) && (e.dontShowAgain && e.dismissId && mc(e.dismissId), b.removeNotification(e), y.emit("notification-dismissed", e)); +} +function Ta(e) { + return nt.getDismissedNotifications().includes(e); +} +function mc(e) { + Ta(e) || nt.addDismissedNotification(e); +} +function bc(e) { + return !(e.dismissId && (Ta(e.dismissId) || b.notifications.find((t) => t.dismissId === e.dismissId))); +} +function yc() { + const e = "A server restart is required"; + return dn() ? ar(le`${e}
${cn()}`) : ar(le`${e}`); +} +function cn() { + return dn() ? le` { + const t = e.target; + t.disabled = !0, t.innerText = "Restarting...", Oc(); + }}> + Restart now + ` : E; +} +function Va(e) { + if (bc(e)) + return wc(e); +} +function wc(e) { + const t = ei; + ei += 1; + const r = { ...e, id: t, dontShowAgain: !1, animatingOut: !1 }; + return b.setNotifications([...b.notifications, r]), (e.delay || !e.link && !e.dismissId) && setTimeout(() => { + Na(r); + }, e.delay ?? gc), y.emit("notification-shown", e), r; +} +const xc = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + dismissNotification: Na, + getRestartRequiredMessage: yc, + renderRestartButton: cn, + showNotification: Va +}, Symbol.toStringTag, { value: "Module" })), xr = window.Vaadin.copilot._earlyProjectState; +if (!xr) + throw new Error("Tried to access early project state before it was initialized."); +function dn() { + return b.idePluginState?.supportedActions?.find((e) => e === "restartApplication"); +} +function Oc() { + Nt(`${he}plugin-restart-application`, {}, () => { + }).catch((e) => { + ce("Error restarting server", e); + }); +} +const Ia = window.Vaadin.copilot._previewState; +if (!Ia) + throw new Error("Tried to access copilot preview state before it was initialized."); +function Ec() { + const e = b.userInfo; + return !e || e.copilotProjectCannotLeaveLocalhost ? !1 : nt.isSendErrorReportsAllowed(); +} +const kc = (e) => { + ce("Unspecified error", e), y.emit("vite-after-update", {}); +}, Cc = (e, t) => e.error ? (Ac(e.error, t), !0) : !1, ti = (e, t, r) => { + Tt({ + type: ye.ERROR, + message: e, + details: ar( + le`
+ ${hc(t)} +
+ + ${r !== void 0 ? le` + Report Issue + ` : E} ` + ), + delay: 3e4 + }); +}, za = (e, t, r, n, i) => { + const a = b.newVaadinVersionState?.versions?.length === 0; + i && a ? Pc( + i, + (o) => { + ti(e, t, o); + }, + e, + t, + r + ) : ti(e, t), Ec() && (n?.templateData && typeof n.templateData == "string" && n.templateData.startsWith("data") && (n.templateData = ""), y.emit("system-info-with-callback", { + callback: (o) => y.send("copilot-error", { + message: e, + details: String(r).replace(" ", ` +`) + (n ? ` + +Request: +${JSON.stringify(n)} +` : ""), + versions: o + }), + notify: !1 + })), b.clearOperationWaitsHmrUpdate(); +}, Ac = (e, t) => { + za( + e.message, + e.exceptionMessage ?? "", + e.exceptionStacktrace?.join(` +`) ?? "", + t, + e.exceptionReport + ); +}; +function Sc(e, t) { + const r = { + title: t.message, + nodes: [], + relevantPairs: [], + items: [] + }; + za(e, t.message, t.stack ?? "", void 0, r); +} +function Dr(e) { + if (e === void 0) + return !1; + const t = Object.keys(e); + return t.length === 1 && t.includes("message") || t.length >= 3 && t.includes("message") && t.includes("exceptionMessage") && t.includes("exceptionStacktrace"); +} +function ce(e, t) { + const r = Dr(t) ? t.exceptionMessage ?? t.message : t, n = { + type: ye.ERROR, + message: "Copilot internal error", + details: e + (r ? ` +${r}` : "") + }; + Dr(t) && t.suggestRestart && dn() && (n.details = ar(le`${e}
${r} ${cn()}`), n.delay = 3e4), Tt(n); + let i; + t instanceof Error ? i = t.stack : Dr(t) ? i = t?.exceptionStacktrace?.join(` +`) : i = t?.toString(), y.emit("system-info-with-callback", { + callback: (a) => y.send("copilot-error", { + message: `Copilot internal error: ${e}`, + details: i, + versions: a + }), + notify: !1 + }); +} +function ri(e) { + return e?.stack?.includes("cdn.vaadin.com/copilot") || e?.stack?.includes("/copilot/copilot/") || e?.stack?.includes("/copilot/copilot-private/"); +} +function Ua() { + const e = window.onerror; + window.onerror = (r, n, i, a, o) => { + if (ri(o)) { + ce(r.toString(), o); + return; + } + e && e(r, n, i, a, o); + }, is((r) => { + ri(r) && ce("", r); + }); + const t = window.Vaadin.ConsoleErrors; + if (Array.isArray(t)) + for (const r of t) + Array.isArray(r) ? Ft.push(...r) : Ft.push(r); + La((r) => Ft.push(r)); +} +function Pc(e, t, r, n, i, a) { + const o = { ...e }, s = window.Vaadin.copilot.tree, l = window.Vaadin.copilot.customComponentHandler; + o.nodes.forEach((u) => { + u.node = s.allNodesFlat.find((v) => { + if (!v.isFlowComponent) + return !1; + const h = v.node; + return h.uiId === u.uiId && h.nodeId === u.nodeId; + }); + }); + const c = []; + r && c.push(`Error Message -> ${r}`), n && c.push(`Error Details -> ${n}`), c.push( + `Active Level -> ${l.getActiveDrillDownContext() ? l.getActiveDrillDownContext()?.nameAndIdentifier : "No active level"}` + ), o.nodes.length > 0 && (c.push(` +Relevant Nodes:`), o.nodes.forEach((u) => { + c.push(`${u.relevance} -> ${u.node?.nameAndIdentifier ?? "Node not found"}`); + })), o.relevantPairs.length > 0 && (c.push(` +Additional Info:`), o.relevantPairs.forEach((u) => { + c.push(`${u.relevance} -> ${u.value}`); + })); + const d = { + name: "Info", + content: c.join(` +`) + }; + o.items.unshift(d), i && o.items.push({ + name: "Stacktrace", + content: i + }), y.emit("system-info-with-callback", { + callback: (u) => { + o.items.push({ + name: "Versions", + content: u + }), t(o); + }, + notify: !1 + }); +} +const Ft = []; +function La(e) { + const t = window.Vaadin.ConsoleErrors; + window.Vaadin.ConsoleErrors = { + push: (r) => { + r[0] === null || r[0] === void 0 || (r[0].type !== void 0 && r[0].message !== void 0 ? e({ + type: r[0].type, + message: r[0].message, + internal: !!r[0].internal, + details: r[0].details, + link: r[0].link + }) : e({ type: ye.ERROR, message: r.map((n) => Dc(n)).join(" "), internal: !1 }), t.push(r)); + } + }; +} +function Dc(e) { + return e.message ? e.message.toString() : e.toString(); +} +function Nc(e) { + Tt({ + type: ye.ERROR, + message: `Unable to ${e}`, + details: "Could not find sources for React components, probably because the project is not a React (or Flow) project" + }); +} +const Tc = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + catchErrors: La, + consoleErrorsQueue: Ft, + handleBrowserOperationError: Sc, + handleCopilotError: ce, + handleErrorDuringOperation: kc, + handleServerOperationErrorIfNeeded: Cc, + installErrorHandlers: Ua, + showNotReactFlowProject: Nc +}, Symbol.toStringTag, { value: "Module" })), Ma = () => { + Vc().then((e) => b.setUserInfo(e)).catch((e) => ce("Failed to load userInfo", e)); +}, Vc = async () => Nt(`${he}get-user-info`, {}, (e) => (delete e.data.reqId, e.data)); +y.on("copilot-prokey-received", (e) => { + Ma(), e.preventDefault(); +}); +/** + * @license + * Copyright 2020 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const ja = Symbol.for(""), Ic = (e) => { + if (e?.r === ja) return e?._$litStatic$; +}, Ra = (e) => ({ _$litStatic$: e, r: ja }), ni = /* @__PURE__ */ new Map(), zc = (e) => (t, ...r) => { + const n = r.length; + let i, a; + const o = [], s = []; + let l, c = 0, d = !1; + for (; c < n; ) { + for (l = t[c]; c < n && (a = r[c], (i = Ic(a)) !== void 0); ) l += i + t[++c], d = !0; + c !== n && s.push(a), o.push(l), c++; + } + if (c === n && o.push(t[n]), d) { + const u = o.join("$$lit$$"); + (t = ni.get(u)) === void 0 && (o.raw = o, ni.set(u, t = o)), r = s; + } + return e(t, ...r); +}, gt = zc(le); +/** + * @license + * Copyright 2020 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const { I: Uc } = ac, tu = (e) => e.strings === void 0, ii = () => document.createComment(""), lt = (e, t, r) => { + const n = e._$AA.parentNode, i = t === void 0 ? e._$AB : t._$AA; + if (r === void 0) { + const a = n.insertBefore(ii(), i), o = n.insertBefore(ii(), i); + r = new Uc(a, o, e, e.options); + } else { + const a = r._$AB.nextSibling, o = r._$AM, s = o !== e; + if (s) { + let l; + r._$AQ?.(e), r._$AM = e, r._$AP !== void 0 && (l = e._$AU) !== o._$AU && r._$AP(l); + } + if (a !== i || s) { + let l = r._$AA; + for (; l !== a; ) { + const c = l.nextSibling; + n.insertBefore(l, i), l = c; + } + } + } + return r; +}, Ee = (e, t, r = e) => (e._$AI(t, r), e), Lc = {}, Mc = (e, t = Lc) => e._$AH = t, jc = (e) => e._$AH, Nr = (e) => { + e._$AP?.(!1, !0); + let t = e._$AA; + const r = e._$AB.nextSibling; + for (; t !== r; ) { + const n = t.nextSibling; + t.remove(), t = n; + } +}; +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const ai = (e, t, r) => { + const n = /* @__PURE__ */ new Map(); + for (let i = t; i <= r; i++) n.set(e[i], i); + return n; +}, qa = Pa(class extends Da { + constructor(e) { + if (super(e), e.type !== Sa.CHILD) throw Error("repeat() can only be used in text expressions"); + } + dt(e, t, r) { + let n; + r === void 0 ? r = t : t !== void 0 && (n = t); + const i = [], a = []; + let o = 0; + for (const s of e) i[o] = n ? n(s, o) : o, a[o] = r(s, o), o++; + return { values: a, keys: i }; + } + render(e, t, r) { + return this.dt(e, t, r).values; + } + update(e, [t, r, n]) { + const i = jc(e), { values: a, keys: o } = this.dt(t, r, n); + if (!Array.isArray(i)) return this.ut = o, a; + const s = this.ut ??= [], l = []; + let c, d, u = 0, v = i.length - 1, h = 0, m = a.length - 1; + for (; u <= v && h <= m; ) if (i[u] === null) u++; + else if (i[v] === null) v--; + else if (s[u] === o[h]) l[h] = Ee(i[u], a[h]), u++, h++; + else if (s[v] === o[m]) l[m] = Ee(i[v], a[m]), v--, m--; + else if (s[u] === o[m]) l[m] = Ee(i[u], a[m]), lt(e, l[m + 1], i[u]), u++, m--; + else if (s[v] === o[h]) l[h] = Ee(i[v], a[h]), lt(e, i[u], i[v]), v--, h++; + else if (c === void 0 && (c = ai(o, h, m), d = ai(s, u, v)), c.has(s[u])) if (c.has(s[v])) { + const O = d.get(o[h]), A = O !== void 0 ? i[O] : null; + if (A === null) { + const G = lt(e, i[u]); + Ee(G, a[h]), l[h] = G; + } else l[h] = Ee(A, a[h]), lt(e, i[u], A), i[O] = null; + h++; + } else Nr(i[v]), v--; + else Nr(i[u]), u++; + for (; h <= m; ) { + const O = lt(e, l[m + 1]); + Ee(O, a[h]), l[h++] = O; + } + for (; u <= v; ) { + const O = i[u++]; + O !== null && Nr(O); + } + return this.ut = o, Mc(e, l), ge; + } +}), Zt = /* @__PURE__ */ new Map(), Rc = (e) => { + const r = se.panels.filter((n) => !n.floating && n.panel === e).sort((n, i) => n.panelOrder - i.panelOrder); + return gt` + ${qa( + r, + (n) => n.tag, + (n) => { + const i = Ra(n.tag); + return gt` + ${se.shouldRender(n.tag) ? gt`<${i} slot="content">` : E} + `; + } + )} + `; +}, qc = () => { + const e = se.panels; + return gt` + ${qa( + e.filter((t) => t.floating), + (t) => t.tag, + (t) => { + const r = Ra(t.tag); + return gt` + + <${r} slot="content"> + `; + } + )} + `; +}, ru = (e) => { + const t = e.panelTag, r = e.querySelector('[slot="content"]'); + r && e.panelInfo?.panel && Zt.set(t, r); +}, nu = (e) => { + if (Zt.has(e.panelTag)) { + const t = Zt.get(e.panelTag); + e.querySelector('[slot="content"]').replaceWith(t); + } + Zt.delete(e.panelTag); +}, S = []; +for (let e = 0; e < 256; ++e) + S.push((e + 256).toString(16).slice(1)); +function Kc(e, t = 0) { + return (S[e[t + 0]] + S[e[t + 1]] + S[e[t + 2]] + S[e[t + 3]] + "-" + S[e[t + 4]] + S[e[t + 5]] + "-" + S[e[t + 6]] + S[e[t + 7]] + "-" + S[e[t + 8]] + S[e[t + 9]] + "-" + S[e[t + 10]] + S[e[t + 11]] + S[e[t + 12]] + S[e[t + 13]] + S[e[t + 14]] + S[e[t + 15]]).toLowerCase(); +} +let Tr; +const Bc = new Uint8Array(16); +function Fc() { + if (!Tr) { + if (typeof crypto > "u" || !crypto.getRandomValues) + throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported"); + Tr = crypto.getRandomValues.bind(crypto); + } + return Tr(Bc); +} +const Zc = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), oi = { randomUUID: Zc }; +function Wc(e, t, r) { + e = e || {}; + const n = e.random ?? e.rng?.() ?? Fc(); + if (n.length < 16) + throw new Error("Random bytes length must be >= 16"); + return n[6] = n[6] & 15 | 64, n[8] = n[8] & 63 | 128, Kc(n); +} +function Ka(e, t, r) { + return oi.randomUUID && !e ? oi.randomUUID() : Wc(e); +} +const Wt = [], pt = [], iu = async (e, t, r) => { + let n, i; + t.reqId = Ka(); + const a = new Promise((o, s) => { + n = o, i = s; + }); + return Wt.push({ + handleMessage(o) { + if (o?.data?.reqId !== t.reqId) + return !1; + try { + n(r(o)); + } catch (s) { + i(s); + } + return !0; + } + }), te(e, t), a; +}; +function Hc(e) { + for (const t of Wt) + if (t.handleMessage(e)) + return Wt.splice(Wt.indexOf(t), 1), !0; + if (y.emitUnsafe({ type: e.command, data: e.data })) + return !0; + for (const t of Fa()) + if (Ba(t, e)) + return !0; + return pt.push(e), !1; +} +function Ba(e, t) { + return e.handleMessage?.call(e, t); +} +function Xc() { + if (pt.length) + for (const e of Fa()) + for (let t = 0; t < pt.length; t++) + Ba(e, pt[t]) && (pt.splice(t, 1), t--); +} +function Fa() { + const e = document.querySelector("copilot-main"); + return e ? e.renderRoot.querySelectorAll("copilot-section-panel-wrapper *") : []; +} +const Jc = ":host{--animate-spin: spin 1s linear infinite;--animate-swirl: swirl 5s linear infinite}@keyframes bounce{0%{transform:scale(.8)}50%{transform:scale(1.5)}to{transform:scale(1)}}@keyframes bounceLeft{0%{transform:translate(0)}30%{transform:translate(-10px)}50%{transform:translate(0)}70%{transform:translate(-5px)}to{transform:translate(0)}}@keyframes bounceRight{0%{transform:translate(0)}30%{transform:translate(10px)}50%{transform:translate(0)}70%{transform:translate(5px)}to{transform:translate(0)}}@keyframes bounceBottom{0%{transform:translateY(0)}30%{transform:translateY(10px)}50%{transform:translateY(0)}70%{transform:translateY(5px)}to{transform:translateY(0)}}@keyframes around-we-go-again{0%{background-position:0 0,0 0,calc(var(--glow-size) * -.5) calc(var(--glow-size) * -.5),calc(100% + calc(var(--glow-size) * .5)) calc(100% + calc(var(--glow-size) * .5))}25%{background-position:0 0,0 0,calc(100% + calc(var(--glow-size) * .5)) calc(var(--glow-size) * -.5),calc(var(--glow-size) * -.5) calc(100% + calc(var(--glow-size) * .5))}50%{background-position:0 0,0 0,calc(100% + calc(var(--glow-size) * .5)) calc(100% + calc(var(--glow-size) * .5)),calc(var(--glow-size) * -.5) calc(var(--glow-size) * -.5)}75%{background-position:0 0,0 0,calc(var(--glow-size) * -.5) calc(100% + calc(var(--glow-size) * .5)),calc(100% + calc(var(--glow-size) * .5)) calc(var(--glow-size) * -.5)}to{background-position:0 0,0 0,calc(var(--glow-size) * -.5) calc(var(--glow-size) * -.5),calc(100% + calc(var(--glow-size) * .5)) calc(100% + calc(var(--glow-size) * .5))}}@keyframes spin{to{transform:rotate(360deg)}}@keyframes swirl{0%{rotate:0deg;filter:hue-rotate(20deg)}50%{filter:hue-rotate(-30deg)}to{rotate:360deg;filter:hue-rotate(20deg)}}@keyframes button-focus-in{0%{box-shadow:0 0 0 0 var(--focus-color)}to{box-shadow:0 0 0 var(--focus-size) var(--focus-color)}}@keyframes button-focus-out{0%{box-shadow:0 0 0 var(--focus-size) var(--focus-color)}}@keyframes button-primary-focus-in{0%{box-shadow:0 0 0 0 var(--focus-color)}to{box-shadow:0 0 0 1px var(--background-color),0 0 0 calc(var(--focus-size) + 2px) var(--focus-color)}}@keyframes button-primary-focus-out{0%{box-shadow:0 0 0 1px var(--background-color),0 0 0 calc(var(--focus-size) + 2px) var(--focus-color)}}@keyframes link-focus-in{0%{box-shadow:0 0 0 0 var(--blue-color)}to{box-shadow:0 0 0 var(--focus-size) var(--blue-color)}}@keyframes link-focus-out{0%{box-shadow:0 0 0 var(--focus-size) var(--blue-color)}}@keyframes ping{75%,to{transform:scale(2);opacity:0}}@keyframes fadeInOut{0%,to{opacity:0}50%{opacity:1}}", Gc = 'button{align-items:center;-webkit-appearance:none;appearance:none;background:transparent;background-origin:border-box;border:1px solid transparent;border-radius:var(--vaadin-radius-s);color:var(--vaadin-text-color);cursor:pointer;display:inline-flex;flex-shrink:0;font:var(--copilot-font-button);height:var(--copilot-size-md);justify-content:center;outline-offset:calc(var(--focus-size) / -1);padding:0 var(--space-100)}button:hover{background:var(--hover-color)}button:focus{outline:var(--vaadin-focus-ring-width) solid var(--vaadin-focus-ring-color);outline-offset:1px}button:active:not([disabled]){background:var(--active-color)}button.primary{background:var(--primary-color);color:var(--primary-contrast-text-color)}button.icon{padding:0;width:var(--copilot-size-md)}button.icon span:has(svg){display:flex;width:fit-content}button svg{height:var(--icon-size-s);width:var(--icon-size-s)}button .prefix,button .suffix{align-items:center;display:flex;height:var(--copilot-size-md);justify-content:center;width:var(--copilot-size-md)}button:has(.prefix){padding-inline-start:0}button:has(.suffix){padding-inline-end:0}button[role=switch]{align-items:center;border:2px solid var(--vaadin-text-color-secondary);border-radius:9999px;box-sizing:border-box;display:flex;flex-shrink:0;height:1rem;justify-content:start;padding:0;transition:.2s;width:1.5rem}button[role=switch] span{background:var(--vaadin-text-color-secondary);border-radius:9999px;content:"";display:flex;flex-shrink:0;height:.5rem;transition:.2s;transform:translate(.125rem);width:.5rem}button[role=switch][aria-checked=true]{background:var(--blue-11);border-color:var(--blue-11)}button[role=switch][aria-checked=true] span{background:var(--blue-5);height:.625rem;transform:translate(.5625rem);width:.625rem}button[disabled]{cursor:not-allowed;opacity:.3}button[hidden]{display:none}button.link-button{all:initial;color:inherit;cursor:pointer;font-family:inherit;font-size:var(--dev-tools-font-size-small);font-weight:600;line-height:1;text-decoration:underline;white-space:nowrap}button.link-button:focus,button.link-button:hover{color:var(--dev-tools-text-color-emphasis)}', Yc = "code.codeblock{background:var(--contrast-color-5);border-radius:var(--vaadin-radius-m);display:block;font-family:var(--monospace-font-family);font-size:var(--copilot-font-size-xs);line-height:var(--copilot-line-height-sm);overflow:hidden;padding:calc((var(--copilot-size-md) - var(--copilot-line-height-sm)) / 2) var(--copilot-size-md) calc((var(--copilot-size-md) - var(--copilot-line-height-sm)) / 2) var(--space-100);position:relative;text-overflow:ellipsis;white-space:pre;min-height:var(--copilot-line-height-sm)}copilot-copy{position:absolute;right:0;top:0}div.message.error code.codeblock copilot-copy svg{color:#ffffffb3}", Qc = ":host{color-scheme:light;--vaadin-background-color: light-dark(var(--gray-1), var(--gray-5));--vaadin-text-color: light-dark(var(--gray-12), white);--vaadin-text-color-secondary: light-dark(var(--gray-11), hsla(0, 0%, 100%, .7));--vaadin-text-color-disabled: var(--vaadin-text-color-secondary);--vaadin-focus-ring-color: var(--vaadin-text-color);--vaadin-divider-color: light-dark(hsla(0, 0%, 0%, .1), hsla(0, 0%, 100%, .15));--vaadin-blue: #1a81fa;--vaadin-violet: #8854fc;--amber-1: light-dark(#fefdfb, #16120c);--amber-2: light-dark(#fefbe9, #1d180f);--amber-3: light-dark(#fff7c2, #302008);--amber-4: light-dark(#ffee9c, #3f2700);--amber-5: light-dark(#fbe577, #4d3000);--amber-6: light-dark(#f3d673, #5c3d05);--amber-7: light-dark(#e9c162, #714f19);--amber-8: light-dark(#e2a336, #8f6424);--amber-9: light-dark(#ffc53d, #ffc53d);--amber-10: light-dark(#ffba18, #ffd60a);--amber-11: light-dark(#ab6400, #ffca16);--amber-12: light-dark(#4f3422, #ffe7b3);--blue-1: light-dark(#fcfdff, #0a111c);--blue-2: light-dark(#f5f9ff, #0f1826);--blue-3: light-dark(#eaf3ff, #0e2649);--blue-4: light-dark(#dbebff, #0d3162);--blue-5: light-dark(#c9e2ff, #133c75);--blue-6: light-dark(#b5d4ff, #1c4885);--blue-7: light-dark(#9bc2fc, #25559a);--blue-8: light-dark(#76aaf7, #2b63b5);--blue-9: light-dark(#0368de, #0368de);--blue-10: light-dark(#0059ce, #265fb0);--blue-11: light-dark(#0368de, #82b8ff);--blue-12: light-dark(#0c3164, #d0e3ff);--gray-1: light-dark(#fcfcfd, #111113);--gray-2: light-dark(#f9f9fb, #19191b);--gray-3: light-dark(#eff0f3, #222325);--gray-4: light-dark(#e7e8ec, #292a2e);--gray-5: light-dark(#e0e1e6, #303136);--gray-6: light-dark(#d8d9e0, #393a40);--gray-7: light-dark(#cdced7, #46484f);--gray-8: light-dark(#b9bbc6, #5f606a);--gray-9: light-dark(#8b8d98, #6c6e79);--gray-10: light-dark(#80828d, #797b86);--gray-11: light-dark(#62636c, #b2b3bd);--gray-12: light-dark(#1e1f24, #eeeef0);--ruby-1: light-dark(#fffcfd, #191113);--ruby-2: light-dark(#fff7f8, #1e1517);--ruby-3: light-dark(#feeaed, #3a141e);--ruby-4: light-dark(#ffdce1, #4e1325);--ruby-5: light-dark(#ffced6, #5e1a2e);--ruby-6: light-dark(#f8bfc8, #6f2539);--ruby-7: light-dark(#efacb8, #883447);--ruby-8: light-dark(#e592a3, #b3445a);--ruby-9: light-dark(#e54666, #e54666);--ruby-10: light-dark(#dc3b5d, #ec5a72);--ruby-11: light-dark(#ca244d, #ff949d);--ruby-12: light-dark(#64172b, #fed2e1);--teal-1: light-dark(#fafefd, #0d1514);--teal-2: light-dark(#f3fbf9, #111c1b);--teal-3: light-dark(#e0f8f3, #0d2d2a);--teal-4: light-dark(#ccf3ea, #023b37);--teal-5: light-dark(#b8eae0, #084843);--teal-6: light-dark(#a1ded2, #145750);--teal-7: light-dark(#83cdc1, #1c6961);--teal-8: light-dark(#53b9ab, #207e73);--teal-9: light-dark(#12a594, #12a594);--teal-10: light-dark(#0d9b8a, #0eb39e);--teal-11: light-dark(#008573, #0bd8b6);--teal-12: light-dark(#0d3d38, #adf0dd);--violet-1: light-dark(#fcfcff, #110d21);--violet-2: light-dark(#f9f8ff, #18132c);--violet-3: light-dark(#f2f0ff, #291853);--violet-4: light-dark(#e8e3ff, #351772);--violet-5: light-dark(#dfd8ff, #3e1f81);--violet-6: light-dark(#d2c8ff, #492b91);--violet-7: light-dark(#c0b0ff, #5838a9);--violet-8: light-dark(#a98fff, #6d45d0);--violet-9: light-dark(#7b2bff, #7b2bff);--violet-10: light-dark(#6c2adf, #6f07ee);--violet-11: light-dark(#6f2fe3, #b8a5ff);--violet-12: light-dark(#361475, #e1dbff);--gray-h: 220;--gray-s: 30%;--gray-l: 30%;--gray-hsl: var(--gray-h) var(--gray-s) var(--gray-l);--gray: hsl(var(--gray-hsl));--gray-50: hsl(var(--gray-hsl) / .05);--gray-100: hsl(var(--gray-hsl) / .1);--gray-150: hsl(var(--gray-hsl) / .16);--gray-200: hsl(var(--gray-hsl) / .24);--gray-250: hsl(var(--gray-hsl) / .34);--gray-300: hsl(var(--gray-hsl) / .46);--gray-350: hsl(var(--gray-hsl) / .6);--gray-400: hsl(var(--gray-hsl) / .7);--gray-450: hsl(var(--gray-hsl) / .8);--gray-500: hsl(var(--gray-hsl) / .9);--gray-550: hsl(var(--gray-hsl));--gray-600: hsl(var(--gray-h) var(--gray-s) calc(var(--gray-l) - 2%));--gray-650: hsl(var(--gray-h) var(--gray-s) calc(var(--gray-l) - 4%));--gray-700: hsl(var(--gray-h) var(--gray-s) calc(var(--gray-l) - 8%));--gray-750: hsl(var(--gray-h) var(--gray-s) calc(var(--gray-l) - 12%));--gray-800: hsl(var(--gray-h) var(--gray-s) calc(var(--gray-l) - 20%));--gray-850: hsl(var(--gray-h) var(--gray-s) calc(var(--gray-l) - 23%));--gray-900: hsl(var(--gray-h) var(--gray-s) calc(var(--gray-l) - 30%));--blue-h: 220;--blue-s: 90%;--blue-l: 53%;--blue-hsl: var(--blue-h) var(--blue-s) var(--blue-l);--blue: hsl(var(--blue-hsl));--blue-50: hsl(var(--blue-hsl) / .05);--blue-100: hsl(var(--blue-hsl) / .1);--blue-150: hsl(var(--blue-hsl) / .2);--blue-200: hsl(var(--blue-hsl) / .3);--blue-250: hsl(var(--blue-hsl) / .4);--blue-300: hsl(var(--blue-hsl) / .5);--blue-350: hsl(var(--blue-hsl) / .6);--blue-400: hsl(var(--blue-hsl) / .7);--blue-450: hsl(var(--blue-hsl) / .8);--blue-500: hsl(var(--blue-hsl) / .9);--blue-550: hsl(var(--blue-hsl));--blue-600: hsl(var(--blue-h) var(--blue-s) calc(var(--blue-l) - 4%));--blue-650: hsl(var(--blue-h) var(--blue-s) calc(var(--blue-l) - 8%));--blue-700: hsl(var(--blue-h) var(--blue-s) calc(var(--blue-l) - 12%));--blue-750: hsl(var(--blue-h) var(--blue-s) calc(var(--blue-l) - 15%));--blue-800: hsl(var(--blue-h) var(--blue-s) calc(var(--blue-l) - 18%));--blue-850: hsl(var(--blue-h) var(--blue-s) calc(var(--blue-l) - 24%));--blue-900: hsl(var(--blue-h) var(--blue-s) calc(var(--blue-l) - 27%));--purple-h: 246;--purple-s: 90%;--purple-l: 60%;--purple-hsl: var(--purple-h) var(--purple-s) var(--purple-l);--purple: hsl(var(--purple-hsl));--purple-50: hsl(var(--purple-hsl) / .05);--purple-100: hsl(var(--purple-hsl) / .1);--purple-150: hsl(var(--purple-hsl) / .2);--purple-200: hsl(var(--purple-hsl) / .3);--purple-250: hsl(var(--purple-hsl) / .4);--purple-300: hsl(var(--purple-hsl) / .5);--purple-350: hsl(var(--purple-hsl) / .6);--purple-400: hsl(var(--purple-hsl) / .7);--purple-450: hsl(var(--purple-hsl) / .8);--purple-500: hsl(var(--purple-hsl) / .9);--purple-550: hsl(var(--purple-hsl));--purple-600: hsl(var(--purple-h) calc(var(--purple-s) - 4%) calc(var(--purple-l) - 2%));--purple-650: hsl(var(--purple-h) calc(var(--purple-s) - 8%) calc(var(--purple-l) - 4%));--purple-700: hsl(var(--purple-h) calc(var(--purple-s) - 15%) calc(var(--purple-l) - 7%));--purple-750: hsl(var(--purple-h) calc(var(--purple-s) - 23%) calc(var(--purple-l) - 11%));--purple-800: hsl(var(--purple-h) calc(var(--purple-s) - 24%) calc(var(--purple-l) - 15%));--purple-850: hsl(var(--purple-h) calc(var(--purple-s) - 24%) calc(var(--purple-l) - 19%));--purple-900: hsl(var(--purple-h) calc(var(--purple-s) - 27%) calc(var(--purple-l) - 23%));--green-h: 150;--green-s: 80%;--green-l: 42%;--green-hsl: var(--green-h) var(--green-s) var(--green-l);--green: hsl(var(--green-hsl));--green-50: hsl(var(--green-hsl) / .05);--green-100: hsl(var(--green-hsl) / .1);--green-150: hsl(var(--green-hsl) / .2);--green-200: hsl(var(--green-hsl) / .3);--green-250: hsl(var(--green-hsl) / .4);--green-300: hsl(var(--green-hsl) / .5);--green-350: hsl(var(--green-hsl) / .6);--green-400: hsl(var(--green-hsl) / .7);--green-450: hsl(var(--green-hsl) / .8);--green-500: hsl(var(--green-hsl) / .9);--green-550: hsl(var(--green-hsl));--green-600: hsl(var(--green-h) var(--green-s) calc(var(--green-l) - 2%));--green-650: hsl(var(--green-h) var(--green-s) calc(var(--green-l) - 4%));--green-700: hsl(var(--green-h) var(--green-s) calc(var(--green-l) - 8%));--green-750: hsl(var(--green-h) var(--green-s) calc(var(--green-l) - 12%));--green-800: hsl(var(--green-h) var(--green-s) calc(var(--green-l) - 15%));--green-850: hsl(var(--green-h) var(--green-s) calc(var(--green-l) - 19%));--green-900: hsl(var(--green-h) var(--green-s) calc(var(--green-l) - 23%));--yellow-h: 38;--yellow-s: 98%;--yellow-l: 64%;--yellow-hsl: var(--yellow-h) var(--yellow-s) var(--yellow-l);--yellow: hsl(var(--yellow-hsl));--yellow-50: hsl(var(--yellow-hsl) / .07);--yellow-100: hsl(var(--yellow-hsl) / .12);--yellow-150: hsl(var(--yellow-hsl) / .2);--yellow-200: hsl(var(--yellow-hsl) / .3);--yellow-250: hsl(var(--yellow-hsl) / .4);--yellow-300: hsl(var(--yellow-hsl) / .5);--yellow-350: hsl(var(--yellow-hsl) / .6);--yellow-400: hsl(var(--yellow-hsl) / .7);--yellow-450: hsl(var(--yellow-hsl) / .8);--yellow-500: hsl(var(--yellow-hsl) / .9);--yellow-550: hsl(var(--yellow-hsl));--yellow-600: hsl(var(--yellow-h) var(--yellow-s) calc(var(--yellow-l) - 5%));--yellow-650: hsl(var(--yellow-h) var(--yellow-s) calc(var(--yellow-l) - 10%));--yellow-700: hsl(var(--yellow-h) var(--yellow-s) calc(var(--yellow-l) - 15%));--yellow-750: hsl(var(--yellow-h) var(--yellow-s) calc(var(--yellow-l) - 20%));--yellow-800: hsl(var(--yellow-h) var(--yellow-s) calc(var(--yellow-l) - 25%));--yellow-850: hsl(var(--yellow-h) var(--yellow-s) calc(var(--yellow-l) - 30%));--yellow-900: hsl(var(--yellow-h) var(--yellow-s) calc(var(--yellow-l) - 35%));--red-h: 355;--red-s: 75%;--red-l: 55%;--red-hsl: var(--red-h) var(--red-s) var(--red-l);--red: hsl(var(--red-hsl));--red-50: hsl(var(--red-hsl) / .05);--red-100: hsl(var(--red-hsl) / .1);--red-150: hsl(var(--red-hsl) / .2);--red-200: hsl(var(--red-hsl) / .3);--red-250: hsl(var(--red-hsl) / .4);--red-300: hsl(var(--red-hsl) / .5);--red-350: hsl(var(--red-hsl) / .6);--red-400: hsl(var(--red-hsl) / .7);--red-450: hsl(var(--red-hsl) / .8);--red-500: hsl(var(--red-hsl) / .9);--red-550: hsl(var(--red-hsl));--red-600: hsl(var(--red-h) calc(var(--red-s) - 5%) calc(var(--red-l) - 2%));--red-650: hsl(var(--red-h) calc(var(--red-s) - 10%) calc(var(--red-l) - 4%));--red-700: hsl(var(--red-h) calc(var(--red-s) - 15%) calc(var(--red-l) - 8%));--red-750: hsl(var(--red-h) calc(var(--red-s) - 20%) calc(var(--red-l) - 12%));--red-800: hsl(var(--red-h) calc(var(--red-s) - 25%) calc(var(--red-l) - 15%));--red-850: hsl(var(--red-h) calc(var(--red-s) - 30%) calc(var(--red-l) - 19%));--red-900: hsl(var(--red-h) calc(var(--red-s) - 35%) calc(var(--red-l) - 23%));--codeblock-bg: #f4f4f4;--background-color: rgba(255, 255, 255, .87);--primary-color: #0368de;--input-border-color: rgba(0, 0, 0, .42);--divider-primary-color: rgba(0, 0, 0, .1);--divider-secondary-color: rgba(0, 0, 0, .05);--switch-active-color: #0d875b;--switch-inactive-color: #757575;--primary-contrast-text-color: white;--active-color: rgba(3, 104, 222, .1);--focus-color: #0377ff;--hover-color: rgba(0, 0, 0, .05);--info-color: var(--blue-400);--success-color: var(--success-color-80);--error-color: var(--error-color-70);--warning-color: #fec941;--success-color-5: #f0fffa;--success-color-10: #eafaf4;--success-color-20: #d2f0e5;--success-color-30: #8ce4c5;--success-color-40: #39c693;--success-color-50: #1ba875;--success-color-60: #0e9c69;--success-color-70: #0d8b5e;--success-color-80: #066845;--success-color-90: #004d31;--error-color-5: #fff5f6;--error-color-10: #ffedee;--error-color-20: #ffd0d4;--error-color-30: #f8a8ae;--error-color-40: #ff707a;--error-color-50: #ff3a49;--error-color-60: #ff0013;--error-color-70: #ce0010;--error-color-80: #97000b;--error-color-90: #680008;--contrast-color-5: rgba(0, 0, 0, .05);--contrast-color-10: rgba(0, 0, 0, .1);--contrast-color-20: rgba(0, 0, 0, .2);--contrast-color-30: rgba(0, 0, 0, .3);--contrast-color-40: rgba(0, 0, 0, .4);--contrast-color-50: rgba(0, 0, 0, .5);--contrast-color-60: rgba(0, 0, 0, .6);--contrast-color-70: rgba(0, 0, 0, .7);--contrast-color-80: rgba(0, 0, 0, .8);--contrast-color-90: rgba(0, 0, 0, .9);--contrast-color-100: black;--blue-color: #0368de;--violet-color: #7b2bff}:host(.dark){color-scheme:dark;--gray-s: 15%;--gray-l: 70%;--gray-600: hsl(var(--gray-h) calc(var(--gray-s) - 2%) calc(var(--gray-l) + 6%));--gray-650: hsl(var(--gray-h) calc(var(--gray-s) - 5%) calc(var(--gray-l) + 14%));--gray-700: hsl(var(--gray-h) calc(var(--gray-s) - 2%) calc(var(--gray-l) + 26%));--gray-750: hsl(var(--gray-h) calc(var(--gray-s) - 2%) calc(var(--gray-l) + 36%));--gray-800: hsl(var(--gray-h) calc(var(--gray-s) - 2%) calc(var(--gray-l) + 48%));--gray-850: hsl(var(--gray-h) calc(var(--gray-s) - 2%) calc(var(--gray-l) + 62%));--gray-900: hsl(var(--gray-h) calc(var(--gray-s) - 2%) calc(var(--gray-l) + 70%));--blue-s: 90%;--blue-l: 58%;--blue-600: hsl(var(--blue-h) var(--blue-s) calc(var(--blue-l) + 6%));--blue-650: hsl(var(--blue-h) var(--blue-s) calc(var(--blue-l) + 12%));--blue-700: hsl(var(--blue-h) var(--blue-s) calc(var(--blue-l) + 17%));--blue-750: hsl(var(--blue-h) var(--blue-s) calc(var(--blue-l) + 22%));--blue-800: hsl(var(--blue-h) var(--blue-s) calc(var(--blue-l) + 28%));--blue-850: hsl(var(--blue-h) var(--blue-s) calc(var(--blue-l) + 35%));--blue-900: hsl(var(--blue-h) var(--blue-s) calc(var(--blue-l) + 43%));--purple-600: hsl(var(--purple-h) var(--purple-s) calc(var(--purple-l) + 4%));--purple-650: hsl(var(--purple-h) var(--purple-s) calc(var(--purple-l) + 9%));--purple-700: hsl(var(--purple-h) var(--purple-s) calc(var(--purple-l) + 12%));--purple-750: hsl(var(--purple-h) var(--purple-s) calc(var(--purple-l) + 18%));--purple-800: hsl(var(--purple-h) var(--purple-s) calc(var(--purple-l) + 24%));--purple-850: hsl(var(--purple-h) var(--purple-s) calc(var(--purple-l) + 29%));--purple-900: hsl(var(--purple-h) var(--purple-s) calc(var(--purple-l) + 33%));--green-600: hsl(calc(var(--green-h) - 1) calc(var(--green-s) - 5%) calc(var(--green-l) + 5%));--green-650: hsl(calc(var(--green-h) - 2) calc(var(--green-s) - 10%) calc(var(--green-l) + 12%));--green-700: hsl(calc(var(--green-h) - 4) calc(var(--green-s) - 15%) calc(var(--green-l) + 20%));--green-750: hsl(calc(var(--green-h) - 6) calc(var(--green-s) - 20%) calc(var(--green-l) + 29%));--green-800: hsl(calc(var(--green-h) - 8) calc(var(--green-s) - 25%) calc(var(--green-l) + 37%));--green-850: hsl(calc(var(--green-h) - 10) calc(var(--green-s) - 30%) calc(var(--green-l) + 42%));--green-900: hsl(calc(var(--green-h) - 12) calc(var(--green-s) - 35%) calc(var(--green-l) + 48%));--yellow-600: hsl(calc(var(--yellow-h) + 1) var(--yellow-s) calc(var(--yellow-l) + 4%));--yellow-650: hsl(calc(var(--yellow-h) + 2) var(--yellow-s) calc(var(--yellow-l) + 7%));--yellow-700: hsl(calc(var(--yellow-h) + 4) var(--yellow-s) calc(var(--yellow-l) + 11%));--yellow-750: hsl(calc(var(--yellow-h) + 6) var(--yellow-s) calc(var(--yellow-l) + 16%));--yellow-800: hsl(calc(var(--yellow-h) + 8) var(--yellow-s) calc(var(--yellow-l) + 20%));--yellow-850: hsl(calc(var(--yellow-h) + 10) var(--yellow-s) calc(var(--yellow-l) + 24%));--yellow-900: hsl(calc(var(--yellow-h) + 12) var(--yellow-s) calc(var(--yellow-l) + 29%));--red-600: hsl(calc(var(--red-h) - 1) calc(var(--red-s) - 5%) calc(var(--red-l) + 3%));--red-650: hsl(calc(var(--red-h) - 2) calc(var(--red-s) - 10%) calc(var(--red-l) + 7%));--red-700: hsl(calc(var(--red-h) - 4) calc(var(--red-s) - 15%) calc(var(--red-l) + 14%));--red-750: hsl(calc(var(--red-h) - 6) calc(var(--red-s) - 20%) calc(var(--red-l) + 19%));--red-800: hsl(calc(var(--red-h) - 8) calc(var(--red-s) - 25%) calc(var(--red-l) + 24%));--red-850: hsl(calc(var(--red-h) - 10) calc(var(--red-s) - 30%) calc(var(--red-l) + 30%));--red-900: hsl(calc(var(--red-h) - 12) calc(var(--red-s) - 35%) calc(var(--red-l) + 36%));--codeblock-bg: var(--gray-100);--background-color: rgba(0, 0, 0, .87);--primary-color: white;--input-border-color: rgba(255, 255, 255, .42);--divider-primary-color: rgba(255, 255, 255, .2);--divider-secondary-color: rgba(255, 255, 255, .1);--primary-contrast-text-color: rgba(0, 0, 0, .87);--active-color: rgba(255, 255, 255, .15);--focus-color: rgba(255, 255, 255, .5);--hover-color: rgba(255, 255, 255, .1);--success-color: var(--success-color-50);--error-color: var(--error-color-50);--warning-color: #fec941;--success-color-5: #004d31;--success-color-10: #066845;--success-color-20: #0d8b5e;--success-color-30: #0e9c69;--success-color-40: #1ba875;--success-color-50: #39c693;--success-color-60: #8ce4c5;--success-color-70: #d2f0e5;--success-color-80: #eafaf4;--success-color-90: #f0fffa;--error-color-5: #680008;--error-color-10: #97000b;--error-color-20: #ce0010;--error-color-30: #ff0013;--error-color-40: #ff3a49;--error-color-50: #ff707a;--error-color-60: #f8a8ae;--error-color-70: #ffd0d4;--error-color-80: #ffedee;--error-color-90: #fff5f6;--contrast-color-5: rgba(255, 255, 255, .05);--contrast-color-10: rgba(255, 255, 255, .1);--contrast-color-20: rgba(255, 255, 255, .2);--contrast-color-30: rgba(255, 255, 255, .3);--contrast-color-40: rgba(255, 255, 255, .4);--contrast-color-50: rgba(255, 255, 255, .5);--contrast-color-60: rgba(255, 255, 255, .6);--contrast-color-70: rgba(255, 255, 255, .7);--contrast-color-80: rgba(255, 255, 255, .8);--contrast-color-90: rgba(255, 255, 255, .9);--contrast-color-100: white;--blue-color: #95c6ff;--violet-color: #cbb4ff}.bg-blue{background-color:var(--blue-color)}.bg-error{background-color:var(--error-color)}.bg-success{background-color:var(--success-color)}.bg-violet{background-color:var(--violet-color)}.bg-warning{background-color:var(--warning-color)}.blue-text{color:var(--blue-color)}.error-text{color:var(--error-color)}.success-text{color:var(--success-color)}.violet-text{color:var(--violet-color)}.warning-text{color:var(--warning-color)}", _c = `vaadin-button{letter-spacing:.25px;padding:var(--vaadin-button-padding)}vaadin-button[focused]{z-index:1}vaadin-button[theme~=icon]{--vaadin-button-height: 2rem;--vaadin-button-padding: 0;width:var(--vaadin-button-height)}vaadin-button vaadin-icon[slot=prefix]{margin-inline-start:-.375rem}vaadin-button vaadin-icon[slot=suffix]{margin-inline-end:-.375rem}vaadin-button[theme~=primary]{min-width:auto}vaadin-button[disabled][theme~=primary]{--vaadin-button-background: var(--vaadin-text-color);--vaadin-button-text-color: var(--vaadin-background-color)}vaadin-button[theme~=lg]{--vaadin-button-height: 2.5rem;--vaadin-icon-size: 1.5rem;--vaadin-icon-visual-size: 1.5rem}vaadin-button[theme~=lg][theme~=icon]{--vaadin-button-height: 2.5rem}vaadin-button[theme~=xl]{--vaadin-button-border-radius: var(--vaadin-radius-l);--vaadin-icon-size: 1.5rem;--vaadin-icon-visual-size: 1.5rem}vaadin-button[theme~=xl][theme~=icon]{--vaadin-button-height: 3rem}vaadin-checkbox::part(checkbox){margin:0}vaadin-combo-box-item{font:var(--copilot-font-sm);gap:var(--vaadin-item-gap);padding:var(--vaadin-item-padding)}.no-checkmark{--vaadin-item-checkmark-display: none;--_lumo-item-selected-icon-display: none}vaadin-context-menu-list-box hr{border-color:var(--vaadin-divider-color);border-width:0 0 1px;margin:.25rem .5rem .25rem calc(var(--vaadin-icon-size) + var(--vaadin-item-gap) + .5rem)}vaadin-context-menu-item{font:var(--copilot-font-sm);gap:var(--vaadin-item-gap);padding:var(--vaadin-item-padding)}vaadin-context-menu-item:is(:hover,[expanded]){background-color:light-dark(var(--gray-3),var(--gray-6))}vaadin-context-menu-item::part(checkmark){display:var(--vaadin-item-checkmark-display)}vaadin-context-menu-item::part(content){display:flex;gap:inherit}vaadin-context-menu-item[aria-haspopup=false]:after{display:none}vaadin-context-menu-item[aria-haspopup=true]:after{background:var(--vaadin-text-color-secondary);color:inherit;content:"";display:block;font:inherit;height:var(--vaadin-icon-size, 1lh);margin:0;mask:var(--_vaadin-icon-chevron-down) 50% / var(--vaadin-icon-visual-size, 100%) no-repeat;padding:0;rotate:-90deg;width:var(--vaadin-icon-size, 1lh)}vaadin-details{margin:0}vaadin-details[theme~=no-padding]::part(content){padding:0}vaadin-details-summary[theme~=reverse]{--vaadin-details-summary-gap: .25rem;--vaadin-details-summary-padding: .375rem .75rem;color:var(--vaadin-text-color-secondary);letter-spacing:var(--copilot-letter-spacing-xs);font:var(--copilot-font-xs-medium);gap:var(--vaadin-details-summary-gap);justify-content:normal;padding:var(--vaadin-details-summary-padding)}vaadin-details-summary[theme~=reverse]::part(toggle){color:inherit;height:auto;margin:0;order:1;width:auto}vaadin-details-summary[theme~=reverse]::part(toggle):before{background:currentColor;content:"";display:block;height:var(--vaadin-icon-size, 1lh);mask:var(--_vaadin-icon-chevron-down) 50% / var(--vaadin-icon-visual-size, 100%) no-repeat;rotate:-90deg;width:var(--vaadin-icon-size, 1lh)}@media (prefers-reduced-motion: no-preference){vaadin-details-summary[theme~=reverse]::part(toggle){transition:.12s}}vaadin-details-summary[theme~=reverse]::part(content){flex-grow:0}vaadin-dialog::part(header){--vaadin-dialog-padding: .5rem .5rem .5rem 1rem}vaadin-dialog::part(footer){--vaadin-dialog-padding: .5rem}vaadin-grid{background-color:var(--vaadin-grid-background)}vaadin-icon{color:inherit;height:var(--vaadin-icon-size, var(--lumo-icon-size-m));width:var(--vaadin-icon-size, var(--lumo-icon-size-m))}:is(vaadin-combo-box,vaadin-radio-group,vaadin-select,vaadin-text-area,vaadin-text-field){padding:0}:is(vaadin-combo-box,vaadin-select){--vaadin-input-field-padding: calc((6 / 16 * 1rem) - var(--vaadin-input-field-border-width)) calc((6 / 16 * 1rem) - var(--vaadin-input-field-border-width)) calc((6 / 16 * 1rem) - var(--vaadin-input-field-border-width)) calc((8 / 16 * 1rem) - var(--vaadin-input-field-border-width))}:is(vaadin-combo-box,vaadin-select,vaadin-text-field):has([slot=prefix]){--vaadin-input-field-padding: calc(.375rem - var(--vaadin-input-field-border-width))}*:not(vaadin-checkbox,vaadin-button)::part(label){letter-spacing:var(--copilot-letter-spacing-xs);line-height:var(--vaadin-input-field-label-line-height);margin-block:0 var(--vaadin-input-field-container-gap);padding:0}::part(input-field){border:var(--vaadin-input-field-border-color) solid var(--vaadin-input-field-border-width);box-shadow:none;gap:var(--vaadin-input-field-gap);padding:var(--vaadin-input-field-padding)}::part(input-field):after{content:none}[readonly]::part(input-field){--vaadin-input-field-border-color: light-dark(var(--gray-9), var(--gray-10));border-style:dashed}[invalid]::part(input-field){--vaadin-input-field-border-color: var(--vaadin-input-field-error-color)}:is(vaadin-combo-box,vaadin-text-field) input{line-height:var(--copilot-line-height-sm);min-height:1lh}:is(vaadin-combo-box,vaadin-number-field,vaadin-text-field) input{padding:0}::part(error-message){--vaadin-icon-size: 1.125rem ;--vaadin-icon-visual-size: 1rem ;line-height:var(--vaadin-input-field-error-line-height);margin:0}[has-error-message]::part(error-message){margin-top:var(--vaadin-input-field-container-gap)}::part(error-message):before{height:auto}::part(error-message):after{content:none}vaadin-text-area textarea{align-self:auto;height:auto;padding:0}::part(input-field):focus-within{outline:var(--vaadin-focus-ring-width) solid var(--vaadin-focus-ring-color);outline-offset:calc(var(--vaadin-input-field-border-width, 1px) * -1)}:is(vaadin-combo-box,vaadin-select,vaadin-text-field)[disabled]{opacity:.5}[disabled]::part(input-field){--vaadin-input-field-border-color: light-dark(var(--gray-9), var(--gray-10))}[theme~=no-border]{--vaadin-input-field-border-width: 0px}[theme~=no-border]:hover{--vaadin-input-field-background: light-dark(var(--gray-4), var(--gray-7))}[theme~=filled]{--vaadin-input-field-background: light-dark(var(--gray-3), var(--gray-6))}[theme~=filled]:hover{--vaadin-input-field-background: light-dark(var(--gray-4), var(--gray-7))}vaadin-menu-bar-item{font:var(--copilot-font-sm)}vaadin-menu-bar-item:after{content:none}vaadin-menu-bar[theme~=dev-tools]{--vaadin-button-border-radius: var(--vaadin-radius-l);--vaadin-overlay-background: linear-gradient(light-dark(var(--gray-1), var(--gray-5)) 0 0) padding-box, linear-gradient(90deg, var(--vaadin-blue), var(--vaadin-violet)) border-box;--vaadin-overlay-border-color: transparent;--vaadin-overlay-border-width: 2px}vaadin-menu-bar-button[theme~=dev-tools]{--vaadin-button-background: transparent;--vaadin-button-border-width: 0;--vaadin-button-height: var(--copilot-size-xl);--vaadin-button-text-color: white;--vaadin-button-padding: 0;--vaadin-icon-size: 1.5rem;--vaadin-icon-visual-size: 1.5rem;min-width:auto;overflow:hidden;position:relative;width:var(--vaadin-button-height)}vaadin-menu-bar-button[theme~=dev-tools]:before{animation:var(--animate-swirl);background-image:radial-gradient(circle at 50% -10%,var(--blue-9) 0%,transparent 60%),radial-gradient(circle at 25% 40%,var(--violet-9) 0%,transparent 70%),radial-gradient(circle at 80% 10%,var(--gray-9) 0%,transparent 80%),radial-gradient(circle at 110% 50%,var(--teal-9) 20%,transparent 100%);border-radius:inherit;content:"";inset:-.375rem;opacity:1;position:absolute}:host(:not([active])) vaadin-menu-bar-button[theme~=dev-tools]:before{animation-duration:10s;background-color:transparent;background-image:radial-gradient(circle at 50% -10%,var(--gray-9) 0%,transparent 60%),radial-gradient(circle at 25% 40%,var(--gray-9) 0%,transparent 70%),radial-gradient(circle at 80% 10%,var(--gray-9) 0%,transparent 80%),radial-gradient(circle at 110% 50%,var(--gray-9) 20%,transparent 100%)}:host([document-hidden]) vaadin-menu-bar-button[theme~=dev-tools]:before{background-color:var(--gray-9);background-image:none}vaadin-menu-bar-button[theme~=dev-tools]:after{background-color:transparent;border:2px solid rgba(255,255,255,.5);border-radius:inherit;content:"";filter:none;inset:0;opacity:1;position:absolute;transform:none;transition:none}vaadin-menu-bar-button[theme~=dev-tools]::part(prefix){margin:0;z-index:1}vaadin-menu-bar-button[theme~=dev-tools]::part(prefix):after{background:currentColor;content:"";display:flex;height:var(--vaadin-icon-visual-size);-webkit-mask-image:url('data:image/svg+xml;utf8,');mask-image:url('data:image/svg+xml;utf8,');width:var(--vaadin-icon-visual-size)}vaadin-menu-bar-button[theme~=dev-tools]::part(label){clip:rect(0,0,0,0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;white-space:nowrap;width:1px}vaadin-menu-bar-button[theme~=dev-tools]::part(suffix){display:none}vaadin-menu-bar-submenu[theme~=dev-tools]::part(overlay){border:var(--vaadin-overlay-border-width) solid var(--vaadin-overlay-border-color);border-radius:var(--vaadin-overlay-border-radius);margin-bottom:.375rem;min-width:20rem}vaadin-menu-bar-submenu[theme~=dev-tools]::part(content){--vaadin-item-overlay-padding: 1rem;padding:var(--vaadin-item-overlay-padding)}vaadin-menu-bar-submenu[theme~=dev-tools] vaadin-menu-bar-submenu{--vaadin-overlay-background: light-dark(var(--gray-1), var(--gray-5));--vaadin-overlay-border-color: var(--vaadin-divider-color);--vaadin-overlay-border-width: 1px;margin-bottom:0}vaadin-menu-bar-list-box[theme~=dev-tools]{--vaadin-item-checkmark-display: none;--_lumo-list-box-item-selected-icon-display: none}vaadin-menu-bar-item[theme~=dev-tools]{--vaadin-item-padding: .5rem;background-color:var(--vaadin-button-background);font-weight:var(--copilot-font-weight-medium);letter-spacing:var(--copilot-letter-spacing-md);padding:var(--vaadin-item-padding)}vaadin-menu-bar-item[theme~=dev-tools]+vaadin-menu-bar-item{border-top-left-radius:0;border-top-right-radius:0}vaadin-menu-bar-item[theme~=dev-tools]:has(+vaadin-menu-bar-item){border-bottom-left-radius:0;border-bottom-right-radius:0}vaadin-menu-bar-item[theme~=dev-tools]::part(content){display:flex;gap:.5rem}hr[theme~=dev-tools]{margin:.25rem 0;opacity:0}::part(overlay){background:var(--vaadin-overlay-background);color:var(--vaadin-text-color);font-family:var(--copilot-font-family);font-size:var(--copilot-font-size-sm);font-weight:400;letter-spacing:var(--copilot-letter-spacing-sm);line-height:var(--copilot-line-height-sm)}vaadin-popover#dev-tools-popover{--vaadin-popover-background: linear-gradient(light-dark(var(--gray-1), var(--gray-5)) 0 0) padding-box, linear-gradient(90deg, var(--vaadin-blue), var(--vaadin-violet)) border-box;--vaadin-popover-border-color: transparent;--vaadin-popover-border-width: 2px;--vaadin-popover-offset-bottom: .75rem}vaadin-popover#dev-tools-popover::part(arrow){--vaadin-popover-border-color: var(--vaadin-violet);--vaadin-popover-border-width: 2px;border:var(--vaadin-popover-border-width) solid var(--vaadin-popover-border-color);margin-inline-end:.4375rem}vaadin-radio-group[theme~=filled]::part(group-field){background:light-dark(var(--gray-5),var(--gray-7));border-radius:var(--vaadin-radius-s);flex-direction:row;flex-wrap:wrap;gap:.125rem 0;padding:.125rem;width:fit-content}vaadin-radio-group[theme~=filled] vaadin-radio-button{--vaadin-radio-button-gap: 0;border-radius:.125rem}vaadin-radio-group[theme~=filled] vaadin-radio-button:before{content:none}vaadin-radio-group[theme~=filled] vaadin-radio-button[focused]{outline:var(--vaadin-focus-ring-width) solid var(--vaadin-focus-ring-color)}vaadin-radio-group[theme~=filled] vaadin-radio-button::part(radio){display:none}vaadin-radio-group[theme~=filled] vaadin-radio-button label{align-items:center;display:inline-flex;gap:.375rem;padding:.25rem .75rem}vaadin-radio-group[theme~=filled] vaadin-radio-button label:has(vaadin-icon:first-child){padding-inline-start:.5rem}vaadin-radio-group[theme~=filled] vaadin-radio-button[checked]{--vaadin-radio-button-label-color: var(--vaadin-text-color);background:light-dark(var(--gray-1),var(--gray-5))}vaadin-select-value-button{display:flex;padding:0}vaadin-item,vaadin-select-item{--_lumo-selected-item-height: 0;--_lumo-selected-item-padding: 0}vaadin-item[role=option]{font-size:var(--copilot-font-size-sm);gap:var(--vaadin-item-gap);padding:var(--vaadin-item-padding)}vaadin-item,vaadin-select-item{line-height:var(--vaadin-input-field-value-line-height)}vaadin-tab{background:var(--vaadin-tab-background);border-radius:var(--vaadin-tab-border-radius);font-size:var(--vaadin-tab-font-size);font-weight:var(--vaadin-tab-font-weight);line-height:var(--vaadin-tab-line-height);padding:var(--vaadin-tab-padding)}vaadin-tab:before,vaadin-tab:after{content:none}vaadin-tab[selected]{--vaadin-tab-background: light-dark(var(--gray-4), var(--gray-7))}vaadin-tabs{box-shadow:none;min-height:auto;padding:var(--vaadin-tabs-padding)}vaadin-tabs::part(tabs){margin:0}vaadin-tabsheet::part(tabs-container){box-shadow:none}vaadin-tabsheet[theme~=horizontal]{flex-direction:row}vaadin-tabsheet[theme~=horizontal] vaadin-tabs::part(tabs){flex-direction:column}vaadin-tabsheet[theme~=horizontal] vaadin-tab{justify-content:start}vaadin-tabsheet[theme~=horizontal]::part(tabs-container){border-inline-end:1px solid var(--vaadin-divider-color)}`, $c = "vaadin-dialog::part(overlay){background:var(--background-color);-webkit-backdrop-filter:var(--surface-backdrop-filter);backdrop-filter:var(--surface-backdrop-filter);border:1px solid var(--contrast-color-5);border-radius:var(--vaadin-radius-m);box-shadow:var(--surface-box-shadow-1)}vaadin-dialog::part(header){background:none;border-bottom:1px solid var(--divider-primary-color);box-sizing:border-box;font:var(--copilot-font-xs-semibold);min-height:var(--copilot-size-xl);padding:var(--space-50) var(--space-50) var(--space-50) var(--space-150)}vaadin-dialog h2{font:var(--copilot-font-xs-bold);margin:0;padding:0}vaadin-dialog::part(content){font:var(--copilot-font-xs);padding:var(--space-150)}vaadin-dialog::part(footer){background:none;padding:var(--space-100)}vaadin-dialog.ai-dialog::part(overlay){max-width:20rem}vaadin-dialog.ai-dialog::part(header){border:none}vaadin-dialog.ai-dialog [slot=header-content] svg{color:var(--blue-color)}vaadin-dialog.ai-dialog::part(content){display:flex;flex-direction:column;gap:var(--space-200)}vaadin-dialog.ai-dialog p{margin:0}vaadin-dialog.ai-dialog label:has(input[type=checkbox]){align-items:center;display:flex}vaadin-dialog.ai-dialog input[type=checkbox]{height:.875rem;margin:calc((var(--copilot-size-md) - .875rem) / 2);width:.875rem}vaadin-dialog.ai-dialog button.primary{min-width:calc(var(--copilot-size-md) * 2)}vaadin-dialog.drop-api-dialog::part(overlay){width:35em}vaadin-dialog.drop-api-dialog::part(header-content){width:unset;justify-content:unset;flex:unset}vaadin-dialog.drop-api-dialog::part(title){font-size:var(--copilot-font-size-sm)}vaadin-dialog.drop-api-dialog::part(header){border-bottom:unset;justify-content:space-between}vaadin-dialog.drop-api-dialog::part(content){padding:var(--space-100);max-height:250px;overflow:auto}vaadin-dialog.drop-api-dialog div.item-content{display:flex;justify-content:center;align-items:start;flex-direction:column}vaadin-dialog.drop-api-dialog div.method-row-container{display:flex;justify-content:space-between;width:100%;align-items:center}vaadin-dialog.drop-api-dialog div.method-row-container div.class-method-name{padding-left:var(--space-150)}vaadin-dialog.drop-api-dialog div.method-row-container div.action-btn-container{width:150px}vaadin-dialog.drop-api-dialog div.method-row-container div.action-btn-container button.action-btn.selected{color:var(--selection-color)}vaadin-dialog.edit-component-dialog{width:25em}vaadin-dialog.edit-component-dialog #component-icon{width:75px}vaadin-dialog#report-exception-dialog{z-index:calc(var(--copilot-notifications-container-z-index) + 1)}vaadin-dialog#report-exception-dialog::part(overlay){height:600px}vaadin-dialog#report-exception-dialog vaadin-text-area{width:100%;min-height:120px}vaadin-dialog#report-exception-dialog .list-preview-container{display:flex;flex-direction:row;gap:var(--space-100);margin-top:var(--space-50)}vaadin-dialog#report-exception-dialog .left-menu{display:flex;flex-direction:column;min-width:200px;width:200px}vaadin-dialog#report-exception-dialog .right-menu{display:flex;flex-direction:column;white-space:break-spaces;overflow:auto;border-radius:var(--vaadin-radius-m);align-items:start;height:300px;width:800px}vaadin-dialog#report-exception-dialog .right-menu pre{margin:0}vaadin-dialog#report-exception-dialog vaadin-item div.item-content{display:inline-block}vaadin-dialog#report-exception-dialog vaadin-item div.item-content span{max-width:150px;white-space:nowrap;text-overflow:ellipsis;overflow:hidden;display:block}vaadin-dialog#report-exception-dialog vaadin-item div.item-content span.item-description{color:var(--vaadin-text-color-secondary)}vaadin-dialog#report-exception-dialog vaadin-item[selected]{background-color:var(--active-color);border-left:2px solid var(--primary-color)}vaadin-dialog#report-exception-dialog vaadin-item::part(content){display:flex;align-items:center;gap:var(--space-100)}vaadin-dialog#report-exception-dialog vaadin-item::part(checkmark){display:none}vaadin-dialog#report-exception-dialog div.section-title{color:var(--vaadin-text-color-secondary);padding-top:var(--space-50);padding-bottom:var(--space-50)}vaadin-dialog#report-exception-dialog code.codeblock{width:100%;box-sizing:border-box;overflow:auto;text-overflow:unset}", ed = ":is(vaadin-context-menu,vaadin-menu-bar,vaadin-select){z-index:var(--z-index-popover)}", td = "", rd = `:host{--vaadin-radius-s: .25rem ;--vaadin-radius-m: .5rem ;--vaadin-radius-l: .75rem ;--copilot-size-sm: 1.75rem;--copilot-size-md: 2rem;--copilot-size-lg: 2.5rem;--copilot-size-xl: 3rem;--vaadin-focus-ring-width: 2px;--vaadin-button-background: light-dark(var(--gray-3), var(--gray-6));--vaadin-button-gap: .375rem ;--vaadin-button-margin: 0;--vaadin-button-padding: .375rem .75rem ;--vaadin-button-font-size: var(--copilot-font-size-sm);--vaadin-button-primary-background: var(--vaadin-text-color);--vaadin-button-primary-font-weight: 500;--vaadin-button-primary-text-color: var(--vaadin-background-color);--_vaadin-button-disabled-pointer-events: all;--vaadin-checkbox-background: transparent;--vaadin-checkbox-border-radius: .125rem ;--vaadin-checkbox-font-weight: 400;--vaadin-checkbox-size: 1rem ;--vaadin-checkbox-label-color: var(--vaadin-text-color);--vaadin-checkbox-label-font-size: .8125rem ;--vaadin-checkbox-label-line-height: 1.25rem ;--vaadin-checkbox-checkmark-color: var(--vaadin-background-color);--vaadin-checkbox-label-padding: 0 .5rem ;--vaadin-icon-size: 1.25rem ;--vaadin-icon-visual-size: 1.125rem ;--_vaadin-icon-chevron-down: url('data:image/svg+xml;utf8,');--vaadin-input-field-background: transparent;--vaadin-input-field-border-color: light-dark(var(--gray-9), var(--gray-10));--vaadin-input-field-border-radius: var(--vaadin-radius-s);--vaadin-input-field-border-width: 1px;--vaadin-input-field-container-gap: .25rem ;--vaadin-input-field-disabled-background: transparent;--vaadin-input-field-disabled-text-color: var(--vaadin-text-color-secondary);--vaadin-input-field-gap: .375rem ;--vaadin-input-field-height: auto;--vaadin-input-field-invalid-background: transparent;--vaadin-input-field-autofill-color: var(--vaadin-text-color);--vaadin-padding-block-container: calc((6 / 16 * 1rem) - var(--vaadin-input-field-border-width));--vaadin-padding-inline-container: calc((8 / 16 * 1rem) - var(--vaadin-input-field-border-width));--vaadin-input-field-padding: var(--vaadin-padding-block-container) var(--vaadin-padding-inline-container);--vaadin-input-field-label-color: var(--vaadin-text-color-secondary);--vaadin-input-field-label-font-size: .75rem ;--vaadin-input-field-label-font-weight: normal;--vaadin-input-field-label-line-height: 1.125rem ;--vaadin-input-field-value-font-size: var(--copilot-font-size-sm);--vaadin-input-field-value-font-weight: 400;--vaadin-input-field-value-line-height: var(--copilot-line-height-sm);--vaadin-input-field-helper-font-size: var(--copilot-font-size-xs);--vaadin-input-field-helper-line-height: var(--copilot-line-height-xs);--vaadin-input-field-helper-spacing: .25rem ;--vaadin-input-field-error-color: var(--ruby-11);--vaadin-input-field-error-font-size: var(--copilot-font-size-xs);--vaadin-input-field-error-line-height: var(--copilot-line-height-xs);--vaadin-item-border-radius: var(--vaadin-radius-m);--vaadin-item-gap: .5rem;--vaadin-item-padding: .375rem .5rem;--vaadin-overlay-background: light-dark(var(--gray-1), var(--gray-5));--vaadin-overlay-border-color: var(--vaadin-divider-color);--vaadin-overlay-border-radius: var(--vaadin-radius-l);--vaadin-overlay-border-width: 1px;--vaadin-popover-border-radius: var(--vaadin-radius-l);--vaadin-radio-button-font-weight: 500;--vaadin-radio-button-label-font-size: .8125rem ;--vaadin-radio-button-label-line-height: 1.25rem ;--vaadin-tab-background: transparent;--vaadin-tab-border-radius: var(--vaadin-radius-m);--vaadin-tab-font-size: var(--copilot-font-size-sm);--vaadin-tab-font-weight: var(--copilot-font-weight-medium);--vaadin-tab-line-height: var(--copilot-line-height-sm);--vaadin-tab-padding: .375rem .5rem ;--vaadin-tabs-gap: .25rem ;--vaadin-tabs-padding: 0 .5rem ;--vaadin-tabsheet-padding: 0;--vaadin-tooltip-background: var(--gray-3);--vaadin-tooltip-border-color: var(--vaadin-divider-color);--monospace-font-family: Inconsolata, Monaco, Consolas, Courier New, Courier, monospace;--z-index-component-selector: 100;--z-index-floating-panel: 101;--z-index-drawer: 150;--z-index-opened-drawer: 151;--z-index-spotlight: 200;--z-index-popover: 300;--z-index-activation-button: 1000;--copilot-notifications-container-z-index: 10000;--duration-1: .1s;--duration-2: .2s;--duration-3: .3s;--duration-4: .4s;--button-background: var(--gray-100);--button-background-hover: var(--gray-150);--focus-size: 2px;--icon-size-xs: .75rem;--icon-size-s: 1rem;--icon-size-m: 1.125rem;--shadow-xs: 0 1px 2px 0 rgb(0 0 0 / .05);--shadow-s: 0 1px 3px 0 rgb(0 0 0 / .1), 0 1px 2px -1px rgb(0 0 0 / .1);--shadow-m: 0 4px 6px -1px rgb(0 0 0 / .1), 0 2px 4px -2px rgb(0 0 0 / .1);--shadow-l: 0 10px 15px -3px rgb(0 0 0 / .1), 0 4px 6px -4px rgb(0 0 0 / .1);--shadow-xl: 0 20px 25px -5px rgb(0 0 0 / .1), 0 8px 10px -6px rgb(0 0 0 / .1);--shadow-2xl: 0 25px 50px -12px rgb(0 0 0 / .25);--copilot-size-xs: 1.25rem;--space-25: 2px;--space-50: 4px;--space-75: 6px;--space-100: 8px;--space-150: 12px;--space-200: 16px;--space-300: 24px;--space-400: 32px;--space-450: 36px;--space-500: 40px;--space-600: 48px;--space-700: 56px;--space-800: 64px;--space-900: 72px}:host{--lumo-font-family: var(--copilot-font-family);--lumo-font-size-xs: var(--copilot-font-size-xs);--lumo-font-size-s: var(--copilot-font-size-sm);--lumo-border-radius-s: var(--vaadin-radius-s);--lumo-border-radius-m: var(--vaadin-radius-m);--lumo-border-radius-l: var(--vaadin-radius-l);--lumo-base-color: var(--surface-0);--lumo-header-text-color: var(--color-high-contrast);--lumo-tertiary-text-color: var(--color);--lumo-primary-text-color: var(--color-high-contrast);--lumo-primary-color: var(--color-high-contrast);--lumo-primary-color-50pct: var(--color-accent);--lumo-primary-contrast-color: var(--lumo-secondary-text-color);--lumo-space-xs: var(--space-50);--lumo-space-s: var(--space-100);--lumo-space-m: var(--space-200);--lumo-space-l: var(--space-300);--lumo-space-xl: var(--space-500);--lumo-icon-size-xs: var(--copilot-font-size-xs);--lumo-icon-size-s: var(--copilot-font-size-sm);--lumo-icon-size-m: var(--copilot-font-size-md);--lumo-font-size-m: var(--copilot-font-size-xs);--lumo-body-text-color: var(--vaadin-text-color);--lumo-secondary-text-color: var(--vaadin-text-color-secondary);--lumo-error-text-color: var(--error-color);--lumo-size-m: var(--copilot-size-md);--source-file-link-color: var(--blue-600);--source-file-link-decoration-color: currentColor;--source-file-link-text-decoration: none;--source-file-link-font-weight: normal;--source-file-link-button-color: currentColor;--vaadin-button-height: var(--lumo-button-size, var(--lumo-size-m))}:host{color-scheme:light;--surface-0: hsl(var(--gray-h) var(--gray-s) 90% / .8);--surface-1: hsl(var(--gray-h) var(--gray-s) 95% / .8);--surface-2: hsl(var(--gray-h) var(--gray-s) 100% / .8);--surface-background: linear-gradient( hsl(var(--gray-h) var(--gray-s) 95% / .7), hsl(var(--gray-h) var(--gray-s) 95% / .65) );--surface-glow: radial-gradient(circle at 30% 0%, hsl(var(--gray-h) var(--gray-s) 98% / .7), transparent 50%);--surface-border-glow: radial-gradient(at 50% 50%, hsl(var(--purple-h) 90% 90% / .8) 0, transparent 50%);--surface: var(--surface-glow) no-repeat border-box, var(--surface-background) no-repeat padding-box, hsl(var(--gray-h) var(--gray-s) 98% / .2);--surface-with-border-glow: var(--surface-glow) no-repeat border-box, linear-gradient(var(--background-color), var(--background-color)) no-repeat padding-box, var(--surface-border-glow) no-repeat border-box 0 0 / var(--glow-size, 600px) var(--glow-size, 600px);--surface-border-color: hsl(var(--gray-h) var(--gray-s) 100% / .7);--surface-backdrop-filter: blur(10px);--surface-box-shadow-1: 0 0 0 .5px hsl(var(--gray-h) var(--gray-s) 5% / .15), 0 6px 12px -1px hsl(var(--shadow-hsl) / .3);--surface-box-shadow-2: 0 0 0 .5px hsl(var(--gray-h) var(--gray-s) 5% / .15), 0 24px 40px -4px hsl(var(--shadow-hsl) / .4);--background-button: linear-gradient( hsl(var(--gray-h) var(--gray-s) 98% / .4), hsl(var(--gray-h) var(--gray-s) 90% / .2) );--background-button-active: hsl(var(--gray-h) var(--gray-s) 80% / .2);--color: var(--gray-500);--color-high-contrast: var(--gray-900);--color-accent: var(--purple-700);--color-danger: var(--red-700);--border-color: var(--gray-150);--border-color-high-contrast: var(--gray-300);--border-color-button: var(--gray-350);--border-color-popover: hsl(var(--gray-hsl) / .08);--border-color-dialog: hsl(var(--gray-hsl) / .08);--accent-color: var(--purple-600);--selection-color: hsl(var(--blue-hsl));--shadow-hsl: var(--gray-h) var(--gray-s) 20%;--lumo-contrast-5pct: var(--gray-100);--lumo-contrast-10pct: var(--gray-200);--lumo-contrast-60pct: var(--gray-400);--lumo-contrast-80pct: var(--gray-600);--lumo-contrast-90pct: var(--gray-800);--card-bg: rgba(255, 255, 255, .5);--card-hover-bg: rgba(255, 255, 255, .65);--card-open-bg: rgba(255, 255, 255, .8);--card-border: 1px solid rgba(0, 50, 100, .15);--card-open-shadow: 0px 1px 4px -1px rgba(28, 52, 84, .26);--card-section-border: var(--card-border);--card-field-bg: var(--lumo-contrast-5pct);--indicator-border: white}:host(.dark){color-scheme:dark;--surface-0: hsl(var(--gray-h) var(--gray-s) 10% / .85);--surface-1: hsl(var(--gray-h) var(--gray-s) 14% / .85);--surface-2: hsl(var(--gray-h) var(--gray-s) 18% / .85);--surface-background: linear-gradient( hsl(var(--gray-h) var(--gray-s) 8% / .65), hsl(var(--gray-h) var(--gray-s) 8% / .7) );--surface-glow: radial-gradient( circle at 30% 0%, hsl(var(--gray-h) calc(var(--gray-s) * 2) 90% / .12), transparent 50% );--surface: var(--surface-glow) no-repeat border-box, var(--surface-background) no-repeat padding-box, hsl(var(--gray-h) var(--gray-s) 20% / .4);--surface-border-glow: hsl(var(--gray-h) var(--gray-s) 20% / .4) radial-gradient(at 50% 50%, hsl(250 40% 80% / .4) 0, transparent 50%);--surface-border-color: hsl(var(--gray-h) var(--gray-s) 50% / .2);--surface-box-shadow-1: 0 0 0 .5px hsl(var(--purple-h) 40% 5% / .4), 0 6px 12px -1px hsl(var(--shadow-hsl) / .4);--surface-box-shadow-2: 0 0 0 .5px hsl(var(--purple-h) 40% 5% / .4), 0 24px 40px -4px hsl(var(--shadow-hsl) / .5);--color: var(--gray-650);--background-button: linear-gradient( hsl(var(--gray-h) calc(var(--gray-s) * 2) 80% / .1), hsl(var(--gray-h) calc(var(--gray-s) * 2) 80% / 0) );--background-button-active: hsl(var(--gray-h) var(--gray-s) 10% / .1);--border-color-popover: hsl(var(--gray-h) var(--gray-s) 90% / .1);--border-color-dialog: hsl(var(--gray-h) var(--gray-s) 90% / .1);--shadow-hsl: 0 0% 0%;--lumo-disabled-text-color: var(--lumo-contrast-60pct);--card-bg: rgba(255, 255, 255, .05);--card-hover-bg: rgba(255, 255, 255, .065);--card-open-bg: rgba(255, 255, 255, .1);--card-border: 1px solid rgba(255, 255, 255, .11);--card-open-shadow: 0px 1px 4px -1px rgba(0, 0, 0, .26);--card-section-border: var(--card-border);--card-field-bg: var(--lumo-contrast-10pct);--indicator-border: var(--lumo-base-color)}`, nd = '@font-face{font-display:swap;font-family:Roboto;font-style:normal;font-weight:400 700;src:url(data:font/woff2;base64,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) format("woff2")}:host{--copilot-font-family: "Roboto", sans-serif;--copilot-font-size: .8125rem ;--copilot-letter-spacing: .25px;--copilot-line-height: 1.25rem ;--copilot-font-size-xs: .75rem;--copilot-font-size-sm: .8125rem;--copilot-font-size-md: .9375rem;--copilot-font-size-lg: 1.375rem;--copilot-font-size-xl: 1.5rem;--copilot-letter-spacing-xs: .4px;--copilot-letter-spacing-sm: .25px;--copilot-letter-spacing-md: .15px;--copilot-letter-spacing-lg: 0;--copilot-letter-spacing-xl: 0;--copilot-line-height-xs: 1.125rem;--copilot-line-height-sm: 1.25rem;--copilot-line-height-md: 1.5rem;--copilot-line-height-lg: 1.75rem;--copilot-line-height-xl: 2rem;--copilot-font-weight-normal: 400;--copilot-font-weight-medium: 500;--copilot-font-weight-semibold: 600;--copilot-font-weight-bold: 700;--copilot-font-xs: normal var(--copilot-font-weight-normal) var(--copilot-font-size-xs) / var(--copilot-line-height-xs) var(--copilot-font-family);--copilot-font-xs-medium: normal var(--copilot-font-weight-medium) var(--copilot-font-size-xs) / var(--copilot-line-height-xs) var(--copilot-font-family);--copilot-font-xs-semibold: normal var(--copilot-font-weight-semibold) var(--copilot-font-size-xs) / var(--copilot-line-height-xs) var(--copilot-font-family);--copilot-font-xs-bold: normal var(--copilot-font-weight-bold) var(--copilot-font-size-xs) / var(--copilot-line-height-xs) var(--copilot-font-family);--copilot-font-sm: normal var(--copilot-font-weight-normal) var(--copilot-font-size-sm) / var(--copilot-line-height-sm) var(--copilot-font-family);--copilot-font-sm-medium: normal var(--copilot-font-weight-medium) var(--copilot-font-size-sm) / var(--copilot-line-height-sm) var(--copilot-font-family);--copilot-font-sm-semibold: normal var(--copilot-font-weight-semibold) var(--copilot-font-size-sm) / var(--copilot-line-height-sm) var(--copilot-font-family);--copilot-font-sm-bold: normal var(--copilot-font-weight-bold) var(--copilot-font-size-sm) / var(--copilot-line-height-sm) var(--copilot-font-family);--copilot-font-md: normal var(--copilot-font-weight-normal) var(--copilot-font-size-md) / var(--copilot-line-height-md) var(--copilot-font-family);--copilot-font-md-medium: normal var(--copilot-font-weight-medium) var(--copilot-font-size-md) / var(--copilot-line-height-md) var(--copilot-font-family);--copilot-font-md-semibold: normal var(--copilot-font-weight-semibold) var(--copilot-font-size-md) / var(--copilot-line-height-md) var(--copilot-font-family);--copilot-font-md-bold: normal var(--copilot-font-weight-bold) var(--copilot-font-size-md) / var(--copilot-line-height-md) var(--copilot-font-family);--copilot-font-button: normal var(--copilot-font-weight-semibold) var(--copilot-font-size-sm) / var(--copilot-line-height-sm) var(--copilot-font-family);--copilot-font-tooltip: normal var(--copilot-font-weight-medium) var(--copilot-font-size-sm) / var(--copilot-line-height-sm) var(--copilot-font-family)}', id = ".items-baseline{align-items:baseline}.items-center{align-items:center}.items-end{align-items:end}.items-start{align-items:start}.self-start{align-self:start}.animate-spin{animation:var(--animate-spin)}.animate-swirl{animation:var(--animate-swirl)}.bg-amber-3{background-color:var(--amber-3)}.bg-blue-3{background-color:var(--blue-3)}.bg-blue-11{background-color:var(--blue-11)}.bg-cover{background-size:cover}.bg-current{background-color:currentColor}.bg-gray-1{background-color:var(--gray-1)}.bg-gray-1\\/90{background-color:color-mix(in oklab,var(--gray-1) 90%,transparent)}.bg-gray-3{background-color:var(--gray-3)}.focus-within\\:bg-gray-3:focus-within{background-color:var(--gray-3)}.hover\\:bg-gray-3:hover{background-color:var(--gray-3)}.bg-gray-4{background-color:var(--gray-4)}.bg-gray-5{background-color:var(--gray-5)}.bg-ruby-3{background-color:var(--ruby-3)}@media (prefers-color-scheme: dark){.dark\\:bg-amber-5{background-color:var(--amber-5)}.dark\\:bg-amber-6{background-color:var(--amber-6)}.dark\\:bg-blue-5{background-color:var(--blue-5)}.dark\\:bg-blue-6{background-color:var(--blue-6)}.dark\\:bg-gray-2\\/90{background-color:color-mix(in oklab,var(--gray-2) 90%,transparent)}.dark\\:bg-gray-3\\/90{background-color:color-mix(in oklab,var(--gray-3) 90%,transparent)}.dark\\:bg-gray-4\\/90{background-color:color-mix(in oklab,var(--gray-4) 90%,transparent)}.dark\\:bg-gray-5{background-color:var(--gray-5)}.dark\\:bg-gray-5\\/90{background-color:color-mix(in oklab,var(--gray-5) 90%,transparent)}.dark\\:bg-gray-6{background-color:var(--gray-6)}.dark\\:focus-within\\:bg-gray-6:focus-within{background-color:var(--gray-6)}.dark\\:hover\\:bg-gray-6:hover{background-color:var(--gray-6)}.dark\\:bg-gray-7{background-color:var(--gray-7)}.dark\\:bg-ruby-6{background-color:var(--ruby-6)}.dark\\:bg-ruby-7{background-color:var(--ruby-7)}}.border{border:1px var(--border-style, solid) var(--border-color, var(--vaadin-divider-color))}.border-dashed{--border-style: dashed}.border-2{border-width:2px}.border-b{border-bottom:1px var(--border-style, solid) var(--border-color, var(--vaadin-divider-color))}.border-e-0{border-inline-end:none}.border-s-0{border-inline-start:none}.border-t{border-top:1px var(--border-style, solid) var(--border-color, var(--vaadin-divider-color))}.border-t-0{border-top:none}.border-amber-9{border-color:var(--amber-9)}.border-black\\/50{border-color:#00000080}.border-white\\/50{border-color:#ffffff80}.rounded-full{border-radius:9999px}.rounded-s-none{border-end-start-radius:0;border-start-start-radius:0}.rounded-sm{border-radius:var(--vaadin-radius-s)}.rounded-md{border-radius:var(--vaadin-radius-m)}.rounded-lg{border-radius:var(--vaadin-radius-l)}.shadow-2xs{box-shadow:0 1px #0000000d}.shadow-xs{box-shadow:0 1px 2px #0000000d}.shadow-sm{box-shadow:0 1px 3px #0000001a,0 1px 2px -1px #0000001a}.shadow-md{box-shadow:0 4px 6px -1px #0000001a,0 2px 4px -2px #0000001a}.shadow-lg{box-shadow:0 10px 15px -3px #0000001a,0 4px 6px -4px #0000001a}.shadow-xl{box-shadow:0 20px 25px -5px #0000001a,0 8px 10px -6px #0000001a}.shadow-2xl{box-shadow:0 25px 50px -12px #00000040}.shadow-none{box-shadow:0 0 #0000}.box-border{box-sizing:border-box}.box-content{box-sizing:content-box}.text-amber-11{color:var(--amber-11)}.text-amber-12{color:var(--amber-12)}.text-blue-11{color:var(--blue-11)}.text-blue-12{color:var(--blue-12)}.text-body{color:var(--vaadin-text-color)}.text-ruby-11{color:var(--ruby-11)}.text-secondary{color:var(--vaadin-text-color-secondary)}.text-teal-11{color:var(--teal-11)}.text-violet-11{color:var(--violet-11)}.text-white{color:#fff}@media (prefers-color-scheme: dark){.dark\\:text-amber-11{color:var(--amber-11)}.dark\\:text-amber-12{color:var(--amber-12)}.dark\\:text-blue-12{color:var(--blue-12)}}.cursor-inherit{cursor:inherit}.text-blue{color:var(--blue-color)}.text-blue-violet{background-clip:text;background-image:linear-gradient(90deg,var(--blue-color),var(--violet-color));color:transparent}.text-inherit{color:inherit}.text-white,.hover\\:text-white:hover{color:#fff}.contents{display:contents}.flex{display:flex}.grid{display:grid}.hidden{display:none}.inline-flex{display:inline-flex}.divide-y>:not(:last-child){border-bottom:1px solid var(--vaadin-divider-color)}.backdrop-blur-xs{-webkit-backdrop-filter:blur(4px);backdrop-filter:blur(4px)}.backdrop-blur-sm{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px)}.backdrop-blur-md{-webkit-backdrop-filter:blur(12px);backdrop-filter:blur(12px)}.backdrop-blur-lg{-webkit-backdrop-filter:blur(16px);backdrop-filter:blur(16px)}.backdrop-blur-xl{-webkit-backdrop-filter:blur(24px);backdrop-filter:blur(24px)}.backdrop-blur-2xl{-webkit-backdrop-filter:blur(40px);backdrop-filter:blur(40px)}.backdrop-blur-3xl{-webkit-backdrop-filter:blur(64px);backdrop-filter:blur(64px)}.flex-1{flex:1}.flex-col{flex-direction:column}.flex-grow{flex-grow:1}.font-sans{font-family:var(--copilot-font-family),sans-serif}.text-xs{font:var(--copilot-font-xs);letter-spacing:var(--copilot-letter-spacing-xs)}.text-sm{font:var(--copilot-font-sm);letter-spacing:var(--copilot-letter-spacing-sm)}.text-md{font:var(--copilot-font-md);letter-spacing:var(--copilot-letter-spacing-md)}.text-1{font-size:var(--copilot-font-size-xs);line-height:var(--copilot-line-height-sm)}.font-normal{font-weight:var(--copilot-font-weight-normal)}.font-medium{font-weight:var(--copilot-font-weight-medium)}.font-semibold{font-weight:var(--copilot-font-weight-semibold)}.font-bold{font-weight:var(--copilot-font-weight-bold)}.gap-1{gap:.25rem}.gap-1\\.5{gap:.375rem}.gap-2{gap:.5rem}.gap-3{gap:.75rem}.gap-4{gap:1rem}.gap-x-1{column-gap:.25rem}.gap-x-2{column-gap:.5rem}.gap-x-3{column-gap:.75rem}.gap-x-4{column-gap:1rem}.gap-y-1{row-gap:.25rem}.gap-y-2{row-gap:.5rem}.gap-y-3{row-gap:.75rem}.gap-y-4{row-gap:1rem}.gap-25{gap:var(--space-25)}.gap-50{gap:var(--space-50)}.gap-75{gap:var(--space-75)}.gap-100{gap:var(--space-100)}.gap-150{gap:var(--space-150)}.gap-200{gap:var(--space-200)}.gap-300{gap:var(--space-300)}.gap-400{gap:var(--space-400)}.icon-s svg{height:var(--icon-size-s);width:var(--icon-size-s)}.col-span-full{grid-column:1 / -1}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.justify-center{justify-content:center}.justify-end{justify-content:end}.justify-start{justify-content:start}.list-none{list-style-type:none}.m-0{margin:0}.m-2{margin:.5rem}.m-3{margin:.75rem}.m-4{margin:1rem}.-m-2{margin:-.5rem}.mb-0{margin-bottom:0}.mb-1{margin-bottom:.25rem}.mb-2{margin-bottom:.5rem}.mb-3{margin-bottom:.75rem}.mb-4{margin-bottom:1rem}.me-auto{margin-inline-end:auto}.-me-2{margin-inline-end:-.5rem}.ms-auto{margin-inline-start:auto}.ms-1{margin-inline-start:.25rem}.ms-2{margin-inline-start:.5rem}.-ms-0\\.5{margin-inline-start:-.125rem}.mt-0{margin-top:0}.mt-1{margin-top:.25rem}.mt-2{margin-top:.5rem}.mx-1{margin-inline:.25rem}.mx-2{margin-inline:.5rem}.mx-3{margin-inline:.75rem}.mx-4{margin-inline:1rem}.my-0{margin-block:0}.my-px{margin-block:1px}.-my-1\\.5{margin-block:-.375rem}.-my-2{margin-block:-.5rem}.m-25{margin:var(--space-25)}.m-50{margin:var(--space-50)}.m-75{margin:var(--space-75)}.m-100{margin:var(--space-100)}.m-150{margin:var(--space-150)}.m-200{margin:var(--space-200)}.m-300{margin:var(--space-300)}.m-400{margin:var(--space-400)}.mb-25{margin-bottom:var(--space-25)}.mb-50{margin-bottom:var(--space-50)}.mb-75{margin-bottom:var(--space-75)}.mb-100{margin-bottom:var(--space-100)}.mb-150{margin-bottom:var(--space-150)}.mb-200{margin-bottom:var(--space-200)}.mb-300{margin-bottom:var(--space-300)}.mb-400{margin-bottom:var(--space-400)}.me-25{margin-inline-end:var(--space-25)}.me-50{margin-inline-end:var(--space-50)}.me-75{margin-inline-end:var(--space-75)}.me-100{margin-inline-end:var(--space-100)}.me-150{margin-inline-end:var(--space-150)}.me-200{margin-inline-end:var(--space-200)}.me-300{margin-inline-end:var(--space-300)}.me-400{margin-inline-end:var(--space-400)}.-me-25{margin-inline-end:calc(var(--space-25) * -1)}.-me-50{margin-inline-end:calc(var(--space-50) * -1)}.-me-75{margin-inline-end:calc(var(--space-75) * -1)}.-me-100{margin-inline-end:calc(var(--space-100) * -1)}.-me-150{margin-inline-end:calc(var(--space-150) * -1)}.-me-200{margin-inline-end:calc(var(--space-200) * -1)}.-me-300{margin-inline-end:calc(var(--space-300) * -1)}.-me-400{margin-inline-end:calc(var(--space-400) * -1)}.ms-25{margin-inline-start:var(--space-25)}.ms-50{margin-inline-start:var(--space-50)}.ms-75{margin-inline-start:var(--space-75)}.ms-100{margin-inline-start:var(--space-100)}.ms-150{margin-inline-start:var(--space-150)}.ms-200{margin-inline-start:var(--space-200)}.ms-300{margin-inline-start:var(--space-300)}.ms-400{margin-inline-start:var(--space-400)}.-ms-25{margin-inline-start:calc(var(--space-25) / -1)}.-ms-50{margin-inline-start:calc(var(--space-50) / -1)}.-ms-75{margin-inline-start:calc(var(--space-75) / -1)}.-ms-100{margin-inline-start:calc(var(--space-100) / -1)}.-ms-150{margin-inline-start:calc(var(--space-150) / -1)}.-ms-200{margin-inline-start:calc(var(--space-200) / -1)}.-ms-300{margin-inline-start:var(--space-300)}.-ms-400{margin-inline-start:var(--space-400)}.mt-25{margin-top:var(--space-25)}.mt-50{margin-top:var(--space-50)}.mt-75{margin-top:var(--space-75)}.mt-100{margin-top:var(--space-100)}.mt-150{margin-top:var(--space-150)}.mt-200{margin-top:var(--space-200)}.mt-300{margin-top:var(--space-300)}.mt-400{margin-top:var(--space-400)}.-mt-25{margin-top:calc(var(--space-25) * -1)}.-mt-50{margin-top:calc(var(--space-50) * -1)}.-mt-75{margin-top:calc(var(--space-75) * -1)}.-mt-100{margin-top:calc(var(--space-100) * -1)}.-mt-150{margin-top:calc(var(--space-150) * -1)}.-mt-200{margin-top:calc(var(--space-200) * -1)}.-mt-300{margin-top:calc(var(--space-300) * -1)}.-mt-400{margin-top:calc(var(--space-400) * -1)}.mx-25{margin-inline:var(--space-25)}.mx-50{margin-inline:var(--space-50)}.mx-75{margin-inline:var(--space-75)}.mx-100{margin-inline:var(--space-100)}.mx-150{margin-inline:var(--space-150)}.mx-200{margin-inline:var(--space-200)}.mx-300{margin-inline:var(--space-300)}.mx-400{margin-inline:var(--space-400)}.my-25{margin-block:var(--space-25)}.my-50{margin-block:var(--space-50)}.my-75{margin-block:var(--space-75)}.my-100{margin-block:var(--space-100)}.my-150{margin-block:var(--space-150)}.my-200{margin-block:var(--space-200)}.my-300{margin-block:var(--space-300)}.my-400{margin-block:var(--space-400)}.-my-25{margin-block:calc(var(--space-25) * -1)}.-my-50{margin-block:calc(var(--space-50) * -1)}.-my-75{margin-block:calc(var(--space-75) * -1)}.-my-100{margin-block:calc(var(--space-100) * -1)}.-my-150{margin-block:calc(var(--space-150) * -1)}.-my-200{margin-block:calc(var(--space-200) * -1)}.-my-300{margin-block:calc(var(--space-300) * -1)}.-my-400{margin-block:calc(var(--space-400) * -1)}.opacity-0{opacity:0}.opacity-50{opacity:.5}.opacity-100{opacity:1}.group:hover .group-hover\\:opacity-0{opacity:0}.group:hover .group-hover\\:opacity-100{opacity:1}.group:focus-within .group-focus-within\\:opacity-0{opacity:0}.group:focus-within .group-focus-within\\:opacity-100{opacity:1}.overflow-auto{overflow:auto}.overflow-hidden{overflow:hidden}.overflow-x-auto{overflow-x:auto}.overflow-x-hidden{overflow-x:hidden}.overflow-y-auto{overflow-y:auto}.overflow-y-hidden{overflow-y:hidden}.truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.p-0{padding:0}.p-1{padding:.25rem}.p-2{padding:.5rem}.p-3{padding:.75rem}.p-4{padding:1rem}.pb-1\\.5{padding-bottom:.375rem}.pb-2{padding-bottom:.5rem}.pb-3{padding-bottom:.75rem}.pb-4{padding-bottom:1rem}.pe-1{padding-inline-end:.25rem}.pe-1\\.75{padding-inline-end:.4375rem}.pe-2{padding-inline-end:.5rem}.pe-3{padding-inline-end:.75rem}.pe-4{padding-inline-end:1rem}.pe-5{padding-inline-end:1.25rem}.pe-6{padding-inline-end:1.5rem}.pe-7{padding-inline-end:1.75rem}.pe-8{padding-inline-end:2rem}.ps-0\\.5{padding-inline-start:.125rem}.ps-1{padding-inline-start:.25rem}.ps-1\\.75{padding-inline-start:.4375rem}.ps-2{padding-inline-start:.5rem}.ps-3{padding-inline-start:.75rem}.ps-3\\.75{padding-inline-start:.9375rem}.ps-4{padding-inline-start:1rem}.pt-1{padding-top:.25rem}.px-0{padding-inline:0}.px-1{padding-inline:.25rem}.px-1\\.5{padding-inline:.375rem}.px-2{padding-inline:.5rem}.px-3{padding-inline:.75rem}.px-4{padding-inline:1rem}.py-1{padding-block:.25rem}.py-1\\.5{padding-block:.375rem}.py-1\\.75{padding-block:.4375rem}.py-2{padding-block:.5rem}.py-2\\.5{padding-block:.625rem}.py-3{padding-block:.75rem}.p-25{padding:var(--space-25)}.p-50{padding:var(--space-50)}.p-75{padding:var(--space-75)}.p-100{padding:var(--space-100)}.p-150{padding:var(--space-150)}.p-200{padding:var(--space-200)}.p-300{padding:var(--space-300)}.p-400{padding:var(--space-400)}.pb-25{padding-bottom:var(--space-25)}.pb-50{padding-bottom:var(--space-50)}.pb-75{padding-bottom:var(--space-75)}.pb-100{padding-bottom:var(--space-100)}.pb-150{padding-bottom:var(--space-150)}.pb-200{padding-bottom:var(--space-200)}.pb-300{padding-bottom:var(--space-300)}.pb-400{padding-bottom:var(--space-400)}.pe-25{padding-inline-end:var(--space-25)}.pe-50{padding-inline-end:var(--space-50)}.pe-75{padding-inline-end:var(--space-75)}.pe-100{padding-inline-end:var(--space-100)}.pe-150{padding-inline-end:var(--space-150)}.pe-200{padding-inline-end:var(--space-200)}.pe-300{padding-inline-end:var(--space-300)}.pe-400{padding-inline-end:var(--space-400)}.ps-25{padding-inline-start:var(--space-25)}.ps-50{padding-inline-start:var(--space-50)}.ps-75{padding-inline-start:var(--space-75)}.ps-100{padding-inline-start:var(--space-100)}.ps-150{padding-inline-start:var(--space-150)}.ps-200{padding-inline-start:var(--space-200)}.ps-300{padding-inline-start:var(--space-300)}.ps-400{padding-inline-start:var(--space-400)}.pt-25{padding-top:var(--space-25)}.pt-50{padding-top:var(--space-50)}.pt-75{padding-top:var(--space-75)}.pt-100{padding-top:var(--space-100)}.pt-150{padding-top:var(--space-150)}.pt-200{padding-top:var(--space-200)}.pt-300{padding-top:var(--space-300)}.pt-400{padding-top:var(--space-400)}.px-25{padding-inline:var(--space-25)}.px-50{padding-inline:var(--space-50)}.px-75{padding-inline:var(--space-75)}.px-100{padding-inline:var(--space-100)}.px-150{padding-inline:var(--space-150)}.px-200{padding-inline:var(--space-200)}.px-300{padding-inline:var(--space-300)}.px-400{padding-inline:var(--space-400)}.py-25{padding-block:var(--space-25)}.py-50{padding-block:var(--space-50)}.py-75{padding-block:var(--space-75)}.py-100{padding-block:var(--space-100)}.py-150{padding-block:var(--space-150)}.py-200{padding-block:var(--space-200)}.py-300{padding-block:var(--space-300)}.py-400{padding-block:var(--space-400)}.pointer-events-none{pointer-events:none}.absolute{position:absolute}.fixed{position:fixed}.relative{position:relative}.-end-4{inset-inline-end:-1rem}.-end-3{inset-inline-end:-.75rem}.-end-2{inset-inline-end:-.5rem}.-end-1{inset-inline-end:-.25rem}.-end-0\\.5{inset-inline-end:-.125rem}.end-0{inset-inline-end:0}.end-1{inset-inline-end:.25rem}.end-2{inset-inline-end:.5rem}.end-3{inset-inline-end:.75rem}.start-0{inset-inline-start:0}.-top-1\\.5{top:-.375rem}.-top-1{top:-.25rem}.-top-0\\.5{top:-.125rem}.top-0{top:0}.top-0\\.5{top:.125rem}.top-1{top:.25rem}.top-1\\.5{top:.375rem}.top-1\\.75{top:.4375rem}.h-5{height:1.25rem}.h-8{height:2rem}.h-9{height:2.25rem}.h-full{height:100%}.max-h-full{max-height:100%}.max-w-full{max-width:100%}.min-w-0{min-width:0}.size-md{height:var(--copilot-size-md);width:var(--copilot-size-md)}.size-1{height:.25rem;width:.25rem}.size-2{height:.5rem;width:.5rem}.size-3{height:.75rem;width:.75rem}.size-4{height:1rem;width:1rem}.size-5{height:1.25rem;width:1.25rem}.size-6{height:1.5rem;width:1.5rem}.size-7{height:1.75rem;width:1.75rem}.size-8{height:2rem;width:2rem}.size-10{height:2.5rem;width:2.5rem}.w-3xs{width:16rem}.w-2xs{width:18rem}.w-xs{width:20rem}.w-sm{width:24rem}.w-md{width:28rem}.w-lg{width:32rem}.w-xl{width:36rem}.w-2xl{width:42rem}.w-3xl{width:48rem}.w-4xl{width:56rem}.w-5xl{width:64rem}.w-6xl{width:72rem}.w-7xl{width:80rem}.w-fit{width:fit-content}.w-full{width:100%}.h-m{height:var(--copilot-size-md)}.h-75{height:var(--space-75)}.h-900{height:var(--space-900)}.w-75{width:var(--space-75)}.text-center{text-align:center}.uppercase{text-transform:uppercase}.text-balance{text-wrap:balance}.text-pretty{text-wrap:pretty}.rotate-90{transform:rotate(90deg)}.transform-none{transform:none}.transition{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,opacity,box-shadow,transform,translate,scale,rotate,filter,-webkit-backdrop-filter,backdrop-filter,display,content-visibility,overlay,pointer-events;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-all{transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-opacity{transition-property:opacity;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-shadow{transition-property:box-shadow;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-transform{transition-property:transform,translate,scale,rotate;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-none{transition-property:none}.translate-y-0{transform:translateY(0)}.group:is(:hover,:focus-within) :is(.group-hover\\:-translate-x-1,.group-focus-within\\:-translate-x-1){transform:translate(-.25rem)}.select-none{-webkit-user-select:none;user-select:none}.invisible{visibility:hidden}.whitespace-nowrap{white-space:nowrap}.z-1{z-index:1}"; +var au = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}; +function ad(e) { + return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e; +} +function ou(e) { + if (Object.prototype.hasOwnProperty.call(e, "__esModule")) return e; + var t = e.default; + if (typeof t == "function") { + var r = function n() { + var i = !1; + try { + i = this instanceof n; + } catch { + } + return i ? Reflect.construct(t, arguments, this.constructor) : t.apply(this, arguments); + }; + r.prototype = t.prototype; + } else r = {}; + return Object.defineProperty(r, "__esModule", { value: !0 }), Object.keys(e).forEach(function(n) { + var i = Object.getOwnPropertyDescriptor(e, n); + Object.defineProperty(r, n, i.get ? i : { + enumerable: !0, + get: function() { + return e[n]; + } + }); + }), r; +} +var Rt = { exports: {} }, si; +function od() { + if (si) return Rt.exports; + si = 1; + function e(t, r = 100, n = {}) { + if (typeof t != "function") + throw new TypeError(`Expected the first parameter to be a function, got \`${typeof t}\`.`); + if (r < 0) + throw new RangeError("`wait` must not be negative."); + const { immediate: i } = typeof n == "boolean" ? { immediate: n } : n; + let a, o, s, l, c; + function d() { + const h = a, m = o; + return a = void 0, o = void 0, c = t.apply(h, m), c; + } + function u() { + const h = Date.now() - l; + h < r && h >= 0 ? s = setTimeout(u, r - h) : (s = void 0, i || (c = d())); + } + const v = function(...h) { + if (a && this !== a && Object.getPrototypeOf(this) === Object.getPrototypeOf(a)) + throw new Error("Debounced method called with different contexts of the same prototype."); + a = this, o = h, l = Date.now(); + const m = i && !s; + return s || (s = setTimeout(u, r)), m && (c = d()), c; + }; + return Object.defineProperty(v, "isPending", { + get() { + return s !== void 0; + } + }), v.clear = () => { + s && (clearTimeout(s), s = void 0); + }, v.flush = () => { + s && v.trigger(); + }, v.trigger = () => { + c = d(), v.clear(); + }, v; + } + return Rt.exports.debounce = e, Rt.exports = e, Rt.exports; +} +var sd = /* @__PURE__ */ od(); +const ld = /* @__PURE__ */ ad(sd); +class cd { + constructor() { + this.documentActive = !0, this.addListeners = () => { + window.addEventListener("pageshow", this.handleWindowVisibilityChange), window.addEventListener("pagehide", this.handleWindowVisibilityChange), window.addEventListener("focus", this.handleWindowFocusChange), window.addEventListener("blur", this.handleWindowFocusChange), document.addEventListener("visibilitychange", this.handleDocumentVisibilityChange); + }, this.removeListeners = () => { + window.removeEventListener("pageshow", this.handleWindowVisibilityChange), window.removeEventListener("pagehide", this.handleWindowVisibilityChange), window.removeEventListener("focus", this.handleWindowFocusChange), window.removeEventListener("blur", this.handleWindowFocusChange), document.removeEventListener("visibilitychange", this.handleDocumentVisibilityChange); + }, this.handleWindowVisibilityChange = (t) => { + t.type === "pageshow" ? this.dispatch(!0) : this.dispatch(!1); + }, this.handleWindowFocusChange = (t) => { + t.type === "focus" ? this.dispatch(!0) : this.dispatch(!1); + }, this.handleDocumentVisibilityChange = () => { + this.dispatch(!document.hidden); + }, this.dispatch = (t) => { + if (t !== this.documentActive) { + const r = window.Vaadin.copilot.eventbus; + this.documentActive = t, r.emit("document-activation-change", { active: this.documentActive }); + } + }; + } + copilotActivated() { + this.addListeners(); + } + copilotDeactivated() { + this.removeListeners(); + } +} +const li = new cd(), dd = "copilot-development-setup-user-guide"; +function su() { + xt("use-dev-workflow-guide"), se.updatePanel(dd, { floating: !0 }); +} +function Za() { + const e = xr.jdkInfo; + return e ? e.jrebel ? "success" : e.hotswapAgentFound ? !e.hotswapVersionOk || !e.runningWithExtendClassDef || !e.runningWitHotswap || !e.runningInJavaDebugMode ? "error" : "success" : "warning" : null; +} +function lu() { + const e = xr.jdkInfo; + return !e || Za() !== "success" ? "none" : e.jrebel ? "jrebel" : e.runningWitHotswap ? "hotswap" : "none"; +} +function ud() { + return b.idePluginState !== void 0 && !b.idePluginState.active ? "warning" : "success"; +} +function cu() { + if (!xr.jdkInfo) + return { status: "success" }; + const e = Za(), t = ud(); + return e === "warning" ? t === "warning" ? { status: "warning", message: "IDE Plugin, Hotswap" } : { status: "warning", message: "Hotswap is not enabled" } : t === "warning" ? { status: "warning", message: "IDE Plugin is not active" } : e === "error" ? { status: "error", message: "Hotswap is partially enabled" } : { status: "success" }; +} +function pd() { + te(`${he}get-dev-setup-info`, {}), window.Vaadin.copilot.eventbus.on("copilot-get-dev-setup-info-response", (e) => { + if (e.detail.content) { + const t = JSON.parse(e.detail.content); + b.setIdePluginState(t.ideInfo); + } + }); +} +const ct = /* @__PURE__ */ new WeakMap(); +class fd { + constructor() { + this.root = null, this.nodeUuidNodeMapFlat = /* @__PURE__ */ new Map(), this.aborted = !1, this._hasFlowComponent = !1, this.flowNodesInSource = {}, this.flowCustomComponentData = {}, this.hillaCustomComponentData = {}, this.componentDragDropApiInfosMap = {}, this.waitForHillaCustomComponentResponseData = () => new Promise((t, r) => { + const n = setTimeout(() => { + r(new Error("Timed out waiting for custom component data")); + }, 1e4); + y.emit("request-hilla-custom-component-data-with-callback", { + tree: this, + callback: (i) => { + clearTimeout(n), t(i); + } + }); + }); + } + async init() { + const t = il(); + if (t) { + const r = await this.addToTree(t); + r && this.root?.abstractRootNode && this.root.children.length === 1 && (this.root = this.root.children[0]), r && (await this.addOverlayContentToTreeIfExists("vaadin-popover[opened]"), await this.addOverlayContentToTreeIfExists("vaadin-dialog[opened]")), this.hillaCustomComponentData = await this.waitForHillaCustomComponentResponseData(); + } + } + getChildren(t) { + return this.nodeUuidNodeMapFlat.get(t)?.children ?? []; + } + get allNodesFlat() { + return Array.from(this.nodeUuidNodeMapFlat.values()); + } + getNodeOfElement(t) { + if (t) + return this.allNodesFlat.find((r) => r.element === t); + } + /** + * Handles route containers that should not be present in the tree. When this returns true, it means that given node is a route container so adding it to tree should be skipped + * + * @param node Node to check whether it is a route container or not + * @param parentNode Parent of the given {@link node} + */ + async handleRouteContainers(t, r) { + const n = In(t); + if (!n && pl(t)) { + const i = ir(t); + if (i && i.nextElementSibling) + return await this.addToTree(i.nextElementSibling, r), !0; + } + if (n && t.localName === "react-router-outlet") { + for (const i of Array.from(t.children)) { + const a = nr(i); + a && await this.addToTree(a, r); + } + return !0; + } + return !1; + } + includeReactNode(t) { + return ut(t) === "PreconfiguredAuthProvider" || ut(t) === "RouterProvider" ? !1 : Nn(t) || ll(t); + } + async includeFlowNode(t) { + if (fl(t) || Ut(t)?.hiddenByServer) + return !1; + const r = Ut(t); + return r && this.nodeUuidNodeMapFlat.has(ci(r)) ? !1 : this.isInitializedInProjectSources(t); + } + async isInitializedInProjectSources(t) { + const r = Ut(t); + if (!r) + return !1; + const { nodeId: n, uiId: i } = r; + if (!this.flowNodesInSource[i]) { + const a = await Nt("copilot-get-component-source-info", { uiId: i }, (o) => o.data); + a.error && ce("Failed to get component source info", a.error), this.flowCustomComponentData[i] = a.customComponentResponse, this.flowNodesInSource[i] = new Set(a.nodeIdsInProject), this.componentDragDropApiInfosMap[i] = a.dragDropApiInfos; + } + return this.flowNodesInSource[i].has(n); + } + /** + * Adds the given element into the tree and returns the result when added. + *

+ * It recursively travels through the children of given node. This method is called for each child ,but the result of adding a child is swallowed + *

+ * @param node Node to add to tree + * @param parentNode Parent of the node, might be null if it is the root element + */ + async addToTree(t, r) { + if (this.isAborted()) + return !1; + const n = await this.handleRouteContainers(t, r); + if (n) + return n; + const i = In(t); + let a; + if (!i) + this.includeReactNode(t) && (a = this.generateNodeFromFiber(t, r)); + else if (await this.includeFlowNode(t)) { + const l = this.generateNodeFromFlow(t, r); + if (!l) + return !1; + this._hasFlowComponent = !0, a = l; + } + if (r) + a && (a.parent = r, r.children || (r.children = []), r.children.push(a)); + else { + if (!a) { + if (!(t instanceof Element) && da(t)) + return Va({ + type: ye.WARNING, + message: "Copilot is partly usable", + details: `${ut(t)} should be a function component to make Copilot work properly`, + dismissId: "react_route_component_is_class" + }), !1; + if (i ? a = this.generateNodeFromFlow(t) : a = this.generateNodeFromFiber(t), !a) + return ce("Unable to add node", new Error("Tree root node is undefined")), !1; + a.abstractRootNode = !0; + } + this.root = a; + } + a && this.nodeUuidNodeMapFlat.set(a.uuid, a); + const o = a ?? r, s = i ? Array.from(t.children) : al(t); + for (const l of s) + await this.addToTree(l, o); + return a !== void 0; + } + generateNodeFromFiber(t, r) { + const n = Nn(t) ? ir(t) : void 0, i = r?.children.length ?? 0, a = this; + return { + node: t, + parent: r, + element: n, + depth: r && r.depth + 1 || 0, + children: [], + siblingIndex: i, + isFlowComponent: !1, + isReactComponent: !0, + isLitTemplate: !1, + zeroSize: n ? Ln(n) : void 0, + get uuid() { + if (ct.has(t)) + return ct.get(t); + if (t.alternate && ct.has(t.alternate)) + return ct.get(t.alternate); + const s = Ka(); + return ct.set(t, s), s; + }, + get name() { + return zn(ut(t)); + }, + get identifier() { + return Un(n); + }, + get nameAndIdentifier() { + return ui(this.name, this.identifier); + }, + get previousSibling() { + if (i !== 0) + return r?.children[i - 1]; + }, + get nextSibling() { + if (!(r === void 0 || i === r.children.length - 1)) + return r.children[i + 1]; + }, + get path() { + return di(this); + }, + get customComponentData() { + if (a.hillaCustomComponentData[this.uuid]) + return a.hillaCustomComponentData[this.uuid]; + } + }; + } + generateNodeFromFlow(t, r) { + const n = Ut(t); + if (!n) + return; + const i = r?.children.length ?? 0, a = this.flowCustomComponentData, o = this.componentDragDropApiInfosMap; + return { + node: n, + parent: r, + element: t, + depth: r && r.depth + 1 || 0, + children: [], + siblingIndex: i, + get uuid() { + return ci(n); + }, + isFlowComponent: !0, + isReactComponent: !1, + get isLitTemplate() { + return !!this.customComponentData?.litTemplate; + }, + zeroSize: t ? Ln(t) : void 0, + get name() { + return ul(n) ?? zn(n.element.localName); + }, + get identifier() { + return Un(t); + }, + get nameAndIdentifier() { + return ui(this.name, this.identifier); + }, + get previousSibling() { + if (i !== 0) + return r?.children[i - 1]; + }, + get nextSibling() { + if (!(r === void 0 || i === r.children.length - 1)) + return r.children[i + 1]; + }, + get path() { + return di(this); + }, + get customComponentData() { + if (a[n.uiId]) + return a[n.uiId].allComponentsInfoForCustomComponentSupport[n.nodeId]; + }, + get componentDragDropApiInfo() { + if (!o[n.uiId]) + return; + const l = o[n.uiId]; + if (l[n.nodeId]) + return l[n.nodeId]; + } + }; + } + async addOverlayContentToTreeIfExists(t) { + const r = document.body.querySelector(t); + if (!r) + return; + let n = !0; + if (!this.getNodeOfElement(r)) { + const i = Ie(nr(r)); + n = await this.addToTree(i ?? r, this.root); + } + if (n) + for (const i of Array.from(r.children)) + await this.addToTree(i, this.getNodeOfElement(r)); + } + hasFlowComponents() { + return this._hasFlowComponent; + } + findNodeByUuid(t) { + if (t) + return this.nodeUuidNodeMapFlat.get(t); + } + getElementByNodeUuid(t) { + return this.findNodeByUuid(t)?.element; + } + findByTreePath(t) { + if (t) + return this.allNodesFlat.find((r) => r.path === t); + } + isAborted() { + return this.aborted; + } + abort() { + this.aborted = !0; + } + get customComponentDataLoaded() { + return Object.keys(this.hillaCustomComponentData).length !== 0 || Object.keys(this.flowCustomComponentData).length !== 0; + } +} +function ci(e) { + return `${e.uiId}#${e.nodeId}`; +} +function di(e) { + if (!e.parent) + return e.name; + let t = 0; + for (let r = 0; r < e.siblingIndex + 1; r++) + e.parent.children[r].name === e.name && t++; + return `${e.parent.path} > ${e.name}[${t}]`; +} +function ui(e, t) { + return t ? `${e} "${t}"` : e; +} +let He = null; +const vd = async () => { + He && He.abort(); + const e = new fd(); + He = e, await e.init(), He = null, e.isAborted() || (window.Vaadin.copilot.tree.currentTree = e); +}, du = () => { + He && He.abort(); +}; +function hd() { + const e = window.navigator.userAgent; + return e.indexOf("Windows") !== -1 ? "Windows" : e.indexOf("Mac") !== -1 ? "Mac" : e.indexOf("Linux") !== -1 ? "Linux" : null; +} +function gd() { + return hd() === "Mac"; +} +function md() { + return gd() ? "⌘" : "Ctrl"; +} +let pi = !1, dt = 0; +const Wr = (e) => { + if (nt.isActivationShortcut()) + if (e.key === "Shift" && !e.ctrlKey && !e.altKey && !e.metaKey) + pi = !0; + else if (pi && e.shiftKey && (e.key === "Control" || e.key === "Meta")) { + if (dt++, dt === 2) + return b.toggleActive("shortcut"), dt = 0, !0; + setTimeout(() => { + dt = 0; + }, 500); + } else + dt = 0; + return !1; +}; +function fi(e) { + if ((e.ctrlKey || e.metaKey) && e.key === "c" && !e.shiftKey) { + const t = document.querySelector("copilot-main")?.shadowRoot; + let r; + if (typeof t?.getSelection == "function" ? r = t?.getSelection() : r = document.getSelection() ?? void 0, r && r.rangeCount === 1) { + const i = r.getRangeAt(0).commonAncestorContainer; + if (i.nodeType === Node.TEXT_NODE) + return fe(i); + } + } + return !1; +} +function bd(e) { + const t = or(e, "vaadin-context-menu-overlay"); + if (!t) + return !1; + const r = t.owner; + return r ? !!or(r, "copilot-component-overlay") : !1; +} +function yd() { + return b.idePluginState?.supportedActions?.find((e) => e === "undo"); +} +const vi = (e) => { + if (!b.active) + return; + if (Wr(e)) { + e.stopPropagation(); + return; + } + const t = Cl(); + if (!t) + return; + const r = bd(t), n = t.localName === "copilot-main", i = or(t, "copilot-outline-panel") !== null; + if (!n && !r && e.key !== "Escape" && !i) { + e.stopPropagation(); + return; + } + let a = !0, o = !1; + if (fi(e)) + a = !1; + else if (e.key === "Escape") { + if (b.loginCheckActive ? b.setLoginCheckActive(!1) : y.emit("close-drawers", {}), xd(t)) { + e.stopPropagation(); + return; + } + y.emit("escape-key-pressed", { event: e }); + } else wd(e) ? (y.emit("delete-selected", {}), o = !0) : (e.ctrlKey || e.metaKey) && e.key === "d" ? (y.emit("duplicate-selected", {}), o = !0) : (e.ctrlKey || e.metaKey) && e.key === "b" ? (y.emit("show-selected-in-ide", { attach: e.shiftKey }), o = !0) : (e.ctrlKey || e.metaKey) && e.key === "z" && yd() ? (y.emit("undoRedo", { undo: !e.shiftKey }), o = !0) : fi(e) || y.emit("keyboard-event", { event: e }); + a && e.stopPropagation(), o && e.preventDefault(); +}, wd = (e) => (e.key === "Backspace" || e.key === "Delete") && !e.shiftKey && !e.ctrlKey && !e.altKey && !e.metaKey; +function xd(e) { + const t = e; + if (Mn(e)) + return !0; + const r = fa(t); + for (const n of r) + if (Mn(n)) + return !0; + return !1; +} +const re = md(), qt = "⇧", uu = { + toggleCopilot: `${qt} + ${re} ${re}`, + openAiPopover: `${qt} + Space`, + undo: `${re} + Z`, + redo: `${re} + ${qt} + Z`, + duplicate: `${re} + D`, + goToSource: `${re} + B`, + goToAttachSource: `${re} + ${qt} + B`, + selectParent: "←", + selectPreviousSibling: "↑", + selectNextSibling: "↓", + delete: "DEL", + copy: `${re} + C`, + paste: `${re} + V` +}; +var Od = Object.getOwnPropertyDescriptor, Ed = (e, t, r, n) => { + for (var i = n > 1 ? void 0 : n ? Od(t, r) : t, a = e.length - 1, o; a >= 0; a--) + (o = e[a]) && (i = o(i) || i); + return i; +}; +let hi = class extends dc { + constructor() { + super(...arguments), this.removers = [], this.initialized = !1, this.active = !1, this.overlayListener = (e) => { + if (!b.active) + return; + const { overlay: t } = e.detail; + if (fe(t)) { + const r = Ke.getOwner(t); + r && this.addDescendantOverlayOwnersToDrawer(r); + return; + } + this.ensureTopmostPopover(); + }, this.overlayCloseEventListener = (e) => { + const t = e.detail?.overlay; + if (!t || !fe(t)) + return; + const r = Ke.getOwner(t); + r && this.removeDescendantOverlayOwnersToDrawer(r); + }, this.addDescendantOverlayOwnersToDrawer = (e) => { + if (e.getAttribute("slot") === "submenu") + return; + const t = this.getAncestorDrawer(e); + t && e && e.localName !== "vaadin-tooltip" && t.openedDescendantOverlayOwners.add(e); + }, this.removeDescendantOverlayOwnersToDrawer = (e) => { + if (e.getAttribute("slot") === "submenu") + return; + const t = this.getAncestorDrawer(e); + t && t.openedDescendantOverlayOwners.has(e) && t.openedDescendantOverlayOwners.delete(e); + }, this.getAncestorDrawer = (e) => { + if (!e) + return; + const t = or(e, "copilot-drawer-panel") ?? void 0; + if (t) + return t; + }, this.toggleOperationInProgressAttr = () => { + this.toggleAttribute("operation-in-progress", b.operationWaitsHmrUpdate !== void 0); + }, this.operationInProgressCursorUpdateDebounceFunc = ld(this.toggleOperationInProgressAttr, 500), this.overlayOutsideClickListener = (e) => { + fe(e.target?.owner) || (b.active || fe(e.detail.sourceEvent.target)) && e.preventDefault(); + }, this.mouseLeaveListener = () => { + y.emit("close-drawers", {}); + }; + } + static get styles() { + return [ + L(Jc), + L(Gc), + L(Yc), + L(Qc), + L(_c), + L($c), + L(ed), + L(td), + L(rd), + L(nd), + L(id), + Rl` + :host { + color: var(--vaadin-text-color); + contain: strict; + cursor: var(--cursor, default); + font: var(--copilot-font-xs); + inset: 0; + pointer-events: all; + position: fixed; + z-index: 9999; + + /* Override native [popover] user agent styles */ + width: auto; + height: auto; + border: none; + padding: 0; + background-color: transparent; + overflow: visible; + } + + :host([operation-in-progress]) { + --cursor: wait; + --lumo-clickable-cursor: wait; + } + + :host(:not([active])) { + visibility: hidden !important; + pointer-events: none; + } + + /* Hide floating panels when not active */ + + :host(:not([active])) > copilot-section-panel-wrapper { + display: none !important; + } + :host(:not([active])) > copilot-section-panel-wrapper[individual] { + display: block !important; + visibility: visible; + pointer-events: all; + } + + /* Keep activation button and menu visible */ + + copilot-activation-button, + .activation-button-menu { + visibility: visible; + display: flex !important; + } + + copilot-activation-button { + pointer-events: auto; + } + + a { + color: var(--blue-11); + } + + :host([user-select-none]) { + -webkit-touch-callout: none; + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + } + + /* Needed to prevent a JS error because of monkey patched '_attachOverlay'. It is some scope issue, */ + /* where 'this._placeholder.parentNode' is undefined - the scope if 'this' gets messed up at some point. */ + /* We also don't want animations on the overlays to make the feel faster, so this is fine. */ + :is(vaadin-tooltip-overlay) { + z-index: calc(var(--copilot-notifications-container-z-index) + 10); + } + :is( + vaadin-context-menu, + vaadin-menu-bar, + vaadin-select, + vaadin-combo-box, + vaadin-tooltip, + vaadin-multi-select-combo-box + ):is([opening], [closing]), + :is( + vaadin-context-menu, + vaadin-menu-bar, + vaadin-select, + vaadin-combo-box, + vaadin-tooltip, + vaadin-multi-select-combo-box + )::part(overlay) { + animation: none !important; + } + + :host(:not([active])) copilot-drawer-panel::before { + animation: none; + } + + :host .alwaysVisible { + visibility: visible !important; + } + ` + ]; + } + connectedCallback() { + super.connectedCallback(), this.popover = "manual", this.ensureTopmostPopover(), document.body.addEventListener("vaadin-overlay-open", this.overlayListener), document.documentElement.addEventListener("vaadin-overlay-close", this.overlayCloseEventListener), this.init().catch((e) => ce("Unable to initialize copilot", e)); + } + ensureTopmostPopover() { + this.isConnected && (this.hidePopover(), this.showPopover()); + } + async init() { + if (this.initialized) + return; + await window.Vaadin.copilot._machineState.initializer.promise, await import("./copilot-global-vars-later-B4pUkXYD.js"), await import("./copilot-init-step2-TY87urez.js"), yl(), uc(), this.tabIndex = 0, jt.hostConnectedCallback(), window.addEventListener("keydown", Wr), this.addEventListener("keydown", vi), y.onSend(this.handleSendEvent), this.removers.push(y.on("close-drawers", this.closeDrawers.bind(this))), this.removers.push( + y.on("open-attention-required-drawer", this.openDrawerIfPanelRequiresAttention.bind(this)) + ), this.removers.push( + y.on("set-pointer-events", (r) => { + this.style.pointerEvents = r.detail.enable ? "" : "none"; + }) + ), this.addEventListener("mousemove", this.mouseMoveListener), this.addEventListener("dragover", this.dragOverListener), this.addEventListener("dragleave", this.dragLeaveListener), this.addEventListener("drop", this.dropListener), Ke.addOverlayOutsideClickEvent(); + const e = window.matchMedia("(prefers-color-scheme: dark)"); + this.classList.toggle("dark", e.matches), e.addEventListener("change", (r) => { + this.classList.toggle("dark", e.matches); + }), this.reaction( + () => b.active, + () => { + this.toggleAttribute("active", b.active), b.active ? this.activate() : this.deactivate(), We.saveCopilotActivation(b.active); + } + ), this.reaction( + () => b.activatedAtLeastOnce, + () => { + Ma(), pc(); + } + ), this.reaction( + () => b.sectionPanelDragging, + () => { + b.sectionPanelDragging && Array.from(this.shadowRoot.children).filter((n) => n.localName.endsWith("-overlay")).forEach((n) => { + n.close && n.close(); + }); + } + ), this.reaction( + () => b.operationWaitsHmrUpdate, + () => { + b.operationWaitsHmrUpdate ? this.operationInProgressCursorUpdateDebounceFunc() : (this.operationInProgressCursorUpdateDebounceFunc.clear(), this.toggleOperationInProgressAttr()); + } + ), this.reaction( + () => se.panels, + () => { + se.panels.find((r) => r.individual) && this.requestUpdate(); + } + ), We.getCopilotActivation() && pa().then(() => { + b.setActive(!0, "restore"); + }), this.removers.push( + y.on("user-select", (r) => { + const { allowSelection: n } = r.detail; + this.toggleAttribute("user-select-none", !n); + }) + ), this.removers.push( + y.on("featureFlags", (r) => { + const n = r.detail.features; + b.setFeatureFlags(n); + }) + ), this.removers.push( + y.on("vaadin-drawer-opened-changed", (r) => { + const { opened: n, owner: i } = r.detail; + n ? this.addDescendantOverlayOwnersToDrawer(i) : this.removeDescendantOverlayOwnersToDrawer(i); + }) + ); + const t = new ResizeObserver(() => { + y.emit("copilot-main-resized", {}); + }); + t.observe(this), this.removers.push(() => { + t.disconnect(); + }), Ua(), this.detectAppTheme(), this.initialized = !0, pd(); + } + /** + * Called when Copilot is activated. Good place to start attach listeners etc. + */ + async activate() { + jt.activate(), li.copilotActivated(), fc(), this.openDrawerIfPanelRequiresAttention(), document.documentElement.addEventListener("mouseleave", this.mouseLeaveListener), Ke.onCopilotActivation(), await vd(), Ia.loadPreviewConfiguration(), this.ensureTopmostPopover(), this.active = !0, nt.isActivationAnimation() && b.activatedFrom !== "restore" && this.getAllDrawers().forEach((e) => { + e.setAttribute("bounce", ""); + }); + } + /** + * Called when Copilot is deactivated. Good place to remove listeners etc. + */ + deactivate() { + this.getAllDrawers().forEach((e) => { + e.removeAttribute("bounce"); + }), this.closeDrawers(), jt.deactivate(), li.copilotDeactivated(), document.documentElement.removeEventListener("mouseleave", this.mouseLeaveListener), Ke.onCopilotDeactivation(), this.active = !1; + } + getAllDrawers() { + return Array.from(this.shadowRoot.querySelectorAll("copilot-drawer-panel")); + } + disconnectedCallback() { + super.disconnectedCallback(), jt.hostDisconnectedCallback(), window.removeEventListener("keydown", Wr), this.removeEventListener("keydown", vi), y.offSend(this.handleSendEvent), this.removers.forEach((e) => e()), this.removeEventListener("mousemove", this.mouseMoveListener), this.removeEventListener("dragover", this.dragOverListener), this.removeEventListener("dragleave", this.dragLeaveListener), this.removeEventListener("drop", this.dropListener), Ke.removeOverlayOutsideClickEvent(), document.documentElement.removeEventListener("vaadin-overlay-outside-click", this.overlayOutsideClickListener), document.body.removeEventListener("vaadin-overlay-open", this.overlayListener), document.documentElement.removeEventListener("vaadin-overlay-close", this.overlayCloseEventListener); + } + handleSendEvent(e) { + const t = e.detail.command, r = e.detail.data; + te(t, r); + } + /** + * Opens the attention required drawer if there is any. + */ + openDrawerIfPanelRequiresAttention() { + const e = se.getAttentionRequiredPanelConfiguration(); + if (!e) + return; + const t = e.panel; + if (!t || e.floating) + return; + const r = this.shadowRoot.querySelector(`copilot-drawer-panel[position="${t}"]`); + r.opened = !0; + } + render() { + return le` + + + + + + ${this.renderDrawer("left")} ${this.renderDrawer("right")} ${this.renderDrawer("bottom")} ${qc()} + + + + + + `; + } + renderDrawer(e) { + return le` ${Rc(e)} `; + } + /** + * Closes the open drawers if any opened unless an overlay is opened from drawer. + */ + closeDrawers() { + const e = this.getAllDrawers(); + if (Array.from(e).some((r) => r.opened)) + for (const r of e) + r.openedDescendantOverlayOwners.size === 0 && (r.opened = !1); + } + updated(e) { + super.updated(e), this.attachActivationButtonToBody(), Xc(); + } + attachActivationButtonToBody() { + const e = document.body.querySelectorAll("copilot-activation-button"); + e.length > 1 && e[0].remove(); + } + mouseMoveListener(e) { + e.composedPath().find((t) => t.localName === `${he}drawer-panel`) || this.closeDrawers(); + } + dragOverListener(e) { + this.mouseMoveListener(e), e.dataTransfer && (e.dataTransfer.dropEffect = "none"), e.preventDefault(), y.emit("drag-and-drop-in-progress", {}); + } + dragLeaveListener(e) { + Nl(e) && y.emit("end-drag-drop", {}); + } + dropListener(e) { + e.preventDefault(), y.emit("end-drag-drop", {}); + } + detectAppTheme() { + Tn("lumo") ? b.setAppTheme("lumo") : Tn("aura") ? b.setAppTheme("aura") : b.setAppTheme(null), Nt(`${he}set-app-theme`, { theme: b.appTheme }, () => { + }); + } +}; +hi = Ed([ + jl("copilot-main") +], hi); +const kd = window.Vaadin, Cd = { + init(e) { + ua( + () => window.Vaadin.devTools, + (t) => { + const r = t.handleFrontendMessage; + t.handleFrontendMessage = (n) => { + Hc(n) || r.call(t, n); + }; + } + ); + } +}; +kd.devToolsPlugins.push(Cd); +function Ad(e, t, r = {}) { + const n = { ...r }; + e.classNames.length > 0 && (n.className = e.classNames.join(" ")); + const i = Sd(e); + Object.keys(i).length > 0 && (n.style = i); + for (const a of Pd()) { + const o = a(e, t); + if (o) { + n.className && o.props?.className && (o.props.className = `${String(o.props.className)} ${String(n.className)}`, delete n.className), o.props = { ...o.props, ...n }; + for (const [s, l] of Object.entries(o.props)) + l === void 0 && delete o.props[s]; + return o; + } + } + console.warn(`No importer found for node: ${e.htmlTag} ${e.reactTag} (${e.type})`); +} +function Sd(e) { + if (Object.keys(e.styles).length === 0) + return {}; + const t = {}; + return Object.keys(e.styles).forEach((r) => { + const n = e.styles[r]; + r.startsWith("--") || (r = r.replace(/-([a-z])/g, (i) => i[1].toUpperCase())), t[r] = n; + }), t; +} +function pu(e) { + Wa().unshift(e); +} +function Pd() { + return [...Wa(), ...Dd()]; +} +function Wa() { + return window.Vaadin.copilot.figmaImporters ??= [], window.Vaadin.copilot.figmaImporters; +} +function Dd() { + return window.Vaadin.copilot.figmaBuiltInImporters ??= [], window.Vaadin.copilot.figmaBuiltInImporters; +} +function Ha(e, t) { + const r = []; + for (const n of e.children) + t(n) && r.push(n); + for (const n of e.children) + r.push(...Ha(n, t)); + return r; +} +function fu(e, t, r) { + return Ha(e, r).map((n) => Ad(n, t)).filter((n) => n !== void 0); +} +export { + uu as $, + Rl as A, + Vd as B, + We as C, + le as D, + E, + ht as F, + Ol as G, + $d as H, + dd as I, + xr as J, + Za as K, + Nd as L, + dc as M, + Ud as N, + eu as O, + he as P, + lu as Q, + Id as R, + nt as S, + cu as T, + Ia as U, + zd as V, + Zd as W, + Gc as X, + _c as Y, + ed as Z, + su as _, + ad as a, + bl as a0, + ru as a1, + nu as a2, + hc as a3, + Hd as a4, + Md as a5, + xt as a6, + Va as a7, + ye as a8, + Td as a9, + pu as aA, + fu as aB, + Yc as aa, + qd as ab, + Na as ac, + vd as ad, + vl as ae, + du as af, + Da as ag, + tu as ah, + Sa as ai, + sc as aj, + Pa as ak, + ar as al, + Kd as am, + Rd as an, + La as ao, + Ft as ap, + hl as aq, + ud as ar, + yc as as, + Ma as at, + dn as au, + Oc as av, + xa as aw, + Fr as ax, + Mn as ay, + Yd as az, + y as b, + au as c, + rr as d, + el as e, + jd as f, + ou as g, + Bd as h, + Ld as i, + b as j, + Nt as k, + ce as l, + $e as m, + Wd as n, + C as o, + iu as p, + fd as q, + jl as r, + te as s, + Fd as t, + xl as u, + ld as v, + se as w, + L as x, + Jc as y, + id as z +}; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/copilot-features-plugin-C7i9ifZr.js b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-features-plugin-C7i9ifZr.js new file mode 100644 index 0000000..a8c4b0d --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-features-plugin-C7i9ifZr.js @@ -0,0 +1,111 @@ +import { j as p, D as g, a6 as m, a7 as R, as as b, a8 as $, at as y, M as F, E as u, au as x, y as w, av as T, r as f } from "./copilot-BvIxHaRg.js"; +import { r as v } from "./state-BGGS46O3.js"; +import { B as O } from "./base-panel-C5as2IDv.js"; +import { i as h } from "./icons-DpjjuYvb.js"; +const S = "copilot-features-panel{padding:var(--space-100);font:var(--copilot-font-xs);display:grid;grid-template-columns:auto 1fr;gap:var(--space-50);height:auto}copilot-features-panel a{display:flex;align-items:center;justify-self:end;gap:var(--space-50);white-space:nowrap}copilot-features-panel a svg{height:12px;width:12px;min-height:12px;min-width:12px}"; +var q = Object.defineProperty, C = Object.getOwnPropertyDescriptor, o = (t, e, a, s) => { + for (var r = s > 1 ? void 0 : s ? C(e, a) : e, i = t.length - 1, n; i >= 0; i--) + (n = t[i]) && (r = (s ? n(e, a, r) : n(r)) || r); + return s && r && q(e, a, r), r; +}; +const l = window.Vaadin.devTools; +let d = class extends O { + constructor() { + super(...arguments), this.toggledFeaturesThatAreRequiresServerRestart = []; + } + render() { + return g` + ${p.featureFlags.map( + (t) => g` + this.toggleFeatureFlag(e, t)}> + + learn more ${h.share} + ` + )}`; + } + toggleFeatureFlag(t, e) { + const a = t.target.checked; + m("use-feature", { source: "toggle", enabled: a, id: e.id }), l.frontendConnection ? (l.frontendConnection.send("setFeature", { featureId: e.id, enabled: a }), e.requiresServerRestart && p.toggleServerRequiringFeatureFlag(e), R({ + type: $.INFORMATION, + message: `“${e.title}” ${a ? "enabled" : "disabled"}`, + details: e.requiresServerRestart ? b() : void 0, + dismissId: `feature${e.id}${a ? "Enabled" : "Disabled"}` + }), y()) : l.log("error", `Unable to toggle feature ${e.title}: No server connection available`); + } +}; +o([ + v() +], d.prototype, "toggledFeaturesThatAreRequiresServerRestart", 2); +d = o([ + f("copilot-features-panel") +], d); +let c = class extends F { + constructor() { + super(...arguments), this.serverRestarting = !1; + } + createRenderRoot() { + return this; + } + render() { + if (p.serverRestartRequiringToggledFeatureFlags.length === 0) + return u; + if (!x()) + return u; + const t = this.serverRestarting ? "Restarting..." : "Click to restart server"; + return g` + + + + `; + } +}; +o([ + v() +], c.prototype, "serverRestarting", 2); +c = o([ + f("copilot-features-actions") +], c); +const I = { + header: "Features", + expanded: !1, + panelOrder: 35, + panel: "right", + floating: !1, + tag: "copilot-features-panel", + helpUrl: "https://vaadin.com/docs/latest/flow/configuration/feature-flags", + actionsTag: "copilot-features-actions" +}, P = { + init(t) { + t.addPanel(I); + } +}; +window.Vaadin.copilot.plugins.push(P); +export { + c as CopilotFeaturesActions, + d as CopilotFeaturesPanel +}; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/copilot-feedback-plugin-DyqC4FEM.js b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-feedback-plugin-DyqC4FEM.js new file mode 100644 index 0000000..d289f97 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-feedback-plugin-DyqC4FEM.js @@ -0,0 +1,214 @@ +import { D as c, j as d, b as h, w as y, a6 as u, s as v, P as f, H as m, r as k } from "./copilot-BvIxHaRg.js"; +import { r as s } from "./state-BGGS46O3.js"; +import { e as w } from "./query-BykXNUlT.js"; +import { B as $ } from "./base-panel-C5as2IDv.js"; +import { i as x } from "./icons-DpjjuYvb.js"; +const A = "copilot-feedback-panel{display:flex;flex-direction:column;font:var(--copilot-font-xs);gap:var(--space-200);padding:var(--space-150)}copilot-feedback-panel>p{margin:0}copilot-feedback-panel .dialog-footer{display:flex;gap:var(--space-100)}copilot-feedback-panel :is(vaadin-select,vaadin-email-field)::part(input-field){padding-block:0}copilot-feedback-panel :is(vaadin-select)::part(input-field){padding-inline-end:0}copilot-feedback-panel vaadin-select::part(toggle-button){align-items:center;display:flex;height:var(--copilot-size-md);justify-content:center;width:var(--copilot-size-md)}copilot-feedback-panel vaadin-text-area textarea{line-height:var(--copilot-line-height-sm)}copilot-feedback-panel vaadin-text-area:hover::part(input-field){background:none}copilot-feedback-panel>*::part(helper-text){line-height:var(--copilot-line-height-sm);margin:0}"; +var P = Object.defineProperty, F = Object.getOwnPropertyDescriptor, o = (e, t, n, l) => { + for (var a = l > 1 ? void 0 : l ? F(t, n) : t, p = e.length - 1, r; p >= 0; p--) + (r = e[p]) && (a = (l ? r(t, n, a) : r(a)) || a); + return l && a && P(t, n, a), a; +}; +const T = "https://github.com/vaadin", b = "https://github.com/vaadin/copilot/issues/new", D = "?template=feature_request.md&title=%5BFEATURE%5D", E = "A short, concise description of the bug and why you consider it a bug. Any details like exceptions and logs can be helpful as well.", C = "Please provide as many details as possible, this will help us deliver a fix as soon as possible.%0AThank you!%0A%0A%23%23%23 Description of the Bug%0A%0A{description}%0A%0A%23%23%23 Expected Behavior%0A%0AA description of what you would expect to happen. (Sometimes it is clear what the expected outcome is if something does not work, other times, it is not super clear.)%0A%0A%23%23%23 Minimal Reproducible Example%0A%0AWe would appreciate the minimum code with which we can reproduce the issue.%0A%0A%23%23%23 Versions%0A{versionsInfo}"; +let i = class extends $ { + constructor() { + super(), this.description = "", this.types = [ + { + label: "Generic feedback", + value: "feedback", + ghTitle: "" + }, + { + label: "Report a bug", + value: "bug", + ghTitle: "[BUG]" + }, + { + label: "Ask a question", + value: "question", + ghTitle: "[QUESTION]" + }, + { + label: "Share an idea", + value: "idea", + ghTitle: "[FEATURE]" + } + ], this.type = this.types[0].value, this.topics = [ + { + label: "Generic", + value: "platform" + }, + { + label: "Flow", + value: "flow" + }, + { + label: "Hilla", + value: "hilla" + }, + { + label: "Copilot", + value: "copilot" + } + ], this.topic = this.topics[0].value; + } + render() { + return c`${this.renderContent()}${this.renderFooter()}`; + } + renderContent() { + return this.message === void 0 ? c` +

+ Your insights are incredibly valuable to us. Whether you’ve encountered a hiccup, have questions, or ideas + to make our platform better, we're all ears! If you wish, leave your email, and we’ll get back to you. You + can even share your code snippet with us for a clearer picture. +

+ { + this.type = e.detail.value; + }}> + + { + this.topic = e.detail.value; + }}> + + { + this.descriptionField.invalid = !1, this.descriptionField.placeholder = ""; + }} + @value-changed=${(e) => { + this.description = e.detail.value; + }} + label="Tell Us More" + helper-text="Describe what you're experiencing, wondering about, or envisioning. The more you share, the better we can understand and act on your feedback"> + { + this.email = e.detail.value; + }} + .required=${this.type === "question"} + id="email" + value="${d.userInfo?.email}" + label="Your Email${this.type === "question" ? "" : " (Optional)"}" + helper-text="Leave your email if you’d like us to follow up, we’d love to keep the conversation going."> + ` : c`

${this.message}

`; + } + renderFooter() { + return this.message === void 0 ? c` +
+ + + +
+ ` : c`
+ Close +
`; + } + close() { + y.updatePanel("copilot-feedback-panel", { + floating: !1 + }); + } + submit() { + if (u("feedback", { github: !1, type: this.type, topic: this.topic }), this.description.trim() === "") { + this.descriptionField.invalid = !0, this.descriptionField.placeholder = "Please tell us more before sending", this.descriptionField.value = ""; + return; + } + const e = { + description: this.description, + email: this.email, + type: this.type, + topic: this.topic + }; + d.active ? h.emit("system-info-with-callback", { + callback: (t) => v(`${f}feedback`, { ...e, versions: t }), + notify: !1 + }) : v(`${f}feedback`, { ...e, versions: {} }), this.parentNode?.style.setProperty("--section-height", "150px"), this.message = "Thank you for sharing feedback."; + } + keyDown(e) { + (e.key === "Backspace" || e.key === "Delete") && e.stopPropagation(); + } + openGithub(e, t) { + if (u("feedback", { github: !0, type: this.type, topic: this.topic }), this.type === "idea") { + window.open(`${b}${D}`); + return; + } + if (this.type === "feedback") { + window.open(`${T}/${this.topic}/issues/new`); + return; + } + const n = e ? e.replace(/\n/g, "%0A") : "Activate Copilot to include version info.", l = `${t.types.find((r) => r.value === this.type)?.ghTitle}`, a = t.description !== "" ? t.description : E, p = C.replace("{description}", a).replace("{versionsInfo}", n); + window.open(`${b}?title=${l}&body=${p}`, "_blank")?.focus(); + } +}; +o([ + s() +], i.prototype, "description", 2); +o([ + s() +], i.prototype, "type", 2); +o([ + s() +], i.prototype, "topic", 2); +o([ + s() +], i.prototype, "email", 2); +o([ + s() +], i.prototype, "message", 2); +o([ + s() +], i.prototype, "types", 2); +o([ + s() +], i.prototype, "topics", 2); +o([ + w("vaadin-text-area") +], i.prototype, "descriptionField", 2); +i = o([ + k("copilot-feedback-panel") +], i); +const g = m({ + header: "Help Us Improve!", + tag: "copilot-feedback-panel", + width: 500, + height: 550, + floatingPosition: { + top: 100, + left: 100 + }, + individual: !0 +}), U = { + init(e) { + e.addPanel(g); + } +}; +window.Vaadin.copilot.plugins.push(U); +y.addPanel(g); +export { + i as CopilotFeedbackPanel +}; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/copilot-global-vars-later-B4pUkXYD.js b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-global-vars-later-B4pUkXYD.js new file mode 100644 index 0000000..fc7ea79 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-global-vars-later-B4pUkXYD.js @@ -0,0 +1,160466 @@ +import { g as Kft, c as I5e, a as ept, b as mge, d as F5e, e as tpt, t as O5e, s as age, P as oge, i as rpt, f as npt, h as ipt, j as cge, k as spt, l as apt, m as opt, o as cpt, E as lpt, n as L5e, C as M5e, p as upt, q as _pt } from "./copilot-BvIxHaRg.js"; +import { i as fpt } from "./icons-DpjjuYvb.js"; +function R5e(Cl) { + throw new Error('Could not dynamically require "' + Cl + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.'); +} +var lge = { exports: {} }; +const ppt = {}, dpt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: ppt +}, Symbol.toStringTag, { value: "Module" })), QE = /* @__PURE__ */ Kft(dpt); +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ +var j5e; +function mpt() { + return j5e || (j5e = 1, function(Cl) { + var es = {}; + ((Ja) => { + var Pc = Object.defineProperty, Na = (e, t) => { + for (var n in t) + Pc(e, n, { get: t[n], enumerable: !0 }); + }, Tg = (e) => e, mb = {}; + Na(mb, { + ANONYMOUS: () => aq, + AccessFlags: () => KQ, + AssertionLevel: () => lQ, + AssignmentDeclarationKind: () => cY, + AssignmentKind: () => OK, + Associativity: () => WK, + BreakpointResolver: () => iH, + BuilderFileEmit: () => Rie, + BuilderProgramKind: () => qie, + BuilderState: () => Md, + CallHierarchy: () => hk, + CharacterCodes: () => vY, + CheckFlags: () => XQ, + CheckMode: () => PW, + ClassificationType: () => hV, + ClassificationTypeNames: () => Gse, + CommentDirectiveType: () => OQ, + Comparison: () => QX, + CompletionInfoFlags: () => Jse, + CompletionTriggerKind: () => mV, + Completions: () => Tk, + ContainerFlags: () => hne, + ContextFlags: () => zQ, + Debug: () => E, + DiagnosticCategory: () => n7, + Diagnostics: () => p, + DocumentHighlights: () => Z9, + ElementFlags: () => ZQ, + EmitFlags: () => fj, + EmitHint: () => xY, + EmitOnly: () => MQ, + EndOfLineState: () => Use, + ExitStatus: () => RQ, + ExportKind: () => Rae, + Extension: () => bY, + ExternalEmitHelpers: () => TY, + FileIncludeKind: () => rj, + FilePreprocessingDiagnosticsKind: () => LQ, + FileSystemEntryKind: () => IY, + FileWatcherEventKind: () => PY, + FindAllReferences: () => ko, + FlattenLevel: () => Bne, + FlowFlags: () => r7, + ForegroundColorEscapeSequences: () => Die, + FunctionFlags: () => JK, + GeneratedIdentifierFlags: () => tj, + GetLiteralTextFlags: () => YZ, + GoToDefinition: () => sE, + HighlightSpanKind: () => jse, + IdentifierNameMap: () => L6, + ImportKind: () => Mae, + ImportsNotUsedAsValues: () => dY, + IndentStyle: () => Bse, + IndexFlags: () => eY, + IndexKind: () => nY, + InferenceFlags: () => aY, + InferencePriority: () => sY, + InlayHintKind: () => Rse, + InlayHints: () => XH, + InternalEmitFlags: () => SY, + InternalNodeBuilderFlags: () => UQ, + InternalSymbolName: () => QQ, + IntersectionFlags: () => JQ, + InvalidatedProjectKind: () => dse, + JSDocParsingMode: () => wY, + JsDoc: () => Ev, + JsTyping: () => t1, + JsxEmit: () => pY, + JsxFlags: () => NQ, + JsxReferenceKind: () => tY, + LanguageFeatureMinimumTarget: () => El, + LanguageServiceMode: () => Lse, + LanguageVariant: () => hY, + LexicalEnvironmentFlags: () => CY, + ListFormat: () => EY, + LogLevel: () => vQ, + MapCode: () => QH, + MemberOverrideStatus: () => jQ, + ModifierFlags: () => KR, + ModuleDetectionKind: () => lY, + ModuleInstanceState: () => mne, + ModuleKind: () => TC, + ModuleResolutionKind: () => SC, + ModuleSpecifierEnding: () => jee, + NavigateTo: () => ooe, + NavigationBar: () => loe, + NewLineKind: () => mY, + NodeBuilderFlags: () => WQ, + NodeCheckFlags: () => sj, + NodeFactoryFlags: () => mte, + NodeFlags: () => ZR, + NodeResolutionFeatures: () => sne, + ObjectFlags: () => oj, + OperationCanceledException: () => lD, + OperatorPrecedence: () => UK, + OrganizeImports: () => Dv, + OrganizeImportsMode: () => dV, + OuterExpressionKinds: () => kY, + OutliningElementsCollector: () => ZH, + OutliningSpanKind: () => zse, + OutputFileType: () => Wse, + PackageJsonAutoImportPreference: () => Ose, + PackageJsonDependencyGroup: () => Fse, + PatternMatchKind: () => Cq, + PollingInterval: () => pj, + PollingWatchKind: () => fY, + PragmaKindFlags: () => DY, + PredicateSemantics: () => AQ, + PreparePasteEdits: () => pG, + PrivateIdentifierKind: () => Cte, + ProcessLevel: () => Une, + ProgramUpdateLevel: () => Tie, + QuotePreference: () => mae, + RegularExpressionFlags: () => IQ, + RelationComparisonResult: () => ej, + Rename: () => LL, + ScriptElementKind: () => qse, + ScriptElementKindModifier: () => Hse, + ScriptKind: () => lj, + ScriptSnapshot: () => u9, + ScriptTarget: () => gY, + SemanticClassificationFormat: () => Mse, + SemanticMeaning: () => $se, + SemicolonPreference: () => gV, + SignatureCheckMode: () => NW, + SignatureFlags: () => cj, + SignatureHelp: () => D8, + SignatureInfo: () => Mie, + SignatureKind: () => rY, + SmartSelectionRange: () => tG, + SnippetKind: () => _j, + StatisticType: () => xse, + StructureIsReused: () => nj, + SymbolAccessibility: () => HQ, + SymbolDisplay: () => O0, + SymbolDisplayPartKind: () => f9, + SymbolFlags: () => ij, + SymbolFormatFlags: () => qQ, + SyntaxKind: () => YR, + Ternary: () => oY, + ThrottledCancellationToken: () => hce, + TokenClass: () => Vse, + TokenFlags: () => FQ, + TransformFlags: () => uj, + TypeFacts: () => wW, + TypeFlags: () => aj, + TypeFormatFlags: () => VQ, + TypeMapKind: () => iY, + TypePredicateKind: () => GQ, + TypeReferenceSerializationKind: () => $Q, + UnionReduction: () => BQ, + UpToDateStatusType: () => ose, + VarianceFlags: () => YQ, + Version: () => xd, + VersionRange: () => t7, + WatchDirectoryFlags: () => yY, + WatchDirectoryKind: () => _Y, + WatchFileKind: () => uY, + WatchLogLevel: () => kie, + WatchType: () => Fl, + accessPrivateIdentifier: () => jne, + addEmitFlags: () => gm, + addEmitHelper: () => jx, + addEmitHelpers: () => Wg, + addInternalEmitFlags: () => bS, + addNodeFactoryPatcher: () => a0e, + addObjectAllocatorPatcher: () => Vhe, + addRange: () => In, + addRelatedInfo: () => zs, + addSyntheticLeadingComment: () => Uy, + addSyntheticTrailingComment: () => C4, + addToSeen: () => Jp, + advancedAsyncSuperHelper: () => bF, + affectsDeclarationPathOptionDeclarations: () => Nre, + affectsEmitOptionDeclarations: () => Pre, + allKeysStartWithDot: () => dO, + altDirectorySeparator: () => o7, + and: () => ZI, + append: () => Er, + appendIfUnique: () => dh, + arrayFrom: () => is, + arrayIsEqualTo: () => Tf, + arrayIsHomogeneous: () => Hee, + arrayOf: () => sQ, + arrayReverseIterator: () => NR, + arrayToMap: () => hC, + arrayToMultiMap: () => BP, + arrayToNumericMap: () => oQ, + assertType: () => bge, + assign: () => H2, + asyncSuperHelper: () => vF, + attachFileToDiagnostics: () => Px, + base64decode: () => uee, + base64encode: () => lee, + binarySearch: () => py, + binarySearchKey: () => $T, + bindSourceFile: () => yne, + breakIntoCharacterSpans: () => Kae, + breakIntoWordSpans: () => eoe, + buildLinkParts: () => xae, + buildOpts: () => tA, + buildOverload: () => Hwe, + bundlerModuleNameResolver: () => ane, + canBeConvertedToAsync: () => Aq, + canHaveDecorators: () => e2, + canHaveExportModifier: () => CN, + canHaveFlowNode: () => HC, + canHaveIllegalDecorators: () => jz, + canHaveIllegalModifiers: () => ure, + canHaveIllegalType: () => I0e, + canHaveIllegalTypeParameters: () => lre, + canHaveJSDoc: () => H3, + canHaveLocals: () => qm, + canHaveModifiers: () => Vp, + canHaveModuleSpecifier: () => AK, + canHaveSymbol: () => Ed, + canIncludeBindAndCheckDiagnostics: () => m4, + canJsonReportNoInputFiles: () => oA, + canProduceDiagnostics: () => gA, + canUsePropertyAccess: () => WJ, + canWatchAffectingLocation: () => Kie, + canWatchAtTypes: () => Zie, + canWatchDirectoryOrFile: () => AU, + canWatchDirectoryOrFilePath: () => AA, + cartesianProduct: () => hQ, + cast: () => Us, + chainBundle: () => Ld, + chainDiagnosticMessages: () => Ts, + changeAnyExtension: () => HP, + changeCompilerHostLikeToUseCache: () => ow, + changeExtension: () => S0, + changeFullExtension: () => u7, + changesAffectModuleResolution: () => R7, + changesAffectingProgramStructure: () => UZ, + characterCodeToRegularExpressionFlag: () => kj, + childIsDecorated: () => RD, + classElementOrClassElementParameterIsDecorated: () => xB, + classHasClassThisAssignment: () => qW, + classHasDeclaredOrExplicitlyAssignedName: () => HW, + classHasExplicitlyAssignedName: () => wO, + classOrConstructorParameterIsDecorated: () => g0, + classicNameResolver: () => pne, + classifier: () => Sce, + cleanExtendedConfigCache: () => OO, + clear: () => Ap, + clearMap: () => B_, + clearSharedExtendedConfigFileWatcher: () => aU, + climbPastPropertyAccess: () => m9, + clone: () => cQ, + cloneCompilerOptions: () => MV, + closeFileWatcher: () => od, + closeFileWatcherOf: () => gp, + codefix: () => Ou, + collapseTextChangeRangesAcrossMultipleVersions: () => tZ, + collectExternalModuleInfo: () => zW, + combine: () => GT, + combinePaths: () => On, + commandLineOptionOfCustomType: () => Fre, + commentPragmas: () => i7, + commonOptionsWithBuild: () => GF, + compact: () => RP, + compareBooleans: () => j1, + compareDataObjects: () => gJ, + compareDiagnostics: () => c4, + compareEmitHelpers: () => Dte, + compareNumberOfDirectorySeparators: () => SN, + comparePaths: () => gh, + comparePathsCaseInsensitive: () => Vge, + comparePathsCaseSensitive: () => Uge, + comparePatternKeys: () => SW, + compareProperties: () => pQ, + compareStringsCaseInsensitive: () => zP, + compareStringsCaseInsensitiveEslintCompatible: () => uQ, + compareStringsCaseSensitive: () => _u, + compareStringsCaseSensitiveUI: () => WP, + compareTextSpans: () => QI, + compareValues: () => ho, + compilerOptionsAffectDeclarationPath: () => Iee, + compilerOptionsAffectEmit: () => Aee, + compilerOptionsAffectSemanticDiagnostics: () => Nee, + compilerOptionsDidYouMeanDiagnostics: () => YF, + compilerOptionsIndicateEsModules: () => WV, + computeCommonSourceDirectoryOfFilenames: () => Cie, + computeLineAndCharacterOfPosition: () => CC, + computeLineOfPosition: () => dD, + computeLineStarts: () => nx, + computePositionOfLineAndCharacter: () => d7, + computeSignatureWithDiagnostics: () => CU, + computeSuggestionDiagnostics: () => wq, + computedOptions: () => l4, + concatenate: () => Bi, + concatenateDiagnosticMessageChains: () => xee, + consumesNodeCoreModules: () => U9, + contains: () => ms, + containsIgnoredPath: () => y4, + containsObjectRestOrSpread: () => YN, + containsParseError: () => fx, + containsPath: () => np, + convertCompilerOptionsForTelemetry: () => $re, + convertCompilerOptionsFromJson: () => zye, + convertJsonOption: () => LS, + convertToBase64: () => cee, + convertToJson: () => iA, + convertToObject: () => Wre, + convertToOptionsWithAbsolutePaths: () => tO, + convertToRelativePath: () => fD, + convertToTSConfig: () => iW, + convertTypeAcquisitionFromJson: () => Wye, + copyComments: () => VS, + copyEntries: () => j7, + copyLeadingComments: () => Y6, + copyProperties: () => RR, + copyTrailingAsLeadingComments: () => ZA, + copyTrailingComments: () => xw, + couldStartTrivia: () => zY, + countWhere: () => l0, + createAbstractBuilder: () => $ve, + createAccessorPropertyBackingField: () => zz, + createAccessorPropertyGetRedirector: () => yre, + createAccessorPropertySetRedirector: () => vre, + createBaseNodeFactory: () => ute, + createBinaryExpressionTrampoline: () => WF, + createBuilderProgram: () => EU, + createBuilderProgramUsingIncrementalBuildInfo: () => Xie, + createBuilderStatusReporter: () => r9, + createCacheableExportInfoMap: () => hq, + createCachedDirectoryStructureHost: () => IO, + createClassifier: () => k2e, + createCommentDirectivesMap: () => XZ, + createCompilerDiagnostic: () => Yo, + createCompilerDiagnosticForInvalidCustomType: () => Ore, + createCompilerDiagnosticFromMessageChain: () => z5, + createCompilerHost: () => Eie, + createCompilerHostFromProgramHost: () => HU, + createCompilerHostWorker: () => LO, + createDetachedDiagnostic: () => wx, + createDiagnosticCollection: () => ZD, + createDiagnosticForFileFromMessageChain: () => yB, + createDiagnosticForNode: () => sn, + createDiagnosticForNodeArray: () => jC, + createDiagnosticForNodeArrayFromMessageChain: () => k3, + createDiagnosticForNodeFromMessageChain: () => Fg, + createDiagnosticForNodeInSourceFile: () => sp, + createDiagnosticForRange: () => lK, + createDiagnosticMessageChainFromDiagnostic: () => cK, + createDiagnosticReporter: () => lk, + createDocumentPositionMapper: () => Fne, + createDocumentRegistry: () => Wae, + createDocumentRegistryInternal: () => Tq, + createEmitAndSemanticDiagnosticsBuilderProgram: () => NU, + createEmitHelperFactory: () => Ete, + createEmptyExports: () => UN, + createEvaluator: () => rte, + createExpressionForJsxElement: () => nre, + createExpressionForJsxFragment: () => ire, + createExpressionForObjectLiteralElementLike: () => sre, + createExpressionForPropertyName: () => Iz, + createExpressionFromEntityName: () => VN, + createExternalHelpersImportDeclarationIfNeeded: () => Lz, + createFileDiagnostic: () => ll, + createFileDiagnosticFromMessageChain: () => $7, + createFlowNode: () => tg, + createForOfBindingStatement: () => Az, + createFutureSourceFile: () => X9, + createGetCanonicalFileName: () => Zl, + createGetIsolatedDeclarationErrors: () => fie, + createGetSourceFile: () => _U, + createGetSymbolAccessibilityDiagnosticForNode: () => gv, + createGetSymbolAccessibilityDiagnosticForNodeName: () => _ie, + createGetSymbolWalker: () => vne, + createIncrementalCompilerHost: () => t9, + createIncrementalProgram: () => ase, + createJsxFactoryExpression: () => Nz, + createLanguageService: () => yce, + createLanguageServiceSourceFile: () => dL, + createMemberAccessForPropertyName: () => FS, + createModeAwareCache: () => N6, + createModeAwareCacheKey: () => H4, + createModeMismatchDetails: () => rB, + createModuleNotFoundChain: () => J7, + createModuleResolutionCache: () => A6, + createModuleResolutionLoader: () => hU, + createModuleResolutionLoaderUsingGlobalCache: () => nse, + createModuleSpecifierResolutionHost: () => bv, + createMultiMap: () => Fp, + createNameResolver: () => GJ, + createNodeConverters: () => pte, + createNodeFactory: () => NN, + createOptionNameMap: () => XF, + createOverload: () => mG, + createPackageJsonImportFilter: () => Z6, + createPackageJsonInfo: () => lq, + createParenthesizerRules: () => _te, + createPatternMatcher: () => Gae, + createPrinter: () => Ky, + createPrinterWithDefaults: () => bie, + createPrinterWithRemoveComments: () => i2, + createPrinterWithRemoveCommentsNeverAsciiEscape: () => Sie, + createPrinterWithRemoveCommentsOmitTrailingSemicolon: () => sU, + createProgram: () => wA, + createProgramDiagnostics: () => Oie, + createProgramHost: () => GU, + createPropertyNameNodeForIdentifierOrLiteral: () => kN, + createQueue: () => JP, + createRange: () => cp, + createRedirectedBuilderProgram: () => PU, + createResolutionCache: () => FU, + createRuntimeTypeSerializer: () => $ne, + createScanner: () => Dg, + createSemanticDiagnosticsBuilderProgram: () => Gve, + createSet: () => jR, + createSolutionBuilder: () => _se, + createSolutionBuilderHost: () => lse, + createSolutionBuilderWithWatch: () => fse, + createSolutionBuilderWithWatchHost: () => use, + createSortedArray: () => PR, + createSourceFile: () => ek, + createSourceMapGenerator: () => wne, + createSourceMapSource: () => u0e, + createSuperAccessVariableStatement: () => NO, + createSymbolTable: () => Bs, + createSymlinkCache: () => EJ, + createSyntacticTypeNodeBuilder: () => Nse, + createSystemWatchFunctions: () => FY, + createTextChange: () => qA, + createTextChangeFromStartLength: () => w9, + createTextChangeRange: () => r3, + createTextRangeFromNode: () => BV, + createTextRangeFromSpan: () => D9, + createTextSpan: () => Kl, + createTextSpanFromBounds: () => Nc, + createTextSpanFromNode: () => u_, + createTextSpanFromRange: () => A0, + createTextSpanFromStringLiteralLikeContent: () => jV, + createTextWriter: () => nN, + createTokenRange: () => _J, + createTypeChecker: () => Ene, + createTypeReferenceDirectiveResolutionCache: () => _O, + createTypeReferenceResolutionLoader: () => jO, + createWatchCompilerHost: () => ibe, + createWatchCompilerHostOfConfigFile: () => $U, + createWatchCompilerHostOfFilesAndCompilerOptions: () => XU, + createWatchFactory: () => qU, + createWatchHost: () => VU, + createWatchProgram: () => QU, + createWatchStatusReporter: () => OU, + createWriteFileMeasuringIO: () => fU, + declarationNameToString: () => co, + decodeMappings: () => jW, + decodedTextSpanIntersectsWith: () => t3, + deduplicate: () => hb, + defaultHoverMaximumTruncationLength: () => zZ, + defaultInitCompilerOptions: () => oye, + defaultMaximumTruncationLength: () => ND, + diagnosticCategoryName: () => $2, + diagnosticToString: () => l2, + diagnosticsEqualityComparer: () => W5, + directoryProbablyExists: () => Pd, + directorySeparator: () => So, + displayPart: () => W_, + displayPartsToString: () => _8, + disposeEmitNodes: () => iz, + documentSpansEqual: () => XV, + dumpTracingLegend: () => PQ, + elementAt: () => fy, + elideNodes: () => hre, + emitDetachedComments: () => ZK, + emitFiles: () => nU, + emitFilesAndReportErrors: () => YO, + emitFilesAndReportErrorsAndGetExitStatus: () => UU, + emitModuleKindIsNonNodeESM: () => hN, + emitNewLineBeforeLeadingCommentOfPosition: () => YK, + emitResolverSkipsTypeChecking: () => rU, + emitSkippedWithNoDiagnostics: () => bU, + emptyArray: () => Ge, + emptyFileSystemEntries: () => OJ, + emptyMap: () => SR, + emptyOptions: () => qp, + endsWith: () => wo, + ensurePathIsNonModuleName: () => X2, + ensureScriptKind: () => Z5, + ensureTrailingDirectorySeparator: () => gl, + entityNameToString: () => ef, + enumerateInsertsAndDeletes: () => e7, + equalOwnProperties: () => aQ, + equateStringsCaseInsensitive: () => hy, + equateStringsCaseSensitive: () => bb, + equateValues: () => gy, + escapeJsxAttributeString: () => GB, + escapeLeadingUnderscores: () => tc, + escapeNonAsciiString: () => S5, + escapeSnippetText: () => Vb, + escapeString: () => Ym, + escapeTemplateSubstitution: () => qB, + evaluatorResult: () => yl, + every: () => Ni, + exclusivelyPrefixedNodeCoreModules: () => pF, + executeCommandLine: () => Rbe, + expandPreOrPostfixIncrementOrDecrementExpression: () => RF, + explainFiles: () => jU, + explainIfFileIsRedirectAndImpliedFormat: () => BU, + exportAssignmentIsAlias: () => Q3, + expressionResultIsUnused: () => $ee, + extend: () => MR, + extensionFromPath: () => p4, + extensionIsTS: () => nF, + extensionsNotSupportingExtensionlessResolution: () => rF, + externalHelpersModuleNameText: () => Py, + factory: () => N, + fileExtensionIs: () => Xo, + fileExtensionIsOneOf: () => xc, + fileIncludeReasonToDiagnostics: () => WU, + fileShouldUseJavaScriptRequire: () => gq, + filter: () => kn, + filterMutate: () => kR, + filterSemanticDiagnostics: () => WO, + find: () => Nn, + findAncestor: () => dr, + findBestPatternMatch: () => VR, + findChildOfKind: () => Ya, + findComputedPropertyNameCacheAssignment: () => UF, + findConfigFile: () => lU, + findConstructorDeclaration: () => wN, + findContainingList: () => b9, + findDiagnosticForNode: () => Fae, + findFirstNonJsxWhitespaceToken: () => rae, + findIndex: () => oc, + findLast: () => gb, + findLastIndex: () => GI, + findListItemInfo: () => tae, + findModifier: () => $6, + findNextToken: () => c2, + findPackageJson: () => Iae, + findPackageJsons: () => cq, + findPrecedingMatchingToken: () => C9, + findPrecedingToken: () => pl, + findSuperStatementIndexPath: () => kO, + findTokenOnLeftOfPosition: () => gw, + findUseStrictPrologue: () => Oz, + first: () => Ca, + firstDefined: () => Lc, + firstDefinedIterator: () => MP, + firstIterator: () => IR, + firstOrOnly: () => fq, + firstOrUndefined: () => Yc, + firstOrUndefinedIterator: () => XI, + fixupCompilerOptions: () => Iq, + flatMap: () => ka, + flatMapIterator: () => CR, + flatMapToMutable: () => KE, + flatten: () => Ip, + flattenCommaList: () => bre, + flattenDestructuringAssignment: () => BS, + flattenDestructuringBinding: () => n2, + flattenDiagnosticMessageText: () => km, + forEach: () => lr, + forEachAncestor: () => VZ, + forEachAncestorDirectory: () => pD, + forEachAncestorDirectoryStoppingAtGlobalCache: () => eg, + forEachChild: () => xs, + forEachChildRecursively: () => Kx, + forEachDynamicImportOrRequireCall: () => dF, + forEachEmittedFile: () => ZW, + forEachEnclosingBlockScopeContainer: () => sK, + forEachEntry: () => hl, + forEachExternalModuleToImportFrom: () => vq, + forEachImportClauseDeclaration: () => IK, + forEachKey: () => Ag, + forEachLeadingCommentRange: () => XP, + forEachNameInAccessChainWalkingLeft: () => yee, + forEachNameOfDefaultExport: () => Y9, + forEachOptionsSyntaxByName: () => KJ, + forEachProjectReference: () => x4, + forEachPropertyAssignment: () => zC, + forEachResolvedProjectReference: () => YJ, + forEachReturnStatement: () => Fy, + forEachRight: () => YX, + forEachTrailingCommentRange: () => QP, + forEachTsConfigPropArray: () => P3, + forEachUnique: () => YV, + forEachYieldExpression: () => pK, + formatColorAndReset: () => s2, + formatDiagnostic: () => pU, + formatDiagnostics: () => Sve, + formatDiagnosticsWithColorAndContext: () => Nie, + formatGeneratedName: () => _v, + formatGeneratedNamePart: () => E6, + formatLocation: () => dU, + formatMessage: () => Nx, + formatStringFromArgs: () => jg, + formatting: () => nl, + generateDjb2Hash: () => uD, + generateTSConfig: () => Ure, + getAdjustedReferenceLocation: () => NV, + getAdjustedRenameLocation: () => T9, + getAliasDeclarationFromName: () => LB, + getAllAccessorDeclarations: () => Bb, + getAllDecoratorsOfClass: () => UW, + getAllDecoratorsOfClassElement: () => EO, + getAllJSDocTags: () => S7, + getAllJSDocTagsOfKind: () => phe, + getAllKeys: () => gge, + getAllProjectOutputs: () => AO, + getAllSuperTypeNodes: () => HD, + getAllowImportingTsExtensions: () => Cee, + getAllowJSCompilerOption: () => Jy, + getAllowSyntheticDefaultImports: () => Ax, + getAncestor: () => Q1, + getAnyExtensionFromPath: () => ex, + getAreDeclarationMapsEnabled: () => U5, + getAssignedExpandoInitializer: () => mx, + getAssignedName: () => y7, + getAssignmentDeclarationKind: () => Ac, + getAssignmentDeclarationPropertyAccessKind: () => z3, + getAssignmentTargetKind: () => Oy, + getAutomaticTypeDirectiveNames: () => lO, + getBaseFileName: () => Zc, + getBinaryOperatorPrecedence: () => eN, + getBuildInfo: () => iU, + getBuildInfoFileVersionMap: () => wU, + getBuildInfoText: () => yie, + getBuildOrderFromAnyBuildOrder: () => FA, + getBuilderCreationParameters: () => HO, + getBuilderFileEmit: () => e1, + getCanonicalDiagnostic: () => uK, + getCheckFlags: () => uc, + getClassExtendsHeritageElement: () => Lb, + getClassLikeDeclarationOfSymbol: () => Eh, + getCombinedLocalAndExportSymbolFlags: () => t6, + getCombinedModifierFlags: () => J1, + getCombinedNodeFlags: () => yh, + getCombinedNodeFlagsAlwaysIncludeJSDoc: () => Nj, + getCommentRange: () => hm, + getCommonSourceDirectory: () => aw, + getCommonSourceDirectoryOfConfig: () => JS, + getCompilerOptionValue: () => H5, + getConditions: () => Qy, + getConfigFileParsingDiagnostics: () => a2, + getConstantValue: () => yte, + getContainerFlags: () => xW, + getContainerNode: () => US, + getContainingClass: () => Wl, + getContainingClassExcludingClassDecorators: () => r5, + getContainingClassStaticBlock: () => SK, + getContainingFunction: () => Af, + getContainingFunctionDeclaration: () => bK, + getContainingFunctionOrClassStaticBlock: () => t5, + getContainingNodeArray: () => Xee, + getContainingObjectLiteralElement: () => f8, + getContextualTypeFromParent: () => R9, + getContextualTypeFromParentOrAncestorTypeNode: () => S9, + getDeclarationDiagnostics: () => pie, + getDeclarationEmitExtensionForPath: () => k5, + getDeclarationEmitOutputFilePath: () => GK, + getDeclarationEmitOutputFilePathWorker: () => x5, + getDeclarationFileExtension: () => qF, + getDeclarationFromName: () => qD, + getDeclarationModifierFlagsFromSymbol: () => up, + getDeclarationOfKind: () => Oo, + getDeclarationsOfKind: () => WZ, + getDeclaredExpandoInitializer: () => zD, + getDecorators: () => Ty, + getDefaultCompilerOptions: () => pL, + getDefaultFormatCodeSettings: () => _9, + getDefaultLibFileName: () => ZP, + getDefaultLibFilePath: () => vce, + getDefaultLikeExportInfo: () => Q9, + getDefaultLikeExportNameFromDeclaration: () => pq, + getDefaultResolutionModeForFileWorker: () => zO, + getDiagnosticText: () => D_, + getDiagnosticsWithinSpan: () => Oae, + getDirectoryPath: () => Hn, + getDirectoryToWatchFailedLookupLocation: () => IU, + getDirectoryToWatchFailedLookupLocationFromTypeRoot: () => tse, + getDocumentPositionMapper: () => Dq, + getDocumentSpansEqualityComparer: () => QV, + getESModuleInterop: () => mm, + getEditsForFileRename: () => Vae, + getEffectiveBaseTypeNode: () => wd, + getEffectiveConstraintOfTypeParameter: () => PC, + getEffectiveContainerForJSDocTemplateTag: () => d5, + getEffectiveImplementsTypeNodes: () => $C, + getEffectiveInitializer: () => j3, + getEffectiveJSDocHost: () => X1, + getEffectiveModifierFlags: () => pu, + getEffectiveModifierFlagsAlwaysIncludeJSDoc: () => ree, + getEffectiveModifierFlagsNoCache: () => nee, + getEffectiveReturnTypeNode: () => nf, + getEffectiveSetAccessorTypeAnnotationNode: () => tJ, + getEffectiveTypeAnnotationNode: () => Kc, + getEffectiveTypeParameterDeclarations: () => xy, + getEffectiveTypeRoots: () => q4, + getElementOrPropertyAccessArgumentExpressionOrName: () => p5, + getElementOrPropertyAccessName: () => Sh, + getElementsOfBindingOrAssignmentPattern: () => C6, + getEmitDeclarations: () => J_, + getEmitFlags: () => Ea, + getEmitHelpers: () => sz, + getEmitModuleDetectionKind: () => Eee, + getEmitModuleFormatOfFileWorker: () => uw, + getEmitModuleKind: () => Hu, + getEmitModuleResolutionKind: () => Pu, + getEmitScriptTarget: () => da, + getEmitStandardClassFields: () => kJ, + getEnclosingBlockScopeContainer: () => Dd, + getEnclosingContainer: () => G7, + getEncodedSemanticClassifications: () => bq, + getEncodedSyntacticClassifications: () => Sq, + getEndLinePosition: () => v3, + getEntityNameFromTypeNode: () => I3, + getEntrypointsFromPackageJsonInfo: () => yW, + getErrorCountForSummary: () => XO, + getErrorSpanForNode: () => aS, + getErrorSummaryText: () => MU, + getEscapedTextOfIdentifierOrLiteral: () => XD, + getEscapedTextOfJsxAttributeName: () => S4, + getEscapedTextOfJsxNamespacedName: () => Lx, + getExpandoInitializer: () => G1, + getExportAssignmentExpression: () => MB, + getExportInfoMap: () => i8, + getExportNeedsImportStarHelper: () => One, + getExpressionAssociativity: () => UB, + getExpressionPrecedence: () => YD, + getExternalHelpersModuleName: () => HN, + getExternalModuleImportEqualsDeclarationExpression: () => jD, + getExternalModuleName: () => hx, + getExternalModuleNameFromDeclaration: () => qK, + getExternalModuleNameFromPath: () => QB, + getExternalModuleNameLiteral: () => Zx, + getExternalModuleRequireArgument: () => CB, + getFallbackOptions: () => CA, + getFileEmitOutput: () => Lie, + getFileMatcherPatterns: () => Y5, + getFileNamesFromConfigSpecs: () => U4, + getFileWatcherEventKind: () => gj, + getFilesInErrorForSummary: () => QO, + getFirstConstructorWithBody: () => Mg, + getFirstIdentifier: () => i_, + getFirstNonSpaceCharacterPosition: () => Eae, + getFirstProjectOutput: () => tU, + getFixableErrorSpanExpression: () => uq, + getFormatCodeSettingsForWriting: () => G9, + getFullWidth: () => h3, + getFunctionFlags: () => Mc, + getHeritageClause: () => Y3, + getHostSignatureFromJSDoc: () => $1, + getIdentifierAutoGenerate: () => p0e, + getIdentifierGeneratedImportReference: () => kte, + getIdentifierTypeArguments: () => SS, + getImmediatelyInvokedFunctionExpression: () => q1, + getImpliedNodeFormatForEmitWorker: () => zS, + getImpliedNodeFormatForFile: () => DA, + getImpliedNodeFormatForFileWorker: () => JO, + getImportNeedsImportDefaultHelper: () => JW, + getImportNeedsImportStarHelper: () => TO, + getIndentString: () => T5, + getInferredLibraryNameResolveFrom: () => BO, + getInitializedVariables: () => s4, + getInitializerOfBinaryExpression: () => PB, + getInitializerOfBindingOrAssignmentElement: () => $N, + getInterfaceBaseTypeNodes: () => GD, + getInternalEmitFlags: () => sd, + getInvokedExpression: () => s5, + getIsFileExcluded: () => Bae, + getIsolatedModules: () => zp, + getJSDocAugmentsTag: () => _Z, + getJSDocClassTag: () => Fj, + getJSDocCommentRanges: () => bB, + getJSDocCommentsAndTags: () => NB, + getJSDocDeprecatedTag: () => Oj, + getJSDocDeprecatedTagNoCache: () => yZ, + getJSDocEnumTag: () => Lj, + getJSDocHost: () => Fb, + getJSDocImplementsTags: () => fZ, + getJSDocOverloadTags: () => IB, + getJSDocOverrideTagNoCache: () => hZ, + getJSDocParameterTags: () => wC, + getJSDocParameterTagsNoCache: () => oZ, + getJSDocPrivateTag: () => lhe, + getJSDocPrivateTagNoCache: () => dZ, + getJSDocProtectedTag: () => uhe, + getJSDocProtectedTagNoCache: () => mZ, + getJSDocPublicTag: () => che, + getJSDocPublicTagNoCache: () => pZ, + getJSDocReadonlyTag: () => _he, + getJSDocReadonlyTagNoCache: () => gZ, + getJSDocReturnTag: () => vZ, + getJSDocReturnType: () => i3, + getJSDocRoot: () => GC, + getJSDocSatisfiesExpressionType: () => VJ, + getJSDocSatisfiesTag: () => Mj, + getJSDocTags: () => W1, + getJSDocTemplateTag: () => fhe, + getJSDocThisTag: () => v7, + getJSDocType: () => f0, + getJSDocTypeAliasName: () => Rz, + getJSDocTypeAssertionType: () => x6, + getJSDocTypeParameterDeclarations: () => P5, + getJSDocTypeParameterTags: () => cZ, + getJSDocTypeParameterTagsNoCache: () => lZ, + getJSDocTypeTag: () => z1, + getJSXImplicitImportBase: () => yN, + getJSXRuntimeImport: () => $5, + getJSXTransformEnabled: () => G5, + getKeyForCompilerOptions: () => pW, + getLanguageVariant: () => fN, + getLastChild: () => hJ, + getLeadingCommentRanges: () => Eg, + getLeadingCommentRangesOfNode: () => vB, + getLeftmostAccessExpression: () => r6, + getLeftmostExpression: () => n6, + getLibFileNameFromLibReference: () => QJ, + getLibNameFromLibReference: () => XJ, + getLibraryNameFromLibFileName: () => yU, + getLineAndCharacterOfPosition: () => js, + getLineInfo: () => RW, + getLineOfLocalPosition: () => KD, + getLineStartPositionForPosition: () => Hp, + getLineStarts: () => kg, + getLinesBetweenPositionAndNextNonWhitespaceCharacter: () => mee, + getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter: () => dee, + getLinesBetweenPositions: () => mD, + getLinesBetweenRangeEndAndRangeStart: () => fJ, + getLinesBetweenRangeEndPositions: () => Whe, + getLiteralText: () => ZZ, + getLocalNameForExternalImport: () => k6, + getLocalSymbolForExportDefault: () => n4, + getLocaleSpecificMessage: () => Ss, + getLocaleTimeString: () => IA, + getMappedContextSpan: () => ZV, + getMappedDocumentSpan: () => O9, + getMappedLocation: () => bw, + getMatchedFileSpec: () => JU, + getMatchedIncludeSpec: () => zU, + getMeaningFromDeclaration: () => p9, + getMeaningFromLocation: () => WS, + getMembersOfDeclaration: () => dK, + getModeForFileReference: () => Aie, + getModeForResolutionAtIndex: () => Dve, + getModeForUsageLocation: () => gU, + getModifiedTime: () => KT, + getModifiers: () => Tb, + getModuleInstanceState: () => Ah, + getModuleNameStringLiteralAt: () => PA, + getModuleSpecifierEndingPreference: () => Bee, + getModuleSpecifierResolverHost: () => UV, + getNameForExportedSymbol: () => V9, + getNameFromImportAttribute: () => uF, + getNameFromIndexInfo: () => aK, + getNameFromPropertyName: () => GA, + getNameOfAccessExpression: () => vJ, + getNameOfCompilerOptionValue: () => eO, + getNameOfDeclaration: () => _s, + getNameOfExpando: () => EB, + getNameOfJSDocTypedef: () => aZ, + getNameOfScriptTarget: () => q5, + getNameOrArgument: () => J3, + getNameTable: () => nH, + getNamespaceDeclarationNode: () => qC, + getNewLineCharacter: () => v0, + getNewLineKind: () => n8, + getNewLineOrDefaultFromHost: () => Fh, + getNewTargetContainer: () => xK, + getNextJSDocCommentLocation: () => AB, + getNodeChildren: () => wz, + getNodeForGeneratedName: () => QN, + getNodeId: () => Ma, + getNodeKind: () => o2, + getNodeModifiers: () => hw, + getNodeModulePathParts: () => oF, + getNonAssignedNameOfDeclaration: () => h7, + getNonAssignmentOperatorForCompoundAssignment: () => K4, + getNonAugmentationDeclaration: () => fB, + getNonDecoratorTokenPosOfNode: () => aB, + getNonIncrementalBuildInfoRoots: () => Qie, + getNonModifierTokenPosOfNode: () => QZ, + getNormalizedAbsolutePath: () => Qi, + getNormalizedAbsolutePathWithoutRoot: () => bj, + getNormalizedPathComponents: () => l7, + getObjectFlags: () => Dn, + getOperatorAssociativity: () => VB, + getOperatorPrecedence: () => K3, + getOptionFromName: () => Kz, + getOptionsForLibraryResolution: () => dW, + getOptionsNameMap: () => w6, + getOptionsSyntaxByArrayElementValue: () => ZJ, + getOptionsSyntaxByValue: () => ote, + getOrCreateEmitNode: () => mu, + getOrUpdate: () => eD, + getOriginalNode: () => Vo, + getOriginalNodeId: () => l_, + getOutputDeclarationFileName: () => sw, + getOutputDeclarationFileNameWorker: () => KW, + getOutputExtension: () => TA, + getOutputFileNames: () => vve, + getOutputJSFileNameWorker: () => eU, + getOutputPathsFor: () => iw, + getOwnEmitOutputFilePath: () => HK, + getOwnKeys: () => rm, + getOwnValues: () => XT, + getPackageJsonTypesVersionsPaths: () => cO, + getPackageNameFromTypesPackageName: () => X4, + getPackageScopeForPath: () => $4, + getParameterSymbolFromJSDoc: () => G3, + getParentNodeInSpan: () => XA, + getParseTreeNode: () => vs, + getParsedCommandLineOfConfigFile: () => rA, + getPathComponents: () => fu, + getPathFromPathComponents: () => B1, + getPathUpdater: () => kq, + getPathsBasePath: () => C5, + getPatternFromSpec: () => PJ, + getPendingEmitKindWithSeen: () => qO, + getPositionOfLineAndCharacter: () => GP, + getPossibleGenericSignatures: () => IV, + getPossibleOriginalInputExtensionForExtension: () => YB, + getPossibleOriginalInputPathWithoutChangingExt: () => ZB, + getPossibleTypeArgumentsInfo: () => FV, + getPreEmitDiagnostics: () => bve, + getPrecedingNonSpaceCharacterPosition: () => L9, + getPrivateIdentifier: () => VW, + getProperties: () => WW, + getProperty: () => jP, + getPropertyAssignmentAliasLikeExpression: () => BK, + getPropertyNameForPropertyNameNode: () => dS, + getPropertyNameFromType: () => fp, + getPropertyNameOfBindingOrAssignmentElement: () => Mz, + getPropertySymbolFromBindingElement: () => F9, + getPropertySymbolsFromContextualType: () => mL, + getQuoteFromPreference: () => qV, + getQuotePreference: () => _f, + getRangesWhere: () => wR, + getRefactorContextSpan: () => pk, + getReferencedFileLocation: () => lw, + getRegexFromPattern: () => b0, + getRegularExpressionForWildcard: () => u4, + getRegularExpressionsForWildcards: () => X5, + getRelativePathFromDirectory: () => Nf, + getRelativePathFromFile: () => kC, + getRelativePathToDirectoryOrUrl: () => rx, + getRenameLocation: () => YA, + getReplacementSpanForContextToken: () => RV, + getResolutionDiagnostic: () => TU, + getResolutionModeOverride: () => R6, + getResolveJsonModule: () => zb, + getResolvePackageJsonExports: () => dN, + getResolvePackageJsonImports: () => mN, + getResolvedExternalModuleName: () => XB, + getResolvedModuleFromResolution: () => _x, + getResolvedTypeReferenceDirectiveFromResolution: () => B7, + getRestIndicatorOfBindingOrAssignmentElement: () => JF, + getRestParameterElementType: () => SB, + getRightMostAssignedExpression: () => B3, + getRootDeclaration: () => _m, + getRootDirectoryOfResolutionCache: () => rse, + getRootLength: () => kd, + getScriptKind: () => rq, + getScriptKindFromFileName: () => K5, + getScriptTargetFeatures: () => oB, + getSelectedEffectiveModifierFlags: () => xx, + getSelectedSyntacticModifierFlags: () => eee, + getSemanticClassifications: () => Jae, + getSemanticJsxChildren: () => QC, + getSetAccessorTypeAnnotationNode: () => XK, + getSetAccessorValueParameter: () => e4, + getSetExternalModuleIndicator: () => pN, + getShebang: () => m7, + getSingleVariableOfVariableStatement: () => bx, + getSnapshotText: () => fk, + getSnippetElement: () => az, + getSourceFileOfModule: () => y3, + getSourceFileOfNode: () => xr, + getSourceFilePathInNewDir: () => D5, + getSourceFileVersionAsHashFromText: () => ZO, + getSourceFilesToEmit: () => E5, + getSourceMapRange: () => x0, + getSourceMapper: () => roe, + getSourceTextOfNodeFromSourceFile: () => Db, + getSpanOfTokenAtPosition: () => om, + getSpellingSuggestion: () => Sb, + getStartPositionOfLine: () => Ny, + getStartPositionOfRange: () => i4, + getStartsOnNewLine: () => k4, + getStaticPropertiesAndClassStaticBlock: () => CO, + getStrictOptionValue: () => du, + getStringComparer: () => vC, + getSubPatternFromSpec: () => Q5, + getSuperCallFromStatement: () => xO, + getSuperContainer: () => N3, + getSupportedCodeFixes: () => tH, + getSupportedExtensions: () => _4, + getSupportedExtensionsWithJsonIfResolveJsonModule: () => bN, + getSwitchedType: () => sq, + getSymbolId: () => Xs, + getSymbolNameForPrivateIdentifier: () => Z3, + getSymbolTarget: () => nq, + getSyntacticClassifications: () => zae, + getSyntacticModifierFlags: () => h0, + getSyntacticModifierFlagsNoCache: () => iJ, + getSynthesizedDeepClone: () => qa, + getSynthesizedDeepCloneWithReplacements: () => PN, + getSynthesizedDeepClones: () => qb, + getSynthesizedDeepClonesWithReplacements: () => ez, + getSyntheticLeadingComments: () => l6, + getSyntheticTrailingComments: () => ON, + getTargetLabel: () => g9, + getTargetOfBindingOrAssignmentElement: () => $y, + getTemporaryModuleResolutionState: () => G4, + getTextOfConstantValue: () => KZ, + getTextOfIdentifierOrLiteral: () => op, + getTextOfJSDocComment: () => s3, + getTextOfJsxAttributeName: () => DN, + getTextOfJsxNamespacedName: () => T4, + getTextOfNode: () => Qo, + getTextOfNodeFromSourceText: () => ID, + getTextOfPropertyName: () => dx, + getThisContainer: () => qu, + getThisParameter: () => Rb, + getTokenAtPosition: () => vi, + getTokenPosOfNode: () => Ay, + getTokenSourceMapRange: () => _0e, + getTouchingPropertyName: () => w_, + getTouchingToken: () => H6, + getTrailingCommentRanges: () => Sy, + getTrailingSemicolonDeferringWriter: () => $B, + getTransformers: () => mie, + getTsBuildInfoEmitOutputFilePath: () => hv, + getTsConfigObjectLiteralExpression: () => MD, + getTsConfigPropArrayElementValue: () => e5, + getTypeAnnotationNode: () => QK, + getTypeArgumentOrTypeParameterList: () => lae, + getTypeKeywordOfTypeOnlyImport: () => $V, + getTypeNode: () => Tte, + getTypeNodeIfAccessible: () => Cw, + getTypeParameterFromJsDoc: () => FK, + getTypeParameterOwner: () => ihe, + getTypesPackageName: () => mO, + getUILocale: () => _Q, + getUniqueName: () => qS, + getUniqueSymbolId: () => Cae, + getUseDefineForClassFields: () => gN, + getWatchErrorSummaryDiagnosticMessage: () => LU, + getWatchFactory: () => cU, + group: () => yC, + groupBy: () => LR, + guessIndentation: () => BZ, + handleNoEmitOptions: () => SU, + handleWatchOptionsConfigDirTemplateSubstitution: () => rO, + hasAbstractModifier: () => Jb, + hasAccessorModifier: () => fm, + hasAmbientModifier: () => nJ, + hasChangesInResolutions: () => nB, + hasContextSensitiveParameters: () => aF, + hasDecorators: () => Ff, + hasDocComment: () => oae, + hasDynamicName: () => Th, + hasEffectiveModifier: () => sf, + hasEffectiveModifiers: () => rJ, + hasEffectiveReadonlyModifier: () => gS, + hasExtension: () => xC, + hasImplementationTSFileExtension: () => Ree, + hasIndexSignature: () => iq, + hasInferredType: () => fF, + hasInitializer: () => d0, + hasInvalidEscape: () => HB, + hasJSDocNodes: () => kf, + hasJSDocParameterTags: () => uZ, + hasJSFileExtension: () => Bg, + hasJsonModuleEmitEnabled: () => V5, + hasOnlyExpressionInitializer: () => iS, + hasOverrideModifier: () => N5, + hasPossibleExternalModuleReference: () => iK, + hasProperty: () => eo, + hasPropertyAccessExpressionWithName: () => BA, + hasQuestionToken: () => yx, + hasRecordedExternalHelpers: () => cre, + hasResolutionModeOverride: () => ete, + hasRestParameter: () => Zj, + hasScopeMarker: () => NZ, + hasStaticModifier: () => cl, + hasSyntacticModifier: () => Gn, + hasSyntacticModifiers: () => KK, + hasTSFileExtension: () => yS, + hasTabstop: () => Yee, + hasTrailingDirectorySeparator: () => vy, + hasType: () => O7, + hasTypeArguments: () => Ihe, + hasZeroOrOneAsteriskCharacter: () => CJ, + hostGetCanonicalFileName: () => xh, + hostUsesCaseSensitiveFileNames: () => mS, + idText: () => An, + identifierIsThisKeyword: () => eJ, + identifierToKeywordKind: () => Z2, + identity: () => go, + identitySourceMapConsumer: () => BW, + ignoreSourceNewlines: () => cz, + ignoredPaths: () => a7, + importFromModuleSpecifier: () => UD, + importSyntaxAffectsModuleResolution: () => xJ, + indexOfAnyCharCode: () => KX, + indexOfNode: () => MC, + indicesOf: () => $I, + inferredTypesContainingFile: () => cw, + injectClassNamedEvaluationHelperBlockIfMissing: () => PO, + injectClassThisAssignmentIfMissing: () => Wne, + insertImports: () => GV, + insertSorted: () => _y, + insertStatementAfterCustomPrologue: () => sS, + insertStatementAfterStandardPrologue: () => Che, + insertStatementsAfterCustomPrologue: () => iB, + insertStatementsAfterStandardPrologue: () => Ig, + intersperse: () => xR, + intrinsicTagNameToString: () => qJ, + introducesArgumentsExoticObject: () => hK, + inverseJsxOptionMap: () => eA, + isAbstractConstructorSymbol: () => gee, + isAbstractModifier: () => Ote, + isAccessExpression: () => To, + isAccessibilityModifier: () => LV, + isAccessor: () => Dy, + isAccessorModifier: () => dz, + isAliasableExpression: () => m5, + isAmbientModule: () => Vu, + isAmbientPropertyDeclaration: () => dB, + isAnyDirectorySeparator: () => hj, + isAnyImportOrBareOrAccessedRequire: () => rK, + isAnyImportOrReExport: () => T3, + isAnyImportOrRequireStatement: () => nK, + isAnyImportSyntax: () => px, + isAnySupportedFileExtension: () => r0e, + isApplicableVersionedTypesKey: () => uA, + isArgumentExpressionOfElementAccess: () => kV, + isArray: () => as, + isArrayBindingElement: () => w7, + isArrayBindingOrAssignmentElement: () => _3, + isArrayBindingOrAssignmentPattern: () => Hj, + isArrayBindingPattern: () => D0, + isArrayLiteralExpression: () => nu, + isArrayLiteralOrObjectLiteralDestructuringPattern: () => N0, + isArrayTypeNode: () => jN, + isArrowFunction: () => xo, + isAsExpression: () => d6, + isAssertClause: () => Wte, + isAssertEntry: () => T0e, + isAssertionExpression: () => Eb, + isAssertsKeyword: () => Ite, + isAssignmentDeclaration: () => JD, + isAssignmentExpression: () => Nl, + isAssignmentOperator: () => kh, + isAssignmentPattern: () => wD, + isAssignmentTarget: () => Ly, + isAsteriskToken: () => MN, + isAsyncFunction: () => $D, + isAsyncModifier: () => D4, + isAutoAccessorPropertyDeclaration: () => b_, + isAwaitExpression: () => Hy, + isAwaitKeyword: () => pz, + isBigIntLiteral: () => u6, + isBinaryExpression: () => _n, + isBinaryLogicalOperator: () => iN, + isBinaryOperatorToken: () => gre, + isBindableObjectDefinePropertyCall: () => uS, + isBindableStaticAccessExpression: () => Ib, + isBindableStaticElementAccessExpression: () => f5, + isBindableStaticNameExpression: () => _S, + isBindingElement: () => ya, + isBindingElementOfBareOrAccessedRequire: () => EK, + isBindingName: () => rS, + isBindingOrAssignmentElement: () => EZ, + isBindingOrAssignmentPattern: () => l3, + isBindingPattern: () => ws, + isBlock: () => Ns, + isBlockLike: () => dk, + isBlockOrCatchScoped: () => cB, + isBlockScope: () => mB, + isBlockScopedContainerTopLevel: () => tK, + isBooleanLiteral: () => DD, + isBreakOrContinueStatement: () => xD, + isBreakStatement: () => v0e, + isBuildCommand: () => kse, + isBuildInfoFile: () => gie, + isBuilderProgram: () => RU, + isBundle: () => Hte, + isCallChain: () => K2, + isCallExpression: () => Ps, + isCallExpressionTarget: () => yV, + isCallLikeExpression: () => Cb, + isCallLikeOrFunctionLikeExpression: () => Gj, + isCallOrNewExpression: () => sm, + isCallOrNewExpressionTarget: () => vV, + isCallSignatureDeclaration: () => Ux, + isCallToHelper: () => E4, + isCaseBlock: () => O4, + isCaseClause: () => y6, + isCaseKeyword: () => Mte, + isCaseOrDefaultClause: () => I7, + isCatchClause: () => Zb, + isCatchClauseVariableDeclaration: () => Qee, + isCatchClauseVariableDeclarationOrBindingElement: () => lB, + isCheckJsEnabledForFile: () => d4, + isCircularBuildOrder: () => uk, + isClassDeclaration: () => tl, + isClassElement: () => Hc, + isClassExpression: () => Rc, + isClassInstanceProperty: () => kZ, + isClassLike: () => $n, + isClassMemberModifier: () => Uj, + isClassNamedEvaluationHelperBlock: () => ok, + isClassOrTypeElement: () => D7, + isClassStaticBlockDeclaration: () => kc, + isClassThisAssignmentBlock: () => tw, + isColonToken: () => Nte, + isCommaExpression: () => qN, + isCommaListExpression: () => I4, + isCommaSequence: () => B4, + isCommaToken: () => Pte, + isComment: () => E9, + isCommonJsExportPropertyAssignment: () => Z7, + isCommonJsExportedExpression: () => mK, + isCompoundAssignment: () => Z4, + isComputedNonLiteralName: () => x3, + isComputedPropertyName: () => Gs, + isConciseBody: () => N7, + isConditionalExpression: () => ES, + isConditionalTypeNode: () => Gb, + isConstAssertion: () => HJ, + isConstTypeReference: () => nd, + isConstructSignatureDeclaration: () => N4, + isConstructorDeclaration: () => nc, + isConstructorTypeNode: () => _6, + isContextualKeyword: () => h5, + isContinueStatement: () => y0e, + isCustomPrologue: () => w3, + isDebuggerStatement: () => b0e, + isDeclaration: () => Pl, + isDeclarationBindingElement: () => c3, + isDeclarationFileName: () => Il, + isDeclarationName: () => Qm, + isDeclarationNameOfEnumOrNamespace: () => dJ, + isDeclarationReadonly: () => C3, + isDeclarationStatement: () => OZ, + isDeclarationWithTypeParameterChildren: () => hB, + isDeclarationWithTypeParameters: () => gB, + isDecorator: () => ul, + isDecoratorTarget: () => Qse, + isDefaultClause: () => L4, + isDefaultImport: () => fS, + isDefaultModifier: () => kF, + isDefaultedExpandoInitializer: () => DK, + isDeleteExpression: () => jte, + isDeleteTarget: () => OB, + isDeprecatedDeclaration: () => q9, + isDestructuringAssignment: () => y0, + isDiskPathRoot: () => yj, + isDoStatement: () => h0e, + isDocumentRegistryEntry: () => s8, + isDotDotDotToken: () => TF, + isDottedName: () => aN, + isDynamicName: () => v5, + isEffectiveExternalModule: () => RC, + isEffectiveStrictModeSourceFile: () => pB, + isElementAccessChain: () => Rj, + isElementAccessExpression: () => uo, + isEmittedFileOfProgram: () => xie, + isEmptyArrayLiteral: () => oee, + isEmptyBindingElement: () => nZ, + isEmptyBindingPattern: () => rZ, + isEmptyObjectLiteral: () => lJ, + isEmptyStatement: () => hz, + isEmptyStringLiteral: () => kB, + isEntityName: () => r_, + isEntityNameExpression: () => to, + isEnumConst: () => V1, + isEnumDeclaration: () => ov, + isEnumMember: () => Ph, + isEqualityOperatorKind: () => j9, + isEqualsGreaterThanToken: () => Ate, + isExclamationToken: () => RN, + isExcludedFile: () => qre, + isExclusivelyTypeOnlyImportOrExport: () => mU, + isExpandoPropertyDeclaration: () => Mx, + isExportAssignment: () => Mo, + isExportDeclaration: () => Bc, + isExportModifier: () => zx, + isExportName: () => jF, + isExportNamespaceAsDefaultDeclaration: () => V7, + isExportOrDefaultModifier: () => XN, + isExportSpecifier: () => Nu, + isExportsIdentifier: () => lS, + isExportsOrModuleExportsOrAlias: () => t2, + isExpression: () => ut, + isExpressionNode: () => Xm, + isExpressionOfExternalModuleImportEqualsDeclaration: () => Kse, + isExpressionOfOptionalChainRoot: () => x7, + isExpressionStatement: () => Al, + isExpressionWithTypeArguments: () => Dh, + isExpressionWithTypeArgumentsInClassExtendsClause: () => I5, + isExternalModule: () => fl, + isExternalModuleAugmentation: () => Pb, + isExternalModuleImportEqualsDeclaration: () => H1, + isExternalModuleIndicator: () => p3, + isExternalModuleNameRelative: () => Dl, + isExternalModuleReference: () => wh, + isExternalModuleSymbol: () => lx, + isExternalOrCommonJsModule: () => tf, + isFileLevelReservedGeneratedIdentifier: () => o3, + isFileLevelUniqueName: () => W7, + isFileProbablyExternalModule: () => ZN, + isFirstDeclarationOfSymbolParameter: () => KV, + isFixablePromiseHandler: () => Nq, + isForInOrOfStatement: () => nS, + isForInStatement: () => PF, + isForInitializer: () => ip, + isForOfStatement: () => JN, + isForStatement: () => av, + isFullSourceFile: () => Og, + isFunctionBlock: () => Nb, + isFunctionBody: () => Xj, + isFunctionDeclaration: () => Cc, + isFunctionExpression: () => yo, + isFunctionExpressionOrArrowFunction: () => zy, + isFunctionLike: () => Es, + isFunctionLikeDeclaration: () => io, + isFunctionLikeKind: () => sx, + isFunctionLikeOrClassStaticBlockDeclaration: () => IC, + isFunctionOrConstructorTypeNode: () => CZ, + isFunctionOrModuleBlock: () => Vj, + isFunctionSymbol: () => NK, + isFunctionTypeNode: () => Zm, + isGeneratedIdentifier: () => Bo, + isGeneratedPrivateIdentifier: () => tS, + isGetAccessor: () => Pg, + isGetAccessorDeclaration: () => pp, + isGetOrSetAccessorDeclaration: () => a3, + isGlobalScopeAugmentation: () => $m, + isGlobalSourceFile: () => m0, + isGrammarError: () => $Z, + isHeritageClause: () => cf, + isHoistedFunction: () => Q7, + isHoistedVariableStatement: () => Y7, + isIdentifier: () => Me, + isIdentifierANonContextualKeyword: () => BB, + isIdentifierName: () => jK, + isIdentifierOrThisTypeNode: () => fre, + isIdentifierPart: () => hh, + isIdentifierStart: () => Vm, + isIdentifierText: () => R_, + isIdentifierTypePredicate: () => yK, + isIdentifierTypeReference: () => qee, + isIfStatement: () => sv, + isIgnoredFileFromWildCardWatching: () => kA, + isImplicitGlob: () => wJ, + isImportAttribute: () => Ute, + isImportAttributeName: () => xZ, + isImportAttributes: () => PS, + isImportCall: () => T_, + isImportClause: () => ld, + isImportDeclaration: () => qo, + isImportEqualsDeclaration: () => _l, + isImportKeyword: () => P4, + isImportMeta: () => JC, + isImportOrExportSpecifier: () => Cy, + isImportOrExportSpecifierName: () => kae, + isImportSpecifier: () => Xu, + isImportTypeAssertionContainer: () => S0e, + isImportTypeNode: () => ym, + isImportable: () => yq, + isInComment: () => P0, + isInCompoundLikeAssignment: () => FB, + isInExpressionContext: () => a5, + isInJSDoc: () => BD, + isInJSFile: () => an, + isInJSXText: () => aae, + isInJsonFile: () => c5, + isInNonReferenceComment: () => fae, + isInReferenceComment: () => _ae, + isInRightSideOfInternalImportEqualsDeclaration: () => d9, + isInString: () => _k, + isInTemplateString: () => AV, + isInTopLevelContext: () => n5, + isInTypeQuery: () => Tx, + isIncrementalBuildInfo: () => NA, + isIncrementalBundleEmitBuildInfo: () => Vie, + isIncrementalCompilation: () => Wb, + isIndexSignatureDeclaration: () => qy, + isIndexedAccessTypeNode: () => $b, + isInferTypeNode: () => xS, + isInfinityOrNaNString: () => v4, + isInitializedProperty: () => dA, + isInitializedVariable: () => _N, + isInsideJsxElement: () => k9, + isInsideJsxElementOrAttribute: () => sae, + isInsideNodeModules: () => e8, + isInsideTemplateLiteral: () => VA, + isInstanceOfExpression: () => F5, + isInstantiatedModule: () => IW, + isInterfaceDeclaration: () => Vl, + isInternalDeclaration: () => JZ, + isInternalModuleImportEqualsDeclaration: () => cS, + isInternalName: () => Fz, + isIntersectionTypeNode: () => Hx, + isIntrinsicJsxName: () => YC, + isIterationStatement: () => wy, + isJSDoc: () => Od, + isJSDocAllType: () => Xte, + isJSDocAugmentsTag: () => Yx, + isJSDocAuthorTag: () => E0e, + isJSDocCallbackTag: () => Sz, + isJSDocClassTag: () => Yte, + isJSDocCommentContainingNode: () => F7, + isJSDocConstructSignature: () => vx, + isJSDocDeprecatedTag: () => Ez, + isJSDocEnumTag: () => WN, + isJSDocFunctionType: () => b6, + isJSDocImplementsTag: () => LF, + isJSDocImportTag: () => xm, + isJSDocIndexSignature: () => u5, + isJSDocLikeText: () => Wz, + isJSDocLink: () => Gte, + isJSDocLinkCode: () => $te, + isJSDocLinkLike: () => cx, + isJSDocLinkPlain: () => k0e, + isJSDocMemberName: () => uv, + isJSDocNameReference: () => M4, + isJSDocNamepathType: () => C0e, + isJSDocNamespaceBody: () => yhe, + isJSDocNode: () => FC, + isJSDocNonNullableType: () => AF, + isJSDocNullableType: () => v6, + isJSDocOptionalParameter: () => cF, + isJSDocOptionalType: () => bz, + isJSDocOverloadTag: () => S6, + isJSDocOverrideTag: () => FF, + isJSDocParameterTag: () => Lf, + isJSDocPrivateTag: () => xz, + isJSDocPropertyLikeTag: () => kD, + isJSDocPropertyTag: () => Zte, + isJSDocProtectedTag: () => kz, + isJSDocPublicTag: () => Tz, + isJSDocReadonlyTag: () => Cz, + isJSDocReturnTag: () => OF, + isJSDocSatisfiesExpression: () => UJ, + isJSDocSatisfiesTag: () => MF, + isJSDocSeeTag: () => D0e, + isJSDocSignature: () => w0, + isJSDocTag: () => OC, + isJSDocTemplateTag: () => Up, + isJSDocThisTag: () => Dz, + isJSDocThrowsTag: () => P0e, + isJSDocTypeAlias: () => jp, + isJSDocTypeAssertion: () => Kb, + isJSDocTypeExpression: () => lv, + isJSDocTypeLiteral: () => AS, + isJSDocTypeTag: () => R4, + isJSDocTypedefTag: () => IS, + isJSDocUnknownTag: () => w0e, + isJSDocUnknownType: () => Qte, + isJSDocVariadicType: () => IF, + isJSXTagName: () => UC, + isJsonEqual: () => iF, + isJsonSourceFile: () => ap, + isJsxAttribute: () => Tm, + isJsxAttributeLike: () => A7, + isJsxAttributeName: () => Kee, + isJsxAttributes: () => Yb, + isJsxCallLike: () => jZ, + isJsxChild: () => g3, + isJsxClosingElement: () => Qb, + isJsxClosingFragment: () => qte, + isJsxElement: () => Sm, + isJsxExpression: () => h6, + isJsxFragment: () => cv, + isJsxNamespacedName: () => Fd, + isJsxOpeningElement: () => Id, + isJsxOpeningFragment: () => ud, + isJsxOpeningLikeElement: () => wu, + isJsxOpeningLikeElementTagName: () => Yse, + isJsxSelfClosingElement: () => NS, + isJsxSpreadAttribute: () => Qx, + isJsxTagNameExpression: () => PD, + isJsxText: () => Bx, + isJumpStatementTarget: () => JA, + isKeyword: () => k_, + isKeywordOrPunctuation: () => g5, + isKnownSymbol: () => QD, + isLabelName: () => TV, + isLabelOfLabeledStatement: () => SV, + isLabeledStatement: () => Gy, + isLateVisibilityPaintedStatement: () => H7, + isLeftHandSideExpression: () => S_, + isLet: () => X7, + isLineBreak: () => Cu, + isLiteralComputedPropertyDeclarationName: () => X3, + isLiteralExpression: () => eS, + isLiteralExpressionOfObject: () => zj, + isLiteralImportTypeNode: () => bh, + isLiteralKind: () => CD, + isLiteralNameOfPropertyDeclarationOrIndexAccess: () => h9, + isLiteralTypeLiteral: () => PZ, + isLiteralTypeNode: () => E0, + isLocalName: () => Nh, + isLogicalOperator: () => iee, + isLogicalOrCoalescingAssignmentExpression: () => sJ, + isLogicalOrCoalescingAssignmentOperator: () => t4, + isLogicalOrCoalescingBinaryExpression: () => sN, + isLogicalOrCoalescingBinaryOperator: () => A5, + isMappedTypeNode: () => CS, + isMemberName: () => wg, + isMetaProperty: () => DS, + isMethodDeclaration: () => rc, + isMethodOrAccessor: () => ax, + isMethodSignature: () => cd, + isMinusToken: () => fz, + isMissingDeclaration: () => x0e, + isMissingPackageJsonInfo: () => rne, + isModifier: () => Zs, + isModifierKind: () => Ey, + isModifierLike: () => Jo, + isModuleAugmentationExternal: () => _B, + isModuleBlock: () => vm, + isModuleBody: () => AZ, + isModuleDeclaration: () => jc, + isModuleExportName: () => NF, + isModuleExportsAccessExpression: () => Lg, + isModuleIdentifier: () => DB, + isModuleName: () => mre, + isModuleOrEnumDeclaration: () => d3, + isModuleReference: () => MZ, + isModuleSpecifierLike: () => I9, + isModuleWithStringLiteralName: () => q7, + isNameOfFunctionDeclaration: () => EV, + isNameOfModuleDeclaration: () => CV, + isNamedDeclaration: () => wl, + isNamedEvaluation: () => rf, + isNamedEvaluationSource: () => JB, + isNamedExportBindings: () => Bj, + isNamedExports: () => mp, + isNamedImportBindings: () => Qj, + isNamedImports: () => bm, + isNamedImportsOrExports: () => B5, + isNamedTupleMember: () => f6, + isNamespaceBody: () => hhe, + isNamespaceExport: () => Km, + isNamespaceExportDeclaration: () => zN, + isNamespaceImport: () => Ug, + isNamespaceReexportDeclaration: () => CK, + isNewExpression: () => Xb, + isNewExpressionTarget: () => dw, + isNewScopeNode: () => ate, + isNoSubstitutionTemplateLiteral: () => TS, + isNodeArray: () => xb, + isNodeArrayMultiLine: () => pee, + isNodeDescendantOf: () => Ob, + isNodeKind: () => C7, + isNodeLikeSystem: () => GR, + isNodeModulesDirectory: () => _7, + isNodeWithPossibleHoistedDeclaration: () => MK, + isNonContextualKeyword: () => jB, + isNonGlobalAmbientModule: () => uB, + isNonNullAccess: () => Zee, + isNonNullChain: () => k7, + isNonNullExpression: () => $x, + isNonStaticMethodOrAccessorWithPrivateName: () => Lne, + isNotEmittedStatement: () => Vte, + isNullishCoalesce: () => jj, + isNumber: () => dy, + isNumericLiteral: () => E_, + isNumericLiteralName: () => zg, + isObjectBindingElementWithoutPropertyName: () => $A, + isObjectBindingOrAssignmentElement: () => u3, + isObjectBindingOrAssignmentPattern: () => qj, + isObjectBindingPattern: () => Of, + isObjectLiteralElement: () => Yj, + isObjectLiteralElementLike: () => vh, + isObjectLiteralExpression: () => _a, + isObjectLiteralMethod: () => Rp, + isObjectLiteralOrClassExpressionMethodOrAccessor: () => K7, + isObjectTypeDeclaration: () => Dx, + isOmittedExpression: () => vl, + isOptionalChain: () => Eu, + isOptionalChainRoot: () => SD, + isOptionalDeclaration: () => Ox, + isOptionalJSDocPropertyLikeTag: () => EN, + isOptionalTypeNode: () => CF, + isOuterExpression: () => BF, + isOutermostOptionalChain: () => TD, + isOverrideModifier: () => Lte, + isPackageJsonInfo: () => uO, + isPackedArrayLiteral: () => zJ, + isParameter: () => Ii, + isParameterPropertyDeclaration: () => K_, + isParameterPropertyModifier: () => ED, + isParenthesizedExpression: () => o_, + isParenthesizedTypeNode: () => kS, + isParseTreeNode: () => bD, + isPartOfParameterDeclaration: () => Y1, + isPartOfTypeNode: () => lm, + isPartOfTypeOnlyImportOrExportDeclaration: () => TZ, + isPartOfTypeQuery: () => o5, + isPartiallyEmittedExpression: () => Bte, + isPatternMatch: () => YI, + isPinnedComment: () => U7, + isPlainJsFile: () => AD, + isPlusToken: () => _z, + isPossiblyTypeArgumentPosition: () => UA, + isPostfixUnaryExpression: () => gz, + isPrefixUnaryExpression: () => iv, + isPrimitiveLiteralValue: () => _F, + isPrivateIdentifier: () => Ai, + isPrivateIdentifierClassElementDeclaration: () => Du, + isPrivateIdentifierPropertyAccessExpression: () => AC, + isPrivateIdentifierSymbol: () => zK, + isProgramUptoDate: () => vU, + isPrologueDirective: () => cm, + isPropertyAccessChain: () => T7, + isPropertyAccessEntityNameExpression: () => oN, + isPropertyAccessExpression: () => wn, + isPropertyAccessOrQualifiedName: () => f3, + isPropertyAccessOrQualifiedNameOrImportTypeNode: () => DZ, + isPropertyAssignment: () => rl, + isPropertyDeclaration: () => os, + isPropertyName: () => qc, + isPropertyNameLiteral: () => um, + isPropertySignature: () => $u, + isPrototypeAccess: () => jy, + isPrototypePropertyAssignment: () => W3, + isPunctuation: () => RB, + isPushOrUnshiftIdentifier: () => zB, + isQualifiedName: () => s_, + isQuestionDotToken: () => xF, + isQuestionOrExclamationToken: () => _re, + isQuestionOrPlusOrMinusToken: () => dre, + isQuestionToken: () => Vy, + isReadonlyKeyword: () => Fte, + isReadonlyKeywordOrPlusOrMinusToken: () => pre, + isRecognizedTripleSlashComment: () => sB, + isReferenceFileLocation: () => j6, + isReferencedFile: () => yv, + isRegularExpressionLiteral: () => lz, + isRequireCall: () => x_, + isRequireVariableStatement: () => M3, + isRestParameter: () => Hm, + isRestTypeNode: () => EF, + isReturnStatement: () => Cf, + isReturnStatementWithFixablePromiseHandler: () => K9, + isRightSideOfAccessExpression: () => cJ, + isRightSideOfInstanceofExpression: () => aee, + isRightSideOfPropertyAccess: () => U6, + isRightSideOfQualifiedName: () => Zse, + isRightSideOfQualifiedNameOrPropertyAccess: () => r4, + isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName: () => see, + isRootedDiskPath: () => Z_, + isSameEntityName: () => VC, + isSatisfiesExpression: () => m6, + isSemicolonClassElement: () => Jte, + isSetAccessor: () => am, + isSetAccessorDeclaration: () => z_, + isShiftOperatorOrHigher: () => Bz, + isShorthandAmbientModuleSymbol: () => S3, + isShorthandPropertyAssignment: () => gu, + isSideEffectImport: () => $J, + isSignedNumericLiteral: () => y5, + isSimpleCopiableExpression: () => r2, + isSimpleInlineableExpression: () => rg, + isSimpleParameterList: () => mA, + isSingleOrDoubleQuote: () => R3, + isSolutionConfig: () => cW, + isSourceElement: () => tte, + isSourceFile: () => Di, + isSourceFileFromLibrary: () => K6, + isSourceFileJS: () => n_, + isSourceFileNotJson: () => l5, + isSourceMapping: () => Ine, + isSpecialPropertyDeclaration: () => PK, + isSpreadAssignment: () => Vg, + isSpreadElement: () => dp, + isStatement: () => Ti, + isStatementButNotDeclaration: () => m3, + isStatementOrBlock: () => LZ, + isStatementWithLocals: () => GZ, + isStatic: () => Js, + isStaticModifier: () => Wx, + isString: () => gs, + isStringANonContextualKeyword: () => Sx, + isStringAndEmptyAnonymousObjectIntersection: () => uae, + isStringDoubleQuoted: () => _5, + isStringLiteral: () => ca, + isStringLiteralLike: () => ja, + isStringLiteralOrJsxExpression: () => RZ, + isStringLiteralOrTemplate: () => wae, + isStringOrNumericLiteralLike: () => If, + isStringOrRegularExpressionOrTemplateLiteral: () => OV, + isStringTextContainingNode: () => Wj, + isSuperCall: () => oS, + isSuperKeyword: () => w4, + isSuperProperty: () => j_, + isSupportedSourceFileName: () => FJ, + isSwitchStatement: () => F4, + isSyntaxList: () => T6, + isSyntheticExpression: () => g0e, + isSyntheticReference: () => Xx, + isTagName: () => xV, + isTaggedTemplateExpression: () => nv, + isTaggedTemplateTag: () => Xse, + isTemplateExpression: () => wF, + isTemplateHead: () => Jx, + isTemplateLiteral: () => ox, + isTemplateLiteralKind: () => ky, + isTemplateLiteralToken: () => bZ, + isTemplateLiteralTypeNode: () => Rte, + isTemplateLiteralTypeSpan: () => mz, + isTemplateMiddle: () => uz, + isTemplateMiddleOrTemplateTail: () => E7, + isTemplateSpan: () => g6, + isTemplateTail: () => SF, + isTextWhiteSpaceLike: () => gae, + isThis: () => V6, + isThisContainerOrFunctionBlock: () => TK, + isThisIdentifier: () => Ry, + isThisInTypeQuery: () => jb, + isThisInitializedDeclaration: () => i5, + isThisInitializedObjectBindingExpression: () => kK, + isThisProperty: () => A3, + isThisTypeNode: () => A4, + isThisTypeParameter: () => b4, + isThisTypePredicate: () => vK, + isThrowStatement: () => vz, + isToken: () => ix, + isTokenKind: () => Jj, + isTraceEnabled: () => Xy, + isTransientSymbol: () => Ng, + isTrivia: () => XC, + isTryStatement: () => wS, + isTupleTypeNode: () => qx, + isTypeAlias: () => q3, + isTypeAliasDeclaration: () => Wp, + isTypeAssertionExpression: () => DF, + isTypeDeclaration: () => Fx, + isTypeElement: () => kb, + isTypeKeyword: () => yw, + isTypeKeywordTokenOrIdentifier: () => P9, + isTypeLiteralNode: () => a_, + isTypeNode: () => li, + isTypeNodeKind: () => yJ, + isTypeOfExpression: () => p6, + isTypeOnlyExportDeclaration: () => SZ, + isTypeOnlyImportDeclaration: () => NC, + isTypeOnlyImportOrExportDeclaration: () => p0, + isTypeOperatorNode: () => rv, + isTypeParameterDeclaration: () => Lo, + isTypePredicateNode: () => Vx, + isTypeQueryNode: () => Hb, + isTypeReferenceNode: () => of, + isTypeReferenceType: () => L7, + isTypeUsableAsPropertyName: () => _p, + isUMDExportSymbol: () => j5, + isUnaryExpression: () => $j, + isUnaryExpressionWithWrite: () => wZ, + isUnicodeIdentifierStart: () => p7, + isUnionTypeNode: () => C0, + isUrl: () => LY, + isValidBigIntString: () => sF, + isValidESSymbolDeclaration: () => gK, + isValidTypeOnlyAliasUseSite: () => K1, + isValueSignatureDeclaration: () => pS, + isVarAwaitUsing: () => E3, + isVarConst: () => BC, + isVarConstLike: () => fK, + isVarUsing: () => D3, + isVariableDeclaration: () => ei, + isVariableDeclarationInVariableStatement: () => LD, + isVariableDeclarationInitializedToBareOrAccessedRequire: () => Ab, + isVariableDeclarationInitializedToRequire: () => L3, + isVariableDeclarationList: () => Ul, + isVariableLike: () => OD, + isVariableStatement: () => Ic, + isVoidExpression: () => Gx, + isWatchSet: () => mJ, + isWhileStatement: () => yz, + isWhiteSpaceLike: () => Cg, + isWhiteSpaceSingleLine: () => im, + isWithStatement: () => zte, + isWriteAccess: () => Ex, + isWriteOnlyAccess: () => R5, + isYieldExpression: () => BN, + jsxModeNeedsExplicitImport: () => mq, + keywordPart: () => ff, + last: () => pa, + lastOrUndefined: () => Do, + length: () => wr, + libMap: () => Gz, + libs: () => HF, + lineBreakPart: () => Q6, + loadModuleFromGlobalCache: () => dne, + loadWithModeAwareCache: () => EA, + makeIdentifierFromModuleName: () => eK, + makeImport: () => r1, + makeStringLiteral: () => vw, + mangleScopedPackageName: () => F6, + map: () => hr, + mapAllOrFail: () => ER, + mapDefined: () => Fi, + mapDefinedIterator: () => uy, + mapEntries: () => rQ, + mapIterator: () => ZE, + mapOneOrMany: () => _q, + mapToDisplayParts: () => n1, + matchFiles: () => NJ, + matchPatternOrExact: () => LJ, + matchedText: () => gQ, + matchesExclude: () => sO, + matchesExcludeWorker: () => aO, + maxBy: () => BR, + maybeBind: () => Os, + maybeSetLocalizedDiagnosticMessages: () => Tee, + memoize: () => Uu, + memoizeOne: () => nm, + min: () => JR, + minAndMax: () => Wee, + missingFileModifiedTime: () => Y_, + modifierToFlag: () => kx, + modifiersToFlags: () => pm, + moduleExportNameIsDefault: () => Gm, + moduleExportNameTextEscaped: () => wb, + moduleExportNameTextUnescaped: () => Iy, + moduleOptionDeclaration: () => Dre, + moduleResolutionIsEqualTo: () => qZ, + moduleResolutionNameAndModeGetter: () => RO, + moduleResolutionOptionDeclarations: () => Xz, + moduleResolutionSupportsPackageJsonExportsAndImports: () => i6, + moduleResolutionUsesNodeModules: () => N9, + moduleSpecifierToValidIdentifier: () => r8, + moduleSpecifiers: () => Ih, + moduleSupportsImportAttributes: () => Pee, + moduleSymbolToValidIdentifier: () => t8, + moveEmitHelpers: () => bte, + moveRangeEnd: () => L5, + moveRangePastDecorators: () => Ch, + moveRangePastModifiers: () => dm, + moveRangePos: () => Z1, + moveSyntheticComments: () => hte, + mutateMap: () => o4, + mutateMapSkippingNewValues: () => Rg, + needsParentheses: () => M9, + needsScopeMarker: () => P7, + newCaseClauseTracker: () => $9, + newPrivateEnvironment: () => Rne, + noEmitNotification: () => vA, + noEmitSubstitution: () => nw, + noTransformers: () => die, + noTruncationMaximumTruncationLength: () => eB, + nodeCanBeDecorated: () => F3, + nodeCoreModules: () => c6, + nodeHasName: () => n3, + nodeIsDecorated: () => WC, + nodeIsMissing: () => lc, + nodeIsPresent: () => Mp, + nodeIsSynthesized: () => lo, + nodeModuleNameResolver: () => one, + nodeModulesPathPart: () => qg, + nodeNextJsonConfigResolver: () => cne, + nodeOrChildIsDecorated: () => O3, + nodeOverlapsWithStartEnd: () => y9, + nodePosToString: () => She, + nodeSeenTracker: () => G6, + nodeStartsNewLexicalEnvironment: () => WB, + noop: () => Ha, + noopFileWatcher: () => z6, + normalizePath: () => Hs, + normalizeSlashes: () => zl, + normalizeSpans: () => Pj, + not: () => KI, + notImplemented: () => Vs, + notImplementedResolver: () => vie, + nullNodeConverters: () => dte, + nullParenthesizerRules: () => fte, + nullTransformationContext: () => SA, + objectAllocator: () => tu, + operatorPart: () => Sw, + optionDeclarations: () => _d, + optionMapToObject: () => KF, + optionsAffectingProgramStructure: () => Are, + optionsForBuild: () => Yz, + optionsForWatch: () => rk, + optionsHaveChanges: () => ux, + or: () => Q_, + orderedRemoveItem: () => rD, + orderedRemoveItemAt: () => yy, + packageIdToPackageName: () => z7, + packageIdToString: () => U1, + parameterIsThisKeyword: () => My, + parameterNamePart: () => yae, + parseBaseNodeFactory: () => Sre, + parseBigInt: () => Vee, + parseBuildCommand: () => Bre, + parseCommandLine: () => Rre, + parseCommandLineWorker: () => Zz, + parseConfigFileTextToJson: () => eW, + parseConfigFileWithSystem: () => ise, + parseConfigHostFromCompilerHostLike: () => UO, + parseCustomTypeOption: () => QF, + parseIsolatedEntityName: () => tk, + parseIsolatedJSDocComment: () => xre, + parseJSDocTypeExpressionForTests: () => K0e, + parseJsonConfigFileContent: () => Pye, + parseJsonSourceFileConfigFileContent: () => sA, + parseJsonText: () => KN, + parseListTypeOption: () => Lre, + parseNodeFactory: () => fv, + parseNodeModuleFromPath: () => lA, + parsePackageName: () => pO, + parsePseudoBigInt: () => g4, + parseValidBigInt: () => BJ, + pasteEdits: () => dG, + patchWriteFileEnsuringDirectory: () => OY, + pathContainsNodeModules: () => Yy, + pathIsAbsolute: () => _D, + pathIsBareSpecifier: () => vj, + pathIsRelative: () => xf, + patternText: () => mQ, + performIncrementalCompilation: () => sse, + performance: () => kQ, + positionBelongsToNode: () => DV, + positionIsASICandidate: () => B9, + positionIsSynthesized: () => Nd, + positionsAreOnSameLine: () => lp, + preProcessFile: () => j2e, + probablyUsesSemicolons: () => KA, + processCommentPragmas: () => qz, + processPragmasIntoFields: () => Hz, + processTaggedTemplateExpression: () => GW, + programContainsEsModules: () => dae, + programContainsModules: () => pae, + projectReferenceIsEqualTo: () => tB, + propertyNamePart: () => vae, + pseudoBigIntToString: () => Ub, + punctuationPart: () => Fu, + pushIfUnique: () => tp, + quote: () => kw, + quotePreferenceFromString: () => VV, + rangeContainsPosition: () => q6, + rangeContainsPositionExclusive: () => zA, + rangeContainsRange: () => C_, + rangeContainsRangeExclusive: () => eae, + rangeContainsStartEnd: () => WA, + rangeEndIsOnSameLineAsRangeStart: () => uN, + rangeEndPositionsAreOnSameLine: () => _ee, + rangeEquals: () => AR, + rangeIsOnSingleLine: () => hS, + rangeOfNode: () => RJ, + rangeOfTypeParameters: () => jJ, + rangeOverlapsWithStartEnd: () => mw, + rangeStartIsOnSameLineAsRangeEnd: () => fee, + rangeStartPositionsAreOnSameLine: () => M5, + readBuilderProgram: () => e9, + readConfigFile: () => nA, + readJson: () => e6, + readJsonConfigFile: () => Jre, + readJsonOrUndefined: () => uJ, + reduceEachLeadingCommentRange: () => UY, + reduceEachTrailingCommentRange: () => VY, + reduceLeft: () => Wu, + reduceLeftIterator: () => ZX, + reducePathComponents: () => tx, + refactor: () => gk, + regExpEscape: () => Qhe, + regularExpressionFlagToCharacterCode: () => Xge, + relativeComplement: () => nQ, + removeAllComments: () => IN, + removeEmitHelper: () => f0e, + removeExtension: () => TN, + removeFileExtension: () => Gu, + removeIgnoredPath: () => GO, + removeMinAndVersionNumbers: () => UR, + removePrefix: () => nD, + removeSuffix: () => bC, + removeTrailingDirectorySeparator: () => _0, + repeatString: () => HA, + replaceElement: () => OR, + replaceFirstStar: () => vS, + resolutionExtensionIsTSOrJson: () => f4, + resolveConfigFileProjectName: () => YU, + resolveJSModule: () => ine, + resolveLibrary: () => fO, + resolveModuleName: () => MS, + resolveModuleNameFromCache: () => s1e, + resolvePackageNameToPackageJson: () => fW, + resolvePath: () => by, + resolveProjectReferencePath: () => ck, + resolveTripleslashReference: () => uU, + resolveTypeReferenceDirective: () => ene, + resolvingEmptyArray: () => Kj, + returnFalse: () => mh, + returnNoopFileWatcher: () => _w, + returnTrue: () => yb, + returnUndefined: () => vb, + returnsPromise: () => Pq, + rewriteModuleSpecifier: () => sk, + sameFlatMap: () => eQ, + sameMap: () => Qc, + sameMapping: () => X1e, + scanTokenAtPosition: () => _K, + scanner: () => ql, + semanticDiagnosticsOptionDeclarations: () => wre, + serializeCompilerOptions: () => sW, + server: () => JPe, + servicesVersion: () => DTe, + setCommentRange: () => el, + setConfigFileInOptions: () => aW, + setConstantValue: () => vte, + setEmitFlags: () => un, + setGetSourceFileAsHashVersioned: () => KO, + setIdentifierAutoGenerate: () => LN, + setIdentifierGeneratedImportReference: () => xte, + setIdentifierTypeArguments: () => k0, + setInternalEmitFlags: () => FN, + setLocalizedDiagnosticMessages: () => See, + setNodeChildren: () => Kte, + setNodeFlags: () => Gee, + setObjectAllocator: () => bee, + setOriginalNode: () => Cn, + setParent: () => za, + setParentRecursive: () => ev, + setPrivateIdentifier: () => jS, + setSnippetElement: () => oz, + setSourceMapRange: () => ha, + setStackTraceLimit: () => Ige, + setStartsOnNewLine: () => hF, + setSyntheticLeadingComments: () => tv, + setSyntheticTrailingComments: () => Rx, + setSys: () => jge, + setSysLog: () => AY, + setTextRange: () => ct, + setTextRangeEnd: () => o6, + setTextRangePos: () => h4, + setTextRangePosEnd: () => Ad, + setTextRangePosWidth: () => JJ, + setTokenSourceMapRange: () => gte, + setTypeNode: () => Ste, + setUILocale: () => fQ, + setValueDeclaration: () => WD, + shouldAllowImportingTsExtension: () => O6, + shouldPreserveConstEnums: () => By, + shouldRewriteModuleSpecifier: () => V3, + shouldUseUriStyleNodeCoreModules: () => H9, + showModuleSpecifier: () => hee, + signatureHasRestParameter: () => Iu, + signatureToDisplayParts: () => tq, + single: () => FR, + singleElementArray: () => ZT, + singleIterator: () => tQ, + singleOrMany: () => Wm, + singleOrUndefined: () => xg, + skipAlias: () => eu, + skipConstraint: () => zV, + skipOuterExpressions: () => hc, + skipParentheses: () => Ba, + skipPartiallyEmittedExpressions: () => id, + skipTrivia: () => oa, + skipTypeChecking: () => a6, + skipTypeCheckingIgnoringNoCheck: () => Uee, + skipTypeParentheses: () => VD, + skipWhile: () => yQ, + sliceAfter: () => MJ, + some: () => ot, + sortAndDeduplicate: () => tD, + sortAndDeduplicateDiagnostics: () => DC, + sourceFileAffectingCompilerOptions: () => Qz, + sourceFileMayBeEmitted: () => Mb, + sourceMapCommentRegExp: () => LW, + sourceMapCommentRegExpDontCareLineStart: () => Pne, + spacePart: () => fc, + spanMap: () => DR, + startEndContainsRange: () => pJ, + startEndOverlapsWithStartEnd: () => v9, + startOnNewLine: () => Au, + startTracing: () => wQ, + startsWith: () => Ui, + startsWithDirectory: () => Tj, + startsWithUnderscore: () => dq, + startsWithUseStrict: () => are, + stringContainsAt: () => Lae, + stringToToken: () => Q2, + stripQuotes: () => Bp, + supportedDeclarationExtensions: () => tF, + supportedJSExtensionsFlat: () => s6, + supportedLocaleDirectories: () => sZ, + supportedTSExtensionsFlat: () => AJ, + supportedTSImplementationExtensions: () => vN, + suppressLeadingAndTrailingTrivia: () => af, + suppressLeadingTrivia: () => tz, + suppressTrailingTrivia: () => cte, + symbolEscapedNameNoDefault: () => A9, + symbolName: () => cc, + symbolNameNoDefault: () => HV, + symbolToDisplayParts: () => Tw, + sys: () => ml, + sysLog: () => qP, + tagNamesAreEquivalent: () => dv, + takeWhile: () => HR, + targetOptionDeclaration: () => $z, + targetToLibMap: () => qY, + testFormatSettings: () => a2e, + textChangeRangeIsUnchanged: () => eZ, + textChangeRangeNewSpan: () => vD, + textChanges: () => cn, + textOrKeywordPart: () => eq, + textPart: () => Bf, + textRangeContainsPositionInclusive: () => KP, + textRangeContainsTextSpan: () => $Y, + textRangeIntersectsWithTextSpan: () => ZY, + textSpanContainsPosition: () => Dj, + textSpanContainsTextRange: () => wj, + textSpanContainsTextSpan: () => GY, + textSpanEnd: () => ec, + textSpanIntersection: () => KY, + textSpanIntersectsWith: () => e3, + textSpanIntersectsWithPosition: () => YY, + textSpanIntersectsWithTextSpan: () => QY, + textSpanIsEmpty: () => HY, + textSpanOverlap: () => XY, + textSpanOverlapsWith: () => nhe, + textSpansEqual: () => X6, + textToKeywordObj: () => f7, + timestamp: () => ao, + toArray: () => QT, + toBuilderFileEmit: () => Gie, + toBuilderStateFileInfoForMultiEmit: () => Hie, + toEditorSettings: () => u8, + toFileNameLowerCase: () => my, + toPath: () => oo, + toProgramEmitPending: () => $ie, + toSorted: () => X_, + tokenIsIdentifierOrKeyword: () => v_, + tokenIsIdentifierOrKeywordOrGreaterThan: () => RY, + tokenToString: () => qs, + trace: () => ts, + tracing: () => on, + tracingEnabled: () => VP, + transferSourceFileChildren: () => ere, + transform: () => RTe, + transformClassFields: () => Gne, + transformDeclarations: () => YW, + transformECMAScriptModule: () => QW, + transformES2015: () => oie, + transformES2016: () => aie, + transformES2017: () => Yne, + transformES2018: () => Zne, + transformES2019: () => Kne, + transformES2020: () => eie, + transformES2021: () => tie, + transformESDecorators: () => Qne, + transformESNext: () => rie, + transformGenerators: () => cie, + transformImpliedNodeFormatDependentModule: () => uie, + transformJsx: () => sie, + transformLegacyDecorators: () => Xne, + transformModule: () => XW, + transformNamedEvaluation: () => lf, + transformNodes: () => bA, + transformSystemModule: () => lie, + transformTypeScript: () => Hne, + transpile: () => G2e, + transpileDeclaration: () => q2e, + transpileModule: () => ioe, + transpileOptionValueCompilerOptions: () => Ire, + tryAddToSet: () => u0, + tryAndIgnoreErrors: () => W9, + tryCast: () => Bn, + tryDirectoryExists: () => z9, + tryExtractTSExtension: () => O5, + tryFileExists: () => Ew, + tryGetClassExtendingExpressionWithTypeArguments: () => aJ, + tryGetClassImplementingOrExtendingExpressionWithTypeArguments: () => oJ, + tryGetDirectories: () => J9, + tryGetExtensionFromPath: () => Jg, + tryGetImportFromModuleSpecifier: () => U3, + tryGetJSDocSatisfiesTypeNode: () => lF, + tryGetModuleNameFromFile: () => GN, + tryGetModuleSpecifierFromDeclaration: () => gx, + tryGetNativePerformanceHooks: () => xQ, + tryGetPropertyAccessOrIdentifierToString: () => cN, + tryGetPropertyNameOfBindingOrAssignmentElement: () => zF, + tryGetSourceMappingURL: () => Nne, + tryGetTextOfPropertyName: () => FD, + tryParseJson: () => lN, + tryParsePattern: () => Ix, + tryParsePatterns: () => xN, + tryParseRawSourceMap: () => Ane, + tryReadDirectory: () => oq, + tryReadFile: () => W4, + tryRemoveDirectoryPrefix: () => DJ, + tryRemoveExtension: () => zee, + tryRemovePrefix: () => qR, + tryRemoveSuffix: () => dQ, + tscBuildOption: () => OS, + typeAcquisitionDeclarations: () => $F, + typeAliasNamePart: () => bae, + typeDirectiveIsEqualTo: () => HZ, + typeKeywords: () => JV, + typeParameterNamePart: () => Sae, + typeToDisplayParts: () => QA, + unchangedPollThresholds: () => s7, + unchangedTextChangeRange: () => g7, + unescapeLeadingUnderscores: () => Si, + unmangleScopedPackageName: () => _A, + unorderedRemoveItem: () => YT, + unprefixedNodeCoreModules: () => ste, + unreachableCodeIsError: () => Dee, + unsetNodeChildren: () => Pz, + unusedLabelIsError: () => wee, + unwrapInnermostStatementOfLabel: () => TB, + unwrapParenthesizedExpression: () => nte, + updateErrorForNoInputFiles: () => iO, + updateLanguageServiceSourceFile: () => rH, + updateMissingFilePathsWatch: () => oU, + updateResolutionField: () => P6, + updateSharedExtendedConfigFileWatcher: () => FO, + updateSourceFile: () => Uz, + updateWatchingWildcardDirectories: () => xA, + usingSingleLineStringWriter: () => LC, + utf16EncodeAsString: () => yD, + validateLocaleAndSetLanguage: () => Aj, + version: () => ep, + versionMajorMinor: () => q2, + visitArray: () => Q4, + visitCommaListElements: () => SO, + visitEachChild: () => br, + visitFunctionBody: () => jf, + visitIterationBody: () => c_, + visitLexicalEnvironment: () => OW, + visitNode: () => Qe, + visitNodes: () => Ar, + visitParameterList: () => _c, + walkUpBindingElementsAndPatterns: () => Y2, + walkUpOuterExpressions: () => ore, + walkUpParenthesizedExpressions: () => ad, + walkUpParenthesizedTypes: () => $3, + walkUpParenthesizedTypesAndGetParentAndChild: () => RK, + whitespaceOrMapCommentRegExp: () => MW, + writeCommentRange: () => KC, + writeFile: () => w5, + writeFileEnsuringDirectories: () => KB, + zipWith: () => TR + }), Ja.exports = Tg(mb); + var q2 = "5.9", ep = "5.9.3", QX = /* @__PURE__ */ ((e) => (e[e.LessThan = -1] = "LessThan", e[e.EqualTo = 0] = "EqualTo", e[e.GreaterThan = 1] = "GreaterThan", e))(QX || {}), Ge = [], SR = /* @__PURE__ */ new Map(); + function wr(e) { + return e !== void 0 ? e.length : 0; + } + function lr(e, t) { + if (e !== void 0) + for (let n = 0; n < e.length; n++) { + const i = t(e[n], n); + if (i) + return i; + } + } + function YX(e, t) { + if (e !== void 0) + for (let n = e.length - 1; n >= 0; n--) { + const i = t(e[n], n); + if (i) + return i; + } + } + function Lc(e, t) { + if (e !== void 0) + for (let n = 0; n < e.length; n++) { + const i = t(e[n], n); + if (i !== void 0) + return i; + } + } + function MP(e, t) { + for (const n of e) { + const i = t(n); + if (i !== void 0) + return i; + } + } + function ZX(e, t, n) { + let i = n; + if (e) { + let s = 0; + for (const o of e) + i = t(i, o, s), s++; + } + return i; + } + function TR(e, t, n) { + const i = []; + E.assertEqual(e.length, t.length); + for (let s = 0; s < e.length; s++) + i.push(n(e[s], t[s], s)); + return i; + } + function xR(e, t) { + if (e.length <= 1) + return e; + const n = []; + for (let i = 0, s = e.length; i < s; i++) + i !== 0 && n.push(t), n.push(e[i]); + return n; + } + function Ni(e, t) { + if (e !== void 0) { + for (let n = 0; n < e.length; n++) + if (!t(e[n], n)) + return !1; + } + return !0; + } + function Nn(e, t, n) { + if (e !== void 0) + for (let i = n ?? 0; i < e.length; i++) { + const s = e[i]; + if (t(s, i)) + return s; + } + } + function gb(e, t, n) { + if (e !== void 0) + for (let i = n ?? e.length - 1; i >= 0; i--) { + const s = e[i]; + if (t(s, i)) + return s; + } + } + function oc(e, t, n) { + if (e === void 0) return -1; + for (let i = n ?? 0; i < e.length; i++) + if (t(e[i], i)) + return i; + return -1; + } + function GI(e, t, n) { + if (e === void 0) return -1; + for (let i = n ?? e.length - 1; i >= 0; i--) + if (t(e[i], i)) + return i; + return -1; + } + function ms(e, t, n = gy) { + if (e !== void 0) { + for (let i = 0; i < e.length; i++) + if (n(e[i], t)) + return !0; + } + return !1; + } + function KX(e, t, n) { + for (let i = n ?? 0; i < e.length; i++) + if (ms(t, e.charCodeAt(i))) + return i; + return -1; + } + function l0(e, t) { + let n = 0; + if (e !== void 0) + for (let i = 0; i < e.length; i++) { + const s = e[i]; + t(s, i) && n++; + } + return n; + } + function kn(e, t) { + if (e !== void 0) { + const n = e.length; + let i = 0; + for (; i < n && t(e[i]); ) i++; + if (i < n) { + const s = e.slice(0, i); + for (i++; i < n; ) { + const o = e[i]; + t(o) && s.push(o), i++; + } + return s; + } + } + return e; + } + function kR(e, t) { + let n = 0; + for (let i = 0; i < e.length; i++) + t(e[i], i, e) && (e[n] = e[i], n++); + e.length = n; + } + function Ap(e) { + e.length = 0; + } + function hr(e, t) { + let n; + if (e !== void 0) { + n = []; + for (let i = 0; i < e.length; i++) + n.push(t(e[i], i)); + } + return n; + } + function* ZE(e, t) { + for (const n of e) + yield t(n); + } + function Qc(e, t) { + if (e !== void 0) + for (let n = 0; n < e.length; n++) { + const i = e[n], s = t(i, n); + if (i !== s) { + const o = e.slice(0, n); + for (o.push(s), n++; n < e.length; n++) + o.push(t(e[n], n)); + return o; + } + } + return e; + } + function Ip(e) { + const t = []; + for (let n = 0; n < e.length; n++) { + const i = e[n]; + i && (as(i) ? In(t, i) : t.push(i)); + } + return t; + } + function ka(e, t) { + let n; + if (e !== void 0) + for (let i = 0; i < e.length; i++) { + const s = t(e[i], i); + s && (as(s) ? n = In(n, s) : n = Er(n, s)); + } + return n ?? Ge; + } + function KE(e, t) { + const n = []; + if (e !== void 0) + for (let i = 0; i < e.length; i++) { + const s = t(e[i], i); + s && (as(s) ? In(n, s) : n.push(s)); + } + return n; + } + function* CR(e, t) { + for (const n of e) { + const i = t(n); + i && (yield* i); + } + } + function eQ(e, t) { + let n; + if (e !== void 0) + for (let i = 0; i < e.length; i++) { + const s = e[i], o = t(s, i); + (n || s !== o || as(o)) && (n || (n = e.slice(0, i)), as(o) ? In(n, o) : n.push(o)); + } + return n ?? e; + } + function ER(e, t) { + const n = []; + for (let i = 0; i < e.length; i++) { + const s = t(e[i], i); + if (s === void 0) + return; + n.push(s); + } + return n; + } + function Fi(e, t) { + const n = []; + if (e !== void 0) + for (let i = 0; i < e.length; i++) { + const s = t(e[i], i); + s !== void 0 && n.push(s); + } + return n; + } + function* uy(e, t) { + for (const n of e) { + const i = t(n); + i !== void 0 && (yield i); + } + } + function eD(e, t, n) { + if (e.has(t)) + return e.get(t); + const i = n(); + return e.set(t, i), i; + } + function u0(e, t) { + return e.has(t) ? !1 : (e.add(t), !0); + } + function* tQ(e) { + yield e; + } + function DR(e, t, n) { + let i; + if (e !== void 0) { + i = []; + const s = e.length; + let o, c, _ = 0, u = 0; + for (; _ < s; ) { + for (; u < s; ) { + const g = e[u]; + if (c = t(g, u), u === 0) + o = c; + else if (c !== o) + break; + u++; + } + if (_ < u) { + const g = n(e.slice(_, u), o, _, u); + g && i.push(g), _ = u; + } + o = c, u++; + } + } + return i; + } + function rQ(e, t) { + if (e === void 0) + return; + const n = /* @__PURE__ */ new Map(); + return e.forEach((i, s) => { + const [o, c] = t(s, i); + n.set(o, c); + }), n; + } + function ot(e, t) { + if (e !== void 0) + if (t !== void 0) { + for (let n = 0; n < e.length; n++) + if (t(e[n])) + return !0; + } else + return e.length > 0; + return !1; + } + function wR(e, t, n) { + let i; + for (let s = 0; s < e.length; s++) + t(e[s]) ? i = i === void 0 ? s : i : i !== void 0 && (n(i, s), i = void 0); + i !== void 0 && n(i, e.length); + } + function Bi(e, t) { + return t === void 0 || t.length === 0 ? e : e === void 0 || e.length === 0 ? t : [...e, ...t]; + } + function G5e(e, t) { + return t; + } + function $I(e) { + return e.map(G5e); + } + function $5e(e, t, n) { + const i = $I(e); + Y5e(e, i, n); + let s = e[i[0]]; + const o = [i[0]]; + for (let c = 1; c < i.length; c++) { + const _ = i[c], u = e[_]; + t(s, u) || (o.push(_), s = u); + } + return o.sort(), o.map((c) => e[c]); + } + function X5e(e, t) { + const n = []; + for (let i = 0; i < e.length; i++) + tp(n, e[i], t); + return n; + } + function hb(e, t, n) { + return e.length === 0 ? [] : e.length === 1 ? e.slice() : n ? $5e(e, t, n) : X5e(e, t); + } + function Q5e(e, t) { + if (e.length === 0) return Ge; + let n = e[0]; + const i = [n]; + for (let s = 1; s < e.length; s++) { + const o = e[s]; + switch (t(o, n)) { + // equality comparison + case !0: + // relational comparison + // falls through + case 0: + continue; + case -1: + return E.fail("Array is unsorted."); + } + i.push(n = o); + } + return i; + } + function PR() { + return []; + } + function _y(e, t, n, i, s) { + if (e.length === 0) + return e.push(t), !0; + const o = py(e, t, go, n); + if (o < 0) { + if (i && !s) { + const c = ~o; + if (c > 0 && i(t, e[c - 1])) + return !1; + if (c < e.length && i(t, e[c])) + return e.splice(c, 1, t), !0; + } + return e.splice(~o, 0, t), !0; + } + return s ? (e.splice(o, 0, t), !0) : !1; + } + function tD(e, t, n) { + return Q5e(X_(e, t), n ?? t ?? _u); + } + function Tf(e, t, n = gy) { + if (e === void 0 || t === void 0) + return e === t; + if (e.length !== t.length) + return !1; + for (let i = 0; i < e.length; i++) + if (!n(e[i], t[i], i)) + return !1; + return !0; + } + function RP(e) { + let t; + if (e !== void 0) + for (let n = 0; n < e.length; n++) { + const i = e[n]; + (t ?? !i) && (t ?? (t = e.slice(0, n)), i && t.push(i)); + } + return t ?? e; + } + function nQ(e, t, n) { + if (!t || !e || t.length === 0 || e.length === 0) return t; + const i = []; + e: + for (let s = 0, o = 0; o < t.length; o++) { + o > 0 && E.assertGreaterThanOrEqual( + n(t[o], t[o - 1]), + 0 + /* EqualTo */ + ); + t: + for (const c = s; s < e.length; s++) + switch (s > c && E.assertGreaterThanOrEqual( + n(e[s], e[s - 1]), + 0 + /* EqualTo */ + ), n(t[o], e[s])) { + case -1: + i.push(t[o]); + continue e; + case 0: + continue e; + case 1: + continue t; + } + } + return i; + } + function Er(e, t) { + return t === void 0 ? e : e === void 0 ? [t] : (e.push(t), e); + } + function GT(e, t) { + return e === void 0 ? t : t === void 0 ? e : as(e) ? as(t) ? Bi(e, t) : Er(e, t) : as(t) ? Er(t, e) : [e, t]; + } + function iQ(e, t) { + return t < 0 ? e.length + t : t; + } + function In(e, t, n, i) { + if (t === void 0 || t.length === 0) return e; + if (e === void 0) return t.slice(n, i); + n = n === void 0 ? 0 : iQ(t, n), i = i === void 0 ? t.length : iQ(t, i); + for (let s = n; s < i && s < t.length; s++) + t[s] !== void 0 && e.push(t[s]); + return e; + } + function tp(e, t, n) { + return ms(e, t, n) ? !1 : (e.push(t), !0); + } + function dh(e, t, n) { + return e !== void 0 ? (tp(e, t, n), e) : [t]; + } + function Y5e(e, t, n) { + t.sort((i, s) => n(e[i], e[s]) || ho(i, s)); + } + function X_(e, t) { + return e.length === 0 ? Ge : e.slice().sort(t); + } + function* NR(e) { + for (let t = e.length - 1; t >= 0; t--) + yield e[t]; + } + function AR(e, t, n, i) { + for (; n < i; ) { + if (e[n] !== t[n]) + return !1; + n++; + } + return !0; + } + var fy = Array.prototype.at ? (e, t) => e?.at(t) : (e, t) => { + if (e !== void 0 && (t = iQ(e, t), t < e.length)) + return e[t]; + }; + function Yc(e) { + return e === void 0 || e.length === 0 ? void 0 : e[0]; + } + function XI(e) { + if (e !== void 0) + for (const t of e) + return t; + } + function Ca(e) { + return E.assert(e.length !== 0), e[0]; + } + function IR(e) { + for (const t of e) + return t; + E.fail("iterator is empty"); + } + function Do(e) { + return e === void 0 || e.length === 0 ? void 0 : e[e.length - 1]; + } + function pa(e) { + return E.assert(e.length !== 0), e[e.length - 1]; + } + function xg(e) { + return e !== void 0 && e.length === 1 ? e[0] : void 0; + } + function FR(e) { + return E.checkDefined(xg(e)); + } + function Wm(e) { + return e !== void 0 && e.length === 1 ? e[0] : e; + } + function OR(e, t, n) { + const i = e.slice(0); + return i[t] = n, i; + } + function py(e, t, n, i, s) { + return $T(e, n(t), n, i, s); + } + function $T(e, t, n, i, s) { + if (!ot(e)) + return -1; + let o = s ?? 0, c = e.length - 1; + for (; o <= c; ) { + const _ = o + (c - o >> 1), u = n(e[_], _); + switch (i(u, t)) { + case -1: + o = _ + 1; + break; + case 0: + return _; + case 1: + c = _ - 1; + break; + } + } + return ~o; + } + function Wu(e, t, n, i, s) { + if (e && e.length > 0) { + const o = e.length; + if (o > 0) { + let c = i === void 0 || i < 0 ? 0 : i; + const _ = s === void 0 || c + s > o - 1 ? o - 1 : c + s; + let u; + for (arguments.length <= 2 ? (u = e[c], c++) : u = n; c <= _; ) + u = t(u, e[c], c), c++; + return u; + } + } + return n; + } + var R1 = Object.prototype.hasOwnProperty; + function eo(e, t) { + return R1.call(e, t); + } + function jP(e, t) { + return R1.call(e, t) ? e[t] : void 0; + } + function rm(e) { + const t = []; + for (const n in e) + R1.call(e, n) && t.push(n); + return t; + } + function gge(e) { + const t = []; + do { + const n = Object.getOwnPropertyNames(e); + for (const i of n) + tp(t, i); + } while (e = Object.getPrototypeOf(e)); + return t; + } + function XT(e) { + const t = []; + for (const n in e) + R1.call(e, n) && t.push(e[n]); + return t; + } + function sQ(e, t) { + const n = new Array(e); + for (let i = 0; i < e; i++) + n[i] = t(i); + return n; + } + function is(e, t) { + const n = []; + for (const i of e) + n.push(t ? t(i) : i); + return n; + } + function H2(e, ...t) { + for (const n of t) + if (n !== void 0) + for (const i in n) + eo(n, i) && (e[i] = n[i]); + return e; + } + function aQ(e, t, n = gy) { + if (e === t) return !0; + if (!e || !t) return !1; + for (const i in e) + if (R1.call(e, i) && (!R1.call(t, i) || !n(e[i], t[i]))) + return !1; + for (const i in t) + if (R1.call(t, i) && !R1.call(e, i)) + return !1; + return !0; + } + function hC(e, t, n = go) { + const i = /* @__PURE__ */ new Map(); + for (let s = 0; s < e.length; s++) { + const o = e[s], c = t(o); + c !== void 0 && i.set(c, n(o)); + } + return i; + } + function oQ(e, t, n = go) { + const i = []; + for (let s = 0; s < e.length; s++) { + const o = e[s]; + i[t(o)] = n(o); + } + return i; + } + function BP(e, t, n = go) { + const i = Fp(); + for (let s = 0; s < e.length; s++) { + const o = e[s]; + i.add(t(o), n(o)); + } + return i; + } + function yC(e, t, n = go) { + return is(BP(e, t).values(), n); + } + function LR(e, t) { + const n = {}; + if (e !== void 0) + for (let i = 0; i < e.length; i++) { + const s = e[i], o = `${t(s)}`; + (n[o] ?? (n[o] = [])).push(s); + } + return n; + } + function cQ(e) { + const t = {}; + for (const n in e) + R1.call(e, n) && (t[n] = e[n]); + return t; + } + function MR(e, t) { + const n = {}; + for (const i in t) + R1.call(t, i) && (n[i] = t[i]); + for (const i in e) + R1.call(e, i) && (n[i] = e[i]); + return n; + } + function RR(e, t) { + for (const n in t) + R1.call(t, n) && (e[n] = t[n]); + } + function Os(e, t) { + return t?.bind(e); + } + function Fp() { + const e = /* @__PURE__ */ new Map(); + return e.add = Z5e, e.remove = K5e, e; + } + function Z5e(e, t) { + let n = this.get(e); + return n !== void 0 ? n.push(t) : this.set(e, n = [t]), n; + } + function K5e(e, t) { + const n = this.get(e); + n !== void 0 && (YT(n, t), n.length || this.delete(e)); + } + function JP(e) { + const t = e?.slice() ?? []; + let n = 0; + function i() { + return n === t.length; + } + function s(...c) { + t.push(...c); + } + function o() { + if (i()) + throw new Error("Queue is empty"); + const c = t[n]; + if (t[n] = void 0, n++, n > 100 && n > t.length >> 1) { + const _ = t.length - n; + t.copyWithin( + /*target*/ + 0, + /*start*/ + n + ), t.length = _, n = 0; + } + return c; + } + return { + enqueue: s, + dequeue: o, + isEmpty: i + }; + } + function jR(e, t) { + const n = /* @__PURE__ */ new Map(); + let i = 0; + function* s() { + for (const c of n.values()) + as(c) ? yield* c : yield c; + } + const o = { + has(c) { + const _ = e(c); + if (!n.has(_)) return !1; + const u = n.get(_); + return as(u) ? ms(u, c, t) : t(u, c); + }, + add(c) { + const _ = e(c); + if (n.has(_)) { + const u = n.get(_); + if (as(u)) + ms(u, c, t) || (u.push(c), i++); + else { + const g = u; + t(g, c) || (n.set(_, [g, c]), i++); + } + } else + n.set(_, c), i++; + return this; + }, + delete(c) { + const _ = e(c); + if (!n.has(_)) return !1; + const u = n.get(_); + if (as(u)) { + for (let g = 0; g < u.length; g++) + if (t(u[g], c)) + return u.length === 1 ? n.delete(_) : u.length === 2 ? n.set(_, u[1 - g]) : vge(u, g), i--, !0; + } else if (t(u, c)) + return n.delete(_), i--, !0; + return !1; + }, + clear() { + n.clear(), i = 0; + }, + get size() { + return i; + }, + forEach(c) { + for (const _ of is(n.values())) + if (as(_)) + for (const u of _) + c(u, u, o); + else { + const u = _; + c(u, u, o); + } + }, + keys() { + return s(); + }, + values() { + return s(); + }, + *entries() { + for (const c of s()) + yield [c, c]; + }, + [Symbol.iterator]: () => s(), + [Symbol.toStringTag]: n[Symbol.toStringTag] + }; + return o; + } + function as(e) { + return Array.isArray(e); + } + function QT(e) { + return as(e) ? e : [e]; + } + function gs(e) { + return typeof e == "string"; + } + function dy(e) { + return typeof e == "number"; + } + function Bn(e, t) { + return e !== void 0 && t(e) ? e : void 0; + } + function Us(e, t) { + return e !== void 0 && t(e) ? e : E.fail(`Invalid cast. The supplied value ${e} did not pass the test '${E.getFunctionName(t)}'.`); + } + function Ha(e) { + } + function mh() { + return !1; + } + function yb() { + return !0; + } + function vb() { + } + function go(e) { + return e; + } + function eFe(e) { + return e.toLowerCase(); + } + var hge = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_. ]+/g; + function my(e) { + return hge.test(e) ? e.replace(hge, eFe) : e; + } + function Vs() { + throw new Error("Not implemented"); + } + function Uu(e) { + let t; + return () => (e && (t = e(), e = void 0), t); + } + function nm(e) { + const t = /* @__PURE__ */ new Map(); + return (n) => { + const i = `${typeof n}:${n}`; + let s = t.get(i); + return s === void 0 && !t.has(i) && (s = e(n), t.set(i, s)), s; + }; + } + var lQ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Normal = 1] = "Normal", e[e.Aggressive = 2] = "Aggressive", e[e.VeryAggressive = 3] = "VeryAggressive", e))(lQ || {}); + function gy(e, t) { + return e === t; + } + function hy(e, t) { + return e === t || e !== void 0 && t !== void 0 && e.toUpperCase() === t.toUpperCase(); + } + function bb(e, t) { + return gy(e, t); + } + function yge(e, t) { + return e === t ? 0 : e === void 0 ? -1 : t === void 0 ? 1 : e < t ? -1 : 1; + } + function ho(e, t) { + return yge(e, t); + } + function QI(e, t) { + return ho(e?.start, t?.start) || ho(e?.length, t?.length); + } + function BR(e, t, n) { + for (let i = 0; i < e.length; i++) + t = Math.max(t, n(e[i])); + return t; + } + function JR(e, t) { + return Wu(e, (n, i) => t(n, i) === -1 ? n : i); + } + function zP(e, t) { + return e === t ? 0 : e === void 0 ? -1 : t === void 0 ? 1 : (e = e.toUpperCase(), t = t.toUpperCase(), e < t ? -1 : e > t ? 1 : 0); + } + function uQ(e, t) { + return e === t ? 0 : e === void 0 ? -1 : t === void 0 ? 1 : (e = e.toLowerCase(), t = t.toLowerCase(), e < t ? -1 : e > t ? 1 : 0); + } + function _u(e, t) { + return yge(e, t); + } + function vC(e) { + return e ? zP : _u; + } + var tFe = /* @__PURE__ */ (() => { + return t; + function e(n, i, s) { + if (n === i) return 0; + if (n === void 0) return -1; + if (i === void 0) return 1; + const o = s(n, i); + return o < 0 ? -1 : o > 0 ? 1 : 0; + } + function t(n) { + const i = new Intl.Collator(n, { usage: "sort", sensitivity: "variant", numeric: !0 }).compare; + return (s, o) => e(s, o, i); + } + })(), zR, WR; + function _Q() { + return WR; + } + function fQ(e) { + WR !== e && (WR = e, zR = void 0); + } + function WP(e, t) { + return zR ?? (zR = tFe(WR)), zR(e, t); + } + function pQ(e, t, n, i) { + return e === t ? 0 : e === void 0 ? -1 : t === void 0 ? 1 : i(e[n], t[n]); + } + function j1(e, t) { + return ho(e ? 1 : 0, t ? 1 : 0); + } + function Sb(e, t, n) { + const i = Math.max(2, Math.floor(e.length * 0.34)); + let s = Math.floor(e.length * 0.4) + 1, o; + for (const c of t) { + const _ = n(c); + if (_ !== void 0 && Math.abs(_.length - e.length) <= i) { + if (_ === e || _.length < 3 && _.toLowerCase() !== e.toLowerCase()) + continue; + const u = rFe(e, _, s - 0.1); + if (u === void 0) + continue; + E.assert(u < s), s = u, o = c; + } + } + return o; + } + function rFe(e, t, n) { + let i = new Array(t.length + 1), s = new Array(t.length + 1); + const o = n + 0.01; + for (let _ = 0; _ <= t.length; _++) + i[_] = _; + for (let _ = 1; _ <= e.length; _++) { + const u = e.charCodeAt(_ - 1), g = Math.ceil(_ > n ? _ - n : 1), m = Math.floor(t.length > n + _ ? n + _ : t.length); + s[0] = _; + let h = _; + for (let T = 1; T < g; T++) + s[T] = o; + for (let T = g; T <= m; T++) { + const k = e[_ - 1].toLowerCase() === t[T - 1].toLowerCase() ? i[T - 1] + 0.1 : i[T - 1] + 2, D = u === t.charCodeAt(T - 1) ? i[T - 1] : Math.min( + /*delete*/ + i[T] + 1, + /*insert*/ + s[T - 1] + 1, + /*substitute*/ + k + ); + s[T] = D, h = Math.min(h, D); + } + for (let T = m + 1; T <= t.length; T++) + s[T] = o; + if (h > n) + return; + const S = i; + i = s, s = S; + } + const c = i[t.length]; + return c > n ? void 0 : c; + } + function wo(e, t, n) { + const i = e.length - t.length; + return i >= 0 && (n ? hy(e.slice(i), t) : e.indexOf(t, i) === i); + } + function bC(e, t) { + return wo(e, t) ? e.slice(0, e.length - t.length) : e; + } + function dQ(e, t) { + return wo(e, t) ? e.slice(0, e.length - t.length) : void 0; + } + function UR(e) { + let t = e.length; + for (let n = t - 1; n > 0; n--) { + let i = e.charCodeAt(n); + if (i >= 48 && i <= 57) + do + --n, i = e.charCodeAt(n); + while (n > 0 && i >= 48 && i <= 57); + else if (n > 4 && (i === 110 || i === 78)) { + if (--n, i = e.charCodeAt(n), i !== 105 && i !== 73 || (--n, i = e.charCodeAt(n), i !== 109 && i !== 77)) + break; + --n, i = e.charCodeAt(n); + } else + break; + if (i !== 45 && i !== 46) + break; + t = n; + } + return t === e.length ? e : e.slice(0, t); + } + function rD(e, t) { + for (let n = 0; n < e.length; n++) + if (e[n] === t) + return yy(e, n), !0; + return !1; + } + function yy(e, t) { + for (let n = t; n < e.length - 1; n++) + e[n] = e[n + 1]; + e.pop(); + } + function vge(e, t) { + e[t] = e[e.length - 1], e.pop(); + } + function YT(e, t) { + return nFe(e, (n) => n === t); + } + function nFe(e, t) { + for (let n = 0; n < e.length; n++) + if (t(e[n])) + return vge(e, n), !0; + return !1; + } + function Zl(e) { + return e ? go : my; + } + function mQ({ prefix: e, suffix: t }) { + return `${e}*${t}`; + } + function gQ(e, t) { + return E.assert(YI(e, t)), t.substring(e.prefix.length, t.length - e.suffix.length); + } + function VR(e, t, n) { + let i, s = -1; + for (let o = 0; o < e.length; o++) { + const c = e[o], _ = t(c); + _.prefix.length > s && YI(_, n) && (s = _.prefix.length, i = c); + } + return i; + } + function Ui(e, t, n) { + return n ? hy(e.slice(0, t.length), t) : e.lastIndexOf(t, 0) === 0; + } + function nD(e, t) { + return Ui(e, t) ? e.substr(t.length) : e; + } + function qR(e, t, n = go) { + return Ui(n(e), n(t)) ? e.substring(t.length) : void 0; + } + function YI({ prefix: e, suffix: t }, n) { + return n.length >= e.length + t.length && Ui(n, e) && wo(n, t); + } + function ZI(e, t) { + return (n) => e(n) && t(n); + } + function Q_(...e) { + return (...t) => { + let n; + for (const i of e) + if (n = i(...t), n) + return n; + return n; + }; + } + function KI(e) { + return (...t) => !e(...t); + } + function bge(e) { + } + function ZT(e) { + return e === void 0 ? void 0 : [e]; + } + function e7(e, t, n, i, s, o) { + o ?? (o = Ha); + let c = 0, _ = 0; + const u = e.length, g = t.length; + let m = !1; + for (; c < u && _ < g; ) { + const h = e[c], S = t[_], T = n(h, S); + T === -1 ? (i(h), c++, m = !0) : T === 1 ? (s(S), _++, m = !0) : (o(S, h), c++, _++); + } + for (; c < u; ) + i(e[c++]), m = !0; + for (; _ < g; ) + s(t[_++]), m = !0; + return m; + } + function hQ(e) { + const t = []; + return Sge( + e, + t, + /*outer*/ + void 0, + 0 + ), t; + } + function Sge(e, t, n, i) { + for (const s of e[i]) { + let o; + n ? (o = n.slice(), o.push(s)) : o = [s], i === e.length - 1 ? t.push(o) : Sge(e, t, o, i + 1); + } + } + function HR(e, t) { + if (e !== void 0) { + const n = e.length; + let i = 0; + for (; i < n && t(e[i]); ) + i++; + return e.slice(0, i); + } + } + function yQ(e, t) { + if (e !== void 0) { + const n = e.length; + let i = 0; + for (; i < n && t(e[i]); ) + i++; + return e.slice(i); + } + } + function GR() { + return typeof process < "u" && !!process.nextTick && !process.browser && typeof R5e < "u"; + } + var vQ = /* @__PURE__ */ ((e) => (e[e.Off = 0] = "Off", e[e.Error = 1] = "Error", e[e.Warning = 2] = "Warning", e[e.Info = 3] = "Info", e[e.Verbose = 4] = "Verbose", e))(vQ || {}), E; + ((e) => { + let t = 0; + e.currentLogLevel = 2, e.isDebugging = !1; + function n(Je) { + return e.currentLogLevel <= Je; + } + e.shouldLog = n; + function i(Je, ft) { + e.loggingHost && n(Je) && e.loggingHost.log(Je, ft); + } + function s(Je) { + i(3, Je); + } + e.log = s, ((Je) => { + function ft(Un) { + i(1, Un); + } + Je.error = ft; + function er(Un) { + i(2, Un); + } + Je.warn = er; + function qr(Un) { + i(3, Un); + } + Je.log = qr; + function Jn(Un) { + i(4, Un); + } + Je.trace = Jn; + })(s = e.log || (e.log = {})); + const o = {}; + function c() { + return t; + } + e.getAssertionLevel = c; + function _(Je) { + const ft = t; + if (t = Je, Je > ft) + for (const er of rm(o)) { + const qr = o[er]; + qr !== void 0 && e[er] !== qr.assertion && Je >= qr.level && (e[er] = qr, o[er] = void 0); + } + } + e.setAssertionLevel = _; + function u(Je) { + return t >= Je; + } + e.shouldAssert = u; + function g(Je, ft) { + return u(Je) ? !0 : (o[ft] = { level: Je, assertion: e[ft] }, e[ft] = Ha, !1); + } + function m(Je, ft) { + debugger; + const er = new Error(Je ? `Debug Failure. ${Je}` : "Debug Failure."); + throw Error.captureStackTrace && Error.captureStackTrace(er, ft || m), er; + } + e.fail = m; + function h(Je, ft, er) { + return m( + `${ft || "Unexpected node."}\r +Node ${be(Je.kind)} was unexpected.`, + er || h + ); + } + e.failBadSyntaxKind = h; + function S(Je, ft, er, qr) { + Je || (ft = ft ? `False expression: ${ft}` : "False expression.", er && (ft += `\r +Verbose Debug Information: ` + (typeof er == "string" ? er : er())), m(ft, qr || S)); + } + e.assert = S; + function T(Je, ft, er, qr, Jn) { + if (Je !== ft) { + const Un = er ? qr ? `${er} ${qr}` : er : ""; + m(`Expected ${Je} === ${ft}. ${Un}`, Jn || T); + } + } + e.assertEqual = T; + function k(Je, ft, er, qr) { + Je >= ft && m(`Expected ${Je} < ${ft}. ${er || ""}`, qr || k); + } + e.assertLessThan = k; + function D(Je, ft, er) { + Je > ft && m(`Expected ${Je} <= ${ft}`, er || D); + } + e.assertLessThanOrEqual = D; + function P(Je, ft, er) { + Je < ft && m(`Expected ${Je} >= ${ft}`, er || P); + } + e.assertGreaterThanOrEqual = P; + function A(Je, ft, er) { + Je == null && m(ft, er || A); + } + e.assertIsDefined = A; + function O(Je, ft, er) { + return A(Je, ft, er || O), Je; + } + e.checkDefined = O; + function F(Je, ft, er) { + for (const qr of Je) + A(qr, ft, er || F); + } + e.assertEachIsDefined = F; + function R(Je, ft, er) { + return F(Je, ft, er || R), Je; + } + e.checkEachDefined = R; + function B(Je, ft = "Illegal value:", er) { + const qr = typeof Je == "object" && eo(Je, "kind") && eo(Je, "pos") ? "SyntaxKind: " + be(Je.kind) : JSON.stringify(Je); + return m(`${ft} ${qr}`, er || B); + } + e.assertNever = B; + function U(Je, ft, er, qr) { + g(1, "assertEachNode") && S( + ft === void 0 || Ni(Je, ft), + er || "Unexpected node.", + () => `Node array did not pass test '${se(ft)}'.`, + qr || U + ); + } + e.assertEachNode = U; + function $(Je, ft, er, qr) { + g(1, "assertNode") && S( + Je !== void 0 && (ft === void 0 || ft(Je)), + er || "Unexpected node.", + () => `Node ${be(Je?.kind)} did not pass test '${se(ft)}'.`, + qr || $ + ); + } + e.assertNode = $; + function W(Je, ft, er, qr) { + g(1, "assertNotNode") && S( + Je === void 0 || ft === void 0 || !ft(Je), + er || "Unexpected node.", + () => `Node ${be(Je.kind)} should not have passed test '${se(ft)}'.`, + qr || W + ); + } + e.assertNotNode = W; + function _e(Je, ft, er, qr) { + g(1, "assertOptionalNode") && S( + ft === void 0 || Je === void 0 || ft(Je), + er || "Unexpected node.", + () => `Node ${be(Je?.kind)} did not pass test '${se(ft)}'.`, + qr || _e + ); + } + e.assertOptionalNode = _e; + function K(Je, ft, er, qr) { + g(1, "assertOptionalToken") && S( + ft === void 0 || Je === void 0 || Je.kind === ft, + er || "Unexpected node.", + () => `Node ${be(Je?.kind)} was not a '${be(ft)}' token.`, + qr || K + ); + } + e.assertOptionalToken = K; + function V(Je, ft, er) { + g(1, "assertMissingNode") && S( + Je === void 0, + ft || "Unexpected node.", + () => `Node ${be(Je.kind)} was unexpected'.`, + er || V + ); + } + e.assertMissingNode = V; + function ae(Je) { + } + e.type = ae; + function se(Je) { + if (typeof Je != "function") + return ""; + if (eo(Je, "name")) + return Je.name; + { + const ft = Function.prototype.toString.call(Je), er = /^function\s+([\w$]+)\s*\(/.exec(ft); + return er ? er[1] : ""; + } + } + e.getFunctionName = se; + function ce(Je) { + return `{ name: ${Si(Je.escapedName)}; flags: ${ne(Je.flags)}; declarations: ${hr(Je.declarations, (ft) => be(ft.kind))} }`; + } + e.formatSymbol = ce; + function fe(Je = 0, ft, er) { + const qr = q(ft); + if (Je === 0) + return qr.length > 0 && qr[0][0] === 0 ? qr[0][1] : "0"; + if (er) { + const Jn = []; + let Un = Je; + for (const [ki, Ds] of qr) { + if (ki > Je) + break; + ki !== 0 && ki & Je && (Jn.push(Ds), Un &= ~ki); + } + if (Un === 0) + return Jn.join("|"); + } else + for (const [Jn, Un] of qr) + if (Jn === Je) + return Un; + return Je.toString(); + } + e.formatEnum = fe; + const he = /* @__PURE__ */ new Map(); + function q(Je) { + const ft = he.get(Je); + if (ft) + return ft; + const er = []; + for (const Jn in Je) { + const Un = Je[Jn]; + typeof Un == "number" && er.push([Un, Jn]); + } + const qr = X_(er, (Jn, Un) => ho(Jn[0], Un[0])); + return he.set(Je, qr), qr; + } + function be(Je) { + return fe( + Je, + YR, + /*isFlags*/ + !1 + ); + } + e.formatSyntaxKind = be; + function je(Je) { + return fe( + Je, + _j, + /*isFlags*/ + !1 + ); + } + e.formatSnippetKind = je; + function me(Je) { + return fe( + Je, + lj, + /*isFlags*/ + !1 + ); + } + e.formatScriptKind = me; + function Z(Je) { + return fe( + Je, + ZR, + /*isFlags*/ + !0 + ); + } + e.formatNodeFlags = Z; + function pe(Je) { + return fe( + Je, + sj, + /*isFlags*/ + !0 + ); + } + e.formatNodeCheckFlags = pe; + function Te(Je) { + return fe( + Je, + KR, + /*isFlags*/ + !0 + ); + } + e.formatModifierFlags = Te; + function Fe(Je) { + return fe( + Je, + uj, + /*isFlags*/ + !0 + ); + } + e.formatTransformFlags = Fe; + function Ye(Je) { + return fe( + Je, + fj, + /*isFlags*/ + !0 + ); + } + e.formatEmitFlags = Ye; + function ne(Je) { + return fe( + Je, + ij, + /*isFlags*/ + !0 + ); + } + e.formatSymbolFlags = ne; + function Se(Je) { + return fe( + Je, + aj, + /*isFlags*/ + !0 + ); + } + e.formatTypeFlags = Se; + function ie(Je) { + return fe( + Je, + cj, + /*isFlags*/ + !0 + ); + } + e.formatSignatureFlags = ie; + function Ne(Je) { + return fe( + Je, + oj, + /*isFlags*/ + !0 + ); + } + e.formatObjectFlags = Ne; + function Ee(Je) { + return fe( + Je, + r7, + /*isFlags*/ + !0 + ); + } + e.formatFlowFlags = Ee; + function Ce(Je) { + return fe( + Je, + ej, + /*isFlags*/ + !0 + ); + } + e.formatRelationComparisonResult = Ce; + function Ve(Je) { + return fe( + Je, + PW, + /*isFlags*/ + !0 + ); + } + e.formatCheckMode = Ve; + function St(Je) { + return fe( + Je, + NW, + /*isFlags*/ + !0 + ); + } + e.formatSignatureCheckMode = St; + function Bt(Je) { + return fe( + Je, + wW, + /*isFlags*/ + !0 + ); + } + e.formatTypeFacts = Bt; + let tr = !1, Nr; + function st(Je) { + "__debugFlowFlags" in Je || Object.defineProperties(Je, { + // for use with vscode-js-debug's new customDescriptionGenerator in launch.json + __tsDebuggerDisplay: { + value() { + const ft = this.flags & 2 ? "FlowStart" : this.flags & 4 ? "FlowBranchLabel" : this.flags & 8 ? "FlowLoopLabel" : this.flags & 16 ? "FlowAssignment" : this.flags & 32 ? "FlowTrueCondition" : this.flags & 64 ? "FlowFalseCondition" : this.flags & 128 ? "FlowSwitchClause" : this.flags & 256 ? "FlowArrayMutation" : this.flags & 512 ? "FlowCall" : this.flags & 1024 ? "FlowReduceLabel" : this.flags & 1 ? "FlowUnreachable" : "UnknownFlow", er = this.flags & -2048; + return `${ft}${er ? ` (${Ee(er)})` : ""}`; + } + }, + __debugFlowFlags: { + get() { + return fe( + this.flags, + r7, + /*isFlags*/ + !0 + ); + } + }, + __debugToString: { + value() { + return _i(this); + } + } + }); + } + function Wt(Je) { + return tr && (typeof Object.setPrototypeOf == "function" ? (Nr || (Nr = Object.create(Object.prototype), st(Nr)), Object.setPrototypeOf(Je, Nr)) : st(Je)), Je; + } + e.attachFlowNodeDebugInfo = Wt; + let Jr; + function ui(Je) { + "__tsDebuggerDisplay" in Je || Object.defineProperties(Je, { + __tsDebuggerDisplay: { + value(ft) { + return ft = String(ft).replace(/(?:,[\s\w]+:[^,]+)+\]$/, "]"), `NodeArray ${ft}`; + } + } + }); + } + function Ji(Je) { + tr && (typeof Object.setPrototypeOf == "function" ? (Jr || (Jr = Object.create(Array.prototype), ui(Jr)), Object.setPrototypeOf(Je, Jr)) : ui(Je)); + } + e.attachNodeArrayDebugInfo = Ji; + function Dt() { + if (tr) return; + const Je = /* @__PURE__ */ new WeakMap(), ft = /* @__PURE__ */ new WeakMap(); + Object.defineProperties(tu.getSymbolConstructor().prototype, { + // for use with vscode-js-debug's new customDescriptionGenerator in launch.json + __tsDebuggerDisplay: { + value() { + const qr = this.flags & 33554432 ? "TransientSymbol" : "Symbol", Jn = this.flags & -33554433; + return `${qr} '${cc(this)}'${Jn ? ` (${ne(Jn)})` : ""}`; + } + }, + __debugFlags: { + get() { + return ne(this.flags); + } + } + }), Object.defineProperties(tu.getTypeConstructor().prototype, { + // for use with vscode-js-debug's new customDescriptionGenerator in launch.json + __tsDebuggerDisplay: { + value() { + const qr = this.flags & 67359327 ? `IntrinsicType ${this.intrinsicName}${this.debugIntrinsicName ? ` (${this.debugIntrinsicName})` : ""}` : this.flags & 98304 ? "NullableType" : this.flags & 384 ? `LiteralType ${JSON.stringify(this.value)}` : this.flags & 2048 ? `LiteralType ${this.value.negative ? "-" : ""}${this.value.base10Value}n` : this.flags & 8192 ? "UniqueESSymbolType" : this.flags & 32 ? "EnumType" : this.flags & 1048576 ? "UnionType" : this.flags & 2097152 ? "IntersectionType" : this.flags & 4194304 ? "IndexType" : this.flags & 8388608 ? "IndexedAccessType" : this.flags & 16777216 ? "ConditionalType" : this.flags & 33554432 ? "SubstitutionType" : this.flags & 262144 ? "TypeParameter" : this.flags & 524288 ? this.objectFlags & 3 ? "InterfaceType" : this.objectFlags & 4 ? "TypeReference" : this.objectFlags & 8 ? "TupleType" : this.objectFlags & 16 ? "AnonymousType" : this.objectFlags & 32 ? "MappedType" : this.objectFlags & 1024 ? "ReverseMappedType" : this.objectFlags & 256 ? "EvolvingArrayType" : "ObjectType" : "Type", Jn = this.flags & 524288 ? this.objectFlags & -1344 : 0; + return `${qr}${this.symbol ? ` '${cc(this.symbol)}'` : ""}${Jn ? ` (${Ne(Jn)})` : ""}`; + } + }, + __debugFlags: { + get() { + return Se(this.flags); + } + }, + __debugObjectFlags: { + get() { + return this.flags & 524288 ? Ne(this.objectFlags) : ""; + } + }, + __debugTypeToString: { + value() { + let qr = Je.get(this); + return qr === void 0 && (qr = this.checker.typeToString(this), Je.set(this, qr)), qr; + } + } + }), Object.defineProperties(tu.getSignatureConstructor().prototype, { + __debugFlags: { + get() { + return ie(this.flags); + } + }, + __debugSignatureToString: { + value() { + var qr; + return (qr = this.checker) == null ? void 0 : qr.signatureToString(this); + } + } + }); + const er = [ + tu.getNodeConstructor(), + tu.getIdentifierConstructor(), + tu.getTokenConstructor(), + tu.getSourceFileConstructor() + ]; + for (const qr of er) + eo(qr.prototype, "__debugKind") || Object.defineProperties(qr.prototype, { + // for use with vscode-js-debug's new customDescriptionGenerator in launch.json + __tsDebuggerDisplay: { + value() { + return `${Bo(this) ? "GeneratedIdentifier" : Me(this) ? `Identifier '${An(this)}'` : Ai(this) ? `PrivateIdentifier '${An(this)}'` : ca(this) ? `StringLiteral ${JSON.stringify(this.text.length < 10 ? this.text : this.text.slice(10) + "...")}` : E_(this) ? `NumericLiteral ${this.text}` : u6(this) ? `BigIntLiteral ${this.text}n` : Lo(this) ? "TypeParameterDeclaration" : Ii(this) ? "ParameterDeclaration" : nc(this) ? "ConstructorDeclaration" : pp(this) ? "GetAccessorDeclaration" : z_(this) ? "SetAccessorDeclaration" : Ux(this) ? "CallSignatureDeclaration" : N4(this) ? "ConstructSignatureDeclaration" : qy(this) ? "IndexSignatureDeclaration" : Vx(this) ? "TypePredicateNode" : of(this) ? "TypeReferenceNode" : Zm(this) ? "FunctionTypeNode" : _6(this) ? "ConstructorTypeNode" : Hb(this) ? "TypeQueryNode" : a_(this) ? "TypeLiteralNode" : jN(this) ? "ArrayTypeNode" : qx(this) ? "TupleTypeNode" : CF(this) ? "OptionalTypeNode" : EF(this) ? "RestTypeNode" : C0(this) ? "UnionTypeNode" : Hx(this) ? "IntersectionTypeNode" : Gb(this) ? "ConditionalTypeNode" : xS(this) ? "InferTypeNode" : kS(this) ? "ParenthesizedTypeNode" : A4(this) ? "ThisTypeNode" : rv(this) ? "TypeOperatorNode" : $b(this) ? "IndexedAccessTypeNode" : CS(this) ? "MappedTypeNode" : E0(this) ? "LiteralTypeNode" : f6(this) ? "NamedTupleMember" : ym(this) ? "ImportTypeNode" : be(this.kind)}${this.flags ? ` (${Z(this.flags)})` : ""}`; + } + }, + __debugKind: { + get() { + return be(this.kind); + } + }, + __debugNodeFlags: { + get() { + return Z(this.flags); + } + }, + __debugModifierFlags: { + get() { + return Te(nee(this)); + } + }, + __debugTransformFlags: { + get() { + return Fe(this.transformFlags); + } + }, + __debugIsParseTreeNode: { + get() { + return bD(this); + } + }, + __debugEmitFlags: { + get() { + return Ye(Ea(this)); + } + }, + __debugGetText: { + value(Jn) { + if (lo(this)) return ""; + let Un = ft.get(this); + if (Un === void 0) { + const ki = vs(this), Ds = ki && xr(ki); + Un = Ds ? Db(Ds, ki, Jn) : "", ft.set(this, Un); + } + return Un; + } + } + }); + tr = !0; + } + e.enableDebugInfo = Dt; + function Mn(Je) { + const ft = Je & 7; + let er = ft === 0 ? "in out" : ft === 3 ? "[bivariant]" : ft === 2 ? "in" : ft === 1 ? "out" : ft === 4 ? "[independent]" : ""; + return Je & 8 ? er += " (unmeasurable)" : Je & 16 && (er += " (unreliable)"), er; + } + e.formatVariance = Mn; + class ai { + __debugToString() { + var ft; + switch (this.kind) { + case 3: + return ((ft = this.debugInfo) == null ? void 0 : ft.call(this)) || "(function mapper)"; + case 0: + return `${this.source.__debugTypeToString()} -> ${this.target.__debugTypeToString()}`; + case 1: + return TR( + this.sources, + this.targets || hr(this.sources, () => "any"), + (er, qr) => `${er.__debugTypeToString()} -> ${typeof qr == "string" ? qr : qr.__debugTypeToString()}` + ).join(", "); + case 2: + return TR( + this.sources, + this.targets, + (er, qr) => `${er.__debugTypeToString()} -> ${qr().__debugTypeToString()}` + ).join(", "); + case 5: + case 4: + return `m1: ${this.mapper1.__debugToString().split(` +`).join(` + `)} +m2: ${this.mapper2.__debugToString().split(` +`).join(` + `)}`; + default: + return B(this); + } + } + } + e.DebugTypeMapper = ai; + function fi(Je) { + return e.isDebugging ? Object.setPrototypeOf(Je, ai.prototype) : Je; + } + e.attachDebugPrototypeIfDebug = fi; + function pn(Je) { + return console.log(_i(Je)); + } + e.printControlFlowGraph = pn; + function _i(Je) { + let ft = -1; + function er(ye) { + return ye.id || (ye.id = ft, ft--), ye.id; + } + let qr; + ((ye) => { + ye.lr = "─", ye.ud = "│", ye.dr = "╭", ye.dl = "╮", ye.ul = "╯", ye.ur = "╰", ye.udr = "├", ye.udl = "┤", ye.dlr = "┬", ye.ulr = "┴", ye.udlr = "╫"; + })(qr || (qr = {})); + let Jn; + ((ye) => { + ye[ye.None = 0] = "None", ye[ye.Up = 1] = "Up", ye[ye.Down = 2] = "Down", ye[ye.Left = 4] = "Left", ye[ye.Right = 8] = "Right", ye[ye.UpDown = 3] = "UpDown", ye[ye.LeftRight = 12] = "LeftRight", ye[ye.UpLeft = 5] = "UpLeft", ye[ye.UpRight = 9] = "UpRight", ye[ye.DownLeft = 6] = "DownLeft", ye[ye.DownRight = 10] = "DownRight", ye[ye.UpDownLeft = 7] = "UpDownLeft", ye[ye.UpDownRight = 11] = "UpDownRight", ye[ye.UpLeftRight = 13] = "UpLeftRight", ye[ye.DownLeftRight = 14] = "DownLeftRight", ye[ye.UpDownLeftRight = 15] = "UpDownLeftRight", ye[ye.NoChildren = 16] = "NoChildren"; + })(Jn || (Jn = {})); + const Un = 2032, ki = 882, Ds = /* @__PURE__ */ Object.create( + /*o*/ + null + ), Ks = [], yr = Ke(Je, /* @__PURE__ */ new Set()); + for (const ye of Ks) + ye.text = rn(ye.flowNode, ye.circular), Le(ye); + const bs = mt(yr), Xe = pt(bs); + return Ct(yr, 0), Pe(); + function Et(ye) { + return !!(ye.flags & 128); + } + function re(ye) { + return !!(ye.flags & 12) && !!ye.antecedent; + } + function it(ye) { + return !!(ye.flags & Un); + } + function Y(ye) { + return !!(ye.flags & ki); + } + function Ae(ye) { + const Q = []; + for (const dt of ye.edges) + dt.source === ye && Q.push(dt.target); + return Q; + } + function $e(ye) { + const Q = []; + for (const dt of ye.edges) + dt.target === ye && Q.push(dt.source); + return Q; + } + function Ke(ye, Q) { + const dt = er(ye); + let Mt = Ds[dt]; + if (Mt && Q.has(ye)) + return Mt.circular = !0, Mt = { + id: -1, + flowNode: ye, + edges: [], + text: "", + lane: -1, + endLane: -1, + level: -1, + circular: "circularity" + }, Ks.push(Mt), Mt; + if (Q.add(ye), !Mt) + if (Ds[dt] = Mt = { id: dt, flowNode: ye, edges: [], text: "", lane: -1, endLane: -1, level: -1, circular: !1 }, Ks.push(Mt), re(ye)) + for (const ke of ye.antecedent) + Tt(Mt, ke, Q); + else it(ye) && Tt(Mt, ye.antecedent, Q); + return Q.delete(ye), Mt; + } + function Tt(ye, Q, dt) { + const Mt = Ke(Q, dt), ke = { source: ye, target: Mt }; + ye.edges.push(ke), Mt.edges.push(ke); + } + function Le(ye) { + if (ye.level !== -1) + return ye.level; + let Q = 0; + for (const dt of $e(ye)) + Q = Math.max(Q, Le(dt) + 1); + return ye.level = Q; + } + function mt(ye) { + let Q = 0; + for (const dt of Ae(ye)) + Q = Math.max(Q, mt(dt)); + return Q + 1; + } + function pt(ye) { + const Q = ue(Array(ye), 0); + for (const dt of Ks) + Q[dt.level] = Math.max(Q[dt.level], dt.text.length); + return Q; + } + function Ct(ye, Q) { + if (ye.lane === -1) { + ye.lane = Q, ye.endLane = Q; + const dt = Ae(ye); + for (let Mt = 0; Mt < dt.length; Mt++) { + Mt > 0 && Q++; + const ke = dt[Mt]; + Ct(ke, Q), ke.endLane > ye.endLane && (Q = ke.endLane); + } + ye.endLane = Q; + } + } + function qe(ye) { + if (ye & 2) return "Start"; + if (ye & 4) return "Branch"; + if (ye & 8) return "Loop"; + if (ye & 16) return "Assignment"; + if (ye & 32) return "True"; + if (ye & 64) return "False"; + if (ye & 128) return "SwitchClause"; + if (ye & 256) return "ArrayMutation"; + if (ye & 512) return "Call"; + if (ye & 1024) return "ReduceLabel"; + if (ye & 1) return "Unreachable"; + throw new Error(); + } + function Lt(ye) { + const Q = xr(ye); + return Db( + Q, + ye, + /*includeTrivia*/ + !1 + ); + } + function rn(ye, Q) { + let dt = qe(ye.flags); + if (Q && (dt = `${dt}#${er(ye)}`), Et(ye)) { + const Mt = [], { switchStatement: ke, clauseStart: at, clauseEnd: wt } = ye.node; + for (let Zr = at; Zr < wt; Zr++) { + const Rr = ke.caseBlock.clauses[Zr]; + L4(Rr) ? Mt.push("default") : Mt.push(Lt(Rr.expression)); + } + dt += ` (${Mt.join(", ")})`; + } else Y(ye) && ye.node && (dt += ` (${Lt(ye.node)})`); + return Q === "circularity" ? `Circular(${dt})` : dt; + } + function Pe() { + const ye = Xe.length, Q = BR(Ks, 0, (wt) => wt.lane) + 1, dt = ue(Array(Q), ""), Mt = Xe.map(() => Array(Q)), ke = Xe.map(() => ue(Array(Q), 0)); + for (const wt of Ks) { + Mt[wt.level][wt.lane] = wt; + const Zr = Ae(wt); + for (let Pr = 0; Pr < Zr.length; Pr++) { + const rt = Zr[Pr]; + let vt = 8; + rt.lane === wt.lane && (vt |= 4), Pr > 0 && (vt |= 1), Pr < Zr.length - 1 && (vt |= 2), ke[wt.level][rt.lane] |= vt; + } + Zr.length === 0 && (ke[wt.level][wt.lane] |= 16); + const Rr = $e(wt); + for (let Pr = 0; Pr < Rr.length; Pr++) { + const rt = Rr[Pr]; + let vt = 4; + Pr > 0 && (vt |= 1), Pr < Rr.length - 1 && (vt |= 2), ke[wt.level - 1][rt.lane] |= vt; + } + } + for (let wt = 0; wt < ye; wt++) + for (let Zr = 0; Zr < Q; Zr++) { + const Rr = wt > 0 ? ke[wt - 1][Zr] : 0, Pr = Zr > 0 ? ke[wt][Zr - 1] : 0; + let rt = ke[wt][Zr]; + rt || (Rr & 8 && (rt |= 12), Pr & 2 && (rt |= 3), ke[wt][Zr] = rt); + } + for (let wt = 0; wt < ye; wt++) + for (let Zr = 0; Zr < dt.length; Zr++) { + const Rr = ke[wt][Zr], Pr = Rr & 4 ? "─" : " ", rt = Mt[wt][Zr]; + rt ? (at(Zr, rt.text), wt < ye - 1 && (at(Zr, " "), at(Zr, M(Pr, Xe[wt] - rt.text.length)))) : wt < ye - 1 && at(Zr, M(Pr, Xe[wt] + 1)), at(Zr, yt(Rr)), at(Zr, Rr & 8 && wt < ye - 1 && !Mt[wt + 1][Zr] ? "─" : " "); + } + return ` +${dt.join(` +`)} +`; + function at(wt, Zr) { + dt[wt] += Zr; + } + } + function yt(ye) { + switch (ye) { + case 3: + return "│"; + case 12: + return "─"; + case 5: + return "╯"; + case 9: + return "╰"; + case 6: + return "╮"; + case 10: + return "╭"; + case 7: + return "┤"; + case 11: + return "├"; + case 13: + return "┴"; + case 14: + return "┬"; + case 15: + return "╫"; + } + return " "; + } + function ue(ye, Q) { + if (ye.fill) + ye.fill(Q); + else + for (let dt = 0; dt < ye.length; dt++) + ye[dt] = Q; + return ye; + } + function M(ye, Q) { + if (ye.repeat) + return Q > 0 ? ye.repeat(Q) : ""; + let dt = ""; + for (; dt.length < Q; ) + dt += ye; + return dt; + } + } + e.formatControlFlowGraph = _i; + })(E || (E = {})); + var iFe = /^(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i, sFe = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)(?:\.(?:0|[1-9]\d*|[a-z-][a-z0-9-]*))*$/i, aFe = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)$/i, oFe = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/i, cFe = /^[a-z0-9-]+$/i, Tge = /^(?:0|[1-9]\d*)$/, bQ = class HI { + constructor(t, n = 0, i = 0, s = "", o = "") { + typeof t == "string" && ({ major: t, minor: n, patch: i, prerelease: s, build: o } = E.checkDefined(xge(t), "Invalid version")), E.assert(t >= 0, "Invalid argument: major"), E.assert(n >= 0, "Invalid argument: minor"), E.assert(i >= 0, "Invalid argument: patch"); + const c = s ? as(s) ? s : s.split(".") : Ge, _ = o ? as(o) ? o : o.split(".") : Ge; + E.assert(Ni(c, (u) => aFe.test(u)), "Invalid argument: prerelease"), E.assert(Ni(_, (u) => cFe.test(u)), "Invalid argument: build"), this.major = t, this.minor = n, this.patch = i, this.prerelease = c, this.build = _; + } + static tryParse(t) { + const n = xge(t); + if (!n) return; + const { major: i, minor: s, patch: o, prerelease: c, build: _ } = n; + return new HI(i, s, o, c, _); + } + compareTo(t) { + return this === t ? 0 : t === void 0 ? 1 : ho(this.major, t.major) || ho(this.minor, t.minor) || ho(this.patch, t.patch) || lFe(this.prerelease, t.prerelease); + } + increment(t) { + switch (t) { + case "major": + return new HI(this.major + 1, 0, 0); + case "minor": + return new HI(this.major, this.minor + 1, 0); + case "patch": + return new HI(this.major, this.minor, this.patch + 1); + default: + return E.assertNever(t); + } + } + with(t) { + const { + major: n = this.major, + minor: i = this.minor, + patch: s = this.patch, + prerelease: o = this.prerelease, + build: c = this.build + } = t; + return new HI(n, i, s, o, c); + } + toString() { + let t = `${this.major}.${this.minor}.${this.patch}`; + return ot(this.prerelease) && (t += `-${this.prerelease.join(".")}`), ot(this.build) && (t += `+${this.build.join(".")}`), t; + } + }; + bQ.zero = new bQ(0, 0, 0, ["0"]); + var xd = bQ; + function xge(e) { + const t = iFe.exec(e); + if (!t) return; + const [, n, i = "0", s = "0", o = "", c = ""] = t; + if (!(o && !sFe.test(o)) && !(c && !oFe.test(c))) + return { + major: parseInt(n, 10), + minor: parseInt(i, 10), + patch: parseInt(s, 10), + prerelease: o, + build: c + }; + } + function lFe(e, t) { + if (e === t) return 0; + if (e.length === 0) return t.length === 0 ? 0 : 1; + if (t.length === 0) return -1; + const n = Math.min(e.length, t.length); + for (let i = 0; i < n; i++) { + const s = e[i], o = t[i]; + if (s === o) continue; + const c = Tge.test(s), _ = Tge.test(o); + if (c || _) { + if (c !== _) return c ? -1 : 1; + const u = ho(+s, +o); + if (u) return u; + } else { + const u = _u(s, o); + if (u) return u; + } + } + return ho(e.length, t.length); + } + var t7 = class B5e { + constructor(t) { + this._alternatives = t ? E.checkDefined(kge(t), "Invalid range spec.") : Ge; + } + static tryParse(t) { + const n = kge(t); + if (n) { + const i = new B5e(""); + return i._alternatives = n, i; + } + } + /** + * Tests whether a version matches the range. This is equivalent to `satisfies(version, range, { includePrerelease: true })`. + * in `node-semver`. + */ + test(t) { + return typeof t == "string" && (t = new xd(t)), hFe(t, this._alternatives); + } + toString() { + return bFe(this._alternatives); + } + }, uFe = /\|\|/, _Fe = /\s+/, fFe = /^([x*0]|[1-9]\d*)(?:\.([x*0]|[1-9]\d*)(?:\.([x*0]|[1-9]\d*)(?:-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i, pFe = /^\s*([a-z0-9-+.*]+)\s+-\s+([a-z0-9-+.*]+)\s*$/i, dFe = /^([~^<>=]|<=|>=)?\s*([a-z0-9-+.*]+)$/i; + function kge(e) { + const t = []; + for (let n of e.trim().split(uFe)) { + if (!n) continue; + const i = []; + n = n.trim(); + const s = pFe.exec(n); + if (s) { + if (!mFe(s[1], s[2], i)) return; + } else + for (const o of n.split(_Fe)) { + const c = dFe.exec(o.trim()); + if (!c || !gFe(c[1], c[2], i)) return; + } + t.push(i); + } + return t; + } + function SQ(e) { + const t = fFe.exec(e); + if (!t) return; + const [, n, i = "*", s = "*", o, c] = t; + return { version: new xd( + Op(n) ? 0 : parseInt(n, 10), + Op(n) || Op(i) ? 0 : parseInt(i, 10), + Op(n) || Op(i) || Op(s) ? 0 : parseInt(s, 10), + o, + c + ), major: n, minor: i, patch: s }; + } + function mFe(e, t, n) { + const i = SQ(e); + if (!i) return !1; + const s = SQ(t); + return s ? (Op(i.major) || n.push(Um(">=", i.version)), Op(s.major) || n.push( + Op(s.minor) ? Um("<", s.version.increment("major")) : Op(s.patch) ? Um("<", s.version.increment("minor")) : Um("<=", s.version) + ), !0) : !1; + } + function gFe(e, t, n) { + const i = SQ(t); + if (!i) return !1; + const { version: s, major: o, minor: c, patch: _ } = i; + if (Op(o)) + (e === "<" || e === ">") && n.push(Um("<", xd.zero)); + else switch (e) { + case "~": + n.push(Um(">=", s)), n.push(Um( + "<", + s.increment( + Op(c) ? "major" : "minor" + ) + )); + break; + case "^": + n.push(Um(">=", s)), n.push(Um( + "<", + s.increment( + s.major > 0 || Op(c) ? "major" : s.minor > 0 || Op(_) ? "minor" : "patch" + ) + )); + break; + case "<": + case ">=": + n.push( + Op(c) || Op(_) ? Um(e, s.with({ prerelease: "0" })) : Um(e, s) + ); + break; + case "<=": + case ">": + n.push( + Op(c) ? Um(e === "<=" ? "<" : ">=", s.increment("major").with({ prerelease: "0" })) : Op(_) ? Um(e === "<=" ? "<" : ">=", s.increment("minor").with({ prerelease: "0" })) : Um(e, s) + ); + break; + case "=": + case void 0: + Op(c) || Op(_) ? (n.push(Um(">=", s.with({ prerelease: "0" }))), n.push(Um("<", s.increment(Op(c) ? "major" : "minor").with({ prerelease: "0" })))) : n.push(Um("=", s)); + break; + default: + return !1; + } + return !0; + } + function Op(e) { + return e === "*" || e === "x" || e === "X"; + } + function Um(e, t) { + return { operator: e, operand: t }; + } + function hFe(e, t) { + if (t.length === 0) return !0; + for (const n of t) + if (yFe(e, n)) return !0; + return !1; + } + function yFe(e, t) { + for (const n of t) + if (!vFe(e, n.operator, n.operand)) return !1; + return !0; + } + function vFe(e, t, n) { + const i = e.compareTo(n); + switch (t) { + case "<": + return i < 0; + case "<=": + return i <= 0; + case ">": + return i > 0; + case ">=": + return i >= 0; + case "=": + return i === 0; + default: + return E.assertNever(t); + } + } + function bFe(e) { + return hr(e, SFe).join(" || ") || "*"; + } + function SFe(e) { + return hr(e, TFe).join(" "); + } + function TFe(e) { + return `${e.operator}${e.operand}`; + } + function xFe() { + if (GR()) + try { + const { performance: e } = QE; + if (e) + return { + shouldWriteNativeEvents: !1, + performance: e + }; + } catch { + } + if (typeof performance == "object") + return { + shouldWriteNativeEvents: !0, + performance + }; + } + function kFe() { + const e = xFe(); + if (!e) return; + const { shouldWriteNativeEvents: t, performance: n } = e, i = { + shouldWriteNativeEvents: t, + performance: void 0, + performanceTime: void 0 + }; + return typeof n.timeOrigin == "number" && typeof n.now == "function" && (i.performanceTime = n), i.performanceTime && typeof n.mark == "function" && typeof n.measure == "function" && typeof n.clearMarks == "function" && typeof n.clearMeasures == "function" && (i.performance = n), i; + } + var TQ = kFe(), Cge = TQ?.performanceTime; + function xQ() { + return TQ; + } + var ao = Cge ? () => Cge.now() : Date.now, kQ = {}; + Na(kQ, { + clearMarks: () => Age, + clearMeasures: () => Nge, + createTimer: () => $R, + createTimerIf: () => Ege, + disable: () => DQ, + enable: () => QR, + forEachMark: () => Pge, + forEachMeasure: () => XR, + getCount: () => wge, + getDuration: () => cD, + isEnabled: () => EQ, + mark: () => Ko, + measure: () => rp, + nullTimer: () => CQ + }); + var iD, G2; + function Ege(e, t, n, i) { + return e ? $R(t, n, i) : CQ; + } + function $R(e, t, n) { + let i = 0; + return { + enter: s, + exit: o + }; + function s() { + ++i === 1 && Ko(t); + } + function o() { + --i === 0 ? (Ko(n), rp(e, t, n)) : i < 0 && E.fail("enter/exit count does not match."); + } + } + var CQ = { enter: Ha, exit: Ha }, sD = !1, Dge = ao(), aD = /* @__PURE__ */ new Map(), UP = /* @__PURE__ */ new Map(), oD = /* @__PURE__ */ new Map(); + function Ko(e) { + if (sD) { + const t = UP.get(e) ?? 0; + UP.set(e, t + 1), aD.set(e, ao()), G2?.mark(e), typeof onProfilerEvent == "function" && onProfilerEvent(e); + } + } + function rp(e, t, n) { + if (sD) { + const i = (n !== void 0 ? aD.get(n) : void 0) ?? ao(), s = (t !== void 0 ? aD.get(t) : void 0) ?? Dge, o = oD.get(e) || 0; + oD.set(e, o + (i - s)), G2?.measure(e, t, n); + } + } + function wge(e) { + return UP.get(e) || 0; + } + function cD(e) { + return oD.get(e) || 0; + } + function XR(e) { + oD.forEach((t, n) => e(n, t)); + } + function Pge(e) { + aD.forEach((t, n) => e(n)); + } + function Nge(e) { + e !== void 0 ? oD.delete(e) : oD.clear(), G2?.clearMeasures(e); + } + function Age(e) { + e !== void 0 ? (UP.delete(e), aD.delete(e)) : (UP.clear(), aD.clear()), G2?.clearMarks(e); + } + function EQ() { + return sD; + } + function QR(e = ml) { + var t; + return sD || (sD = !0, iD || (iD = xQ()), iD?.performance && (Dge = iD.performance.timeOrigin, (iD.shouldWriteNativeEvents || (t = e?.cpuProfilingEnabled) != null && t.call(e) || e?.debugMode) && (G2 = iD.performance))), !0; + } + function DQ() { + sD && (aD.clear(), UP.clear(), oD.clear(), G2 = void 0, sD = !1); + } + var on, VP; + ((e) => { + let t, n = 0, i = 0, s; + const o = []; + let c; + const _ = []; + function u(U, $, W) { + if (E.assert(!on, "Tracing already started"), t === void 0) + try { + t = QE; + } catch (se) { + throw new Error(`tracing requires having fs +(original error: ${se.message || se})`); + } + s = U, o.length = 0, c === void 0 && (c = On($, "legend.json")), t.existsSync($) || t.mkdirSync($, { recursive: !0 }); + const _e = s === "build" ? `.${process.pid}-${++n}` : s === "server" ? `.${process.pid}` : "", K = On($, `trace${_e}.json`), V = On($, `types${_e}.json`); + _.push({ + configFilePath: W, + tracePath: K, + typesPath: V + }), i = t.openSync(K, "w"), on = e; + const ae = { cat: "__metadata", ph: "M", ts: 1e3 * ao(), pid: 1, tid: 1 }; + t.writeSync( + i, + `[ +` + [{ name: "process_name", args: { name: "tsc" }, ...ae }, { name: "thread_name", args: { name: "Main" }, ...ae }, { name: "TracingStartedInBrowser", ...ae, cat: "disabled-by-default-devtools.timeline" }].map((se) => JSON.stringify(se)).join(`, +`) + ); + } + e.startTracing = u; + function g() { + E.assert(on, "Tracing is not in progress"), E.assert(!!o.length == (s !== "server")), t.writeSync(i, ` +] +`), t.closeSync(i), on = void 0, o.length ? R(o) : _[_.length - 1].typesPath = void 0; + } + e.stopTracing = g; + function m(U) { + s !== "server" && o.push(U); + } + e.recordType = m, ((U) => { + U.Parse = "parse", U.Program = "program", U.Bind = "bind", U.Check = "check", U.CheckTypes = "checkTypes", U.Emit = "emit", U.Session = "session"; + })(e.Phase || (e.Phase = {})); + function h(U, $, W) { + O("I", U, $, W, '"s":"g"'); + } + e.instant = h; + const S = []; + function T(U, $, W, _e = !1) { + _e && O("B", U, $, W), S.push({ phase: U, name: $, args: W, time: 1e3 * ao(), separateBeginAndEnd: _e }); + } + e.push = T; + function k(U) { + E.assert(S.length > 0), A(S.length - 1, 1e3 * ao(), U), S.length--; + } + e.pop = k; + function D() { + const U = 1e3 * ao(); + for (let $ = S.length - 1; $ >= 0; $--) + A($, U); + S.length = 0; + } + e.popAll = D; + const P = 1e3 * 10; + function A(U, $, W) { + const { phase: _e, name: K, args: V, time: ae, separateBeginAndEnd: se } = S[U]; + se ? (E.assert(!W, "`results` are not supported for events with `separateBeginAndEnd`"), O( + "E", + _e, + K, + V, + /*extras*/ + void 0, + $ + )) : P - ae % P <= $ - ae && O("X", _e, K, { ...V, results: W }, `"dur":${$ - ae}`, ae); + } + function O(U, $, W, _e, K, V = 1e3 * ao()) { + s === "server" && $ === "checkTypes" || (Ko("beginTracing"), t.writeSync(i, `, +{"pid":1,"tid":1,"ph":"${U}","cat":"${$}","ts":${V},"name":"${W}"`), K && t.writeSync(i, `,${K}`), _e && t.writeSync(i, `,"args":${JSON.stringify(_e)}`), t.writeSync(i, "}"), Ko("endTracing"), rp("Tracing", "beginTracing", "endTracing")); + } + function F(U) { + const $ = xr(U); + return $ ? { + path: $.path, + start: W(js($, U.pos)), + end: W(js($, U.end)) + } : void 0; + function W(_e) { + return { + line: _e.line + 1, + character: _e.character + 1 + }; + } + } + function R(U) { + var $, W, _e, K, V, ae, se, ce, fe, he, q, be, je, me, Z, pe, Te, Fe, Ye; + Ko("beginDumpTypes"); + const ne = _[_.length - 1].typesPath, Se = t.openSync(ne, "w"), ie = /* @__PURE__ */ new Map(); + t.writeSync(Se, "["); + const Ne = U.length; + for (let Ee = 0; Ee < Ne; Ee++) { + const Ce = U[Ee], Ve = Ce.objectFlags, St = Ce.aliasSymbol ?? Ce.symbol; + let Bt; + if (Ve & 16 | Ce.flags & 2944) + try { + Bt = ($ = Ce.checker) == null ? void 0 : $.typeToString(Ce); + } catch { + Bt = void 0; + } + let tr = {}; + if (Ce.flags & 8388608) { + const ai = Ce; + tr = { + indexedAccessObjectType: (W = ai.objectType) == null ? void 0 : W.id, + indexedAccessIndexType: (_e = ai.indexType) == null ? void 0 : _e.id + }; + } + let Nr = {}; + if (Ve & 4) { + const ai = Ce; + Nr = { + instantiatedType: (K = ai.target) == null ? void 0 : K.id, + typeArguments: (V = ai.resolvedTypeArguments) == null ? void 0 : V.map((fi) => fi.id), + referenceLocation: F(ai.node) + }; + } + let st = {}; + if (Ce.flags & 16777216) { + const ai = Ce; + st = { + conditionalCheckType: (ae = ai.checkType) == null ? void 0 : ae.id, + conditionalExtendsType: (se = ai.extendsType) == null ? void 0 : se.id, + conditionalTrueType: ((ce = ai.resolvedTrueType) == null ? void 0 : ce.id) ?? -1, + conditionalFalseType: ((fe = ai.resolvedFalseType) == null ? void 0 : fe.id) ?? -1 + }; + } + let Wt = {}; + if (Ce.flags & 33554432) { + const ai = Ce; + Wt = { + substitutionBaseType: (he = ai.baseType) == null ? void 0 : he.id, + constraintType: (q = ai.constraint) == null ? void 0 : q.id + }; + } + let Jr = {}; + if (Ve & 1024) { + const ai = Ce; + Jr = { + reverseMappedSourceType: (be = ai.source) == null ? void 0 : be.id, + reverseMappedMappedType: (je = ai.mappedType) == null ? void 0 : je.id, + reverseMappedConstraintType: (me = ai.constraintType) == null ? void 0 : me.id + }; + } + let ui = {}; + if (Ve & 256) { + const ai = Ce; + ui = { + evolvingArrayElementType: ai.elementType.id, + evolvingArrayFinalType: (Z = ai.finalArrayType) == null ? void 0 : Z.id + }; + } + let Ji; + const Dt = Ce.checker.getRecursionIdentity(Ce); + Dt && (Ji = ie.get(Dt), Ji || (Ji = ie.size, ie.set(Dt, Ji))); + const Mn = { + id: Ce.id, + intrinsicName: Ce.intrinsicName, + symbolName: St?.escapedName && Si(St.escapedName), + recursionId: Ji, + isTuple: Ve & 8 ? !0 : void 0, + unionTypes: Ce.flags & 1048576 ? (pe = Ce.types) == null ? void 0 : pe.map((ai) => ai.id) : void 0, + intersectionTypes: Ce.flags & 2097152 ? Ce.types.map((ai) => ai.id) : void 0, + aliasTypeArguments: (Te = Ce.aliasTypeArguments) == null ? void 0 : Te.map((ai) => ai.id), + keyofType: Ce.flags & 4194304 ? (Fe = Ce.type) == null ? void 0 : Fe.id : void 0, + ...tr, + ...Nr, + ...st, + ...Wt, + ...Jr, + ...ui, + destructuringPattern: F(Ce.pattern), + firstDeclaration: F((Ye = St?.declarations) == null ? void 0 : Ye[0]), + flags: E.formatTypeFlags(Ce.flags).split("|"), + display: Bt + }; + t.writeSync(Se, JSON.stringify(Mn)), Ee < Ne - 1 && t.writeSync(Se, `, +`); + } + t.writeSync(Se, `] +`), t.closeSync(Se), Ko("endDumpTypes"), rp("Dump types", "beginDumpTypes", "endDumpTypes"); + } + function B() { + c && t.writeFileSync(c, JSON.stringify(_)); + } + e.dumpLegend = B; + })(VP || (VP = {})); + var wQ = VP.startTracing, PQ = VP.dumpLegend, YR = /* @__PURE__ */ ((e) => (e[e.Unknown = 0] = "Unknown", e[e.EndOfFileToken = 1] = "EndOfFileToken", e[e.SingleLineCommentTrivia = 2] = "SingleLineCommentTrivia", e[e.MultiLineCommentTrivia = 3] = "MultiLineCommentTrivia", e[e.NewLineTrivia = 4] = "NewLineTrivia", e[e.WhitespaceTrivia = 5] = "WhitespaceTrivia", e[e.ShebangTrivia = 6] = "ShebangTrivia", e[e.ConflictMarkerTrivia = 7] = "ConflictMarkerTrivia", e[e.NonTextFileMarkerTrivia = 8] = "NonTextFileMarkerTrivia", e[e.NumericLiteral = 9] = "NumericLiteral", e[e.BigIntLiteral = 10] = "BigIntLiteral", e[e.StringLiteral = 11] = "StringLiteral", e[e.JsxText = 12] = "JsxText", e[e.JsxTextAllWhiteSpaces = 13] = "JsxTextAllWhiteSpaces", e[e.RegularExpressionLiteral = 14] = "RegularExpressionLiteral", e[e.NoSubstitutionTemplateLiteral = 15] = "NoSubstitutionTemplateLiteral", e[e.TemplateHead = 16] = "TemplateHead", e[e.TemplateMiddle = 17] = "TemplateMiddle", e[e.TemplateTail = 18] = "TemplateTail", e[e.OpenBraceToken = 19] = "OpenBraceToken", e[e.CloseBraceToken = 20] = "CloseBraceToken", e[e.OpenParenToken = 21] = "OpenParenToken", e[e.CloseParenToken = 22] = "CloseParenToken", e[e.OpenBracketToken = 23] = "OpenBracketToken", e[e.CloseBracketToken = 24] = "CloseBracketToken", e[e.DotToken = 25] = "DotToken", e[e.DotDotDotToken = 26] = "DotDotDotToken", e[e.SemicolonToken = 27] = "SemicolonToken", e[e.CommaToken = 28] = "CommaToken", e[e.QuestionDotToken = 29] = "QuestionDotToken", e[e.LessThanToken = 30] = "LessThanToken", e[e.LessThanSlashToken = 31] = "LessThanSlashToken", e[e.GreaterThanToken = 32] = "GreaterThanToken", e[e.LessThanEqualsToken = 33] = "LessThanEqualsToken", e[e.GreaterThanEqualsToken = 34] = "GreaterThanEqualsToken", e[e.EqualsEqualsToken = 35] = "EqualsEqualsToken", e[e.ExclamationEqualsToken = 36] = "ExclamationEqualsToken", e[e.EqualsEqualsEqualsToken = 37] = "EqualsEqualsEqualsToken", e[e.ExclamationEqualsEqualsToken = 38] = "ExclamationEqualsEqualsToken", e[e.EqualsGreaterThanToken = 39] = "EqualsGreaterThanToken", e[e.PlusToken = 40] = "PlusToken", e[e.MinusToken = 41] = "MinusToken", e[e.AsteriskToken = 42] = "AsteriskToken", e[e.AsteriskAsteriskToken = 43] = "AsteriskAsteriskToken", e[e.SlashToken = 44] = "SlashToken", e[e.PercentToken = 45] = "PercentToken", e[e.PlusPlusToken = 46] = "PlusPlusToken", e[e.MinusMinusToken = 47] = "MinusMinusToken", e[e.LessThanLessThanToken = 48] = "LessThanLessThanToken", e[e.GreaterThanGreaterThanToken = 49] = "GreaterThanGreaterThanToken", e[e.GreaterThanGreaterThanGreaterThanToken = 50] = "GreaterThanGreaterThanGreaterThanToken", e[e.AmpersandToken = 51] = "AmpersandToken", e[e.BarToken = 52] = "BarToken", e[e.CaretToken = 53] = "CaretToken", e[e.ExclamationToken = 54] = "ExclamationToken", e[e.TildeToken = 55] = "TildeToken", e[e.AmpersandAmpersandToken = 56] = "AmpersandAmpersandToken", e[e.BarBarToken = 57] = "BarBarToken", e[e.QuestionToken = 58] = "QuestionToken", e[e.ColonToken = 59] = "ColonToken", e[e.AtToken = 60] = "AtToken", e[e.QuestionQuestionToken = 61] = "QuestionQuestionToken", e[e.BacktickToken = 62] = "BacktickToken", e[e.HashToken = 63] = "HashToken", e[e.EqualsToken = 64] = "EqualsToken", e[e.PlusEqualsToken = 65] = "PlusEqualsToken", e[e.MinusEqualsToken = 66] = "MinusEqualsToken", e[e.AsteriskEqualsToken = 67] = "AsteriskEqualsToken", e[e.AsteriskAsteriskEqualsToken = 68] = "AsteriskAsteriskEqualsToken", e[e.SlashEqualsToken = 69] = "SlashEqualsToken", e[e.PercentEqualsToken = 70] = "PercentEqualsToken", e[e.LessThanLessThanEqualsToken = 71] = "LessThanLessThanEqualsToken", e[e.GreaterThanGreaterThanEqualsToken = 72] = "GreaterThanGreaterThanEqualsToken", e[e.GreaterThanGreaterThanGreaterThanEqualsToken = 73] = "GreaterThanGreaterThanGreaterThanEqualsToken", e[e.AmpersandEqualsToken = 74] = "AmpersandEqualsToken", e[e.BarEqualsToken = 75] = "BarEqualsToken", e[e.BarBarEqualsToken = 76] = "BarBarEqualsToken", e[e.AmpersandAmpersandEqualsToken = 77] = "AmpersandAmpersandEqualsToken", e[e.QuestionQuestionEqualsToken = 78] = "QuestionQuestionEqualsToken", e[e.CaretEqualsToken = 79] = "CaretEqualsToken", e[e.Identifier = 80] = "Identifier", e[e.PrivateIdentifier = 81] = "PrivateIdentifier", e[e.JSDocCommentTextToken = 82] = "JSDocCommentTextToken", e[e.BreakKeyword = 83] = "BreakKeyword", e[e.CaseKeyword = 84] = "CaseKeyword", e[e.CatchKeyword = 85] = "CatchKeyword", e[e.ClassKeyword = 86] = "ClassKeyword", e[e.ConstKeyword = 87] = "ConstKeyword", e[e.ContinueKeyword = 88] = "ContinueKeyword", e[e.DebuggerKeyword = 89] = "DebuggerKeyword", e[e.DefaultKeyword = 90] = "DefaultKeyword", e[e.DeleteKeyword = 91] = "DeleteKeyword", e[e.DoKeyword = 92] = "DoKeyword", e[e.ElseKeyword = 93] = "ElseKeyword", e[e.EnumKeyword = 94] = "EnumKeyword", e[e.ExportKeyword = 95] = "ExportKeyword", e[e.ExtendsKeyword = 96] = "ExtendsKeyword", e[e.FalseKeyword = 97] = "FalseKeyword", e[e.FinallyKeyword = 98] = "FinallyKeyword", e[e.ForKeyword = 99] = "ForKeyword", e[e.FunctionKeyword = 100] = "FunctionKeyword", e[e.IfKeyword = 101] = "IfKeyword", e[e.ImportKeyword = 102] = "ImportKeyword", e[e.InKeyword = 103] = "InKeyword", e[e.InstanceOfKeyword = 104] = "InstanceOfKeyword", e[e.NewKeyword = 105] = "NewKeyword", e[e.NullKeyword = 106] = "NullKeyword", e[e.ReturnKeyword = 107] = "ReturnKeyword", e[e.SuperKeyword = 108] = "SuperKeyword", e[e.SwitchKeyword = 109] = "SwitchKeyword", e[e.ThisKeyword = 110] = "ThisKeyword", e[e.ThrowKeyword = 111] = "ThrowKeyword", e[e.TrueKeyword = 112] = "TrueKeyword", e[e.TryKeyword = 113] = "TryKeyword", e[e.TypeOfKeyword = 114] = "TypeOfKeyword", e[e.VarKeyword = 115] = "VarKeyword", e[e.VoidKeyword = 116] = "VoidKeyword", e[e.WhileKeyword = 117] = "WhileKeyword", e[e.WithKeyword = 118] = "WithKeyword", e[e.ImplementsKeyword = 119] = "ImplementsKeyword", e[e.InterfaceKeyword = 120] = "InterfaceKeyword", e[e.LetKeyword = 121] = "LetKeyword", e[e.PackageKeyword = 122] = "PackageKeyword", e[e.PrivateKeyword = 123] = "PrivateKeyword", e[e.ProtectedKeyword = 124] = "ProtectedKeyword", e[e.PublicKeyword = 125] = "PublicKeyword", e[e.StaticKeyword = 126] = "StaticKeyword", e[e.YieldKeyword = 127] = "YieldKeyword", e[e.AbstractKeyword = 128] = "AbstractKeyword", e[e.AccessorKeyword = 129] = "AccessorKeyword", e[e.AsKeyword = 130] = "AsKeyword", e[e.AssertsKeyword = 131] = "AssertsKeyword", e[e.AssertKeyword = 132] = "AssertKeyword", e[e.AnyKeyword = 133] = "AnyKeyword", e[e.AsyncKeyword = 134] = "AsyncKeyword", e[e.AwaitKeyword = 135] = "AwaitKeyword", e[e.BooleanKeyword = 136] = "BooleanKeyword", e[e.ConstructorKeyword = 137] = "ConstructorKeyword", e[e.DeclareKeyword = 138] = "DeclareKeyword", e[e.GetKeyword = 139] = "GetKeyword", e[e.InferKeyword = 140] = "InferKeyword", e[e.IntrinsicKeyword = 141] = "IntrinsicKeyword", e[e.IsKeyword = 142] = "IsKeyword", e[e.KeyOfKeyword = 143] = "KeyOfKeyword", e[e.ModuleKeyword = 144] = "ModuleKeyword", e[e.NamespaceKeyword = 145] = "NamespaceKeyword", e[e.NeverKeyword = 146] = "NeverKeyword", e[e.OutKeyword = 147] = "OutKeyword", e[e.ReadonlyKeyword = 148] = "ReadonlyKeyword", e[e.RequireKeyword = 149] = "RequireKeyword", e[e.NumberKeyword = 150] = "NumberKeyword", e[e.ObjectKeyword = 151] = "ObjectKeyword", e[e.SatisfiesKeyword = 152] = "SatisfiesKeyword", e[e.SetKeyword = 153] = "SetKeyword", e[e.StringKeyword = 154] = "StringKeyword", e[e.SymbolKeyword = 155] = "SymbolKeyword", e[e.TypeKeyword = 156] = "TypeKeyword", e[e.UndefinedKeyword = 157] = "UndefinedKeyword", e[e.UniqueKeyword = 158] = "UniqueKeyword", e[e.UnknownKeyword = 159] = "UnknownKeyword", e[e.UsingKeyword = 160] = "UsingKeyword", e[e.FromKeyword = 161] = "FromKeyword", e[e.GlobalKeyword = 162] = "GlobalKeyword", e[e.BigIntKeyword = 163] = "BigIntKeyword", e[e.OverrideKeyword = 164] = "OverrideKeyword", e[e.OfKeyword = 165] = "OfKeyword", e[e.DeferKeyword = 166] = "DeferKeyword", e[e.QualifiedName = 167] = "QualifiedName", e[e.ComputedPropertyName = 168] = "ComputedPropertyName", e[e.TypeParameter = 169] = "TypeParameter", e[e.Parameter = 170] = "Parameter", e[e.Decorator = 171] = "Decorator", e[e.PropertySignature = 172] = "PropertySignature", e[e.PropertyDeclaration = 173] = "PropertyDeclaration", e[e.MethodSignature = 174] = "MethodSignature", e[e.MethodDeclaration = 175] = "MethodDeclaration", e[e.ClassStaticBlockDeclaration = 176] = "ClassStaticBlockDeclaration", e[e.Constructor = 177] = "Constructor", e[e.GetAccessor = 178] = "GetAccessor", e[e.SetAccessor = 179] = "SetAccessor", e[e.CallSignature = 180] = "CallSignature", e[e.ConstructSignature = 181] = "ConstructSignature", e[e.IndexSignature = 182] = "IndexSignature", e[e.TypePredicate = 183] = "TypePredicate", e[e.TypeReference = 184] = "TypeReference", e[e.FunctionType = 185] = "FunctionType", e[e.ConstructorType = 186] = "ConstructorType", e[e.TypeQuery = 187] = "TypeQuery", e[e.TypeLiteral = 188] = "TypeLiteral", e[e.ArrayType = 189] = "ArrayType", e[e.TupleType = 190] = "TupleType", e[e.OptionalType = 191] = "OptionalType", e[e.RestType = 192] = "RestType", e[e.UnionType = 193] = "UnionType", e[e.IntersectionType = 194] = "IntersectionType", e[e.ConditionalType = 195] = "ConditionalType", e[e.InferType = 196] = "InferType", e[e.ParenthesizedType = 197] = "ParenthesizedType", e[e.ThisType = 198] = "ThisType", e[e.TypeOperator = 199] = "TypeOperator", e[e.IndexedAccessType = 200] = "IndexedAccessType", e[e.MappedType = 201] = "MappedType", e[e.LiteralType = 202] = "LiteralType", e[e.NamedTupleMember = 203] = "NamedTupleMember", e[e.TemplateLiteralType = 204] = "TemplateLiteralType", e[e.TemplateLiteralTypeSpan = 205] = "TemplateLiteralTypeSpan", e[e.ImportType = 206] = "ImportType", e[e.ObjectBindingPattern = 207] = "ObjectBindingPattern", e[e.ArrayBindingPattern = 208] = "ArrayBindingPattern", e[e.BindingElement = 209] = "BindingElement", e[e.ArrayLiteralExpression = 210] = "ArrayLiteralExpression", e[e.ObjectLiteralExpression = 211] = "ObjectLiteralExpression", e[e.PropertyAccessExpression = 212] = "PropertyAccessExpression", e[e.ElementAccessExpression = 213] = "ElementAccessExpression", e[e.CallExpression = 214] = "CallExpression", e[e.NewExpression = 215] = "NewExpression", e[e.TaggedTemplateExpression = 216] = "TaggedTemplateExpression", e[e.TypeAssertionExpression = 217] = "TypeAssertionExpression", e[e.ParenthesizedExpression = 218] = "ParenthesizedExpression", e[e.FunctionExpression = 219] = "FunctionExpression", e[e.ArrowFunction = 220] = "ArrowFunction", e[e.DeleteExpression = 221] = "DeleteExpression", e[e.TypeOfExpression = 222] = "TypeOfExpression", e[e.VoidExpression = 223] = "VoidExpression", e[e.AwaitExpression = 224] = "AwaitExpression", e[e.PrefixUnaryExpression = 225] = "PrefixUnaryExpression", e[e.PostfixUnaryExpression = 226] = "PostfixUnaryExpression", e[e.BinaryExpression = 227] = "BinaryExpression", e[e.ConditionalExpression = 228] = "ConditionalExpression", e[e.TemplateExpression = 229] = "TemplateExpression", e[e.YieldExpression = 230] = "YieldExpression", e[e.SpreadElement = 231] = "SpreadElement", e[e.ClassExpression = 232] = "ClassExpression", e[e.OmittedExpression = 233] = "OmittedExpression", e[e.ExpressionWithTypeArguments = 234] = "ExpressionWithTypeArguments", e[e.AsExpression = 235] = "AsExpression", e[e.NonNullExpression = 236] = "NonNullExpression", e[e.MetaProperty = 237] = "MetaProperty", e[e.SyntheticExpression = 238] = "SyntheticExpression", e[e.SatisfiesExpression = 239] = "SatisfiesExpression", e[e.TemplateSpan = 240] = "TemplateSpan", e[e.SemicolonClassElement = 241] = "SemicolonClassElement", e[e.Block = 242] = "Block", e[e.EmptyStatement = 243] = "EmptyStatement", e[e.VariableStatement = 244] = "VariableStatement", e[e.ExpressionStatement = 245] = "ExpressionStatement", e[e.IfStatement = 246] = "IfStatement", e[e.DoStatement = 247] = "DoStatement", e[e.WhileStatement = 248] = "WhileStatement", e[e.ForStatement = 249] = "ForStatement", e[e.ForInStatement = 250] = "ForInStatement", e[e.ForOfStatement = 251] = "ForOfStatement", e[e.ContinueStatement = 252] = "ContinueStatement", e[e.BreakStatement = 253] = "BreakStatement", e[e.ReturnStatement = 254] = "ReturnStatement", e[e.WithStatement = 255] = "WithStatement", e[e.SwitchStatement = 256] = "SwitchStatement", e[e.LabeledStatement = 257] = "LabeledStatement", e[e.ThrowStatement = 258] = "ThrowStatement", e[e.TryStatement = 259] = "TryStatement", e[e.DebuggerStatement = 260] = "DebuggerStatement", e[e.VariableDeclaration = 261] = "VariableDeclaration", e[e.VariableDeclarationList = 262] = "VariableDeclarationList", e[e.FunctionDeclaration = 263] = "FunctionDeclaration", e[e.ClassDeclaration = 264] = "ClassDeclaration", e[e.InterfaceDeclaration = 265] = "InterfaceDeclaration", e[e.TypeAliasDeclaration = 266] = "TypeAliasDeclaration", e[e.EnumDeclaration = 267] = "EnumDeclaration", e[e.ModuleDeclaration = 268] = "ModuleDeclaration", e[e.ModuleBlock = 269] = "ModuleBlock", e[e.CaseBlock = 270] = "CaseBlock", e[e.NamespaceExportDeclaration = 271] = "NamespaceExportDeclaration", e[e.ImportEqualsDeclaration = 272] = "ImportEqualsDeclaration", e[e.ImportDeclaration = 273] = "ImportDeclaration", e[e.ImportClause = 274] = "ImportClause", e[e.NamespaceImport = 275] = "NamespaceImport", e[e.NamedImports = 276] = "NamedImports", e[e.ImportSpecifier = 277] = "ImportSpecifier", e[e.ExportAssignment = 278] = "ExportAssignment", e[e.ExportDeclaration = 279] = "ExportDeclaration", e[e.NamedExports = 280] = "NamedExports", e[e.NamespaceExport = 281] = "NamespaceExport", e[e.ExportSpecifier = 282] = "ExportSpecifier", e[e.MissingDeclaration = 283] = "MissingDeclaration", e[e.ExternalModuleReference = 284] = "ExternalModuleReference", e[e.JsxElement = 285] = "JsxElement", e[e.JsxSelfClosingElement = 286] = "JsxSelfClosingElement", e[e.JsxOpeningElement = 287] = "JsxOpeningElement", e[e.JsxClosingElement = 288] = "JsxClosingElement", e[e.JsxFragment = 289] = "JsxFragment", e[e.JsxOpeningFragment = 290] = "JsxOpeningFragment", e[e.JsxClosingFragment = 291] = "JsxClosingFragment", e[e.JsxAttribute = 292] = "JsxAttribute", e[e.JsxAttributes = 293] = "JsxAttributes", e[e.JsxSpreadAttribute = 294] = "JsxSpreadAttribute", e[e.JsxExpression = 295] = "JsxExpression", e[e.JsxNamespacedName = 296] = "JsxNamespacedName", e[e.CaseClause = 297] = "CaseClause", e[e.DefaultClause = 298] = "DefaultClause", e[e.HeritageClause = 299] = "HeritageClause", e[e.CatchClause = 300] = "CatchClause", e[e.ImportAttributes = 301] = "ImportAttributes", e[e.ImportAttribute = 302] = "ImportAttribute", e[ + e.AssertClause = 301 + /* ImportAttributes */ + ] = "AssertClause", e[ + e.AssertEntry = 302 + /* ImportAttribute */ + ] = "AssertEntry", e[e.ImportTypeAssertionContainer = 303] = "ImportTypeAssertionContainer", e[e.PropertyAssignment = 304] = "PropertyAssignment", e[e.ShorthandPropertyAssignment = 305] = "ShorthandPropertyAssignment", e[e.SpreadAssignment = 306] = "SpreadAssignment", e[e.EnumMember = 307] = "EnumMember", e[e.SourceFile = 308] = "SourceFile", e[e.Bundle = 309] = "Bundle", e[e.JSDocTypeExpression = 310] = "JSDocTypeExpression", e[e.JSDocNameReference = 311] = "JSDocNameReference", e[e.JSDocMemberName = 312] = "JSDocMemberName", e[e.JSDocAllType = 313] = "JSDocAllType", e[e.JSDocUnknownType = 314] = "JSDocUnknownType", e[e.JSDocNullableType = 315] = "JSDocNullableType", e[e.JSDocNonNullableType = 316] = "JSDocNonNullableType", e[e.JSDocOptionalType = 317] = "JSDocOptionalType", e[e.JSDocFunctionType = 318] = "JSDocFunctionType", e[e.JSDocVariadicType = 319] = "JSDocVariadicType", e[e.JSDocNamepathType = 320] = "JSDocNamepathType", e[e.JSDoc = 321] = "JSDoc", e[ + e.JSDocComment = 321 + /* JSDoc */ + ] = "JSDocComment", e[e.JSDocText = 322] = "JSDocText", e[e.JSDocTypeLiteral = 323] = "JSDocTypeLiteral", e[e.JSDocSignature = 324] = "JSDocSignature", e[e.JSDocLink = 325] = "JSDocLink", e[e.JSDocLinkCode = 326] = "JSDocLinkCode", e[e.JSDocLinkPlain = 327] = "JSDocLinkPlain", e[e.JSDocTag = 328] = "JSDocTag", e[e.JSDocAugmentsTag = 329] = "JSDocAugmentsTag", e[e.JSDocImplementsTag = 330] = "JSDocImplementsTag", e[e.JSDocAuthorTag = 331] = "JSDocAuthorTag", e[e.JSDocDeprecatedTag = 332] = "JSDocDeprecatedTag", e[e.JSDocClassTag = 333] = "JSDocClassTag", e[e.JSDocPublicTag = 334] = "JSDocPublicTag", e[e.JSDocPrivateTag = 335] = "JSDocPrivateTag", e[e.JSDocProtectedTag = 336] = "JSDocProtectedTag", e[e.JSDocReadonlyTag = 337] = "JSDocReadonlyTag", e[e.JSDocOverrideTag = 338] = "JSDocOverrideTag", e[e.JSDocCallbackTag = 339] = "JSDocCallbackTag", e[e.JSDocOverloadTag = 340] = "JSDocOverloadTag", e[e.JSDocEnumTag = 341] = "JSDocEnumTag", e[e.JSDocParameterTag = 342] = "JSDocParameterTag", e[e.JSDocReturnTag = 343] = "JSDocReturnTag", e[e.JSDocThisTag = 344] = "JSDocThisTag", e[e.JSDocTypeTag = 345] = "JSDocTypeTag", e[e.JSDocTemplateTag = 346] = "JSDocTemplateTag", e[e.JSDocTypedefTag = 347] = "JSDocTypedefTag", e[e.JSDocSeeTag = 348] = "JSDocSeeTag", e[e.JSDocPropertyTag = 349] = "JSDocPropertyTag", e[e.JSDocThrowsTag = 350] = "JSDocThrowsTag", e[e.JSDocSatisfiesTag = 351] = "JSDocSatisfiesTag", e[e.JSDocImportTag = 352] = "JSDocImportTag", e[e.SyntaxList = 353] = "SyntaxList", e[e.NotEmittedStatement = 354] = "NotEmittedStatement", e[e.NotEmittedTypeElement = 355] = "NotEmittedTypeElement", e[e.PartiallyEmittedExpression = 356] = "PartiallyEmittedExpression", e[e.CommaListExpression = 357] = "CommaListExpression", e[e.SyntheticReferenceExpression = 358] = "SyntheticReferenceExpression", e[e.Count = 359] = "Count", e[ + e.FirstAssignment = 64 + /* EqualsToken */ + ] = "FirstAssignment", e[ + e.LastAssignment = 79 + /* CaretEqualsToken */ + ] = "LastAssignment", e[ + e.FirstCompoundAssignment = 65 + /* PlusEqualsToken */ + ] = "FirstCompoundAssignment", e[ + e.LastCompoundAssignment = 79 + /* CaretEqualsToken */ + ] = "LastCompoundAssignment", e[ + e.FirstReservedWord = 83 + /* BreakKeyword */ + ] = "FirstReservedWord", e[ + e.LastReservedWord = 118 + /* WithKeyword */ + ] = "LastReservedWord", e[ + e.FirstKeyword = 83 + /* BreakKeyword */ + ] = "FirstKeyword", e[ + e.LastKeyword = 166 + /* DeferKeyword */ + ] = "LastKeyword", e[ + e.FirstFutureReservedWord = 119 + /* ImplementsKeyword */ + ] = "FirstFutureReservedWord", e[ + e.LastFutureReservedWord = 127 + /* YieldKeyword */ + ] = "LastFutureReservedWord", e[ + e.FirstTypeNode = 183 + /* TypePredicate */ + ] = "FirstTypeNode", e[ + e.LastTypeNode = 206 + /* ImportType */ + ] = "LastTypeNode", e[ + e.FirstPunctuation = 19 + /* OpenBraceToken */ + ] = "FirstPunctuation", e[ + e.LastPunctuation = 79 + /* CaretEqualsToken */ + ] = "LastPunctuation", e[ + e.FirstToken = 0 + /* Unknown */ + ] = "FirstToken", e[ + e.LastToken = 166 + /* LastKeyword */ + ] = "LastToken", e[ + e.FirstTriviaToken = 2 + /* SingleLineCommentTrivia */ + ] = "FirstTriviaToken", e[ + e.LastTriviaToken = 7 + /* ConflictMarkerTrivia */ + ] = "LastTriviaToken", e[ + e.FirstLiteralToken = 9 + /* NumericLiteral */ + ] = "FirstLiteralToken", e[ + e.LastLiteralToken = 15 + /* NoSubstitutionTemplateLiteral */ + ] = "LastLiteralToken", e[ + e.FirstTemplateToken = 15 + /* NoSubstitutionTemplateLiteral */ + ] = "FirstTemplateToken", e[ + e.LastTemplateToken = 18 + /* TemplateTail */ + ] = "LastTemplateToken", e[ + e.FirstBinaryOperator = 30 + /* LessThanToken */ + ] = "FirstBinaryOperator", e[ + e.LastBinaryOperator = 79 + /* CaretEqualsToken */ + ] = "LastBinaryOperator", e[ + e.FirstStatement = 244 + /* VariableStatement */ + ] = "FirstStatement", e[ + e.LastStatement = 260 + /* DebuggerStatement */ + ] = "LastStatement", e[ + e.FirstNode = 167 + /* QualifiedName */ + ] = "FirstNode", e[ + e.FirstJSDocNode = 310 + /* JSDocTypeExpression */ + ] = "FirstJSDocNode", e[ + e.LastJSDocNode = 352 + /* JSDocImportTag */ + ] = "LastJSDocNode", e[ + e.FirstJSDocTagNode = 328 + /* JSDocTag */ + ] = "FirstJSDocTagNode", e[ + e.LastJSDocTagNode = 352 + /* JSDocImportTag */ + ] = "LastJSDocTagNode", e[ + e.FirstContextualKeyword = 128 + /* AbstractKeyword */ + ] = "FirstContextualKeyword", e[ + e.LastContextualKeyword = 166 + /* LastKeyword */ + ] = "LastContextualKeyword", e))(YR || {}), ZR = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Let = 1] = "Let", e[e.Const = 2] = "Const", e[e.Using = 4] = "Using", e[e.AwaitUsing = 6] = "AwaitUsing", e[e.NestedNamespace = 8] = "NestedNamespace", e[e.Synthesized = 16] = "Synthesized", e[e.Namespace = 32] = "Namespace", e[e.OptionalChain = 64] = "OptionalChain", e[e.ExportContext = 128] = "ExportContext", e[e.ContainsThis = 256] = "ContainsThis", e[e.HasImplicitReturn = 512] = "HasImplicitReturn", e[e.HasExplicitReturn = 1024] = "HasExplicitReturn", e[e.GlobalAugmentation = 2048] = "GlobalAugmentation", e[e.HasAsyncFunctions = 4096] = "HasAsyncFunctions", e[e.DisallowInContext = 8192] = "DisallowInContext", e[e.YieldContext = 16384] = "YieldContext", e[e.DecoratorContext = 32768] = "DecoratorContext", e[e.AwaitContext = 65536] = "AwaitContext", e[e.DisallowConditionalTypesContext = 131072] = "DisallowConditionalTypesContext", e[e.ThisNodeHasError = 262144] = "ThisNodeHasError", e[e.JavaScriptFile = 524288] = "JavaScriptFile", e[e.ThisNodeOrAnySubNodesHasError = 1048576] = "ThisNodeOrAnySubNodesHasError", e[e.HasAggregatedChildData = 2097152] = "HasAggregatedChildData", e[e.PossiblyContainsDynamicImport = 4194304] = "PossiblyContainsDynamicImport", e[e.PossiblyContainsImportMeta = 8388608] = "PossiblyContainsImportMeta", e[e.JSDoc = 16777216] = "JSDoc", e[e.Ambient = 33554432] = "Ambient", e[e.InWithStatement = 67108864] = "InWithStatement", e[e.JsonFile = 134217728] = "JsonFile", e[e.TypeCached = 268435456] = "TypeCached", e[e.Deprecated = 536870912] = "Deprecated", e[e.BlockScoped = 7] = "BlockScoped", e[e.Constant = 6] = "Constant", e[e.ReachabilityCheckFlags = 1536] = "ReachabilityCheckFlags", e[e.ReachabilityAndEmitFlags = 5632] = "ReachabilityAndEmitFlags", e[e.ContextFlags = 101441536] = "ContextFlags", e[e.TypeExcludesFlags = 81920] = "TypeExcludesFlags", e[e.PermanentlySetIncrementalFlags = 12582912] = "PermanentlySetIncrementalFlags", e[ + e.IdentifierHasExtendedUnicodeEscape = 256 + /* ContainsThis */ + ] = "IdentifierHasExtendedUnicodeEscape", e[ + e.IdentifierIsInJSDocNamespace = 4096 + /* HasAsyncFunctions */ + ] = "IdentifierIsInJSDocNamespace", e))(ZR || {}), KR = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Public = 1] = "Public", e[e.Private = 2] = "Private", e[e.Protected = 4] = "Protected", e[e.Readonly = 8] = "Readonly", e[e.Override = 16] = "Override", e[e.Export = 32] = "Export", e[e.Abstract = 64] = "Abstract", e[e.Ambient = 128] = "Ambient", e[e.Static = 256] = "Static", e[e.Accessor = 512] = "Accessor", e[e.Async = 1024] = "Async", e[e.Default = 2048] = "Default", e[e.Const = 4096] = "Const", e[e.In = 8192] = "In", e[e.Out = 16384] = "Out", e[e.Decorator = 32768] = "Decorator", e[e.Deprecated = 65536] = "Deprecated", e[e.JSDocPublic = 8388608] = "JSDocPublic", e[e.JSDocPrivate = 16777216] = "JSDocPrivate", e[e.JSDocProtected = 33554432] = "JSDocProtected", e[e.JSDocReadonly = 67108864] = "JSDocReadonly", e[e.JSDocOverride = 134217728] = "JSDocOverride", e[e.SyntacticOrJSDocModifiers = 31] = "SyntacticOrJSDocModifiers", e[e.SyntacticOnlyModifiers = 65504] = "SyntacticOnlyModifiers", e[e.SyntacticModifiers = 65535] = "SyntacticModifiers", e[e.JSDocCacheOnlyModifiers = 260046848] = "JSDocCacheOnlyModifiers", e[ + e.JSDocOnlyModifiers = 65536 + /* Deprecated */ + ] = "JSDocOnlyModifiers", e[e.NonCacheOnlyModifiers = 131071] = "NonCacheOnlyModifiers", e[e.HasComputedJSDocModifiers = 268435456] = "HasComputedJSDocModifiers", e[e.HasComputedFlags = 536870912] = "HasComputedFlags", e[e.AccessibilityModifier = 7] = "AccessibilityModifier", e[e.ParameterPropertyModifier = 31] = "ParameterPropertyModifier", e[e.NonPublicAccessibilityModifier = 6] = "NonPublicAccessibilityModifier", e[e.TypeScriptModifier = 28895] = "TypeScriptModifier", e[e.ExportDefault = 2080] = "ExportDefault", e[e.All = 131071] = "All", e[e.Modifier = 98303] = "Modifier", e))(KR || {}), NQ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.IntrinsicNamedElement = 1] = "IntrinsicNamedElement", e[e.IntrinsicIndexedElement = 2] = "IntrinsicIndexedElement", e[e.IntrinsicElement = 3] = "IntrinsicElement", e))(NQ || {}), ej = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Succeeded = 1] = "Succeeded", e[e.Failed = 2] = "Failed", e[e.ReportsUnmeasurable = 8] = "ReportsUnmeasurable", e[e.ReportsUnreliable = 16] = "ReportsUnreliable", e[e.ReportsMask = 24] = "ReportsMask", e[e.ComplexityOverflow = 32] = "ComplexityOverflow", e[e.StackDepthOverflow = 64] = "StackDepthOverflow", e[e.Overflow = 96] = "Overflow", e))(ej || {}), AQ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Always = 1] = "Always", e[e.Never = 2] = "Never", e[e.Sometimes = 3] = "Sometimes", e))(AQ || {}), tj = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Auto = 1] = "Auto", e[e.Loop = 2] = "Loop", e[e.Unique = 3] = "Unique", e[e.Node = 4] = "Node", e[e.KindMask = 7] = "KindMask", e[e.ReservedInNestedScopes = 8] = "ReservedInNestedScopes", e[e.Optimistic = 16] = "Optimistic", e[e.FileLevel = 32] = "FileLevel", e[e.AllowNameSubstitution = 64] = "AllowNameSubstitution", e))(tj || {}), IQ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.HasIndices = 1] = "HasIndices", e[e.Global = 2] = "Global", e[e.IgnoreCase = 4] = "IgnoreCase", e[e.Multiline = 8] = "Multiline", e[e.DotAll = 16] = "DotAll", e[e.Unicode = 32] = "Unicode", e[e.UnicodeSets = 64] = "UnicodeSets", e[e.Sticky = 128] = "Sticky", e[e.AnyUnicodeMode = 96] = "AnyUnicodeMode", e[e.Modifiers = 28] = "Modifiers", e))(IQ || {}), FQ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.PrecedingLineBreak = 1] = "PrecedingLineBreak", e[e.PrecedingJSDocComment = 2] = "PrecedingJSDocComment", e[e.Unterminated = 4] = "Unterminated", e[e.ExtendedUnicodeEscape = 8] = "ExtendedUnicodeEscape", e[e.Scientific = 16] = "Scientific", e[e.Octal = 32] = "Octal", e[e.HexSpecifier = 64] = "HexSpecifier", e[e.BinarySpecifier = 128] = "BinarySpecifier", e[e.OctalSpecifier = 256] = "OctalSpecifier", e[e.ContainsSeparator = 512] = "ContainsSeparator", e[e.UnicodeEscape = 1024] = "UnicodeEscape", e[e.ContainsInvalidEscape = 2048] = "ContainsInvalidEscape", e[e.HexEscape = 4096] = "HexEscape", e[e.ContainsLeadingZero = 8192] = "ContainsLeadingZero", e[e.ContainsInvalidSeparator = 16384] = "ContainsInvalidSeparator", e[e.PrecedingJSDocLeadingAsterisks = 32768] = "PrecedingJSDocLeadingAsterisks", e[e.BinaryOrOctalSpecifier = 384] = "BinaryOrOctalSpecifier", e[e.WithSpecifier = 448] = "WithSpecifier", e[e.StringLiteralFlags = 7176] = "StringLiteralFlags", e[e.NumericLiteralFlags = 25584] = "NumericLiteralFlags", e[e.TemplateLiteralLikeFlags = 7176] = "TemplateLiteralLikeFlags", e[e.IsInvalid = 26656] = "IsInvalid", e))(FQ || {}), r7 = /* @__PURE__ */ ((e) => (e[e.Unreachable = 1] = "Unreachable", e[e.Start = 2] = "Start", e[e.BranchLabel = 4] = "BranchLabel", e[e.LoopLabel = 8] = "LoopLabel", e[e.Assignment = 16] = "Assignment", e[e.TrueCondition = 32] = "TrueCondition", e[e.FalseCondition = 64] = "FalseCondition", e[e.SwitchClause = 128] = "SwitchClause", e[e.ArrayMutation = 256] = "ArrayMutation", e[e.Call = 512] = "Call", e[e.ReduceLabel = 1024] = "ReduceLabel", e[e.Referenced = 2048] = "Referenced", e[e.Shared = 4096] = "Shared", e[e.Label = 12] = "Label", e[e.Condition = 96] = "Condition", e))(r7 || {}), OQ = /* @__PURE__ */ ((e) => (e[e.ExpectError = 0] = "ExpectError", e[e.Ignore = 1] = "Ignore", e))(OQ || {}), lD = class { + }, rj = /* @__PURE__ */ ((e) => (e[e.RootFile = 0] = "RootFile", e[e.SourceFromProjectReference = 1] = "SourceFromProjectReference", e[e.OutputFromProjectReference = 2] = "OutputFromProjectReference", e[e.Import = 3] = "Import", e[e.ReferenceFile = 4] = "ReferenceFile", e[e.TypeReferenceDirective = 5] = "TypeReferenceDirective", e[e.LibFile = 6] = "LibFile", e[e.LibReferenceDirective = 7] = "LibReferenceDirective", e[e.AutomaticTypeDirectiveFile = 8] = "AutomaticTypeDirectiveFile", e))(rj || {}), LQ = /* @__PURE__ */ ((e) => (e[e.FilePreprocessingLibReferenceDiagnostic = 0] = "FilePreprocessingLibReferenceDiagnostic", e[e.FilePreprocessingFileExplainingDiagnostic = 1] = "FilePreprocessingFileExplainingDiagnostic", e[e.ResolutionDiagnostics = 2] = "ResolutionDiagnostics", e))(LQ || {}), MQ = /* @__PURE__ */ ((e) => (e[e.Js = 0] = "Js", e[e.Dts = 1] = "Dts", e[e.BuilderSignature = 2] = "BuilderSignature", e))(MQ || {}), nj = /* @__PURE__ */ ((e) => (e[e.Not = 0] = "Not", e[e.SafeModules = 1] = "SafeModules", e[e.Completely = 2] = "Completely", e))(nj || {}), RQ = /* @__PURE__ */ ((e) => (e[e.Success = 0] = "Success", e[e.DiagnosticsPresent_OutputsSkipped = 1] = "DiagnosticsPresent_OutputsSkipped", e[e.DiagnosticsPresent_OutputsGenerated = 2] = "DiagnosticsPresent_OutputsGenerated", e[e.InvalidProject_OutputsSkipped = 3] = "InvalidProject_OutputsSkipped", e[e.ProjectReferenceCycle_OutputsSkipped = 4] = "ProjectReferenceCycle_OutputsSkipped", e))(RQ || {}), jQ = /* @__PURE__ */ ((e) => (e[e.Ok = 0] = "Ok", e[e.NeedsOverride = 1] = "NeedsOverride", e[e.HasInvalidOverride = 2] = "HasInvalidOverride", e))(jQ || {}), BQ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Literal = 1] = "Literal", e[e.Subtype = 2] = "Subtype", e))(BQ || {}), JQ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.NoSupertypeReduction = 1] = "NoSupertypeReduction", e[e.NoConstraintReduction = 2] = "NoConstraintReduction", e))(JQ || {}), zQ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Signature = 1] = "Signature", e[e.NoConstraints = 2] = "NoConstraints", e[e.Completions = 4] = "Completions", e[e.SkipBindingPatterns = 8] = "SkipBindingPatterns", e))(zQ || {}), WQ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.NoTruncation = 1] = "NoTruncation", e[e.WriteArrayAsGenericType = 2] = "WriteArrayAsGenericType", e[e.GenerateNamesForShadowedTypeParams = 4] = "GenerateNamesForShadowedTypeParams", e[e.UseStructuralFallback = 8] = "UseStructuralFallback", e[e.ForbidIndexedAccessSymbolReferences = 16] = "ForbidIndexedAccessSymbolReferences", e[e.WriteTypeArgumentsOfSignature = 32] = "WriteTypeArgumentsOfSignature", e[e.UseFullyQualifiedType = 64] = "UseFullyQualifiedType", e[e.UseOnlyExternalAliasing = 128] = "UseOnlyExternalAliasing", e[e.SuppressAnyReturnType = 256] = "SuppressAnyReturnType", e[e.WriteTypeParametersInQualifiedName = 512] = "WriteTypeParametersInQualifiedName", e[e.MultilineObjectLiterals = 1024] = "MultilineObjectLiterals", e[e.WriteClassExpressionAsTypeLiteral = 2048] = "WriteClassExpressionAsTypeLiteral", e[e.UseTypeOfFunction = 4096] = "UseTypeOfFunction", e[e.OmitParameterModifiers = 8192] = "OmitParameterModifiers", e[e.UseAliasDefinedOutsideCurrentScope = 16384] = "UseAliasDefinedOutsideCurrentScope", e[e.UseSingleQuotesForStringLiteralType = 268435456] = "UseSingleQuotesForStringLiteralType", e[e.NoTypeReduction = 536870912] = "NoTypeReduction", e[e.OmitThisParameter = 33554432] = "OmitThisParameter", e[e.AllowThisInObjectLiteral = 32768] = "AllowThisInObjectLiteral", e[e.AllowQualifiedNameInPlaceOfIdentifier = 65536] = "AllowQualifiedNameInPlaceOfIdentifier", e[e.AllowAnonymousIdentifier = 131072] = "AllowAnonymousIdentifier", e[e.AllowEmptyUnionOrIntersection = 262144] = "AllowEmptyUnionOrIntersection", e[e.AllowEmptyTuple = 524288] = "AllowEmptyTuple", e[e.AllowUniqueESSymbolType = 1048576] = "AllowUniqueESSymbolType", e[e.AllowEmptyIndexInfoType = 2097152] = "AllowEmptyIndexInfoType", e[e.AllowNodeModulesRelativePaths = 67108864] = "AllowNodeModulesRelativePaths", e[e.IgnoreErrors = 70221824] = "IgnoreErrors", e[e.InObjectTypeLiteral = 4194304] = "InObjectTypeLiteral", e[e.InTypeAlias = 8388608] = "InTypeAlias", e[e.InInitialEntityName = 16777216] = "InInitialEntityName", e))(WQ || {}), UQ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.WriteComputedProps = 1] = "WriteComputedProps", e[e.NoSyntacticPrinter = 2] = "NoSyntacticPrinter", e[e.DoNotIncludeSymbolChain = 4] = "DoNotIncludeSymbolChain", e[e.AllowUnresolvedNames = 8] = "AllowUnresolvedNames", e))(UQ || {}), VQ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.NoTruncation = 1] = "NoTruncation", e[e.WriteArrayAsGenericType = 2] = "WriteArrayAsGenericType", e[e.GenerateNamesForShadowedTypeParams = 4] = "GenerateNamesForShadowedTypeParams", e[e.UseStructuralFallback = 8] = "UseStructuralFallback", e[e.WriteTypeArgumentsOfSignature = 32] = "WriteTypeArgumentsOfSignature", e[e.UseFullyQualifiedType = 64] = "UseFullyQualifiedType", e[e.SuppressAnyReturnType = 256] = "SuppressAnyReturnType", e[e.MultilineObjectLiterals = 1024] = "MultilineObjectLiterals", e[e.WriteClassExpressionAsTypeLiteral = 2048] = "WriteClassExpressionAsTypeLiteral", e[e.UseTypeOfFunction = 4096] = "UseTypeOfFunction", e[e.OmitParameterModifiers = 8192] = "OmitParameterModifiers", e[e.UseAliasDefinedOutsideCurrentScope = 16384] = "UseAliasDefinedOutsideCurrentScope", e[e.UseSingleQuotesForStringLiteralType = 268435456] = "UseSingleQuotesForStringLiteralType", e[e.NoTypeReduction = 536870912] = "NoTypeReduction", e[e.OmitThisParameter = 33554432] = "OmitThisParameter", e[e.AllowUniqueESSymbolType = 1048576] = "AllowUniqueESSymbolType", e[e.AddUndefined = 131072] = "AddUndefined", e[e.WriteArrowStyleSignature = 262144] = "WriteArrowStyleSignature", e[e.InArrayType = 524288] = "InArrayType", e[e.InElementType = 2097152] = "InElementType", e[e.InFirstTypeArgument = 4194304] = "InFirstTypeArgument", e[e.InTypeAlias = 8388608] = "InTypeAlias", e[e.NodeBuilderFlagsMask = 848330095] = "NodeBuilderFlagsMask", e))(VQ || {}), qQ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.WriteTypeParametersOrArguments = 1] = "WriteTypeParametersOrArguments", e[e.UseOnlyExternalAliasing = 2] = "UseOnlyExternalAliasing", e[e.AllowAnyNodeKind = 4] = "AllowAnyNodeKind", e[e.UseAliasDefinedOutsideCurrentScope = 8] = "UseAliasDefinedOutsideCurrentScope", e[e.WriteComputedProps = 16] = "WriteComputedProps", e[e.DoNotIncludeSymbolChain = 32] = "DoNotIncludeSymbolChain", e))(qQ || {}), HQ = /* @__PURE__ */ ((e) => (e[e.Accessible = 0] = "Accessible", e[e.NotAccessible = 1] = "NotAccessible", e[e.CannotBeNamed = 2] = "CannotBeNamed", e[e.NotResolved = 3] = "NotResolved", e))(HQ || {}), GQ = /* @__PURE__ */ ((e) => (e[e.This = 0] = "This", e[e.Identifier = 1] = "Identifier", e[e.AssertsThis = 2] = "AssertsThis", e[e.AssertsIdentifier = 3] = "AssertsIdentifier", e))(GQ || {}), $Q = /* @__PURE__ */ ((e) => (e[e.Unknown = 0] = "Unknown", e[e.TypeWithConstructSignatureAndValue = 1] = "TypeWithConstructSignatureAndValue", e[e.VoidNullableOrNeverType = 2] = "VoidNullableOrNeverType", e[e.NumberLikeType = 3] = "NumberLikeType", e[e.BigIntLikeType = 4] = "BigIntLikeType", e[e.StringLikeType = 5] = "StringLikeType", e[e.BooleanType = 6] = "BooleanType", e[e.ArrayLikeType = 7] = "ArrayLikeType", e[e.ESSymbolType = 8] = "ESSymbolType", e[e.Promise = 9] = "Promise", e[e.TypeWithCallSignature = 10] = "TypeWithCallSignature", e[e.ObjectType = 11] = "ObjectType", e))($Q || {}), ij = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.FunctionScopedVariable = 1] = "FunctionScopedVariable", e[e.BlockScopedVariable = 2] = "BlockScopedVariable", e[e.Property = 4] = "Property", e[e.EnumMember = 8] = "EnumMember", e[e.Function = 16] = "Function", e[e.Class = 32] = "Class", e[e.Interface = 64] = "Interface", e[e.ConstEnum = 128] = "ConstEnum", e[e.RegularEnum = 256] = "RegularEnum", e[e.ValueModule = 512] = "ValueModule", e[e.NamespaceModule = 1024] = "NamespaceModule", e[e.TypeLiteral = 2048] = "TypeLiteral", e[e.ObjectLiteral = 4096] = "ObjectLiteral", e[e.Method = 8192] = "Method", e[e.Constructor = 16384] = "Constructor", e[e.GetAccessor = 32768] = "GetAccessor", e[e.SetAccessor = 65536] = "SetAccessor", e[e.Signature = 131072] = "Signature", e[e.TypeParameter = 262144] = "TypeParameter", e[e.TypeAlias = 524288] = "TypeAlias", e[e.ExportValue = 1048576] = "ExportValue", e[e.Alias = 2097152] = "Alias", e[e.Prototype = 4194304] = "Prototype", e[e.ExportStar = 8388608] = "ExportStar", e[e.Optional = 16777216] = "Optional", e[e.Transient = 33554432] = "Transient", e[e.Assignment = 67108864] = "Assignment", e[e.ModuleExports = 134217728] = "ModuleExports", e[e.All = -1] = "All", e[e.Enum = 384] = "Enum", e[e.Variable = 3] = "Variable", e[e.Value = 111551] = "Value", e[e.Type = 788968] = "Type", e[e.Namespace = 1920] = "Namespace", e[e.Module = 1536] = "Module", e[e.Accessor = 98304] = "Accessor", e[e.FunctionScopedVariableExcludes = 111550] = "FunctionScopedVariableExcludes", e[ + e.BlockScopedVariableExcludes = 111551 + /* Value */ + ] = "BlockScopedVariableExcludes", e[ + e.ParameterExcludes = 111551 + /* Value */ + ] = "ParameterExcludes", e[ + e.PropertyExcludes = 0 + /* None */ + ] = "PropertyExcludes", e[e.EnumMemberExcludes = 900095] = "EnumMemberExcludes", e[e.FunctionExcludes = 110991] = "FunctionExcludes", e[e.ClassExcludes = 899503] = "ClassExcludes", e[e.InterfaceExcludes = 788872] = "InterfaceExcludes", e[e.RegularEnumExcludes = 899327] = "RegularEnumExcludes", e[e.ConstEnumExcludes = 899967] = "ConstEnumExcludes", e[e.ValueModuleExcludes = 110735] = "ValueModuleExcludes", e[e.NamespaceModuleExcludes = 0] = "NamespaceModuleExcludes", e[e.MethodExcludes = 103359] = "MethodExcludes", e[e.GetAccessorExcludes = 46015] = "GetAccessorExcludes", e[e.SetAccessorExcludes = 78783] = "SetAccessorExcludes", e[e.AccessorExcludes = 13247] = "AccessorExcludes", e[e.TypeParameterExcludes = 526824] = "TypeParameterExcludes", e[ + e.TypeAliasExcludes = 788968 + /* Type */ + ] = "TypeAliasExcludes", e[ + e.AliasExcludes = 2097152 + /* Alias */ + ] = "AliasExcludes", e[e.ModuleMember = 2623475] = "ModuleMember", e[e.ExportHasLocal = 944] = "ExportHasLocal", e[e.BlockScoped = 418] = "BlockScoped", e[e.PropertyOrAccessor = 98308] = "PropertyOrAccessor", e[e.ClassMember = 106500] = "ClassMember", e[e.ExportSupportsDefaultModifier = 112] = "ExportSupportsDefaultModifier", e[e.ExportDoesNotSupportDefaultModifier = -113] = "ExportDoesNotSupportDefaultModifier", e[e.Classifiable = 2885600] = "Classifiable", e[e.LateBindingContainer = 6256] = "LateBindingContainer", e))(ij || {}), XQ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Instantiated = 1] = "Instantiated", e[e.SyntheticProperty = 2] = "SyntheticProperty", e[e.SyntheticMethod = 4] = "SyntheticMethod", e[e.Readonly = 8] = "Readonly", e[e.ReadPartial = 16] = "ReadPartial", e[e.WritePartial = 32] = "WritePartial", e[e.HasNonUniformType = 64] = "HasNonUniformType", e[e.HasLiteralType = 128] = "HasLiteralType", e[e.ContainsPublic = 256] = "ContainsPublic", e[e.ContainsProtected = 512] = "ContainsProtected", e[e.ContainsPrivate = 1024] = "ContainsPrivate", e[e.ContainsStatic = 2048] = "ContainsStatic", e[e.Late = 4096] = "Late", e[e.ReverseMapped = 8192] = "ReverseMapped", e[e.OptionalParameter = 16384] = "OptionalParameter", e[e.RestParameter = 32768] = "RestParameter", e[e.DeferredType = 65536] = "DeferredType", e[e.HasNeverType = 131072] = "HasNeverType", e[e.Mapped = 262144] = "Mapped", e[e.StripOptional = 524288] = "StripOptional", e[e.Unresolved = 1048576] = "Unresolved", e[e.Synthetic = 6] = "Synthetic", e[e.Discriminant = 192] = "Discriminant", e[e.Partial = 48] = "Partial", e))(XQ || {}), QQ = /* @__PURE__ */ ((e) => (e.Call = "__call", e.Constructor = "__constructor", e.New = "__new", e.Index = "__index", e.ExportStar = "__export", e.Global = "__global", e.Missing = "__missing", e.Type = "__type", e.Object = "__object", e.JSXAttributes = "__jsxAttributes", e.Class = "__class", e.Function = "__function", e.Computed = "__computed", e.Resolving = "__resolving__", e.ExportEquals = "export=", e.Default = "default", e.This = "this", e.InstantiationExpression = "__instantiationExpression", e.ImportAttributes = "__importAttributes", e))(QQ || {}), sj = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.TypeChecked = 1] = "TypeChecked", e[e.LexicalThis = 2] = "LexicalThis", e[e.CaptureThis = 4] = "CaptureThis", e[e.CaptureNewTarget = 8] = "CaptureNewTarget", e[e.SuperInstance = 16] = "SuperInstance", e[e.SuperStatic = 32] = "SuperStatic", e[e.ContextChecked = 64] = "ContextChecked", e[e.MethodWithSuperPropertyAccessInAsync = 128] = "MethodWithSuperPropertyAccessInAsync", e[e.MethodWithSuperPropertyAssignmentInAsync = 256] = "MethodWithSuperPropertyAssignmentInAsync", e[e.CaptureArguments = 512] = "CaptureArguments", e[e.EnumValuesComputed = 1024] = "EnumValuesComputed", e[e.LexicalModuleMergesWithClass = 2048] = "LexicalModuleMergesWithClass", e[e.LoopWithCapturedBlockScopedBinding = 4096] = "LoopWithCapturedBlockScopedBinding", e[e.ContainsCapturedBlockScopeBinding = 8192] = "ContainsCapturedBlockScopeBinding", e[e.CapturedBlockScopedBinding = 16384] = "CapturedBlockScopedBinding", e[e.BlockScopedBindingInLoop = 32768] = "BlockScopedBindingInLoop", e[e.NeedsLoopOutParameter = 65536] = "NeedsLoopOutParameter", e[e.AssignmentsMarked = 131072] = "AssignmentsMarked", e[e.ContainsConstructorReference = 262144] = "ContainsConstructorReference", e[e.ConstructorReference = 536870912] = "ConstructorReference", e[e.ContainsClassWithPrivateIdentifiers = 1048576] = "ContainsClassWithPrivateIdentifiers", e[e.ContainsSuperPropertyInStaticInitializer = 2097152] = "ContainsSuperPropertyInStaticInitializer", e[e.InCheckIdentifier = 4194304] = "InCheckIdentifier", e[e.PartiallyTypeChecked = 8388608] = "PartiallyTypeChecked", e[e.LazyFlags = 539358128] = "LazyFlags", e))(sj || {}), aj = /* @__PURE__ */ ((e) => (e[e.Any = 1] = "Any", e[e.Unknown = 2] = "Unknown", e[e.String = 4] = "String", e[e.Number = 8] = "Number", e[e.Boolean = 16] = "Boolean", e[e.Enum = 32] = "Enum", e[e.BigInt = 64] = "BigInt", e[e.StringLiteral = 128] = "StringLiteral", e[e.NumberLiteral = 256] = "NumberLiteral", e[e.BooleanLiteral = 512] = "BooleanLiteral", e[e.EnumLiteral = 1024] = "EnumLiteral", e[e.BigIntLiteral = 2048] = "BigIntLiteral", e[e.ESSymbol = 4096] = "ESSymbol", e[e.UniqueESSymbol = 8192] = "UniqueESSymbol", e[e.Void = 16384] = "Void", e[e.Undefined = 32768] = "Undefined", e[e.Null = 65536] = "Null", e[e.Never = 131072] = "Never", e[e.TypeParameter = 262144] = "TypeParameter", e[e.Object = 524288] = "Object", e[e.Union = 1048576] = "Union", e[e.Intersection = 2097152] = "Intersection", e[e.Index = 4194304] = "Index", e[e.IndexedAccess = 8388608] = "IndexedAccess", e[e.Conditional = 16777216] = "Conditional", e[e.Substitution = 33554432] = "Substitution", e[e.NonPrimitive = 67108864] = "NonPrimitive", e[e.TemplateLiteral = 134217728] = "TemplateLiteral", e[e.StringMapping = 268435456] = "StringMapping", e[e.Reserved1 = 536870912] = "Reserved1", e[e.Reserved2 = 1073741824] = "Reserved2", e[e.AnyOrUnknown = 3] = "AnyOrUnknown", e[e.Nullable = 98304] = "Nullable", e[e.Literal = 2944] = "Literal", e[e.Unit = 109472] = "Unit", e[e.Freshable = 2976] = "Freshable", e[e.StringOrNumberLiteral = 384] = "StringOrNumberLiteral", e[e.StringOrNumberLiteralOrUnique = 8576] = "StringOrNumberLiteralOrUnique", e[e.DefinitelyFalsy = 117632] = "DefinitelyFalsy", e[e.PossiblyFalsy = 117724] = "PossiblyFalsy", e[e.Intrinsic = 67359327] = "Intrinsic", e[e.StringLike = 402653316] = "StringLike", e[e.NumberLike = 296] = "NumberLike", e[e.BigIntLike = 2112] = "BigIntLike", e[e.BooleanLike = 528] = "BooleanLike", e[e.EnumLike = 1056] = "EnumLike", e[e.ESSymbolLike = 12288] = "ESSymbolLike", e[e.VoidLike = 49152] = "VoidLike", e[e.Primitive = 402784252] = "Primitive", e[e.DefinitelyNonNullable = 470302716] = "DefinitelyNonNullable", e[e.DisjointDomains = 469892092] = "DisjointDomains", e[e.UnionOrIntersection = 3145728] = "UnionOrIntersection", e[e.StructuredType = 3670016] = "StructuredType", e[e.TypeVariable = 8650752] = "TypeVariable", e[e.InstantiableNonPrimitive = 58982400] = "InstantiableNonPrimitive", e[e.InstantiablePrimitive = 406847488] = "InstantiablePrimitive", e[e.Instantiable = 465829888] = "Instantiable", e[e.StructuredOrInstantiable = 469499904] = "StructuredOrInstantiable", e[e.ObjectFlagsType = 3899393] = "ObjectFlagsType", e[e.Simplifiable = 25165824] = "Simplifiable", e[e.Singleton = 67358815] = "Singleton", e[e.Narrowable = 536624127] = "Narrowable", e[e.IncludesMask = 473694207] = "IncludesMask", e[ + e.IncludesMissingType = 262144 + /* TypeParameter */ + ] = "IncludesMissingType", e[ + e.IncludesNonWideningType = 4194304 + /* Index */ + ] = "IncludesNonWideningType", e[ + e.IncludesWildcard = 8388608 + /* IndexedAccess */ + ] = "IncludesWildcard", e[ + e.IncludesEmptyObject = 16777216 + /* Conditional */ + ] = "IncludesEmptyObject", e[ + e.IncludesInstantiable = 33554432 + /* Substitution */ + ] = "IncludesInstantiable", e[ + e.IncludesConstrainedTypeVariable = 536870912 + /* Reserved1 */ + ] = "IncludesConstrainedTypeVariable", e[ + e.IncludesError = 1073741824 + /* Reserved2 */ + ] = "IncludesError", e[e.NotPrimitiveUnion = 36323331] = "NotPrimitiveUnion", e))(aj || {}), oj = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Class = 1] = "Class", e[e.Interface = 2] = "Interface", e[e.Reference = 4] = "Reference", e[e.Tuple = 8] = "Tuple", e[e.Anonymous = 16] = "Anonymous", e[e.Mapped = 32] = "Mapped", e[e.Instantiated = 64] = "Instantiated", e[e.ObjectLiteral = 128] = "ObjectLiteral", e[e.EvolvingArray = 256] = "EvolvingArray", e[e.ObjectLiteralPatternWithComputedProperties = 512] = "ObjectLiteralPatternWithComputedProperties", e[e.ReverseMapped = 1024] = "ReverseMapped", e[e.JsxAttributes = 2048] = "JsxAttributes", e[e.JSLiteral = 4096] = "JSLiteral", e[e.FreshLiteral = 8192] = "FreshLiteral", e[e.ArrayLiteral = 16384] = "ArrayLiteral", e[e.PrimitiveUnion = 32768] = "PrimitiveUnion", e[e.ContainsWideningType = 65536] = "ContainsWideningType", e[e.ContainsObjectOrArrayLiteral = 131072] = "ContainsObjectOrArrayLiteral", e[e.NonInferrableType = 262144] = "NonInferrableType", e[e.CouldContainTypeVariablesComputed = 524288] = "CouldContainTypeVariablesComputed", e[e.CouldContainTypeVariables = 1048576] = "CouldContainTypeVariables", e[e.SingleSignatureType = 134217728] = "SingleSignatureType", e[e.ClassOrInterface = 3] = "ClassOrInterface", e[e.RequiresWidening = 196608] = "RequiresWidening", e[e.PropagatingFlags = 458752] = "PropagatingFlags", e[e.InstantiatedMapped = 96] = "InstantiatedMapped", e[e.ObjectTypeKindMask = 1343] = "ObjectTypeKindMask", e[e.ContainsSpread = 2097152] = "ContainsSpread", e[e.ObjectRestType = 4194304] = "ObjectRestType", e[e.InstantiationExpressionType = 8388608] = "InstantiationExpressionType", e[e.IsClassInstanceClone = 16777216] = "IsClassInstanceClone", e[e.IdenticalBaseTypeCalculated = 33554432] = "IdenticalBaseTypeCalculated", e[e.IdenticalBaseTypeExists = 67108864] = "IdenticalBaseTypeExists", e[e.IsGenericTypeComputed = 2097152] = "IsGenericTypeComputed", e[e.IsGenericObjectType = 4194304] = "IsGenericObjectType", e[e.IsGenericIndexType = 8388608] = "IsGenericIndexType", e[e.IsGenericType = 12582912] = "IsGenericType", e[e.ContainsIntersections = 16777216] = "ContainsIntersections", e[e.IsUnknownLikeUnionComputed = 33554432] = "IsUnknownLikeUnionComputed", e[e.IsUnknownLikeUnion = 67108864] = "IsUnknownLikeUnion", e[e.IsNeverIntersectionComputed = 16777216] = "IsNeverIntersectionComputed", e[e.IsNeverIntersection = 33554432] = "IsNeverIntersection", e[e.IsConstrainedTypeVariable = 67108864] = "IsConstrainedTypeVariable", e))(oj || {}), YQ = /* @__PURE__ */ ((e) => (e[e.Invariant = 0] = "Invariant", e[e.Covariant = 1] = "Covariant", e[e.Contravariant = 2] = "Contravariant", e[e.Bivariant = 3] = "Bivariant", e[e.Independent = 4] = "Independent", e[e.VarianceMask = 7] = "VarianceMask", e[e.Unmeasurable = 8] = "Unmeasurable", e[e.Unreliable = 16] = "Unreliable", e[e.AllowsStructuralFallback = 24] = "AllowsStructuralFallback", e))(YQ || {}), ZQ = /* @__PURE__ */ ((e) => (e[e.Required = 1] = "Required", e[e.Optional = 2] = "Optional", e[e.Rest = 4] = "Rest", e[e.Variadic = 8] = "Variadic", e[e.Fixed = 3] = "Fixed", e[e.Variable = 12] = "Variable", e[e.NonRequired = 14] = "NonRequired", e[e.NonRest = 11] = "NonRest", e))(ZQ || {}), KQ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.IncludeUndefined = 1] = "IncludeUndefined", e[e.NoIndexSignatures = 2] = "NoIndexSignatures", e[e.Writing = 4] = "Writing", e[e.CacheSymbol = 8] = "CacheSymbol", e[e.AllowMissing = 16] = "AllowMissing", e[e.ExpressionPosition = 32] = "ExpressionPosition", e[e.ReportDeprecated = 64] = "ReportDeprecated", e[e.SuppressNoImplicitAnyError = 128] = "SuppressNoImplicitAnyError", e[e.Contextual = 256] = "Contextual", e[ + e.Persistent = 1 + /* IncludeUndefined */ + ] = "Persistent", e))(KQ || {}), eY = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.StringsOnly = 1] = "StringsOnly", e[e.NoIndexSignatures = 2] = "NoIndexSignatures", e[e.NoReducibleCheck = 4] = "NoReducibleCheck", e))(eY || {}), tY = /* @__PURE__ */ ((e) => (e[e.Component = 0] = "Component", e[e.Function = 1] = "Function", e[e.Mixed = 2] = "Mixed", e))(tY || {}), rY = /* @__PURE__ */ ((e) => (e[e.Call = 0] = "Call", e[e.Construct = 1] = "Construct", e))(rY || {}), cj = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.HasRestParameter = 1] = "HasRestParameter", e[e.HasLiteralTypes = 2] = "HasLiteralTypes", e[e.Abstract = 4] = "Abstract", e[e.IsInnerCallChain = 8] = "IsInnerCallChain", e[e.IsOuterCallChain = 16] = "IsOuterCallChain", e[e.IsUntypedSignatureInJSFile = 32] = "IsUntypedSignatureInJSFile", e[e.IsNonInferrable = 64] = "IsNonInferrable", e[e.IsSignatureCandidateForOverloadFailure = 128] = "IsSignatureCandidateForOverloadFailure", e[e.PropagatingFlags = 167] = "PropagatingFlags", e[e.CallChainFlags = 24] = "CallChainFlags", e))(cj || {}), nY = /* @__PURE__ */ ((e) => (e[e.String = 0] = "String", e[e.Number = 1] = "Number", e))(nY || {}), iY = /* @__PURE__ */ ((e) => (e[e.Simple = 0] = "Simple", e[e.Array = 1] = "Array", e[e.Deferred = 2] = "Deferred", e[e.Function = 3] = "Function", e[e.Composite = 4] = "Composite", e[e.Merged = 5] = "Merged", e))(iY || {}), sY = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.NakedTypeVariable = 1] = "NakedTypeVariable", e[e.SpeculativeTuple = 2] = "SpeculativeTuple", e[e.SubstituteSource = 4] = "SubstituteSource", e[e.HomomorphicMappedType = 8] = "HomomorphicMappedType", e[e.PartialHomomorphicMappedType = 16] = "PartialHomomorphicMappedType", e[e.MappedTypeConstraint = 32] = "MappedTypeConstraint", e[e.ContravariantConditional = 64] = "ContravariantConditional", e[e.ReturnType = 128] = "ReturnType", e[e.LiteralKeyof = 256] = "LiteralKeyof", e[e.NoConstraints = 512] = "NoConstraints", e[e.AlwaysStrict = 1024] = "AlwaysStrict", e[e.MaxValue = 2048] = "MaxValue", e[e.PriorityImpliesCombination = 416] = "PriorityImpliesCombination", e[e.Circularity = -1] = "Circularity", e))(sY || {}), aY = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.NoDefault = 1] = "NoDefault", e[e.AnyDefault = 2] = "AnyDefault", e[e.SkippedGenericFunction = 4] = "SkippedGenericFunction", e))(aY || {}), oY = /* @__PURE__ */ ((e) => (e[e.False = 0] = "False", e[e.Unknown = 1] = "Unknown", e[e.Maybe = 3] = "Maybe", e[e.True = -1] = "True", e))(oY || {}), cY = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.ExportsProperty = 1] = "ExportsProperty", e[e.ModuleExports = 2] = "ModuleExports", e[e.PrototypeProperty = 3] = "PrototypeProperty", e[e.ThisProperty = 4] = "ThisProperty", e[e.Property = 5] = "Property", e[e.Prototype = 6] = "Prototype", e[e.ObjectDefinePropertyValue = 7] = "ObjectDefinePropertyValue", e[e.ObjectDefinePropertyExports = 8] = "ObjectDefinePropertyExports", e[e.ObjectDefinePrototypeProperty = 9] = "ObjectDefinePrototypeProperty", e))(cY || {}), n7 = /* @__PURE__ */ ((e) => (e[e.Warning = 0] = "Warning", e[e.Error = 1] = "Error", e[e.Suggestion = 2] = "Suggestion", e[e.Message = 3] = "Message", e))(n7 || {}); + function $2(e, t = !0) { + const n = n7[e.category]; + return t ? n.toLowerCase() : n; + } + var SC = /* @__PURE__ */ ((e) => (e[e.Classic = 1] = "Classic", e[e.NodeJs = 2] = "NodeJs", e[e.Node10 = 2] = "Node10", e[e.Node16 = 3] = "Node16", e[e.NodeNext = 99] = "NodeNext", e[e.Bundler = 100] = "Bundler", e))(SC || {}), lY = /* @__PURE__ */ ((e) => (e[e.Legacy = 1] = "Legacy", e[e.Auto = 2] = "Auto", e[e.Force = 3] = "Force", e))(lY || {}), uY = /* @__PURE__ */ ((e) => (e[e.FixedPollingInterval = 0] = "FixedPollingInterval", e[e.PriorityPollingInterval = 1] = "PriorityPollingInterval", e[e.DynamicPriorityPolling = 2] = "DynamicPriorityPolling", e[e.FixedChunkSizePolling = 3] = "FixedChunkSizePolling", e[e.UseFsEvents = 4] = "UseFsEvents", e[e.UseFsEventsOnParentDirectory = 5] = "UseFsEventsOnParentDirectory", e))(uY || {}), _Y = /* @__PURE__ */ ((e) => (e[e.UseFsEvents = 0] = "UseFsEvents", e[e.FixedPollingInterval = 1] = "FixedPollingInterval", e[e.DynamicPriorityPolling = 2] = "DynamicPriorityPolling", e[e.FixedChunkSizePolling = 3] = "FixedChunkSizePolling", e))(_Y || {}), fY = /* @__PURE__ */ ((e) => (e[e.FixedInterval = 0] = "FixedInterval", e[e.PriorityInterval = 1] = "PriorityInterval", e[e.DynamicPriority = 2] = "DynamicPriority", e[e.FixedChunkSize = 3] = "FixedChunkSize", e))(fY || {}), TC = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.CommonJS = 1] = "CommonJS", e[e.AMD = 2] = "AMD", e[e.UMD = 3] = "UMD", e[e.System = 4] = "System", e[e.ES2015 = 5] = "ES2015", e[e.ES2020 = 6] = "ES2020", e[e.ES2022 = 7] = "ES2022", e[e.ESNext = 99] = "ESNext", e[e.Node16 = 100] = "Node16", e[e.Node18 = 101] = "Node18", e[e.Node20 = 102] = "Node20", e[e.NodeNext = 199] = "NodeNext", e[e.Preserve = 200] = "Preserve", e))(TC || {}), pY = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Preserve = 1] = "Preserve", e[e.React = 2] = "React", e[e.ReactNative = 3] = "ReactNative", e[e.ReactJSX = 4] = "ReactJSX", e[e.ReactJSXDev = 5] = "ReactJSXDev", e))(pY || {}), dY = /* @__PURE__ */ ((e) => (e[e.Remove = 0] = "Remove", e[e.Preserve = 1] = "Preserve", e[e.Error = 2] = "Error", e))(dY || {}), mY = /* @__PURE__ */ ((e) => (e[e.CarriageReturnLineFeed = 0] = "CarriageReturnLineFeed", e[e.LineFeed = 1] = "LineFeed", e))(mY || {}), lj = /* @__PURE__ */ ((e) => (e[e.Unknown = 0] = "Unknown", e[e.JS = 1] = "JS", e[e.JSX = 2] = "JSX", e[e.TS = 3] = "TS", e[e.TSX = 4] = "TSX", e[e.External = 5] = "External", e[e.JSON = 6] = "JSON", e[e.Deferred = 7] = "Deferred", e))(lj || {}), gY = /* @__PURE__ */ ((e) => (e[e.ES3 = 0] = "ES3", e[e.ES5 = 1] = "ES5", e[e.ES2015 = 2] = "ES2015", e[e.ES2016 = 3] = "ES2016", e[e.ES2017 = 4] = "ES2017", e[e.ES2018 = 5] = "ES2018", e[e.ES2019 = 6] = "ES2019", e[e.ES2020 = 7] = "ES2020", e[e.ES2021 = 8] = "ES2021", e[e.ES2022 = 9] = "ES2022", e[e.ES2023 = 10] = "ES2023", e[e.ES2024 = 11] = "ES2024", e[e.ESNext = 99] = "ESNext", e[e.JSON = 100] = "JSON", e[ + e.Latest = 99 + /* ESNext */ + ] = "Latest", e))(gY || {}), hY = /* @__PURE__ */ ((e) => (e[e.Standard = 0] = "Standard", e[e.JSX = 1] = "JSX", e))(hY || {}), yY = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Recursive = 1] = "Recursive", e))(yY || {}), vY = /* @__PURE__ */ ((e) => (e[e.EOF = -1] = "EOF", e[e.nullCharacter = 0] = "nullCharacter", e[e.maxAsciiCharacter = 127] = "maxAsciiCharacter", e[e.lineFeed = 10] = "lineFeed", e[e.carriageReturn = 13] = "carriageReturn", e[e.lineSeparator = 8232] = "lineSeparator", e[e.paragraphSeparator = 8233] = "paragraphSeparator", e[e.nextLine = 133] = "nextLine", e[e.space = 32] = "space", e[e.nonBreakingSpace = 160] = "nonBreakingSpace", e[e.enQuad = 8192] = "enQuad", e[e.emQuad = 8193] = "emQuad", e[e.enSpace = 8194] = "enSpace", e[e.emSpace = 8195] = "emSpace", e[e.threePerEmSpace = 8196] = "threePerEmSpace", e[e.fourPerEmSpace = 8197] = "fourPerEmSpace", e[e.sixPerEmSpace = 8198] = "sixPerEmSpace", e[e.figureSpace = 8199] = "figureSpace", e[e.punctuationSpace = 8200] = "punctuationSpace", e[e.thinSpace = 8201] = "thinSpace", e[e.hairSpace = 8202] = "hairSpace", e[e.zeroWidthSpace = 8203] = "zeroWidthSpace", e[e.narrowNoBreakSpace = 8239] = "narrowNoBreakSpace", e[e.ideographicSpace = 12288] = "ideographicSpace", e[e.mathematicalSpace = 8287] = "mathematicalSpace", e[e.ogham = 5760] = "ogham", e[e.replacementCharacter = 65533] = "replacementCharacter", e[e._ = 95] = "_", e[e.$ = 36] = "$", e[e._0 = 48] = "_0", e[e._1 = 49] = "_1", e[e._2 = 50] = "_2", e[e._3 = 51] = "_3", e[e._4 = 52] = "_4", e[e._5 = 53] = "_5", e[e._6 = 54] = "_6", e[e._7 = 55] = "_7", e[e._8 = 56] = "_8", e[e._9 = 57] = "_9", e[e.a = 97] = "a", e[e.b = 98] = "b", e[e.c = 99] = "c", e[e.d = 100] = "d", e[e.e = 101] = "e", e[e.f = 102] = "f", e[e.g = 103] = "g", e[e.h = 104] = "h", e[e.i = 105] = "i", e[e.j = 106] = "j", e[e.k = 107] = "k", e[e.l = 108] = "l", e[e.m = 109] = "m", e[e.n = 110] = "n", e[e.o = 111] = "o", e[e.p = 112] = "p", e[e.q = 113] = "q", e[e.r = 114] = "r", e[e.s = 115] = "s", e[e.t = 116] = "t", e[e.u = 117] = "u", e[e.v = 118] = "v", e[e.w = 119] = "w", e[e.x = 120] = "x", e[e.y = 121] = "y", e[e.z = 122] = "z", e[e.A = 65] = "A", e[e.B = 66] = "B", e[e.C = 67] = "C", e[e.D = 68] = "D", e[e.E = 69] = "E", e[e.F = 70] = "F", e[e.G = 71] = "G", e[e.H = 72] = "H", e[e.I = 73] = "I", e[e.J = 74] = "J", e[e.K = 75] = "K", e[e.L = 76] = "L", e[e.M = 77] = "M", e[e.N = 78] = "N", e[e.O = 79] = "O", e[e.P = 80] = "P", e[e.Q = 81] = "Q", e[e.R = 82] = "R", e[e.S = 83] = "S", e[e.T = 84] = "T", e[e.U = 85] = "U", e[e.V = 86] = "V", e[e.W = 87] = "W", e[e.X = 88] = "X", e[e.Y = 89] = "Y", e[e.Z = 90] = "Z", e[e.ampersand = 38] = "ampersand", e[e.asterisk = 42] = "asterisk", e[e.at = 64] = "at", e[e.backslash = 92] = "backslash", e[e.backtick = 96] = "backtick", e[e.bar = 124] = "bar", e[e.caret = 94] = "caret", e[e.closeBrace = 125] = "closeBrace", e[e.closeBracket = 93] = "closeBracket", e[e.closeParen = 41] = "closeParen", e[e.colon = 58] = "colon", e[e.comma = 44] = "comma", e[e.dot = 46] = "dot", e[e.doubleQuote = 34] = "doubleQuote", e[e.equals = 61] = "equals", e[e.exclamation = 33] = "exclamation", e[e.greaterThan = 62] = "greaterThan", e[e.hash = 35] = "hash", e[e.lessThan = 60] = "lessThan", e[e.minus = 45] = "minus", e[e.openBrace = 123] = "openBrace", e[e.openBracket = 91] = "openBracket", e[e.openParen = 40] = "openParen", e[e.percent = 37] = "percent", e[e.plus = 43] = "plus", e[e.question = 63] = "question", e[e.semicolon = 59] = "semicolon", e[e.singleQuote = 39] = "singleQuote", e[e.slash = 47] = "slash", e[e.tilde = 126] = "tilde", e[e.backspace = 8] = "backspace", e[e.formFeed = 12] = "formFeed", e[e.byteOrderMark = 65279] = "byteOrderMark", e[e.tab = 9] = "tab", e[e.verticalTab = 11] = "verticalTab", e))(vY || {}), bY = /* @__PURE__ */ ((e) => (e.Ts = ".ts", e.Tsx = ".tsx", e.Dts = ".d.ts", e.Js = ".js", e.Jsx = ".jsx", e.Json = ".json", e.TsBuildInfo = ".tsbuildinfo", e.Mjs = ".mjs", e.Mts = ".mts", e.Dmts = ".d.mts", e.Cjs = ".cjs", e.Cts = ".cts", e.Dcts = ".d.cts", e))(bY || {}), uj = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.ContainsTypeScript = 1] = "ContainsTypeScript", e[e.ContainsJsx = 2] = "ContainsJsx", e[e.ContainsESNext = 4] = "ContainsESNext", e[e.ContainsES2022 = 8] = "ContainsES2022", e[e.ContainsES2021 = 16] = "ContainsES2021", e[e.ContainsES2020 = 32] = "ContainsES2020", e[e.ContainsES2019 = 64] = "ContainsES2019", e[e.ContainsES2018 = 128] = "ContainsES2018", e[e.ContainsES2017 = 256] = "ContainsES2017", e[e.ContainsES2016 = 512] = "ContainsES2016", e[e.ContainsES2015 = 1024] = "ContainsES2015", e[e.ContainsGenerator = 2048] = "ContainsGenerator", e[e.ContainsDestructuringAssignment = 4096] = "ContainsDestructuringAssignment", e[e.ContainsTypeScriptClassSyntax = 8192] = "ContainsTypeScriptClassSyntax", e[e.ContainsLexicalThis = 16384] = "ContainsLexicalThis", e[e.ContainsRestOrSpread = 32768] = "ContainsRestOrSpread", e[e.ContainsObjectRestOrSpread = 65536] = "ContainsObjectRestOrSpread", e[e.ContainsComputedPropertyName = 131072] = "ContainsComputedPropertyName", e[e.ContainsBlockScopedBinding = 262144] = "ContainsBlockScopedBinding", e[e.ContainsBindingPattern = 524288] = "ContainsBindingPattern", e[e.ContainsYield = 1048576] = "ContainsYield", e[e.ContainsAwait = 2097152] = "ContainsAwait", e[e.ContainsHoistedDeclarationOrCompletion = 4194304] = "ContainsHoistedDeclarationOrCompletion", e[e.ContainsDynamicImport = 8388608] = "ContainsDynamicImport", e[e.ContainsClassFields = 16777216] = "ContainsClassFields", e[e.ContainsDecorators = 33554432] = "ContainsDecorators", e[e.ContainsPossibleTopLevelAwait = 67108864] = "ContainsPossibleTopLevelAwait", e[e.ContainsLexicalSuper = 134217728] = "ContainsLexicalSuper", e[e.ContainsUpdateExpressionForIdentifier = 268435456] = "ContainsUpdateExpressionForIdentifier", e[e.ContainsPrivateIdentifierInExpression = 536870912] = "ContainsPrivateIdentifierInExpression", e[e.HasComputedFlags = -2147483648] = "HasComputedFlags", e[ + e.AssertTypeScript = 1 + /* ContainsTypeScript */ + ] = "AssertTypeScript", e[ + e.AssertJsx = 2 + /* ContainsJsx */ + ] = "AssertJsx", e[ + e.AssertESNext = 4 + /* ContainsESNext */ + ] = "AssertESNext", e[ + e.AssertES2022 = 8 + /* ContainsES2022 */ + ] = "AssertES2022", e[ + e.AssertES2021 = 16 + /* ContainsES2021 */ + ] = "AssertES2021", e[ + e.AssertES2020 = 32 + /* ContainsES2020 */ + ] = "AssertES2020", e[ + e.AssertES2019 = 64 + /* ContainsES2019 */ + ] = "AssertES2019", e[ + e.AssertES2018 = 128 + /* ContainsES2018 */ + ] = "AssertES2018", e[ + e.AssertES2017 = 256 + /* ContainsES2017 */ + ] = "AssertES2017", e[ + e.AssertES2016 = 512 + /* ContainsES2016 */ + ] = "AssertES2016", e[ + e.AssertES2015 = 1024 + /* ContainsES2015 */ + ] = "AssertES2015", e[ + e.AssertGenerator = 2048 + /* ContainsGenerator */ + ] = "AssertGenerator", e[ + e.AssertDestructuringAssignment = 4096 + /* ContainsDestructuringAssignment */ + ] = "AssertDestructuringAssignment", e[ + e.OuterExpressionExcludes = -2147483648 + /* HasComputedFlags */ + ] = "OuterExpressionExcludes", e[ + e.PropertyAccessExcludes = -2147483648 + /* OuterExpressionExcludes */ + ] = "PropertyAccessExcludes", e[ + e.NodeExcludes = -2147483648 + /* PropertyAccessExcludes */ + ] = "NodeExcludes", e[e.ArrowFunctionExcludes = -2072174592] = "ArrowFunctionExcludes", e[e.FunctionExcludes = -1937940480] = "FunctionExcludes", e[e.ConstructorExcludes = -1937948672] = "ConstructorExcludes", e[e.MethodOrAccessorExcludes = -2005057536] = "MethodOrAccessorExcludes", e[e.PropertyExcludes = -2013249536] = "PropertyExcludes", e[e.ClassExcludes = -2147344384] = "ClassExcludes", e[e.ModuleExcludes = -1941676032] = "ModuleExcludes", e[e.TypeExcludes = -2] = "TypeExcludes", e[e.ObjectLiteralExcludes = -2147278848] = "ObjectLiteralExcludes", e[e.ArrayLiteralOrCallOrNewExcludes = -2147450880] = "ArrayLiteralOrCallOrNewExcludes", e[e.VariableDeclarationListExcludes = -2146893824] = "VariableDeclarationListExcludes", e[ + e.ParameterExcludes = -2147483648 + /* NodeExcludes */ + ] = "ParameterExcludes", e[e.CatchClauseExcludes = -2147418112] = "CatchClauseExcludes", e[e.BindingPatternExcludes = -2147450880] = "BindingPatternExcludes", e[e.ContainsLexicalThisOrSuper = 134234112] = "ContainsLexicalThisOrSuper", e[e.PropertyNamePropagatingFlags = 134234112] = "PropertyNamePropagatingFlags", e))(uj || {}), _j = /* @__PURE__ */ ((e) => (e[e.TabStop = 0] = "TabStop", e[e.Placeholder = 1] = "Placeholder", e[e.Choice = 2] = "Choice", e[e.Variable = 3] = "Variable", e))(_j || {}), fj = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.SingleLine = 1] = "SingleLine", e[e.MultiLine = 2] = "MultiLine", e[e.AdviseOnEmitNode = 4] = "AdviseOnEmitNode", e[e.NoSubstitution = 8] = "NoSubstitution", e[e.CapturesThis = 16] = "CapturesThis", e[e.NoLeadingSourceMap = 32] = "NoLeadingSourceMap", e[e.NoTrailingSourceMap = 64] = "NoTrailingSourceMap", e[e.NoSourceMap = 96] = "NoSourceMap", e[e.NoNestedSourceMaps = 128] = "NoNestedSourceMaps", e[e.NoTokenLeadingSourceMaps = 256] = "NoTokenLeadingSourceMaps", e[e.NoTokenTrailingSourceMaps = 512] = "NoTokenTrailingSourceMaps", e[e.NoTokenSourceMaps = 768] = "NoTokenSourceMaps", e[e.NoLeadingComments = 1024] = "NoLeadingComments", e[e.NoTrailingComments = 2048] = "NoTrailingComments", e[e.NoComments = 3072] = "NoComments", e[e.NoNestedComments = 4096] = "NoNestedComments", e[e.HelperName = 8192] = "HelperName", e[e.ExportName = 16384] = "ExportName", e[e.LocalName = 32768] = "LocalName", e[e.InternalName = 65536] = "InternalName", e[e.Indented = 131072] = "Indented", e[e.NoIndentation = 262144] = "NoIndentation", e[e.AsyncFunctionBody = 524288] = "AsyncFunctionBody", e[e.ReuseTempVariableScope = 1048576] = "ReuseTempVariableScope", e[e.CustomPrologue = 2097152] = "CustomPrologue", e[e.NoHoisting = 4194304] = "NoHoisting", e[e.Iterator = 8388608] = "Iterator", e[e.NoAsciiEscaping = 16777216] = "NoAsciiEscaping", e))(fj || {}), SY = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.TypeScriptClassWrapper = 1] = "TypeScriptClassWrapper", e[e.NeverApplyImportHelper = 2] = "NeverApplyImportHelper", e[e.IgnoreSourceNewlines = 4] = "IgnoreSourceNewlines", e[e.Immutable = 8] = "Immutable", e[e.IndirectCall = 16] = "IndirectCall", e[e.TransformPrivateStaticElements = 32] = "TransformPrivateStaticElements", e))(SY || {}), El = { + Classes: 2, + ForOf: 2, + Generators: 2, + Iteration: 2, + SpreadElements: 2, + RestElements: 2, + TaggedTemplates: 2, + DestructuringAssignment: 2, + BindingPatterns: 2, + ArrowFunctions: 2, + BlockScopedVariables: 2, + ObjectAssign: 2, + RegularExpressionFlagsUnicode: 2, + RegularExpressionFlagsSticky: 2, + Exponentiation: 3, + AsyncFunctions: 4, + ForAwaitOf: 5, + AsyncGenerators: 5, + AsyncIteration: 5, + ObjectSpreadRest: 5, + RegularExpressionFlagsDotAll: 5, + BindinglessCatch: 6, + BigInt: 7, + NullishCoalesce: 7, + OptionalChaining: 7, + LogicalAssignment: 8, + TopLevelAwait: 9, + ClassFields: 9, + PrivateNamesAndClassStaticBlocks: 9, + RegularExpressionFlagsHasIndices: 9, + ShebangComments: 10, + RegularExpressionFlagsUnicodeSets: 11, + UsingAndAwaitUsing: 99, + ClassAndClassElementDecorators: 99 + /* ESNext */ + }, TY = /* @__PURE__ */ ((e) => (e[e.Extends = 1] = "Extends", e[e.Assign = 2] = "Assign", e[e.Rest = 4] = "Rest", e[e.Decorate = 8] = "Decorate", e[ + e.ESDecorateAndRunInitializers = 8 + /* Decorate */ + ] = "ESDecorateAndRunInitializers", e[e.Metadata = 16] = "Metadata", e[e.Param = 32] = "Param", e[e.Awaiter = 64] = "Awaiter", e[e.Generator = 128] = "Generator", e[e.Values = 256] = "Values", e[e.Read = 512] = "Read", e[e.SpreadArray = 1024] = "SpreadArray", e[e.Await = 2048] = "Await", e[e.AsyncGenerator = 4096] = "AsyncGenerator", e[e.AsyncDelegator = 8192] = "AsyncDelegator", e[e.AsyncValues = 16384] = "AsyncValues", e[e.ExportStar = 32768] = "ExportStar", e[e.ImportStar = 65536] = "ImportStar", e[e.ImportDefault = 131072] = "ImportDefault", e[e.MakeTemplateObject = 262144] = "MakeTemplateObject", e[e.ClassPrivateFieldGet = 524288] = "ClassPrivateFieldGet", e[e.ClassPrivateFieldSet = 1048576] = "ClassPrivateFieldSet", e[e.ClassPrivateFieldIn = 2097152] = "ClassPrivateFieldIn", e[e.SetFunctionName = 4194304] = "SetFunctionName", e[e.PropKey = 8388608] = "PropKey", e[e.AddDisposableResourceAndDisposeResources = 16777216] = "AddDisposableResourceAndDisposeResources", e[e.RewriteRelativeImportExtension = 33554432] = "RewriteRelativeImportExtension", e[ + e.FirstEmitHelper = 1 + /* Extends */ + ] = "FirstEmitHelper", e[ + e.LastEmitHelper = 16777216 + /* AddDisposableResourceAndDisposeResources */ + ] = "LastEmitHelper", e[ + e.ForOfIncludes = 256 + /* Values */ + ] = "ForOfIncludes", e[ + e.ForAwaitOfIncludes = 16384 + /* AsyncValues */ + ] = "ForAwaitOfIncludes", e[e.AsyncGeneratorIncludes = 6144] = "AsyncGeneratorIncludes", e[e.AsyncDelegatorIncludes = 26624] = "AsyncDelegatorIncludes", e[e.SpreadIncludes = 1536] = "SpreadIncludes", e))(TY || {}), xY = /* @__PURE__ */ ((e) => (e[e.SourceFile = 0] = "SourceFile", e[e.Expression = 1] = "Expression", e[e.IdentifierName = 2] = "IdentifierName", e[e.MappedTypeParameter = 3] = "MappedTypeParameter", e[e.Unspecified = 4] = "Unspecified", e[e.EmbeddedStatement = 5] = "EmbeddedStatement", e[e.JsxAttributeValue = 6] = "JsxAttributeValue", e[e.ImportTypeNodeAttributes = 7] = "ImportTypeNodeAttributes", e))(xY || {}), kY = /* @__PURE__ */ ((e) => (e[e.Parentheses = 1] = "Parentheses", e[e.TypeAssertions = 2] = "TypeAssertions", e[e.NonNullAssertions = 4] = "NonNullAssertions", e[e.PartiallyEmittedExpressions = 8] = "PartiallyEmittedExpressions", e[e.ExpressionsWithTypeArguments = 16] = "ExpressionsWithTypeArguments", e[e.Satisfies = 32] = "Satisfies", e[e.Assertions = 38] = "Assertions", e[e.All = 63] = "All", e[e.ExcludeJSDocTypeAssertion = -2147483648] = "ExcludeJSDocTypeAssertion", e))(kY || {}), CY = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.InParameters = 1] = "InParameters", e[e.VariablesHoistedInParameters = 2] = "VariablesHoistedInParameters", e))(CY || {}), EY = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.SingleLine = 0] = "SingleLine", e[e.MultiLine = 1] = "MultiLine", e[e.PreserveLines = 2] = "PreserveLines", e[e.LinesMask = 3] = "LinesMask", e[e.NotDelimited = 0] = "NotDelimited", e[e.BarDelimited = 4] = "BarDelimited", e[e.AmpersandDelimited = 8] = "AmpersandDelimited", e[e.CommaDelimited = 16] = "CommaDelimited", e[e.AsteriskDelimited = 32] = "AsteriskDelimited", e[e.DelimitersMask = 60] = "DelimitersMask", e[e.AllowTrailingComma = 64] = "AllowTrailingComma", e[e.Indented = 128] = "Indented", e[e.SpaceBetweenBraces = 256] = "SpaceBetweenBraces", e[e.SpaceBetweenSiblings = 512] = "SpaceBetweenSiblings", e[e.Braces = 1024] = "Braces", e[e.Parenthesis = 2048] = "Parenthesis", e[e.AngleBrackets = 4096] = "AngleBrackets", e[e.SquareBrackets = 8192] = "SquareBrackets", e[e.BracketsMask = 15360] = "BracketsMask", e[e.OptionalIfUndefined = 16384] = "OptionalIfUndefined", e[e.OptionalIfEmpty = 32768] = "OptionalIfEmpty", e[e.Optional = 49152] = "Optional", e[e.PreferNewLine = 65536] = "PreferNewLine", e[e.NoTrailingNewLine = 131072] = "NoTrailingNewLine", e[e.NoInterveningComments = 262144] = "NoInterveningComments", e[e.NoSpaceIfEmpty = 524288] = "NoSpaceIfEmpty", e[e.SingleElement = 1048576] = "SingleElement", e[e.SpaceAfterList = 2097152] = "SpaceAfterList", e[e.Modifiers = 2359808] = "Modifiers", e[e.HeritageClauses = 512] = "HeritageClauses", e[e.SingleLineTypeLiteralMembers = 768] = "SingleLineTypeLiteralMembers", e[e.MultiLineTypeLiteralMembers = 32897] = "MultiLineTypeLiteralMembers", e[e.SingleLineTupleTypeElements = 528] = "SingleLineTupleTypeElements", e[e.MultiLineTupleTypeElements = 657] = "MultiLineTupleTypeElements", e[e.UnionTypeConstituents = 516] = "UnionTypeConstituents", e[e.IntersectionTypeConstituents = 520] = "IntersectionTypeConstituents", e[e.ObjectBindingPatternElements = 525136] = "ObjectBindingPatternElements", e[e.ArrayBindingPatternElements = 524880] = "ArrayBindingPatternElements", e[e.ObjectLiteralExpressionProperties = 526226] = "ObjectLiteralExpressionProperties", e[e.ImportAttributes = 526226] = "ImportAttributes", e[ + e.ImportClauseEntries = 526226 + /* ImportAttributes */ + ] = "ImportClauseEntries", e[e.ArrayLiteralExpressionElements = 8914] = "ArrayLiteralExpressionElements", e[e.CommaListElements = 528] = "CommaListElements", e[e.CallExpressionArguments = 2576] = "CallExpressionArguments", e[e.NewExpressionArguments = 18960] = "NewExpressionArguments", e[e.TemplateExpressionSpans = 262144] = "TemplateExpressionSpans", e[e.SingleLineBlockStatements = 768] = "SingleLineBlockStatements", e[e.MultiLineBlockStatements = 129] = "MultiLineBlockStatements", e[e.VariableDeclarationList = 528] = "VariableDeclarationList", e[e.SingleLineFunctionBodyStatements = 768] = "SingleLineFunctionBodyStatements", e[ + e.MultiLineFunctionBodyStatements = 1 + /* MultiLine */ + ] = "MultiLineFunctionBodyStatements", e[ + e.ClassHeritageClauses = 0 + /* SingleLine */ + ] = "ClassHeritageClauses", e[e.ClassMembers = 129] = "ClassMembers", e[e.InterfaceMembers = 129] = "InterfaceMembers", e[e.EnumMembers = 145] = "EnumMembers", e[e.CaseBlockClauses = 129] = "CaseBlockClauses", e[e.NamedImportsOrExportsElements = 525136] = "NamedImportsOrExportsElements", e[e.JsxElementOrFragmentChildren = 262144] = "JsxElementOrFragmentChildren", e[e.JsxElementAttributes = 262656] = "JsxElementAttributes", e[e.CaseOrDefaultClauseStatements = 163969] = "CaseOrDefaultClauseStatements", e[e.HeritageClauseTypes = 528] = "HeritageClauseTypes", e[e.SourceFileStatements = 131073] = "SourceFileStatements", e[e.Decorators = 2146305] = "Decorators", e[e.TypeArguments = 53776] = "TypeArguments", e[e.TypeParameters = 53776] = "TypeParameters", e[e.Parameters = 2576] = "Parameters", e[e.IndexSignatureParameters = 8848] = "IndexSignatureParameters", e[e.JSDocComment = 33] = "JSDocComment", e))(EY || {}), DY = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.TripleSlashXML = 1] = "TripleSlashXML", e[e.SingleLine = 2] = "SingleLine", e[e.MultiLine = 4] = "MultiLine", e[e.All = 7] = "All", e[ + e.Default = 7 + /* All */ + ] = "Default", e))(DY || {}), i7 = { + reference: { + args: [ + { name: "types", optional: !0, captureSpan: !0 }, + { name: "lib", optional: !0, captureSpan: !0 }, + { name: "path", optional: !0, captureSpan: !0 }, + { name: "no-default-lib", optional: !0 }, + { name: "resolution-mode", optional: !0 }, + { name: "preserve", optional: !0 } + ], + kind: 1 + /* TripleSlashXML */ + }, + "amd-dependency": { + args: [{ name: "path" }, { name: "name", optional: !0 }], + kind: 1 + /* TripleSlashXML */ + }, + "amd-module": { + args: [{ name: "name" }], + kind: 1 + /* TripleSlashXML */ + }, + "ts-check": { + kind: 2 + /* SingleLine */ + }, + "ts-nocheck": { + kind: 2 + /* SingleLine */ + }, + jsx: { + args: [{ name: "factory" }], + kind: 4 + /* MultiLine */ + }, + jsxfrag: { + args: [{ name: "factory" }], + kind: 4 + /* MultiLine */ + }, + jsximportsource: { + args: [{ name: "factory" }], + kind: 4 + /* MultiLine */ + }, + jsxruntime: { + args: [{ name: "factory" }], + kind: 4 + /* MultiLine */ + } + }, wY = /* @__PURE__ */ ((e) => (e[e.ParseAll = 0] = "ParseAll", e[e.ParseNone = 1] = "ParseNone", e[e.ParseForTypeErrors = 2] = "ParseForTypeErrors", e[e.ParseForTypeInfo = 3] = "ParseForTypeInfo", e))(wY || {}); + function uD(e) { + let t = 5381; + for (let n = 0; n < e.length; n++) + t = (t << 5) + t + e.charCodeAt(n); + return t.toString(); + } + function Ige() { + Error.stackTraceLimit < 100 && (Error.stackTraceLimit = 100); + } + var PY = /* @__PURE__ */ ((e) => (e[e.Created = 0] = "Created", e[e.Changed = 1] = "Changed", e[e.Deleted = 2] = "Deleted", e))(PY || {}), pj = /* @__PURE__ */ ((e) => (e[e.High = 2e3] = "High", e[e.Medium = 500] = "Medium", e[e.Low = 250] = "Low", e))(pj || {}), Y_ = /* @__PURE__ */ new Date(0); + function KT(e, t) { + return e.getModifiedTime(t) || Y_; + } + function NY(e) { + return { + 250: e.Low, + 500: e.Medium, + 2e3: e.High + }; + } + var dj = { Low: 32, Medium: 64, High: 256 }, mj = NY(dj), s7 = NY(dj); + function CFe(e) { + if (!e.getEnvironmentVariable) + return; + const t = s("TSC_WATCH_POLLINGINTERVAL", pj); + mj = o("TSC_WATCH_POLLINGCHUNKSIZE", dj) || mj, s7 = o("TSC_WATCH_UNCHANGEDPOLLTHRESHOLDS", dj) || s7; + function n(c, _) { + return e.getEnvironmentVariable(`${c}_${_.toUpperCase()}`); + } + function i(c) { + let _; + return u("Low"), u("Medium"), u("High"), _; + function u(g) { + const m = n(c, g); + m && ((_ || (_ = {}))[g] = Number(m)); + } + } + function s(c, _) { + const u = i(c); + if (u) + return g("Low"), g("Medium"), g("High"), !0; + return !1; + function g(m) { + _[m] = u[m] || _[m]; + } + } + function o(c, _) { + const u = i(c); + return (t || u) && NY(u ? { ..._, ...u } : _); + } + } + function Fge(e, t, n, i, s) { + let o = n; + for (let _ = t.length; i && _; c(), _--) { + const u = t[n]; + if (u) { + if (u.isClosed) { + t[n] = void 0; + continue; + } + } else continue; + i--; + const g = PFe(u, KT(e, u.fileName)); + if (u.isClosed) { + t[n] = void 0; + continue; + } + s?.(u, n, g), t[n] && (o < n && (t[o] = u, t[n] = void 0), o++); + } + return n; + function c() { + n++, n === t.length && (o < n && (t.length = o), n = 0, o = 0); + } + } + function EFe(e) { + const t = [], n = [], i = _( + 250 + /* Low */ + ), s = _( + 500 + /* Medium */ + ), o = _( + 2e3 + /* High */ + ); + return c; + function c(P, A, O) { + const F = { + fileName: P, + callback: A, + unchangedPolls: 0, + mtime: KT(e, P) + }; + return t.push(F), S(F, O), { + close: () => { + F.isClosed = !0, YT(t, F); + } + }; + } + function _(P) { + const A = []; + return A.pollingInterval = P, A.pollIndex = 0, A.pollScheduled = !1, A; + } + function u(P, A) { + A.pollIndex = m(A, A.pollingInterval, A.pollIndex, mj[A.pollingInterval]), A.length ? D(A.pollingInterval) : (E.assert(A.pollIndex === 0), A.pollScheduled = !1); + } + function g(P, A) { + m( + n, + 250, + /*pollIndex*/ + 0, + n.length + ), u(P, A), !A.pollScheduled && n.length && D( + 250 + /* Low */ + ); + } + function m(P, A, O, F) { + return Fge( + e, + P, + O, + F, + R + ); + function R(B, U, $) { + $ ? (B.unchangedPolls = 0, P !== n && (P[U] = void 0, T(B))) : B.unchangedPolls !== s7[A] ? B.unchangedPolls++ : P === n ? (B.unchangedPolls = 1, P[U] = void 0, S( + B, + 250 + /* Low */ + )) : A !== 2e3 && (B.unchangedPolls++, P[U] = void 0, S( + B, + A === 250 ? 500 : 2e3 + /* High */ + )); + } + } + function h(P) { + switch (P) { + case 250: + return i; + case 500: + return s; + case 2e3: + return o; + } + } + function S(P, A) { + h(A).push(P), k(A); + } + function T(P) { + n.push(P), k( + 250 + /* Low */ + ); + } + function k(P) { + h(P).pollScheduled || D(P); + } + function D(P) { + h(P).pollScheduled = e.setTimeout(P === 250 ? g : u, P, P === 250 ? "pollLowPollingIntervalQueue" : "pollPollingIntervalQueue", h(P)); + } + } + function DFe(e, t, n, i) { + const s = Fp(), o = i ? /* @__PURE__ */ new Map() : void 0, c = /* @__PURE__ */ new Map(), _ = Zl(t); + return u; + function u(m, h, S, T) { + const k = _(m); + s.add(k, h).length === 1 && o && o.set(k, n(m) || Y_); + const D = Hn(k) || ".", P = c.get(D) || g(Hn(m) || ".", D, T); + return P.referenceCount++, { + close: () => { + P.referenceCount === 1 ? (P.close(), c.delete(D)) : P.referenceCount--, s.remove(k, h); + } + }; + } + function g(m, h, S) { + const T = e( + m, + 1, + (k, D) => { + if (!gs(D)) return; + const P = Qi(D, m), A = _(P), O = P && s.get(A); + if (O) { + let F, R = 1; + if (o) { + const B = o.get(A); + if (k === "change" && (F = n(P) || Y_, F.getTime() === B.getTime())) + return; + F || (F = n(P) || Y_), o.set(A, F), B === Y_ ? R = 0 : F === Y_ && (R = 2); + } + for (const B of O) + B(P, R, F); + } + }, + /*recursive*/ + !1, + 500, + S + ); + return T.referenceCount = 0, c.set(h, T), T; + } + } + function wFe(e) { + const t = []; + let n = 0, i; + return s; + function s(_, u) { + const g = { + fileName: _, + callback: u, + mtime: KT(e, _) + }; + return t.push(g), c(), { + close: () => { + g.isClosed = !0, YT(t, g); + } + }; + } + function o() { + i = void 0, n = Fge(e, t, n, mj[ + 250 + /* Low */ + ]), c(); + } + function c() { + !t.length || i || (i = e.setTimeout(o, 2e3, "pollQueue")); + } + } + function Oge(e, t, n, i, s) { + const c = Zl(t)(n), _ = e.get(c); + return _ ? _.callbacks.push(i) : e.set(c, { + watcher: s( + // Cant infer types correctly so lets satisfy checker + (u, g, m) => { + var h; + return (h = e.get(c)) == null ? void 0 : h.callbacks.slice().forEach((S) => S(u, g, m)); + } + ), + callbacks: [i] + }), { + close: () => { + const u = e.get(c); + u && (!rD(u.callbacks, i) || u.callbacks.length || (e.delete(c), gp(u))); + } + }; + } + function PFe(e, t) { + const n = e.mtime.getTime(), i = t.getTime(); + return n !== i ? (e.mtime = t, e.callback(e.fileName, gj(n, i), t), !0) : !1; + } + function gj(e, t) { + return e === 0 ? 0 : t === 0 ? 2 : 1; + } + var a7 = ["/node_modules/.", "/.git", "/.#"], Lge = Ha; + function qP(e) { + return Lge(e); + } + function AY(e) { + Lge = e; + } + function NFe({ + watchDirectory: e, + useCaseSensitiveFileNames: t, + getCurrentDirectory: n, + getAccessibleSortedChildDirectories: i, + fileSystemEntryExists: s, + realpath: o, + setTimeout: c, + clearTimeout: _ + }) { + const u = /* @__PURE__ */ new Map(), g = Fp(), m = /* @__PURE__ */ new Map(); + let h; + const S = vC(!t), T = Zl(t); + return (W, _e, K, V) => K ? k(W, V, _e) : e(W, _e, K, V); + function k(W, _e, K, V) { + const ae = T(W); + let se = u.get(ae); + se ? se.refCount++ : (se = { + watcher: e( + W, + (fe) => { + var he; + U(fe, _e) || (_e?.synchronousWatchDirectory ? ((he = u.get(ae)) != null && he.targetWatcher || D(W, ae, fe), B(W, ae, _e)) : P(W, ae, fe, _e)); + }, + /*recursive*/ + !1, + _e + ), + refCount: 1, + childWatches: Ge, + targetWatcher: void 0, + links: void 0 + }, u.set(ae, se), B(W, ae, _e)), V && (se.links ?? (se.links = /* @__PURE__ */ new Set())).add(V); + const ce = K && { dirName: W, callback: K }; + return ce && g.add(ae, ce), { + dirName: W, + close: () => { + var fe; + const he = E.checkDefined(u.get(ae)); + ce && g.remove(ae, ce), V && ((fe = he.links) == null || fe.delete(V)), he.refCount--, !he.refCount && (u.delete(ae), he.links = void 0, gp(he), R(he), he.childWatches.forEach(od)); + } + }; + } + function D(W, _e, K, V) { + var ae, se; + let ce, fe; + gs(K) ? ce = K : fe = K, g.forEach((he, q) => { + if (!(fe && fe.get(q) === !0) && (q === _e || Ui(_e, q) && _e[q.length] === So)) + if (fe) + if (V) { + const be = fe.get(q); + be ? be.push(...V) : fe.set(q, V.slice()); + } else + fe.set(q, !0); + else + he.forEach(({ callback: be }) => be(ce)); + }), (se = (ae = u.get(_e)) == null ? void 0 : ae.links) == null || se.forEach((he) => { + const q = (be) => On(he, Nf(W, be, T)); + fe ? D(he, T(he), fe, V?.map(q)) : D(he, T(he), q(ce)); + }); + } + function P(W, _e, K, V) { + const ae = u.get(_e); + if (ae && s( + W, + 1 + /* Directory */ + )) { + A(W, _e, K, V); + return; + } + D(W, _e, K), R(ae), F(ae); + } + function A(W, _e, K, V) { + const ae = m.get(_e); + ae ? ae.fileNames.push(K) : m.set(_e, { dirName: W, options: V, fileNames: [K] }), h && (_(h), h = void 0), h = c(O, 1e3, "timerToUpdateChildWatches"); + } + function O() { + var W; + h = void 0, qP(`sysLog:: onTimerToUpdateChildWatches:: ${m.size}`); + const _e = ao(), K = /* @__PURE__ */ new Map(); + for (; !h && m.size; ) { + const ae = m.entries().next(); + E.assert(!ae.done); + const { value: [se, { dirName: ce, options: fe, fileNames: he }] } = ae; + m.delete(se); + const q = B(ce, se, fe); + (W = u.get(se)) != null && W.targetWatcher || D(ce, se, K, q ? void 0 : he); + } + qP(`sysLog:: invokingWatchers:: Elapsed:: ${ao() - _e}ms:: ${m.size}`), g.forEach((ae, se) => { + const ce = K.get(se); + ce && ae.forEach(({ callback: fe, dirName: he }) => { + as(ce) ? ce.forEach(fe) : fe(he); + }); + }); + const V = ao() - _e; + qP(`sysLog:: Elapsed:: ${V}ms:: onTimerToUpdateChildWatches:: ${m.size} ${h}`); + } + function F(W) { + if (!W) return; + const _e = W.childWatches; + W.childWatches = Ge; + for (const K of _e) + K.close(), F(u.get(T(K.dirName))); + } + function R(W) { + W?.targetWatcher && (W.targetWatcher.close(), W.targetWatcher = void 0); + } + function B(W, _e, K) { + const V = u.get(_e); + if (!V) return !1; + const ae = Hs(o(W)); + let se, ce; + return S(ae, W) === 0 ? se = e7( + s( + W, + 1 + /* Directory */ + ) ? Fi(i(W), (q) => { + const be = Qi(q, W); + return !U(be, K) && S(be, Hs(o(be))) === 0 ? be : void 0; + }) : Ge, + V.childWatches, + (q, be) => S(q, be.dirName), + fe, + od, + he + ) : V.targetWatcher && S(ae, V.targetWatcher.dirName) === 0 ? (se = !1, E.assert(V.childWatches === Ge)) : (R(V), V.targetWatcher = k( + ae, + K, + /*callback*/ + void 0, + W + ), V.childWatches.forEach(od), se = !0), V.childWatches = ce || Ge, se; + function fe(q) { + const be = k(q, K); + he(be); + } + function he(q) { + (ce || (ce = [])).push(q); + } + } + function U(W, _e) { + return ot(a7, (K) => $(W, K)) || Mge(W, _e, t, n); + } + function $(W, _e) { + return W.includes(_e) ? !0 : t ? !1 : T(W).includes(_e); + } + } + var IY = /* @__PURE__ */ ((e) => (e[e.File = 0] = "File", e[e.Directory = 1] = "Directory", e))(IY || {}); + function AFe(e) { + return (t, n, i) => e(n === 1 ? "change" : "rename", "", i); + } + function IFe(e, t, n) { + return (i, s, o) => { + i === "rename" ? (o || (o = n(e) || Y_), t(e, o !== Y_ ? 0 : 2, o)) : t(e, 1, o); + }; + } + function Mge(e, t, n, i) { + return (t?.excludeDirectories || t?.excludeFiles) && (sO(e, t?.excludeFiles, n, i()) || sO(e, t?.excludeDirectories, n, i())); + } + function Rge(e, t, n, i, s) { + return (o, c) => { + if (o === "rename") { + const _ = c ? Hs(On(e, c)) : e; + (!c || !Mge(_, n, i, s)) && t(_); + } + }; + } + function FY({ + pollingWatchFileWorker: e, + getModifiedTime: t, + setTimeout: n, + clearTimeout: i, + fsWatchWorker: s, + fileSystemEntryExists: o, + useCaseSensitiveFileNames: c, + getCurrentDirectory: _, + fsSupportsRecursiveFsWatch: u, + getAccessibleSortedChildDirectories: g, + realpath: m, + tscWatchFile: h, + useNonPollingWatchers: S, + tscWatchDirectory: T, + inodeWatching: k, + fsWatchWithTimestamp: D, + sysLog: P + }) { + const A = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Map(), F = /* @__PURE__ */ new Map(); + let R, B, U, $, W = !1; + return { + watchFile: _e, + watchDirectory: ce + }; + function _e(Z, pe, Te, Fe) { + Fe = ae(Fe, S); + const Ye = E.checkDefined(Fe.watchFile); + switch (Ye) { + case 0: + return q( + Z, + pe, + 250, + /*options*/ + void 0 + ); + case 1: + return q( + Z, + pe, + Te, + /*options*/ + void 0 + ); + case 2: + return K()( + Z, + pe, + Te, + /*options*/ + void 0 + ); + case 3: + return V()( + Z, + pe, + /* pollingInterval */ + void 0, + /*options*/ + void 0 + ); + case 4: + return be( + Z, + 0, + IFe(Z, pe, t), + /*recursive*/ + !1, + Te, + CA(Fe) + ); + case 5: + return U || (U = DFe(be, c, t, D)), U(Z, pe, Te, CA(Fe)); + default: + E.assertNever(Ye); + } + } + function K() { + return R || (R = EFe({ getModifiedTime: t, setTimeout: n })); + } + function V() { + return B || (B = wFe({ getModifiedTime: t, setTimeout: n })); + } + function ae(Z, pe) { + if (Z && Z.watchFile !== void 0) return Z; + switch (h) { + case "PriorityPollingInterval": + return { + watchFile: 1 + /* PriorityPollingInterval */ + }; + case "DynamicPriorityPolling": + return { + watchFile: 2 + /* DynamicPriorityPolling */ + }; + case "UseFsEvents": + return se(4, 1, Z); + case "UseFsEventsWithFallbackDynamicPolling": + return se(4, 2, Z); + case "UseFsEventsOnParentDirectory": + pe = !0; + // fall through + default: + return pe ? ( + // Use notifications from FS to watch with falling back to fs.watchFile + se(5, 1, Z) + ) : ( + // Default to using fs events + { + watchFile: 4 + /* UseFsEvents */ + } + ); + } + } + function se(Z, pe, Te) { + const Fe = Te?.fallbackPolling; + return { + watchFile: Z, + fallbackPolling: Fe === void 0 ? pe : Fe + }; + } + function ce(Z, pe, Te, Fe) { + return u ? be( + Z, + 1, + Rge(Z, pe, Fe, c, _), + Te, + 500, + CA(Fe) + ) : ($ || ($ = NFe({ + useCaseSensitiveFileNames: c, + getCurrentDirectory: _, + fileSystemEntryExists: o, + getAccessibleSortedChildDirectories: g, + watchDirectory: fe, + realpath: m, + setTimeout: n, + clearTimeout: i + })), $(Z, pe, Te, Fe)); + } + function fe(Z, pe, Te, Fe) { + E.assert(!Te); + const Ye = he(Fe), ne = E.checkDefined(Ye.watchDirectory); + switch (ne) { + case 1: + return q( + Z, + () => pe(Z), + 500, + /*options*/ + void 0 + ); + case 2: + return K()( + Z, + () => pe(Z), + 500, + /*options*/ + void 0 + ); + case 3: + return V()( + Z, + () => pe(Z), + /* pollingInterval */ + void 0, + /*options*/ + void 0 + ); + case 0: + return be( + Z, + 1, + Rge(Z, pe, Fe, c, _), + Te, + 500, + CA(Ye) + ); + default: + E.assertNever(ne); + } + } + function he(Z) { + if (Z && Z.watchDirectory !== void 0) return Z; + switch (T) { + case "RecursiveDirectoryUsingFsWatchFile": + return { + watchDirectory: 1 + /* FixedPollingInterval */ + }; + case "RecursiveDirectoryUsingDynamicPriorityPolling": + return { + watchDirectory: 2 + /* DynamicPriorityPolling */ + }; + default: + const pe = Z?.fallbackPolling; + return { + watchDirectory: 0, + fallbackPolling: pe !== void 0 ? pe : void 0 + }; + } + } + function q(Z, pe, Te, Fe) { + return Oge( + A, + c, + Z, + pe, + (Ye) => e(Z, Ye, Te, Fe) + ); + } + function be(Z, pe, Te, Fe, Ye, ne) { + return Oge( + Fe ? F : O, + c, + Z, + Te, + (Se) => je(Z, pe, Se, Fe, Ye, ne) + ); + } + function je(Z, pe, Te, Fe, Ye, ne) { + let Se, ie; + k && (Se = Z.substring(Z.lastIndexOf(So)), ie = Se.slice(So.length)); + let Ne = o(Z, pe) ? Ce() : Bt(); + return { + close: () => { + Ne && (Ne.close(), Ne = void 0); + } + }; + function Ee(tr) { + Ne && (P(`sysLog:: ${Z}:: Changing watcher to ${tr === Ce ? "Present" : "Missing"}FileSystemEntryWatcher`), Ne.close(), Ne = tr()); + } + function Ce() { + if (W) + return P(`sysLog:: ${Z}:: Defaulting to watchFile`), St(); + try { + const tr = (pe === 1 || !D ? s : me)( + Z, + Fe, + k ? Ve : Te + ); + return tr.on("error", () => { + Te("rename", ""), Ee(Bt); + }), tr; + } catch (tr) { + return W || (W = tr.code === "ENOSPC"), P(`sysLog:: ${Z}:: Changing to watchFile`), St(); + } + } + function Ve(tr, Nr) { + let st; + if (Nr && wo(Nr, "~") && (st = Nr, Nr = Nr.slice(0, Nr.length - 1)), tr === "rename" && (!Nr || Nr === ie || wo(Nr, Se))) { + const Wt = t(Z) || Y_; + st && Te(tr, st, Wt), Te(tr, Nr, Wt), k ? Ee(Wt === Y_ ? Bt : Ce) : Wt === Y_ && Ee(Bt); + } else + st && Te(tr, st), Te(tr, Nr); + } + function St() { + return _e( + Z, + AFe(Te), + Ye, + ne + ); + } + function Bt() { + return _e( + Z, + (tr, Nr, st) => { + Nr === 0 && (st || (st = t(Z) || Y_), st !== Y_ && (Te("rename", "", st), Ee(Ce))); + }, + Ye, + ne + ); + } + } + function me(Z, pe, Te) { + let Fe = t(Z) || Y_; + return s(Z, pe, (Ye, ne, Se) => { + Ye === "change" && (Se || (Se = t(Z) || Y_), Se.getTime() === Fe.getTime()) || (Fe = Se || t(Z) || Y_, Te(Ye, ne, Fe)); + }); + } + } + function OY(e) { + const t = e.writeFile; + e.writeFile = (n, i, s) => KB( + n, + i, + !!s, + (o, c, _) => t.call(e, o, c, _), + (o) => e.createDirectory(o), + (o) => e.directoryExists(o) + ); + } + var ml = (() => { + const e = "\uFEFF"; + function t() { + const i = /^native |^\([^)]+\)$|^(?:internal[\\/]|[\w\s]+(?:\.js)?$)/, s = QE, o = QE, c = QE; + let _; + try { + _ = QE; + } catch { + _ = void 0; + } + let u, g = "./profile.cpuprofile"; + const m = process.platform === "darwin", h = process.platform === "linux" || m, S = { throwIfNoEntry: !1 }, T = c.platform(), k = K(), D = s.realpathSync.native ? process.platform === "win32" ? pe : s.realpathSync.native : s.realpathSync, P = __filename.endsWith("sys.js") ? o.join(o.dirname(__dirname), "__fake__.js") : __filename, A = process.platform === "win32" || m, O = Uu(() => process.cwd()), { watchFile: F, watchDirectory: R } = FY({ + pollingWatchFileWorker: ae, + getModifiedTime: Fe, + setTimeout, + clearTimeout, + fsWatchWorker: se, + useCaseSensitiveFileNames: k, + getCurrentDirectory: O, + fileSystemEntryExists: be, + // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows + // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643) + fsSupportsRecursiveFsWatch: A, + getAccessibleSortedChildDirectories: (ie) => he(ie).directories, + realpath: Te, + tscWatchFile: process.env.TSC_WATCHFILE, + useNonPollingWatchers: !!process.env.TSC_NONPOLLING_WATCHER, + tscWatchDirectory: process.env.TSC_WATCHDIRECTORY, + inodeWatching: h, + fsWatchWithTimestamp: m, + sysLog: qP + }), B = { + args: process.argv.slice(2), + newLine: c.EOL, + useCaseSensitiveFileNames: k, + write(ie) { + process.stdout.write(ie); + }, + getWidthOfTerminal() { + return process.stdout.columns; + }, + writeOutputIsTTY() { + return process.stdout.isTTY; + }, + readFile: ce, + writeFile: fe, + watchFile: F, + watchDirectory: R, + preferNonRecursiveWatch: !A, + resolvePath: (ie) => o.resolve(ie), + fileExists: je, + directoryExists: me, + getAccessibleFileSystemEntries: he, + createDirectory(ie) { + if (!B.directoryExists(ie)) + try { + s.mkdirSync(ie); + } catch (Ne) { + if (Ne.code !== "EEXIST") + throw Ne; + } + }, + getExecutingFilePath() { + return P; + }, + getCurrentDirectory: O, + getDirectories: Z, + getEnvironmentVariable(ie) { + return process.env[ie] || ""; + }, + readDirectory: q, + getModifiedTime: Fe, + setModifiedTime: Ye, + deleteFile: ne, + createHash: _ ? Se : uD, + createSHA256Hash: _ ? Se : void 0, + getMemoryUsage() { + return I5e.gc && I5e.gc(), process.memoryUsage().heapUsed; + }, + getFileSize(ie) { + const Ne = U(ie); + return Ne?.isFile() ? Ne.size : 0; + }, + exit(ie) { + _e(() => process.exit(ie)); + }, + enableCPUProfiler: $, + disableCPUProfiler: _e, + cpuProfilingEnabled: () => !!u || ms(process.execArgv, "--cpu-prof") || ms(process.execArgv, "--prof"), + realpath: Te, + debugMode: !!process.env.NODE_INSPECTOR_IPC || !!process.env.VSCODE_INSPECTOR_OPTIONS || ot(process.execArgv, (ie) => /^--(?:inspect|debug)(?:-brk)?(?:=\d+)?$/i.test(ie)) || !!process.recordreplay, + tryEnableSourceMapsForHost() { + try { + QE.install(); + } catch { + } + }, + setTimeout, + clearTimeout, + clearScreen: () => { + process.stdout.write("\x1B[2J\x1B[3J\x1B[H"); + }, + setBlocking: () => { + var ie; + const Ne = (ie = process.stdout) == null ? void 0 : ie._handle; + Ne && Ne.setBlocking && Ne.setBlocking(!0); + }, + base64decode: (ie) => Buffer.from(ie, "base64").toString("utf8"), + base64encode: (ie) => Buffer.from(ie).toString("base64"), + require: (ie, Ne) => { + try { + const Ee = ine(Ne, ie, B); + return { module: R5e(Ee), modulePath: Ee, error: void 0 }; + } catch (Ee) { + return { module: void 0, modulePath: void 0, error: Ee }; + } + } + }; + return B; + function U(ie) { + try { + return s.statSync(ie, S); + } catch { + return; + } + } + function $(ie, Ne) { + if (u) + return Ne(), !1; + const Ee = QE; + if (!Ee || !Ee.Session) + return Ne(), !1; + const Ce = new Ee.Session(); + return Ce.connect(), Ce.post("Profiler.enable", () => { + Ce.post("Profiler.start", () => { + u = Ce, g = ie, Ne(); + }); + }), !0; + } + function W(ie) { + let Ne = 0; + const Ee = /* @__PURE__ */ new Map(), Ce = zl(o.dirname(P)), Ve = `file://${kd(Ce) === 1 ? "" : "/"}${Ce}`; + for (const St of ie.nodes) + if (St.callFrame.url) { + const Bt = zl(St.callFrame.url); + np(Ve, Bt, k) ? St.callFrame.url = rx( + Ve, + Bt, + Ve, + Zl(k), + /*isAbsolutePathAnUrl*/ + !0 + ) : i.test(Bt) || (St.callFrame.url = (Ee.has(Bt) ? Ee : Ee.set(Bt, `external${Ne}.js`)).get(Bt), Ne++); + } + return ie; + } + function _e(ie) { + if (u && u !== "stopping") { + const Ne = u; + return u.post("Profiler.stop", (Ee, { profile: Ce }) => { + var Ve; + if (!Ee) { + (Ve = U(g)) != null && Ve.isDirectory() && (g = o.join(g, `${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}+P${process.pid}.cpuprofile`)); + try { + s.mkdirSync(o.dirname(g), { recursive: !0 }); + } catch { + } + s.writeFileSync(g, JSON.stringify(W(Ce))); + } + u = void 0, Ne.disconnect(), ie(); + }), u = "stopping", !0; + } else + return ie(), !1; + } + function K() { + return T === "win32" || T === "win64" ? !1 : !je(V(__filename)); + } + function V(ie) { + return ie.replace(/\w/g, (Ne) => { + const Ee = Ne.toUpperCase(); + return Ne === Ee ? Ne.toLowerCase() : Ee; + }); + } + function ae(ie, Ne, Ee) { + s.watchFile(ie, { persistent: !0, interval: Ee }, Ve); + let Ce; + return { + close: () => s.unwatchFile(ie, Ve) + }; + function Ve(St, Bt) { + const tr = +Bt.mtime == 0 || Ce === 2; + if (+St.mtime == 0) { + if (tr) + return; + Ce = 2; + } else if (tr) + Ce = 0; + else { + if (+St.mtime == +Bt.mtime) + return; + Ce = 1; + } + Ne(ie, Ce, St.mtime); + } + } + function se(ie, Ne, Ee) { + return s.watch( + ie, + A ? { persistent: !0, recursive: !!Ne } : { persistent: !0 }, + Ee + ); + } + function ce(ie, Ne) { + let Ee; + try { + Ee = s.readFileSync(ie); + } catch { + return; + } + let Ce = Ee.length; + if (Ce >= 2 && Ee[0] === 254 && Ee[1] === 255) { + Ce &= -2; + for (let Ve = 0; Ve < Ce; Ve += 2) { + const St = Ee[Ve]; + Ee[Ve] = Ee[Ve + 1], Ee[Ve + 1] = St; + } + return Ee.toString("utf16le", 2); + } + return Ce >= 2 && Ee[0] === 255 && Ee[1] === 254 ? Ee.toString("utf16le", 2) : Ce >= 3 && Ee[0] === 239 && Ee[1] === 187 && Ee[2] === 191 ? Ee.toString("utf8", 3) : Ee.toString("utf8"); + } + function fe(ie, Ne, Ee) { + Ee && (Ne = e + Ne); + let Ce; + try { + Ce = s.openSync(ie, "w"), s.writeSync( + Ce, + Ne, + /*position*/ + void 0, + "utf8" + ); + } finally { + Ce !== void 0 && s.closeSync(Ce); + } + } + function he(ie) { + try { + const Ne = s.readdirSync(ie || ".", { withFileTypes: !0 }), Ee = [], Ce = []; + for (const Ve of Ne) { + const St = typeof Ve == "string" ? Ve : Ve.name; + if (St === "." || St === "..") + continue; + let Bt; + if (typeof Ve == "string" || Ve.isSymbolicLink()) { + const tr = On(ie, St); + if (Bt = U(tr), !Bt) + continue; + } else + Bt = Ve; + Bt.isFile() ? Ee.push(St) : Bt.isDirectory() && Ce.push(St); + } + return Ee.sort(), Ce.sort(), { files: Ee, directories: Ce }; + } catch { + return OJ; + } + } + function q(ie, Ne, Ee, Ce, Ve) { + return NJ(ie, Ne, Ee, Ce, k, process.cwd(), Ve, he, Te); + } + function be(ie, Ne) { + const Ee = U(ie); + if (!Ee) + return !1; + switch (Ne) { + case 0: + return Ee.isFile(); + case 1: + return Ee.isDirectory(); + default: + return !1; + } + } + function je(ie) { + return be( + ie, + 0 + /* File */ + ); + } + function me(ie) { + return be( + ie, + 1 + /* Directory */ + ); + } + function Z(ie) { + return he(ie).directories.slice(); + } + function pe(ie) { + return ie.length < 260 ? s.realpathSync.native(ie) : s.realpathSync(ie); + } + function Te(ie) { + try { + return D(ie); + } catch { + return ie; + } + } + function Fe(ie) { + var Ne; + return (Ne = U(ie)) == null ? void 0 : Ne.mtime; + } + function Ye(ie, Ne) { + try { + s.utimesSync(ie, Ne, Ne); + } catch { + return; + } + } + function ne(ie) { + try { + return s.unlinkSync(ie); + } catch { + return; + } + } + function Se(ie) { + const Ne = _.createHash("sha256"); + return Ne.update(ie), Ne.digest("hex"); + } + } + let n; + return GR() && (n = t()), n && OY(n), n; + })(); + function jge(e) { + ml = e; + } + ml && ml.getEnvironmentVariable && (CFe(ml), E.setAssertionLevel( + /^development$/i.test(ml.getEnvironmentVariable("NODE_ENV")) ? 1 : 0 + /* None */ + )), ml && ml.debugMode && (E.isDebugging = !0); + var So = "/", o7 = "\\", Bge = "://", FFe = /\\/g; + function hj(e) { + return e === 47 || e === 92; + } + function LY(e) { + return c7(e) < 0; + } + function Z_(e) { + return c7(e) > 0; + } + function yj(e) { + const t = c7(e); + return t > 0 && t === e.length; + } + function _D(e) { + return c7(e) !== 0; + } + function xf(e) { + return /^\.\.?(?:$|[\\/])/.test(e); + } + function vj(e) { + return !_D(e) && !xf(e); + } + function xC(e) { + return Zc(e).includes("."); + } + function Xo(e, t) { + return e.length > t.length && wo(e, t); + } + function xc(e, t) { + for (const n of t) + if (Xo(e, n)) + return !0; + return !1; + } + function vy(e) { + return e.length > 0 && hj(e.charCodeAt(e.length - 1)); + } + function Jge(e) { + return e >= 97 && e <= 122 || e >= 65 && e <= 90; + } + function OFe(e, t) { + const n = e.charCodeAt(t); + if (n === 58) return t + 1; + if (n === 37 && e.charCodeAt(t + 1) === 51) { + const i = e.charCodeAt(t + 2); + if (i === 97 || i === 65) return t + 3; + } + return -1; + } + function c7(e) { + if (!e) return 0; + const t = e.charCodeAt(0); + if (t === 47 || t === 92) { + if (e.charCodeAt(1) !== t) return 1; + const i = e.indexOf(t === 47 ? So : o7, 2); + return i < 0 ? e.length : i + 1; + } + if (Jge(t) && e.charCodeAt(1) === 58) { + const i = e.charCodeAt(2); + if (i === 47 || i === 92) return 3; + if (e.length === 2) return 2; + } + const n = e.indexOf(Bge); + if (n !== -1) { + const i = n + Bge.length, s = e.indexOf(So, i); + if (s !== -1) { + const o = e.slice(0, n), c = e.slice(i, s); + if (o === "file" && (c === "" || c === "localhost") && Jge(e.charCodeAt(s + 1))) { + const _ = OFe(e, s + 2); + if (_ !== -1) { + if (e.charCodeAt(_) === 47) + return ~(_ + 1); + if (_ === e.length) + return ~_; + } + } + return ~(s + 1); + } + return ~e.length; + } + return 0; + } + function kd(e) { + const t = c7(e); + return t < 0 ? ~t : t; + } + function Hn(e) { + e = zl(e); + const t = kd(e); + return t === e.length ? e : (e = _0(e), e.slice(0, Math.max(t, e.lastIndexOf(So)))); + } + function Zc(e, t, n) { + if (e = zl(e), kd(e) === e.length) return ""; + e = _0(e); + const s = e.slice(Math.max(kd(e), e.lastIndexOf(So) + 1)), o = t !== void 0 && n !== void 0 ? ex(s, t, n) : void 0; + return o ? s.slice(0, s.length - o.length) : s; + } + function zge(e, t, n) { + if (Ui(t, ".") || (t = "." + t), e.length >= t.length && e.charCodeAt(e.length - t.length) === 46) { + const i = e.slice(e.length - t.length); + if (n(i, t)) + return i; + } + } + function LFe(e, t, n) { + if (typeof t == "string") + return zge(e, t, n) || ""; + for (const i of t) { + const s = zge(e, i, n); + if (s) return s; + } + return ""; + } + function ex(e, t, n) { + if (t) + return LFe(_0(e), t, n ? hy : bb); + const i = Zc(e), s = i.lastIndexOf("."); + return s >= 0 ? i.substring(s) : ""; + } + function MFe(e, t) { + const n = e.substring(0, t), i = e.substring(t).split(So); + return i.length && !Do(i) && i.pop(), [n, ...i]; + } + function fu(e, t = "") { + return e = On(t, e), MFe(e, kd(e)); + } + function B1(e, t) { + return e.length === 0 ? "" : (e[0] && gl(e[0])) + e.slice(1, t).join(So); + } + function zl(e) { + return e.includes("\\") ? e.replace(FFe, So) : e; + } + function tx(e) { + if (!ot(e)) return []; + const t = [e[0]]; + for (let n = 1; n < e.length; n++) { + const i = e[n]; + if (i && i !== ".") { + if (i === "..") { + if (t.length > 1) { + if (t[t.length - 1] !== "..") { + t.pop(); + continue; + } + } else if (t[0]) continue; + } + t.push(i); + } + } + return t; + } + function On(e, ...t) { + e && (e = zl(e)); + for (let n of t) + n && (n = zl(n), !e || kd(n) !== 0 ? e = n : e = gl(e) + n); + return e; + } + function by(e, ...t) { + return Hs(ot(t) ? On(e, ...t) : zl(e)); + } + function l7(e, t) { + return tx(fu(e, t)); + } + function Qi(e, t) { + let n = kd(e); + n === 0 && t ? (e = On(t, e), n = kd(e)) : e = zl(e); + const i = Wge(e); + if (i !== void 0) + return i.length > n ? _0(i) : i; + const s = e.length, o = e.substring(0, n); + let c, _ = n, u = _, g = _, m = n !== 0; + for (; _ < s; ) { + u = _; + let h = e.charCodeAt(_); + for (; h === 47 && _ + 1 < s; ) + _++, h = e.charCodeAt(_); + _ > u && (c ?? (c = e.substring(0, u - 1)), u = _); + let S = e.indexOf(So, _ + 1); + S === -1 && (S = s); + const T = S - u; + if (T === 1 && e.charCodeAt(_) === 46) + c ?? (c = e.substring(0, g)); + else if (T === 2 && e.charCodeAt(_) === 46 && e.charCodeAt(_ + 1) === 46) + if (!m) + c !== void 0 ? c += c.length === n ? ".." : "/.." : g = _ + 2; + else if (c === void 0) + g - 2 >= 0 ? c = e.substring(0, Math.max(n, e.lastIndexOf(So, g - 2))) : c = e.substring(0, g); + else { + const k = c.lastIndexOf(So); + k !== -1 ? c = c.substring(0, Math.max(n, k)) : c = o, c.length === n && (m = n !== 0); + } + else c !== void 0 ? (c.length !== n && (c += So), m = !0, c += e.substring(u, S)) : (m = !0, g = S); + _ = S + 1; + } + return c ?? (s > n ? _0(e) : e); + } + function Hs(e) { + e = zl(e); + let t = Wge(e); + return t !== void 0 ? t : (t = Qi(e, ""), t && vy(e) ? gl(t) : t); + } + function Wge(e) { + if (!Sj.test(e)) + return e; + let t = e.replace(/\/\.\//g, "/"); + if (t.startsWith("./") && (t = t.slice(2)), t !== e && (e = t, !Sj.test(e))) + return e; + } + function RFe(e) { + return e.length === 0 ? "" : e.slice(1).join(So); + } + function bj(e, t) { + return RFe(l7(e, t)); + } + function oo(e, t, n) { + const i = Z_(e) ? Hs(e) : Qi(e, t); + return n(i); + } + function _0(e) { + return vy(e) ? e.substr(0, e.length - 1) : e; + } + function gl(e) { + return vy(e) ? e : e + So; + } + function X2(e) { + return !_D(e) && !xf(e) ? "./" + e : e; + } + function HP(e, t, n, i) { + const s = n !== void 0 && i !== void 0 ? ex(e, n, i) : ex(e); + return s ? e.slice(0, e.length - s.length) + (Ui(t, ".") ? t : "." + t) : e; + } + function u7(e, t) { + const n = qF(e); + return n ? e.slice(0, e.length - n.length) + (Ui(t, ".") ? t : "." + t) : HP(e, t); + } + var Sj = /\/\/|(?:^|\/)\.\.?(?:$|\/)/; + function MY(e, t, n) { + if (e === t) return 0; + if (e === void 0) return -1; + if (t === void 0) return 1; + const i = e.substring(0, kd(e)), s = t.substring(0, kd(t)), o = zP(i, s); + if (o !== 0) + return o; + const c = e.substring(i.length), _ = t.substring(s.length); + if (!Sj.test(c) && !Sj.test(_)) + return n(c, _); + const u = tx(fu(e)), g = tx(fu(t)), m = Math.min(u.length, g.length); + for (let h = 1; h < m; h++) { + const S = n(u[h], g[h]); + if (S !== 0) + return S; + } + return ho(u.length, g.length); + } + function Uge(e, t) { + return MY(e, t, _u); + } + function Vge(e, t) { + return MY(e, t, zP); + } + function gh(e, t, n, i) { + return typeof n == "string" ? (e = On(n, e), t = On(n, t)) : typeof n == "boolean" && (i = n), MY(e, t, vC(i)); + } + function np(e, t, n, i) { + if (typeof n == "string" ? (e = On(n, e), t = On(n, t)) : typeof n == "boolean" && (i = n), e === void 0 || t === void 0) return !1; + if (e === t) return !0; + const s = tx(fu(e)), o = tx(fu(t)); + if (o.length < s.length) + return !1; + const c = i ? hy : bb; + for (let _ = 0; _ < s.length; _++) + if (!(_ === 0 ? hy : c)(s[_], o[_])) + return !1; + return !0; + } + function Tj(e, t, n) { + const i = n(e), s = n(t); + return Ui(i, s + "/") || Ui(i, s + "\\"); + } + function qge(e, t, n, i) { + const s = tx(fu(e)), o = tx(fu(t)); + let c; + for (c = 0; c < s.length && c < o.length; c++) { + const g = i(s[c]), m = i(o[c]); + if (!(c === 0 ? hy : n)(g, m)) break; + } + if (c === 0) + return o; + const _ = o.slice(c), u = []; + for (; c < s.length; c++) + u.push(".."); + return ["", ...u, ..._]; + } + function Nf(e, t, n) { + E.assert(kd(e) > 0 == kd(t) > 0, "Paths must either both be absolute or both be relative"); + const o = qge(e, t, (typeof n == "boolean" ? n : !1) ? hy : bb, typeof n == "function" ? n : go); + return B1(o); + } + function fD(e, t, n) { + return Z_(e) ? rx( + t, + e, + t, + n, + /*isAbsolutePathAnUrl*/ + !1 + ) : e; + } + function kC(e, t, n) { + return X2(Nf(Hn(e), t, n)); + } + function rx(e, t, n, i, s) { + const o = qge( + by(n, e), + by(n, t), + bb, + i + ), c = o[0]; + if (s && Z_(c)) { + const _ = c.charAt(0) === So ? "file://" : "file:///"; + o[0] = _ + c; + } + return B1(o); + } + function pD(e, t) { + for (; ; ) { + const n = t(e); + if (n !== void 0) + return n; + const i = Hn(e); + if (i === e) + return; + e = i; + } + } + function _7(e) { + return wo(e, "/node_modules"); + } + function b(e, t, n, i, s, o, c) { + return { code: e, category: t, key: n, message: i, reportsUnnecessary: s, elidedInCompatabilityPyramid: o, reportsDeprecated: c }; + } + var p = { + Unterminated_string_literal: b(1002, 1, "Unterminated_string_literal_1002", "Unterminated string literal."), + Identifier_expected: b(1003, 1, "Identifier_expected_1003", "Identifier expected."), + _0_expected: b(1005, 1, "_0_expected_1005", "'{0}' expected."), + A_file_cannot_have_a_reference_to_itself: b(1006, 1, "A_file_cannot_have_a_reference_to_itself_1006", "A file cannot have a reference to itself."), + The_parser_expected_to_find_a_1_to_match_the_0_token_here: b(1007, 1, "The_parser_expected_to_find_a_1_to_match_the_0_token_here_1007", "The parser expected to find a '{1}' to match the '{0}' token here."), + Trailing_comma_not_allowed: b(1009, 1, "Trailing_comma_not_allowed_1009", "Trailing comma not allowed."), + Asterisk_Slash_expected: b(1010, 1, "Asterisk_Slash_expected_1010", "'*/' expected."), + An_element_access_expression_should_take_an_argument: b(1011, 1, "An_element_access_expression_should_take_an_argument_1011", "An element access expression should take an argument."), + Unexpected_token: b(1012, 1, "Unexpected_token_1012", "Unexpected token."), + A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma: b(1013, 1, "A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma_1013", "A rest parameter or binding pattern may not have a trailing comma."), + A_rest_parameter_must_be_last_in_a_parameter_list: b(1014, 1, "A_rest_parameter_must_be_last_in_a_parameter_list_1014", "A rest parameter must be last in a parameter list."), + Parameter_cannot_have_question_mark_and_initializer: b(1015, 1, "Parameter_cannot_have_question_mark_and_initializer_1015", "Parameter cannot have question mark and initializer."), + A_required_parameter_cannot_follow_an_optional_parameter: b(1016, 1, "A_required_parameter_cannot_follow_an_optional_parameter_1016", "A required parameter cannot follow an optional parameter."), + An_index_signature_cannot_have_a_rest_parameter: b(1017, 1, "An_index_signature_cannot_have_a_rest_parameter_1017", "An index signature cannot have a rest parameter."), + An_index_signature_parameter_cannot_have_an_accessibility_modifier: b(1018, 1, "An_index_signature_parameter_cannot_have_an_accessibility_modifier_1018", "An index signature parameter cannot have an accessibility modifier."), + An_index_signature_parameter_cannot_have_a_question_mark: b(1019, 1, "An_index_signature_parameter_cannot_have_a_question_mark_1019", "An index signature parameter cannot have a question mark."), + An_index_signature_parameter_cannot_have_an_initializer: b(1020, 1, "An_index_signature_parameter_cannot_have_an_initializer_1020", "An index signature parameter cannot have an initializer."), + An_index_signature_must_have_a_type_annotation: b(1021, 1, "An_index_signature_must_have_a_type_annotation_1021", "An index signature must have a type annotation."), + An_index_signature_parameter_must_have_a_type_annotation: b(1022, 1, "An_index_signature_parameter_must_have_a_type_annotation_1022", "An index signature parameter must have a type annotation."), + readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature: b(1024, 1, "readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature_1024", "'readonly' modifier can only appear on a property declaration or index signature."), + An_index_signature_cannot_have_a_trailing_comma: b(1025, 1, "An_index_signature_cannot_have_a_trailing_comma_1025", "An index signature cannot have a trailing comma."), + Accessibility_modifier_already_seen: b(1028, 1, "Accessibility_modifier_already_seen_1028", "Accessibility modifier already seen."), + _0_modifier_must_precede_1_modifier: b(1029, 1, "_0_modifier_must_precede_1_modifier_1029", "'{0}' modifier must precede '{1}' modifier."), + _0_modifier_already_seen: b(1030, 1, "_0_modifier_already_seen_1030", "'{0}' modifier already seen."), + _0_modifier_cannot_appear_on_class_elements_of_this_kind: b(1031, 1, "_0_modifier_cannot_appear_on_class_elements_of_this_kind_1031", "'{0}' modifier cannot appear on class elements of this kind."), + super_must_be_followed_by_an_argument_list_or_member_access: b(1034, 1, "super_must_be_followed_by_an_argument_list_or_member_access_1034", "'super' must be followed by an argument list or member access."), + Only_ambient_modules_can_use_quoted_names: b(1035, 1, "Only_ambient_modules_can_use_quoted_names_1035", "Only ambient modules can use quoted names."), + Statements_are_not_allowed_in_ambient_contexts: b(1036, 1, "Statements_are_not_allowed_in_ambient_contexts_1036", "Statements are not allowed in ambient contexts."), + A_declare_modifier_cannot_be_used_in_an_already_ambient_context: b(1038, 1, "A_declare_modifier_cannot_be_used_in_an_already_ambient_context_1038", "A 'declare' modifier cannot be used in an already ambient context."), + Initializers_are_not_allowed_in_ambient_contexts: b(1039, 1, "Initializers_are_not_allowed_in_ambient_contexts_1039", "Initializers are not allowed in ambient contexts."), + _0_modifier_cannot_be_used_in_an_ambient_context: b(1040, 1, "_0_modifier_cannot_be_used_in_an_ambient_context_1040", "'{0}' modifier cannot be used in an ambient context."), + _0_modifier_cannot_be_used_here: b(1042, 1, "_0_modifier_cannot_be_used_here_1042", "'{0}' modifier cannot be used here."), + _0_modifier_cannot_appear_on_a_module_or_namespace_element: b(1044, 1, "_0_modifier_cannot_appear_on_a_module_or_namespace_element_1044", "'{0}' modifier cannot appear on a module or namespace element."), + Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier: b(1046, 1, "Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier_1046", "Top-level declarations in .d.ts files must start with either a 'declare' or 'export' modifier."), + A_rest_parameter_cannot_be_optional: b(1047, 1, "A_rest_parameter_cannot_be_optional_1047", "A rest parameter cannot be optional."), + A_rest_parameter_cannot_have_an_initializer: b(1048, 1, "A_rest_parameter_cannot_have_an_initializer_1048", "A rest parameter cannot have an initializer."), + A_set_accessor_must_have_exactly_one_parameter: b(1049, 1, "A_set_accessor_must_have_exactly_one_parameter_1049", "A 'set' accessor must have exactly one parameter."), + A_set_accessor_cannot_have_an_optional_parameter: b(1051, 1, "A_set_accessor_cannot_have_an_optional_parameter_1051", "A 'set' accessor cannot have an optional parameter."), + A_set_accessor_parameter_cannot_have_an_initializer: b(1052, 1, "A_set_accessor_parameter_cannot_have_an_initializer_1052", "A 'set' accessor parameter cannot have an initializer."), + A_set_accessor_cannot_have_rest_parameter: b(1053, 1, "A_set_accessor_cannot_have_rest_parameter_1053", "A 'set' accessor cannot have rest parameter."), + A_get_accessor_cannot_have_parameters: b(1054, 1, "A_get_accessor_cannot_have_parameters_1054", "A 'get' accessor cannot have parameters."), + Type_0_is_not_a_valid_async_function_return_type_in_ES5_because_it_does_not_refer_to_a_Promise_compatible_constructor_value: b(1055, 1, "Type_0_is_not_a_valid_async_function_return_type_in_ES5_because_it_does_not_refer_to_a_Promise_compa_1055", "Type '{0}' is not a valid async function return type in ES5 because it does not refer to a Promise-compatible constructor value."), + Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: b(1056, 1, "Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher_1056", "Accessors are only available when targeting ECMAScript 5 and higher."), + The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: b(1058, 1, "The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_t_1058", "The return type of an async function must either be a valid promise or must not contain a callable 'then' member."), + A_promise_must_have_a_then_method: b(1059, 1, "A_promise_must_have_a_then_method_1059", "A promise must have a 'then' method."), + The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback: b(1060, 1, "The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback_1060", "The first parameter of the 'then' method of a promise must be a callback."), + Enum_member_must_have_initializer: b(1061, 1, "Enum_member_must_have_initializer_1061", "Enum member must have initializer."), + Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: b(1062, 1, "Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062", "Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method."), + An_export_assignment_cannot_be_used_in_a_namespace: b(1063, 1, "An_export_assignment_cannot_be_used_in_a_namespace_1063", "An export assignment cannot be used in a namespace."), + The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0: b(1064, 1, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_wri_1064", "The return type of an async function or method must be the global Promise type. Did you mean to write 'Promise<{0}>'?"), + The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type: b(1065, 1, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_1065", "The return type of an async function or method must be the global Promise type."), + In_ambient_enum_declarations_member_initializer_must_be_constant_expression: b(1066, 1, "In_ambient_enum_declarations_member_initializer_must_be_constant_expression_1066", "In ambient enum declarations member initializer must be constant expression."), + Unexpected_token_A_constructor_method_accessor_or_property_was_expected: b(1068, 1, "Unexpected_token_A_constructor_method_accessor_or_property_was_expected_1068", "Unexpected token. A constructor, method, accessor, or property was expected."), + Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces: b(1069, 1, "Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces_1069", "Unexpected token. A type parameter name was expected without curly braces."), + _0_modifier_cannot_appear_on_a_type_member: b(1070, 1, "_0_modifier_cannot_appear_on_a_type_member_1070", "'{0}' modifier cannot appear on a type member."), + _0_modifier_cannot_appear_on_an_index_signature: b(1071, 1, "_0_modifier_cannot_appear_on_an_index_signature_1071", "'{0}' modifier cannot appear on an index signature."), + A_0_modifier_cannot_be_used_with_an_import_declaration: b(1079, 1, "A_0_modifier_cannot_be_used_with_an_import_declaration_1079", "A '{0}' modifier cannot be used with an import declaration."), + Invalid_reference_directive_syntax: b(1084, 1, "Invalid_reference_directive_syntax_1084", "Invalid 'reference' directive syntax."), + _0_modifier_cannot_appear_on_a_constructor_declaration: b(1089, 1, "_0_modifier_cannot_appear_on_a_constructor_declaration_1089", "'{0}' modifier cannot appear on a constructor declaration."), + _0_modifier_cannot_appear_on_a_parameter: b(1090, 1, "_0_modifier_cannot_appear_on_a_parameter_1090", "'{0}' modifier cannot appear on a parameter."), + Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: b(1091, 1, "Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement_1091", "Only a single variable declaration is allowed in a 'for...in' statement."), + Type_parameters_cannot_appear_on_a_constructor_declaration: b(1092, 1, "Type_parameters_cannot_appear_on_a_constructor_declaration_1092", "Type parameters cannot appear on a constructor declaration."), + Type_annotation_cannot_appear_on_a_constructor_declaration: b(1093, 1, "Type_annotation_cannot_appear_on_a_constructor_declaration_1093", "Type annotation cannot appear on a constructor declaration."), + An_accessor_cannot_have_type_parameters: b(1094, 1, "An_accessor_cannot_have_type_parameters_1094", "An accessor cannot have type parameters."), + A_set_accessor_cannot_have_a_return_type_annotation: b(1095, 1, "A_set_accessor_cannot_have_a_return_type_annotation_1095", "A 'set' accessor cannot have a return type annotation."), + An_index_signature_must_have_exactly_one_parameter: b(1096, 1, "An_index_signature_must_have_exactly_one_parameter_1096", "An index signature must have exactly one parameter."), + _0_list_cannot_be_empty: b(1097, 1, "_0_list_cannot_be_empty_1097", "'{0}' list cannot be empty."), + Type_parameter_list_cannot_be_empty: b(1098, 1, "Type_parameter_list_cannot_be_empty_1098", "Type parameter list cannot be empty."), + Type_argument_list_cannot_be_empty: b(1099, 1, "Type_argument_list_cannot_be_empty_1099", "Type argument list cannot be empty."), + Invalid_use_of_0_in_strict_mode: b(1100, 1, "Invalid_use_of_0_in_strict_mode_1100", "Invalid use of '{0}' in strict mode."), + with_statements_are_not_allowed_in_strict_mode: b(1101, 1, "with_statements_are_not_allowed_in_strict_mode_1101", "'with' statements are not allowed in strict mode."), + delete_cannot_be_called_on_an_identifier_in_strict_mode: b(1102, 1, "delete_cannot_be_called_on_an_identifier_in_strict_mode_1102", "'delete' cannot be called on an identifier in strict mode."), + for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: b(1103, 1, "for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1103", "'for await' loops are only allowed within async functions and at the top levels of modules."), + A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: b(1104, 1, "A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement_1104", "A 'continue' statement can only be used within an enclosing iteration statement."), + A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: b(1105, 1, "A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement_1105", "A 'break' statement can only be used within an enclosing iteration or switch statement."), + The_left_hand_side_of_a_for_of_statement_may_not_be_async: b(1106, 1, "The_left_hand_side_of_a_for_of_statement_may_not_be_async_1106", "The left-hand side of a 'for...of' statement may not be 'async'."), + Jump_target_cannot_cross_function_boundary: b(1107, 1, "Jump_target_cannot_cross_function_boundary_1107", "Jump target cannot cross function boundary."), + A_return_statement_can_only_be_used_within_a_function_body: b(1108, 1, "A_return_statement_can_only_be_used_within_a_function_body_1108", "A 'return' statement can only be used within a function body."), + Expression_expected: b(1109, 1, "Expression_expected_1109", "Expression expected."), + Type_expected: b(1110, 1, "Type_expected_1110", "Type expected."), + Private_field_0_must_be_declared_in_an_enclosing_class: b(1111, 1, "Private_field_0_must_be_declared_in_an_enclosing_class_1111", "Private field '{0}' must be declared in an enclosing class."), + A_default_clause_cannot_appear_more_than_once_in_a_switch_statement: b(1113, 1, "A_default_clause_cannot_appear_more_than_once_in_a_switch_statement_1113", "A 'default' clause cannot appear more than once in a 'switch' statement."), + Duplicate_label_0: b(1114, 1, "Duplicate_label_0_1114", "Duplicate label '{0}'."), + A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement: b(1115, 1, "A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement_1115", "A 'continue' statement can only jump to a label of an enclosing iteration statement."), + A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement: b(1116, 1, "A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement_1116", "A 'break' statement can only jump to a label of an enclosing statement."), + An_object_literal_cannot_have_multiple_properties_with_the_same_name: b(1117, 1, "An_object_literal_cannot_have_multiple_properties_with_the_same_name_1117", "An object literal cannot have multiple properties with the same name."), + An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: b(1118, 1, "An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name_1118", "An object literal cannot have multiple get/set accessors with the same name."), + An_object_literal_cannot_have_property_and_accessor_with_the_same_name: b(1119, 1, "An_object_literal_cannot_have_property_and_accessor_with_the_same_name_1119", "An object literal cannot have property and accessor with the same name."), + An_export_assignment_cannot_have_modifiers: b(1120, 1, "An_export_assignment_cannot_have_modifiers_1120", "An export assignment cannot have modifiers."), + Octal_literals_are_not_allowed_Use_the_syntax_0: b(1121, 1, "Octal_literals_are_not_allowed_Use_the_syntax_0_1121", "Octal literals are not allowed. Use the syntax '{0}'."), + Variable_declaration_list_cannot_be_empty: b(1123, 1, "Variable_declaration_list_cannot_be_empty_1123", "Variable declaration list cannot be empty."), + Digit_expected: b(1124, 1, "Digit_expected_1124", "Digit expected."), + Hexadecimal_digit_expected: b(1125, 1, "Hexadecimal_digit_expected_1125", "Hexadecimal digit expected."), + Unexpected_end_of_text: b(1126, 1, "Unexpected_end_of_text_1126", "Unexpected end of text."), + Invalid_character: b(1127, 1, "Invalid_character_1127", "Invalid character."), + Declaration_or_statement_expected: b(1128, 1, "Declaration_or_statement_expected_1128", "Declaration or statement expected."), + Statement_expected: b(1129, 1, "Statement_expected_1129", "Statement expected."), + case_or_default_expected: b(1130, 1, "case_or_default_expected_1130", "'case' or 'default' expected."), + Property_or_signature_expected: b(1131, 1, "Property_or_signature_expected_1131", "Property or signature expected."), + Enum_member_expected: b(1132, 1, "Enum_member_expected_1132", "Enum member expected."), + Variable_declaration_expected: b(1134, 1, "Variable_declaration_expected_1134", "Variable declaration expected."), + Argument_expression_expected: b(1135, 1, "Argument_expression_expected_1135", "Argument expression expected."), + Property_assignment_expected: b(1136, 1, "Property_assignment_expected_1136", "Property assignment expected."), + Expression_or_comma_expected: b(1137, 1, "Expression_or_comma_expected_1137", "Expression or comma expected."), + Parameter_declaration_expected: b(1138, 1, "Parameter_declaration_expected_1138", "Parameter declaration expected."), + Type_parameter_declaration_expected: b(1139, 1, "Type_parameter_declaration_expected_1139", "Type parameter declaration expected."), + Type_argument_expected: b(1140, 1, "Type_argument_expected_1140", "Type argument expected."), + String_literal_expected: b(1141, 1, "String_literal_expected_1141", "String literal expected."), + Line_break_not_permitted_here: b(1142, 1, "Line_break_not_permitted_here_1142", "Line break not permitted here."), + or_expected: b(1144, 1, "or_expected_1144", "'{' or ';' expected."), + or_JSX_element_expected: b(1145, 1, "or_JSX_element_expected_1145", "'{' or JSX element expected."), + Declaration_expected: b(1146, 1, "Declaration_expected_1146", "Declaration expected."), + Import_declarations_in_a_namespace_cannot_reference_a_module: b(1147, 1, "Import_declarations_in_a_namespace_cannot_reference_a_module_1147", "Import declarations in a namespace cannot reference a module."), + Cannot_use_imports_exports_or_module_augmentations_when_module_is_none: b(1148, 1, "Cannot_use_imports_exports_or_module_augmentations_when_module_is_none_1148", "Cannot use imports, exports, or module augmentations when '--module' is 'none'."), + File_name_0_differs_from_already_included_file_name_1_only_in_casing: b(1149, 1, "File_name_0_differs_from_already_included_file_name_1_only_in_casing_1149", "File name '{0}' differs from already included file name '{1}' only in casing."), + _0_declarations_must_be_initialized: b(1155, 1, "_0_declarations_must_be_initialized_1155", "'{0}' declarations must be initialized."), + _0_declarations_can_only_be_declared_inside_a_block: b(1156, 1, "_0_declarations_can_only_be_declared_inside_a_block_1156", "'{0}' declarations can only be declared inside a block."), + Unterminated_template_literal: b(1160, 1, "Unterminated_template_literal_1160", "Unterminated template literal."), + Unterminated_regular_expression_literal: b(1161, 1, "Unterminated_regular_expression_literal_1161", "Unterminated regular expression literal."), + An_object_member_cannot_be_declared_optional: b(1162, 1, "An_object_member_cannot_be_declared_optional_1162", "An object member cannot be declared optional."), + A_yield_expression_is_only_allowed_in_a_generator_body: b(1163, 1, "A_yield_expression_is_only_allowed_in_a_generator_body_1163", "A 'yield' expression is only allowed in a generator body."), + Computed_property_names_are_not_allowed_in_enums: b(1164, 1, "Computed_property_names_are_not_allowed_in_enums_1164", "Computed property names are not allowed in enums."), + A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: b(1165, 1, "A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_t_1165", "A computed property name in an ambient context must refer to an expression whose type is a literal type or a 'unique symbol' type."), + A_computed_property_name_in_a_class_property_declaration_must_have_a_simple_literal_type_or_a_unique_symbol_type: b(1166, 1, "A_computed_property_name_in_a_class_property_declaration_must_have_a_simple_literal_type_or_a_unique_1166", "A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type."), + A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: b(1168, 1, "A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_ty_1168", "A computed property name in a method overload must refer to an expression whose type is a literal type or a 'unique symbol' type."), + A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: b(1169, 1, "A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_1169", "A computed property name in an interface must refer to an expression whose type is a literal type or a 'unique symbol' type."), + A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: b(1170, 1, "A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type__1170", "A computed property name in a type literal must refer to an expression whose type is a literal type or a 'unique symbol' type."), + A_comma_expression_is_not_allowed_in_a_computed_property_name: b(1171, 1, "A_comma_expression_is_not_allowed_in_a_computed_property_name_1171", "A comma expression is not allowed in a computed property name."), + extends_clause_already_seen: b(1172, 1, "extends_clause_already_seen_1172", "'extends' clause already seen."), + extends_clause_must_precede_implements_clause: b(1173, 1, "extends_clause_must_precede_implements_clause_1173", "'extends' clause must precede 'implements' clause."), + Classes_can_only_extend_a_single_class: b(1174, 1, "Classes_can_only_extend_a_single_class_1174", "Classes can only extend a single class."), + implements_clause_already_seen: b(1175, 1, "implements_clause_already_seen_1175", "'implements' clause already seen."), + Interface_declaration_cannot_have_implements_clause: b(1176, 1, "Interface_declaration_cannot_have_implements_clause_1176", "Interface declaration cannot have 'implements' clause."), + Binary_digit_expected: b(1177, 1, "Binary_digit_expected_1177", "Binary digit expected."), + Octal_digit_expected: b(1178, 1, "Octal_digit_expected_1178", "Octal digit expected."), + Unexpected_token_expected: b(1179, 1, "Unexpected_token_expected_1179", "Unexpected token. '{' expected."), + Property_destructuring_pattern_expected: b(1180, 1, "Property_destructuring_pattern_expected_1180", "Property destructuring pattern expected."), + Array_element_destructuring_pattern_expected: b(1181, 1, "Array_element_destructuring_pattern_expected_1181", "Array element destructuring pattern expected."), + A_destructuring_declaration_must_have_an_initializer: b(1182, 1, "A_destructuring_declaration_must_have_an_initializer_1182", "A destructuring declaration must have an initializer."), + An_implementation_cannot_be_declared_in_ambient_contexts: b(1183, 1, "An_implementation_cannot_be_declared_in_ambient_contexts_1183", "An implementation cannot be declared in ambient contexts."), + Modifiers_cannot_appear_here: b(1184, 1, "Modifiers_cannot_appear_here_1184", "Modifiers cannot appear here."), + Merge_conflict_marker_encountered: b(1185, 1, "Merge_conflict_marker_encountered_1185", "Merge conflict marker encountered."), + A_rest_element_cannot_have_an_initializer: b(1186, 1, "A_rest_element_cannot_have_an_initializer_1186", "A rest element cannot have an initializer."), + A_parameter_property_may_not_be_declared_using_a_binding_pattern: b(1187, 1, "A_parameter_property_may_not_be_declared_using_a_binding_pattern_1187", "A parameter property may not be declared using a binding pattern."), + Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement: b(1188, 1, "Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement_1188", "Only a single variable declaration is allowed in a 'for...of' statement."), + The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer: b(1189, 1, "The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer_1189", "The variable declaration of a 'for...in' statement cannot have an initializer."), + The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer: b(1190, 1, "The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer_1190", "The variable declaration of a 'for...of' statement cannot have an initializer."), + An_import_declaration_cannot_have_modifiers: b(1191, 1, "An_import_declaration_cannot_have_modifiers_1191", "An import declaration cannot have modifiers."), + Module_0_has_no_default_export: b(1192, 1, "Module_0_has_no_default_export_1192", "Module '{0}' has no default export."), + An_export_declaration_cannot_have_modifiers: b(1193, 1, "An_export_declaration_cannot_have_modifiers_1193", "An export declaration cannot have modifiers."), + Export_declarations_are_not_permitted_in_a_namespace: b(1194, 1, "Export_declarations_are_not_permitted_in_a_namespace_1194", "Export declarations are not permitted in a namespace."), + export_Asterisk_does_not_re_export_a_default: b(1195, 1, "export_Asterisk_does_not_re_export_a_default_1195", "'export *' does not re-export a default."), + Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified: b(1196, 1, "Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified_1196", "Catch clause variable type annotation must be 'any' or 'unknown' if specified."), + Catch_clause_variable_cannot_have_an_initializer: b(1197, 1, "Catch_clause_variable_cannot_have_an_initializer_1197", "Catch clause variable cannot have an initializer."), + An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive: b(1198, 1, "An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive_1198", "An extended Unicode escape value must be between 0x0 and 0x10FFFF inclusive."), + Unterminated_Unicode_escape_sequence: b(1199, 1, "Unterminated_Unicode_escape_sequence_1199", "Unterminated Unicode escape sequence."), + Line_terminator_not_permitted_before_arrow: b(1200, 1, "Line_terminator_not_permitted_before_arrow_1200", "Line terminator not permitted before arrow."), + Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead: b(1202, 1, "Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_1202", `Import assignment cannot be used when targeting ECMAScript modules. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead.`), + Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead: b(1203, 1, "Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or__1203", "Export assignment cannot be used when targeting ECMAScript modules. Consider using 'export default' or another module format instead."), + Re_exporting_a_type_when_0_is_enabled_requires_using_export_type: b(1205, 1, "Re_exporting_a_type_when_0_is_enabled_requires_using_export_type_1205", "Re-exporting a type when '{0}' is enabled requires using 'export type'."), + Decorators_are_not_valid_here: b(1206, 1, "Decorators_are_not_valid_here_1206", "Decorators are not valid here."), + Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name: b(1207, 1, "Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name_1207", "Decorators cannot be applied to multiple get/set accessors of the same name."), + Invalid_optional_chain_from_new_expression_Did_you_mean_to_call_0: b(1209, 1, "Invalid_optional_chain_from_new_expression_Did_you_mean_to_call_0_1209", "Invalid optional chain from new expression. Did you mean to call '{0}()'?"), + Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of_0_For_more_information_see_https_Colon_Slash_Slashdeveloper_mozilla_org_Slashen_US_Slashdocs_SlashWeb_SlashJavaScript_SlashReference_SlashStrict_mode: b(1210, 1, "Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of__1210", "Code contained in a class is evaluated in JavaScript's strict mode which does not allow this use of '{0}'. For more information, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode."), + A_class_declaration_without_the_default_modifier_must_have_a_name: b(1211, 1, "A_class_declaration_without_the_default_modifier_must_have_a_name_1211", "A class declaration without the 'default' modifier must have a name."), + Identifier_expected_0_is_a_reserved_word_in_strict_mode: b(1212, 1, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_1212", "Identifier expected. '{0}' is a reserved word in strict mode."), + Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: b(1213, 1, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_stric_1213", "Identifier expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode."), + Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode: b(1214, 1, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode_1214", "Identifier expected. '{0}' is a reserved word in strict mode. Modules are automatically in strict mode."), + Invalid_use_of_0_Modules_are_automatically_in_strict_mode: b(1215, 1, "Invalid_use_of_0_Modules_are_automatically_in_strict_mode_1215", "Invalid use of '{0}'. Modules are automatically in strict mode."), + Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules: b(1216, 1, "Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules_1216", "Identifier expected. '__esModule' is reserved as an exported marker when transforming ECMAScript modules."), + Export_assignment_is_not_supported_when_module_flag_is_system: b(1218, 1, "Export_assignment_is_not_supported_when_module_flag_is_system_1218", "Export assignment is not supported when '--module' flag is 'system'."), + Generators_are_not_allowed_in_an_ambient_context: b(1221, 1, "Generators_are_not_allowed_in_an_ambient_context_1221", "Generators are not allowed in an ambient context."), + An_overload_signature_cannot_be_declared_as_a_generator: b(1222, 1, "An_overload_signature_cannot_be_declared_as_a_generator_1222", "An overload signature cannot be declared as a generator."), + _0_tag_already_specified: b(1223, 1, "_0_tag_already_specified_1223", "'{0}' tag already specified."), + Signature_0_must_be_a_type_predicate: b(1224, 1, "Signature_0_must_be_a_type_predicate_1224", "Signature '{0}' must be a type predicate."), + Cannot_find_parameter_0: b(1225, 1, "Cannot_find_parameter_0_1225", "Cannot find parameter '{0}'."), + Type_predicate_0_is_not_assignable_to_1: b(1226, 1, "Type_predicate_0_is_not_assignable_to_1_1226", "Type predicate '{0}' is not assignable to '{1}'."), + Parameter_0_is_not_in_the_same_position_as_parameter_1: b(1227, 1, "Parameter_0_is_not_in_the_same_position_as_parameter_1_1227", "Parameter '{0}' is not in the same position as parameter '{1}'."), + A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods: b(1228, 1, "A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods_1228", "A type predicate is only allowed in return type position for functions and methods."), + A_type_predicate_cannot_reference_a_rest_parameter: b(1229, 1, "A_type_predicate_cannot_reference_a_rest_parameter_1229", "A type predicate cannot reference a rest parameter."), + A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: b(1230, 1, "A_type_predicate_cannot_reference_element_0_in_a_binding_pattern_1230", "A type predicate cannot reference element '{0}' in a binding pattern."), + An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration: b(1231, 1, "An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration_1231", "An export assignment must be at the top level of a file or module declaration."), + An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module: b(1232, 1, "An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module_1232", "An import declaration can only be used at the top level of a namespace or module."), + An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module: b(1233, 1, "An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module_1233", "An export declaration can only be used at the top level of a namespace or module."), + An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: b(1234, 1, "An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file_1234", "An ambient module declaration is only allowed at the top level in a file."), + A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module: b(1235, 1, "A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module_1235", "A namespace declaration is only allowed at the top level of a namespace or module."), + The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: b(1236, 1, "The_return_type_of_a_property_decorator_function_must_be_either_void_or_any_1236", "The return type of a property decorator function must be either 'void' or 'any'."), + The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: b(1237, 1, "The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any_1237", "The return type of a parameter decorator function must be either 'void' or 'any'."), + Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: b(1238, 1, "Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression_1238", "Unable to resolve signature of class decorator when called as an expression."), + Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression: b(1239, 1, "Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression_1239", "Unable to resolve signature of parameter decorator when called as an expression."), + Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression: b(1240, 1, "Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression_1240", "Unable to resolve signature of property decorator when called as an expression."), + Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression: b(1241, 1, "Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression_1241", "Unable to resolve signature of method decorator when called as an expression."), + abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration: b(1242, 1, "abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration_1242", "'abstract' modifier can only appear on a class, method, or property declaration."), + _0_modifier_cannot_be_used_with_1_modifier: b(1243, 1, "_0_modifier_cannot_be_used_with_1_modifier_1243", "'{0}' modifier cannot be used with '{1}' modifier."), + Abstract_methods_can_only_appear_within_an_abstract_class: b(1244, 1, "Abstract_methods_can_only_appear_within_an_abstract_class_1244", "Abstract methods can only appear within an abstract class."), + Method_0_cannot_have_an_implementation_because_it_is_marked_abstract: b(1245, 1, "Method_0_cannot_have_an_implementation_because_it_is_marked_abstract_1245", "Method '{0}' cannot have an implementation because it is marked abstract."), + An_interface_property_cannot_have_an_initializer: b(1246, 1, "An_interface_property_cannot_have_an_initializer_1246", "An interface property cannot have an initializer."), + A_type_literal_property_cannot_have_an_initializer: b(1247, 1, "A_type_literal_property_cannot_have_an_initializer_1247", "A type literal property cannot have an initializer."), + A_class_member_cannot_have_the_0_keyword: b(1248, 1, "A_class_member_cannot_have_the_0_keyword_1248", "A class member cannot have the '{0}' keyword."), + A_decorator_can_only_decorate_a_method_implementation_not_an_overload: b(1249, 1, "A_decorator_can_only_decorate_a_method_implementation_not_an_overload_1249", "A decorator can only decorate a method implementation, not an overload."), + Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES5: b(1250, 1, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES5_1250", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES5'."), + Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES5_Class_definitions_are_automatically_in_strict_mode: b(1251, 1, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES5_Class_definiti_1251", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES5'. Class definitions are automatically in strict mode."), + Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES5_Modules_are_automatically_in_strict_mode: b(1252, 1, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES5_Modules_are_au_1252", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES5'. Modules are automatically in strict mode."), + Abstract_properties_can_only_appear_within_an_abstract_class: b(1253, 1, "Abstract_properties_can_only_appear_within_an_abstract_class_1253", "Abstract properties can only appear within an abstract class."), + A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference: b(1254, 1, "A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_refere_1254", "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference."), + A_definite_assignment_assertion_is_not_permitted_in_this_context: b(1255, 1, "A_definite_assignment_assertion_is_not_permitted_in_this_context_1255", "A definite assignment assertion '!' is not permitted in this context."), + A_required_element_cannot_follow_an_optional_element: b(1257, 1, "A_required_element_cannot_follow_an_optional_element_1257", "A required element cannot follow an optional element."), + A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration: b(1258, 1, "A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration_1258", "A default export must be at the top level of a file or module declaration."), + Module_0_can_only_be_default_imported_using_the_1_flag: b(1259, 1, "Module_0_can_only_be_default_imported_using_the_1_flag_1259", "Module '{0}' can only be default-imported using the '{1}' flag"), + Keywords_cannot_contain_escape_characters: b(1260, 1, "Keywords_cannot_contain_escape_characters_1260", "Keywords cannot contain escape characters."), + Already_included_file_name_0_differs_from_file_name_1_only_in_casing: b(1261, 1, "Already_included_file_name_0_differs_from_file_name_1_only_in_casing_1261", "Already included file name '{0}' differs from file name '{1}' only in casing."), + Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module: b(1262, 1, "Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module_1262", "Identifier expected. '{0}' is a reserved word at the top-level of a module."), + Declarations_with_initializers_cannot_also_have_definite_assignment_assertions: b(1263, 1, "Declarations_with_initializers_cannot_also_have_definite_assignment_assertions_1263", "Declarations with initializers cannot also have definite assignment assertions."), + Declarations_with_definite_assignment_assertions_must_also_have_type_annotations: b(1264, 1, "Declarations_with_definite_assignment_assertions_must_also_have_type_annotations_1264", "Declarations with definite assignment assertions must also have type annotations."), + A_rest_element_cannot_follow_another_rest_element: b(1265, 1, "A_rest_element_cannot_follow_another_rest_element_1265", "A rest element cannot follow another rest element."), + An_optional_element_cannot_follow_a_rest_element: b(1266, 1, "An_optional_element_cannot_follow_a_rest_element_1266", "An optional element cannot follow a rest element."), + Property_0_cannot_have_an_initializer_because_it_is_marked_abstract: b(1267, 1, "Property_0_cannot_have_an_initializer_because_it_is_marked_abstract_1267", "Property '{0}' cannot have an initializer because it is marked abstract."), + An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type: b(1268, 1, "An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type_1268", "An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type."), + Cannot_use_export_import_on_a_type_or_type_only_namespace_when_0_is_enabled: b(1269, 1, "Cannot_use_export_import_on_a_type_or_type_only_namespace_when_0_is_enabled_1269", "Cannot use 'export import' on a type or type-only namespace when '{0}' is enabled."), + Decorator_function_return_type_0_is_not_assignable_to_type_1: b(1270, 1, "Decorator_function_return_type_0_is_not_assignable_to_type_1_1270", "Decorator function return type '{0}' is not assignable to type '{1}'."), + Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any: b(1271, 1, "Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any_1271", "Decorator function return type is '{0}' but is expected to be 'void' or 'any'."), + A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled: b(1272, 1, "A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_w_1272", "A type referenced in a decorated signature must be imported with 'import type' or a namespace import when 'isolatedModules' and 'emitDecoratorMetadata' are enabled."), + _0_modifier_cannot_appear_on_a_type_parameter: b(1273, 1, "_0_modifier_cannot_appear_on_a_type_parameter_1273", "'{0}' modifier cannot appear on a type parameter"), + _0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias: b(1274, 1, "_0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias_1274", "'{0}' modifier can only appear on a type parameter of a class, interface or type alias"), + accessor_modifier_can_only_appear_on_a_property_declaration: b(1275, 1, "accessor_modifier_can_only_appear_on_a_property_declaration_1275", "'accessor' modifier can only appear on a property declaration."), + An_accessor_property_cannot_be_declared_optional: b(1276, 1, "An_accessor_property_cannot_be_declared_optional_1276", "An 'accessor' property cannot be declared optional."), + _0_modifier_can_only_appear_on_a_type_parameter_of_a_function_method_or_class: b(1277, 1, "_0_modifier_can_only_appear_on_a_type_parameter_of_a_function_method_or_class_1277", "'{0}' modifier can only appear on a type parameter of a function, method or class"), + The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_0: b(1278, 1, "The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_0_1278", "The runtime will invoke the decorator with {1} arguments, but the decorator expects {0}."), + The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_at_least_0: b(1279, 1, "The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_at_least_0_1279", "The runtime will invoke the decorator with {1} arguments, but the decorator expects at least {0}."), + Namespaces_are_not_allowed_in_global_script_files_when_0_is_enabled_If_this_file_is_not_intended_to_be_a_global_script_set_moduleDetection_to_force_or_add_an_empty_export_statement: b(1280, 1, "Namespaces_are_not_allowed_in_global_script_files_when_0_is_enabled_If_this_file_is_not_intended_to__1280", "Namespaces are not allowed in global script files when '{0}' is enabled. If this file is not intended to be a global script, set 'moduleDetection' to 'force' or add an empty 'export {}' statement."), + Cannot_access_0_from_another_file_without_qualification_when_1_is_enabled_Use_2_instead: b(1281, 1, "Cannot_access_0_from_another_file_without_qualification_when_1_is_enabled_Use_2_instead_1281", "Cannot access '{0}' from another file without qualification when '{1}' is enabled. Use '{2}' instead."), + An_export_declaration_must_reference_a_value_when_verbatimModuleSyntax_is_enabled_but_0_only_refers_to_a_type: b(1282, 1, "An_export_declaration_must_reference_a_value_when_verbatimModuleSyntax_is_enabled_but_0_only_refers__1282", "An 'export =' declaration must reference a value when 'verbatimModuleSyntax' is enabled, but '{0}' only refers to a type."), + An_export_declaration_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_a_type_only_declaration: b(1283, 1, "An_export_declaration_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolve_1283", "An 'export =' declaration must reference a real value when 'verbatimModuleSyntax' is enabled, but '{0}' resolves to a type-only declaration."), + An_export_default_must_reference_a_value_when_verbatimModuleSyntax_is_enabled_but_0_only_refers_to_a_type: b(1284, 1, "An_export_default_must_reference_a_value_when_verbatimModuleSyntax_is_enabled_but_0_only_refers_to_a_1284", "An 'export default' must reference a value when 'verbatimModuleSyntax' is enabled, but '{0}' only refers to a type."), + An_export_default_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_a_type_only_declaration: b(1285, 1, "An_export_default_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_1285", "An 'export default' must reference a real value when 'verbatimModuleSyntax' is enabled, but '{0}' resolves to a type-only declaration."), + ECMAScript_imports_and_exports_cannot_be_written_in_a_CommonJS_file_under_verbatimModuleSyntax: b(1286, 1, "ECMAScript_imports_and_exports_cannot_be_written_in_a_CommonJS_file_under_verbatimModuleSyntax_1286", "ECMAScript imports and exports cannot be written in a CommonJS file under 'verbatimModuleSyntax'."), + A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled: b(1287, 1, "A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimM_1287", "A top-level 'export' modifier cannot be used on value declarations in a CommonJS module when 'verbatimModuleSyntax' is enabled."), + An_import_alias_cannot_resolve_to_a_type_or_type_only_declaration_when_verbatimModuleSyntax_is_enabled: b(1288, 1, "An_import_alias_cannot_resolve_to_a_type_or_type_only_declaration_when_verbatimModuleSyntax_is_enabl_1288", "An import alias cannot resolve to a type or type-only declaration when 'verbatimModuleSyntax' is enabled."), + _0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported: b(1289, 1, "_0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_1289", "'{0}' resolves to a type-only declaration and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'import type' where '{0}' is imported."), + _0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default: b(1290, 1, "_0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_1290", "'{0}' resolves to a type-only declaration and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'export type { {0} as default }'."), + _0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported: b(1291, 1, "_0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enable_1291", "'{0}' resolves to a type and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'import type' where '{0}' is imported."), + _0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default: b(1292, 1, "_0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enable_1292", "'{0}' resolves to a type and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'export type { {0} as default }'."), + ECMAScript_module_syntax_is_not_allowed_in_a_CommonJS_module_when_module_is_set_to_preserve: b(1293, 1, "ECMAScript_module_syntax_is_not_allowed_in_a_CommonJS_module_when_module_is_set_to_preserve_1293", "ECMAScript module syntax is not allowed in a CommonJS module when 'module' is set to 'preserve'."), + This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled: b(1294, 1, "This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled_1294", "This syntax is not allowed when 'erasableSyntaxOnly' is enabled."), + ECMAScript_imports_and_exports_cannot_be_written_in_a_CommonJS_file_under_verbatimModuleSyntax_Adjust_the_type_field_in_the_nearest_package_json_to_make_this_file_an_ECMAScript_module_or_adjust_your_verbatimModuleSyntax_module_and_moduleResolution_settings_in_TypeScript: b(1295, 1, "ECMAScript_imports_and_exports_cannot_be_written_in_a_CommonJS_file_under_verbatimModuleSyntax_Adjus_1295", "ECMAScript imports and exports cannot be written in a CommonJS file under 'verbatimModuleSyntax'. Adjust the 'type' field in the nearest 'package.json' to make this file an ECMAScript module, or adjust your 'verbatimModuleSyntax', 'module', and 'moduleResolution' settings in TypeScript."), + with_statements_are_not_allowed_in_an_async_function_block: b(1300, 1, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."), + await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: b(1308, 1, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."), + The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level: b(1309, 1, "The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level_1309", "The current file is a CommonJS module and cannot use 'await' at the top level."), + Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern: b(1312, 1, "Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_1312", "Did you mean to use a ':'? An '=' can only follow a property name when the containing object literal is part of a destructuring pattern."), + The_body_of_an_if_statement_cannot_be_the_empty_statement: b(1313, 1, "The_body_of_an_if_statement_cannot_be_the_empty_statement_1313", "The body of an 'if' statement cannot be the empty statement."), + Global_module_exports_may_only_appear_in_module_files: b(1314, 1, "Global_module_exports_may_only_appear_in_module_files_1314", "Global module exports may only appear in module files."), + Global_module_exports_may_only_appear_in_declaration_files: b(1315, 1, "Global_module_exports_may_only_appear_in_declaration_files_1315", "Global module exports may only appear in declaration files."), + Global_module_exports_may_only_appear_at_top_level: b(1316, 1, "Global_module_exports_may_only_appear_at_top_level_1316", "Global module exports may only appear at top level."), + A_parameter_property_cannot_be_declared_using_a_rest_parameter: b(1317, 1, "A_parameter_property_cannot_be_declared_using_a_rest_parameter_1317", "A parameter property cannot be declared using a rest parameter."), + An_abstract_accessor_cannot_have_an_implementation: b(1318, 1, "An_abstract_accessor_cannot_have_an_implementation_1318", "An abstract accessor cannot have an implementation."), + A_default_export_can_only_be_used_in_an_ECMAScript_style_module: b(1319, 1, "A_default_export_can_only_be_used_in_an_ECMAScript_style_module_1319", "A default export can only be used in an ECMAScript-style module."), + Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: b(1320, 1, "Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member_1320", "Type of 'await' operand must either be a valid promise or must not contain a callable 'then' member."), + Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: b(1321, 1, "Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_cal_1321", "Type of 'yield' operand in an async generator must either be a valid promise or must not contain a callable 'then' member."), + Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: b(1322, 1, "Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_con_1322", "Type of iterated elements of a 'yield*' operand must either be a valid promise or must not contain a callable 'then' member."), + Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_node18_node20_or_nodenext: b(1323, 1, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'es2022', 'esnext', 'commonjs', 'amd', 'system', 'umd', 'node16', 'node18', 'node20', or 'nodenext'."), + Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_node18_node20_nodenext_or_preserve: b(1324, 1, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_node18_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext', 'node16', 'node18', 'node20', 'nodenext', or 'preserve'."), + Argument_of_dynamic_import_cannot_be_spread_element: b(1325, 1, "Argument_of_dynamic_import_cannot_be_spread_element_1325", "Argument of dynamic import cannot be spread element."), + This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments: b(1326, 1, "This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot__1326", "This use of 'import' is invalid. 'import()' calls can be written, but they must have parentheses and cannot have type arguments."), + String_literal_with_double_quotes_expected: b(1327, 1, "String_literal_with_double_quotes_expected_1327", "String literal with double quotes expected."), + Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal: b(1328, 1, "Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_li_1328", "Property value can only be string literal, numeric literal, 'true', 'false', 'null', object literal or array literal."), + _0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0: b(1329, 1, "_0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write__1329", "'{0}' accepts too few arguments to be used as a decorator here. Did you mean to call it first and write '@{0}()'?"), + A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly: b(1330, 1, "A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly_1330", "A property of an interface or type literal whose type is a 'unique symbol' type must be 'readonly'."), + A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly: b(1331, 1, "A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly_1331", "A property of a class whose type is a 'unique symbol' type must be both 'static' and 'readonly'."), + A_variable_whose_type_is_a_unique_symbol_type_must_be_const: b(1332, 1, "A_variable_whose_type_is_a_unique_symbol_type_must_be_const_1332", "A variable whose type is a 'unique symbol' type must be 'const'."), + unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name: b(1333, 1, "unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name_1333", "'unique symbol' types may not be used on a variable declaration with a binding name."), + unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement: b(1334, 1, "unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement_1334", "'unique symbol' types are only allowed on variables in a variable statement."), + unique_symbol_types_are_not_allowed_here: b(1335, 1, "unique_symbol_types_are_not_allowed_here_1335", "'unique symbol' types are not allowed here."), + An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead: b(1337, 1, "An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_o_1337", "An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead."), + infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type: b(1338, 1, "infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type_1338", "'infer' declarations are only permitted in the 'extends' clause of a conditional type."), + Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here: b(1339, 1, "Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here_1339", "Module '{0}' does not refer to a value, but is used as a value here."), + Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0: b(1340, 1, "Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0_1340", "Module '{0}' does not refer to a type, but is used as a type here. Did you mean 'typeof import('{0}')'?"), + Class_constructor_may_not_be_an_accessor: b(1341, 1, "Class_constructor_may_not_be_an_accessor_1341", "Class constructor may not be an accessor."), + The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_node18_node20_or_nodenext: b(1343, 1, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system__1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', or 'nodenext'."), + A_label_is_not_allowed_here: b(1344, 1, "A_label_is_not_allowed_here_1344", "'A label is not allowed here."), + An_expression_of_type_void_cannot_be_tested_for_truthiness: b(1345, 1, "An_expression_of_type_void_cannot_be_tested_for_truthiness_1345", "An expression of type 'void' cannot be tested for truthiness."), + This_parameter_is_not_allowed_with_use_strict_directive: b(1346, 1, "This_parameter_is_not_allowed_with_use_strict_directive_1346", "This parameter is not allowed with 'use strict' directive."), + use_strict_directive_cannot_be_used_with_non_simple_parameter_list: b(1347, 1, "use_strict_directive_cannot_be_used_with_non_simple_parameter_list_1347", "'use strict' directive cannot be used with non-simple parameter list."), + Non_simple_parameter_declared_here: b(1348, 1, "Non_simple_parameter_declared_here_1348", "Non-simple parameter declared here."), + use_strict_directive_used_here: b(1349, 1, "use_strict_directive_used_here_1349", "'use strict' directive used here."), + Print_the_final_configuration_instead_of_building: b(1350, 3, "Print_the_final_configuration_instead_of_building_1350", "Print the final configuration instead of building."), + An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal: b(1351, 1, "An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal_1351", "An identifier or keyword cannot immediately follow a numeric literal."), + A_bigint_literal_cannot_use_exponential_notation: b(1352, 1, "A_bigint_literal_cannot_use_exponential_notation_1352", "A bigint literal cannot use exponential notation."), + A_bigint_literal_must_be_an_integer: b(1353, 1, "A_bigint_literal_must_be_an_integer_1353", "A bigint literal must be an integer."), + readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types: b(1354, 1, "readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types_1354", "'readonly' type modifier is only permitted on array and tuple literal types."), + A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals: b(1355, 1, "A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array__1355", "A 'const' assertions can only be applied to references to enum members, or string, number, boolean, array, or object literals."), + Did_you_mean_to_mark_this_function_as_async: b(1356, 1, "Did_you_mean_to_mark_this_function_as_async_1356", "Did you mean to mark this function as 'async'?"), + An_enum_member_name_must_be_followed_by_a_or: b(1357, 1, "An_enum_member_name_must_be_followed_by_a_or_1357", "An enum member name must be followed by a ',', '=', or '}'."), + Tagged_template_expressions_are_not_permitted_in_an_optional_chain: b(1358, 1, "Tagged_template_expressions_are_not_permitted_in_an_optional_chain_1358", "Tagged template expressions are not permitted in an optional chain."), + Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here: b(1359, 1, "Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here_1359", "Identifier expected. '{0}' is a reserved word that cannot be used here."), + Type_0_does_not_satisfy_the_expected_type_1: b(1360, 1, "Type_0_does_not_satisfy_the_expected_type_1_1360", "Type '{0}' does not satisfy the expected type '{1}'."), + _0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type: b(1361, 1, "_0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type_1361", "'{0}' cannot be used as a value because it was imported using 'import type'."), + _0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type: b(1362, 1, "_0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type_1362", "'{0}' cannot be used as a value because it was exported using 'export type'."), + A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both: b(1363, 1, "A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both_1363", "A type-only import can specify a default import or named bindings, but not both."), + Convert_to_type_only_export: b(1364, 3, "Convert_to_type_only_export_1364", "Convert to type-only export"), + Convert_all_re_exported_types_to_type_only_exports: b(1365, 3, "Convert_all_re_exported_types_to_type_only_exports_1365", "Convert all re-exported types to type-only exports"), + Split_into_two_separate_import_declarations: b(1366, 3, "Split_into_two_separate_import_declarations_1366", "Split into two separate import declarations"), + Split_all_invalid_type_only_imports: b(1367, 3, "Split_all_invalid_type_only_imports_1367", "Split all invalid type-only imports"), + Class_constructor_may_not_be_a_generator: b(1368, 1, "Class_constructor_may_not_be_a_generator_1368", "Class constructor may not be a generator."), + Did_you_mean_0: b(1369, 3, "Did_you_mean_0_1369", "Did you mean '{0}'?"), + await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module: b(1375, 1, "await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_fi_1375", "'await' expressions are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module."), + _0_was_imported_here: b(1376, 3, "_0_was_imported_here_1376", "'{0}' was imported here."), + _0_was_exported_here: b(1377, 3, "_0_was_exported_here_1377", "'{0}' was exported here."), + Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher: b(1378, 1, "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_n_1378", "Top-level 'await' expressions are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', 'nodenext', or 'preserve', and the 'target' option is set to 'es2017' or higher."), + An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type: b(1379, 1, "An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type_1379", "An import alias cannot reference a declaration that was exported using 'export type'."), + An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type: b(1380, 1, "An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type_1380", "An import alias cannot reference a declaration that was imported using 'import type'."), + Unexpected_token_Did_you_mean_or_rbrace: b(1381, 1, "Unexpected_token_Did_you_mean_or_rbrace_1381", "Unexpected token. Did you mean `{'}'}` or `}`?"), + Unexpected_token_Did_you_mean_or_gt: b(1382, 1, "Unexpected_token_Did_you_mean_or_gt_1382", "Unexpected token. Did you mean `{'>'}` or `>`?"), + Function_type_notation_must_be_parenthesized_when_used_in_a_union_type: b(1385, 1, "Function_type_notation_must_be_parenthesized_when_used_in_a_union_type_1385", "Function type notation must be parenthesized when used in a union type."), + Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type: b(1386, 1, "Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type_1386", "Constructor type notation must be parenthesized when used in a union type."), + Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type: b(1387, 1, "Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type_1387", "Function type notation must be parenthesized when used in an intersection type."), + Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type: b(1388, 1, "Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type_1388", "Constructor type notation must be parenthesized when used in an intersection type."), + _0_is_not_allowed_as_a_variable_declaration_name: b(1389, 1, "_0_is_not_allowed_as_a_variable_declaration_name_1389", "'{0}' is not allowed as a variable declaration name."), + _0_is_not_allowed_as_a_parameter_name: b(1390, 1, "_0_is_not_allowed_as_a_parameter_name_1390", "'{0}' is not allowed as a parameter name."), + An_import_alias_cannot_use_import_type: b(1392, 1, "An_import_alias_cannot_use_import_type_1392", "An import alias cannot use 'import type'"), + Imported_via_0_from_file_1: b(1393, 3, "Imported_via_0_from_file_1_1393", "Imported via {0} from file '{1}'"), + Imported_via_0_from_file_1_with_packageId_2: b(1394, 3, "Imported_via_0_from_file_1_with_packageId_2_1394", "Imported via {0} from file '{1}' with packageId '{2}'"), + Imported_via_0_from_file_1_to_import_importHelpers_as_specified_in_compilerOptions: b(1395, 3, "Imported_via_0_from_file_1_to_import_importHelpers_as_specified_in_compilerOptions_1395", "Imported via {0} from file '{1}' to import 'importHelpers' as specified in compilerOptions"), + Imported_via_0_from_file_1_with_packageId_2_to_import_importHelpers_as_specified_in_compilerOptions: b(1396, 3, "Imported_via_0_from_file_1_with_packageId_2_to_import_importHelpers_as_specified_in_compilerOptions_1396", "Imported via {0} from file '{1}' with packageId '{2}' to import 'importHelpers' as specified in compilerOptions"), + Imported_via_0_from_file_1_to_import_jsx_and_jsxs_factory_functions: b(1397, 3, "Imported_via_0_from_file_1_to_import_jsx_and_jsxs_factory_functions_1397", "Imported via {0} from file '{1}' to import 'jsx' and 'jsxs' factory functions"), + Imported_via_0_from_file_1_with_packageId_2_to_import_jsx_and_jsxs_factory_functions: b(1398, 3, "Imported_via_0_from_file_1_with_packageId_2_to_import_jsx_and_jsxs_factory_functions_1398", "Imported via {0} from file '{1}' with packageId '{2}' to import 'jsx' and 'jsxs' factory functions"), + File_is_included_via_import_here: b(1399, 3, "File_is_included_via_import_here_1399", "File is included via import here."), + Referenced_via_0_from_file_1: b(1400, 3, "Referenced_via_0_from_file_1_1400", "Referenced via '{0}' from file '{1}'"), + File_is_included_via_reference_here: b(1401, 3, "File_is_included_via_reference_here_1401", "File is included via reference here."), + Type_library_referenced_via_0_from_file_1: b(1402, 3, "Type_library_referenced_via_0_from_file_1_1402", "Type library referenced via '{0}' from file '{1}'"), + Type_library_referenced_via_0_from_file_1_with_packageId_2: b(1403, 3, "Type_library_referenced_via_0_from_file_1_with_packageId_2_1403", "Type library referenced via '{0}' from file '{1}' with packageId '{2}'"), + File_is_included_via_type_library_reference_here: b(1404, 3, "File_is_included_via_type_library_reference_here_1404", "File is included via type library reference here."), + Library_referenced_via_0_from_file_1: b(1405, 3, "Library_referenced_via_0_from_file_1_1405", "Library referenced via '{0}' from file '{1}'"), + File_is_included_via_library_reference_here: b(1406, 3, "File_is_included_via_library_reference_here_1406", "File is included via library reference here."), + Matched_by_include_pattern_0_in_1: b(1407, 3, "Matched_by_include_pattern_0_in_1_1407", "Matched by include pattern '{0}' in '{1}'"), + File_is_matched_by_include_pattern_specified_here: b(1408, 3, "File_is_matched_by_include_pattern_specified_here_1408", "File is matched by include pattern specified here."), + Part_of_files_list_in_tsconfig_json: b(1409, 3, "Part_of_files_list_in_tsconfig_json_1409", "Part of 'files' list in tsconfig.json"), + File_is_matched_by_files_list_specified_here: b(1410, 3, "File_is_matched_by_files_list_specified_here_1410", "File is matched by 'files' list specified here."), + Output_from_referenced_project_0_included_because_1_specified: b(1411, 3, "Output_from_referenced_project_0_included_because_1_specified_1411", "Output from referenced project '{0}' included because '{1}' specified"), + Output_from_referenced_project_0_included_because_module_is_specified_as_none: b(1412, 3, "Output_from_referenced_project_0_included_because_module_is_specified_as_none_1412", "Output from referenced project '{0}' included because '--module' is specified as 'none'"), + File_is_output_from_referenced_project_specified_here: b(1413, 3, "File_is_output_from_referenced_project_specified_here_1413", "File is output from referenced project specified here."), + Source_from_referenced_project_0_included_because_1_specified: b(1414, 3, "Source_from_referenced_project_0_included_because_1_specified_1414", "Source from referenced project '{0}' included because '{1}' specified"), + Source_from_referenced_project_0_included_because_module_is_specified_as_none: b(1415, 3, "Source_from_referenced_project_0_included_because_module_is_specified_as_none_1415", "Source from referenced project '{0}' included because '--module' is specified as 'none'"), + File_is_source_from_referenced_project_specified_here: b(1416, 3, "File_is_source_from_referenced_project_specified_here_1416", "File is source from referenced project specified here."), + Entry_point_of_type_library_0_specified_in_compilerOptions: b(1417, 3, "Entry_point_of_type_library_0_specified_in_compilerOptions_1417", "Entry point of type library '{0}' specified in compilerOptions"), + Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1: b(1418, 3, "Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1_1418", "Entry point of type library '{0}' specified in compilerOptions with packageId '{1}'"), + File_is_entry_point_of_type_library_specified_here: b(1419, 3, "File_is_entry_point_of_type_library_specified_here_1419", "File is entry point of type library specified here."), + Entry_point_for_implicit_type_library_0: b(1420, 3, "Entry_point_for_implicit_type_library_0_1420", "Entry point for implicit type library '{0}'"), + Entry_point_for_implicit_type_library_0_with_packageId_1: b(1421, 3, "Entry_point_for_implicit_type_library_0_with_packageId_1_1421", "Entry point for implicit type library '{0}' with packageId '{1}'"), + Library_0_specified_in_compilerOptions: b(1422, 3, "Library_0_specified_in_compilerOptions_1422", "Library '{0}' specified in compilerOptions"), + File_is_library_specified_here: b(1423, 3, "File_is_library_specified_here_1423", "File is library specified here."), + Default_library: b(1424, 3, "Default_library_1424", "Default library"), + Default_library_for_target_0: b(1425, 3, "Default_library_for_target_0_1425", "Default library for target '{0}'"), + File_is_default_library_for_target_specified_here: b(1426, 3, "File_is_default_library_for_target_specified_here_1426", "File is default library for target specified here."), + Root_file_specified_for_compilation: b(1427, 3, "Root_file_specified_for_compilation_1427", "Root file specified for compilation"), + File_is_output_of_project_reference_source_0: b(1428, 3, "File_is_output_of_project_reference_source_0_1428", "File is output of project reference source '{0}'"), + File_redirects_to_file_0: b(1429, 3, "File_redirects_to_file_0_1429", "File redirects to file '{0}'"), + The_file_is_in_the_program_because_Colon: b(1430, 3, "The_file_is_in_the_program_because_Colon_1430", "The file is in the program because:"), + for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module: b(1431, 1, "for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_1431", "'for await' loops are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module."), + Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher: b(1432, 1, "Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_nod_1432", "Top-level 'for await' loops are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', 'nodenext', or 'preserve', and the 'target' option is set to 'es2017' or higher."), + Neither_decorators_nor_modifiers_may_be_applied_to_this_parameters: b(1433, 1, "Neither_decorators_nor_modifiers_may_be_applied_to_this_parameters_1433", "Neither decorators nor modifiers may be applied to 'this' parameters."), + Unexpected_keyword_or_identifier: b(1434, 1, "Unexpected_keyword_or_identifier_1434", "Unexpected keyword or identifier."), + Unknown_keyword_or_identifier_Did_you_mean_0: b(1435, 1, "Unknown_keyword_or_identifier_Did_you_mean_0_1435", "Unknown keyword or identifier. Did you mean '{0}'?"), + Decorators_must_precede_the_name_and_all_keywords_of_property_declarations: b(1436, 1, "Decorators_must_precede_the_name_and_all_keywords_of_property_declarations_1436", "Decorators must precede the name and all keywords of property declarations."), + Namespace_must_be_given_a_name: b(1437, 1, "Namespace_must_be_given_a_name_1437", "Namespace must be given a name."), + Interface_must_be_given_a_name: b(1438, 1, "Interface_must_be_given_a_name_1438", "Interface must be given a name."), + Type_alias_must_be_given_a_name: b(1439, 1, "Type_alias_must_be_given_a_name_1439", "Type alias must be given a name."), + Variable_declaration_not_allowed_at_this_location: b(1440, 1, "Variable_declaration_not_allowed_at_this_location_1440", "Variable declaration not allowed at this location."), + Cannot_start_a_function_call_in_a_type_annotation: b(1441, 1, "Cannot_start_a_function_call_in_a_type_annotation_1441", "Cannot start a function call in a type annotation."), + Expected_for_property_initializer: b(1442, 1, "Expected_for_property_initializer_1442", "Expected '=' for property initializer."), + Module_declaration_names_may_only_use_or_quoted_strings: b(1443, 1, "Module_declaration_names_may_only_use_or_quoted_strings_1443", `Module declaration names may only use ' or " quoted strings.`), + _0_resolves_to_a_type_only_declaration_and_must_be_re_exported_using_a_type_only_re_export_when_1_is_enabled: b(1448, 1, "_0_resolves_to_a_type_only_declaration_and_must_be_re_exported_using_a_type_only_re_export_when_1_is_1448", "'{0}' resolves to a type-only declaration and must be re-exported using a type-only re-export when '{1}' is enabled."), + Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed: b(1449, 3, "Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed_1449", "Preserve unused imported values in the JavaScript output that would otherwise be removed."), + Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_set_of_attributes_as_arguments: b(1450, 3, "Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_set_of_attributes_as_arguments_1450", "Dynamic imports can only accept a module specifier and an optional set of attributes as arguments"), + Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression: b(1451, 1, "Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member__1451", "Private identifiers are only allowed in class bodies and may only be used as part of a class member declaration, property access, or on the left-hand-side of an 'in' expression"), + resolution_mode_should_be_either_require_or_import: b(1453, 1, "resolution_mode_should_be_either_require_or_import_1453", "`resolution-mode` should be either `require` or `import`."), + resolution_mode_can_only_be_set_for_type_only_imports: b(1454, 1, "resolution_mode_can_only_be_set_for_type_only_imports_1454", "`resolution-mode` can only be set for type-only imports."), + resolution_mode_is_the_only_valid_key_for_type_import_assertions: b(1455, 1, "resolution_mode_is_the_only_valid_key_for_type_import_assertions_1455", "`resolution-mode` is the only valid key for type import assertions."), + Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require: b(1456, 1, "Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require_1456", "Type import assertions should have exactly one key - `resolution-mode` - with value `import` or `require`."), + Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk: b(1457, 3, "Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk_1457", "Matched by default include pattern '**/*'"), + File_is_ECMAScript_module_because_0_has_field_type_with_value_module: b(1458, 3, "File_is_ECMAScript_module_because_0_has_field_type_with_value_module_1458", `File is ECMAScript module because '{0}' has field "type" with value "module"`), + File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module: b(1459, 3, "File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module_1459", `File is CommonJS module because '{0}' has field "type" whose value is not "module"`), + File_is_CommonJS_module_because_0_does_not_have_field_type: b(1460, 3, "File_is_CommonJS_module_because_0_does_not_have_field_type_1460", `File is CommonJS module because '{0}' does not have field "type"`), + File_is_CommonJS_module_because_package_json_was_not_found: b(1461, 3, "File_is_CommonJS_module_because_package_json_was_not_found_1461", "File is CommonJS module because 'package.json' was not found"), + resolution_mode_is_the_only_valid_key_for_type_import_attributes: b(1463, 1, "resolution_mode_is_the_only_valid_key_for_type_import_attributes_1463", "'resolution-mode' is the only valid key for type import attributes."), + Type_import_attributes_should_have_exactly_one_key_resolution_mode_with_value_import_or_require: b(1464, 1, "Type_import_attributes_should_have_exactly_one_key_resolution_mode_with_value_import_or_require_1464", "Type import attributes should have exactly one key - 'resolution-mode' - with value 'import' or 'require'."), + The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output: b(1470, 1, "The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output_1470", "The 'import.meta' meta-property is not allowed in files which will build into CommonJS output."), + Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_with_require_Use_an_ECMAScript_import_instead: b(1471, 1, "Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_c_1471", "Module '{0}' cannot be imported using this construct. The specifier only resolves to an ES module, which cannot be imported with 'require'. Use an ECMAScript import instead."), + catch_or_finally_expected: b(1472, 1, "catch_or_finally_expected_1472", "'catch' or 'finally' expected."), + An_import_declaration_can_only_be_used_at_the_top_level_of_a_module: b(1473, 1, "An_import_declaration_can_only_be_used_at_the_top_level_of_a_module_1473", "An import declaration can only be used at the top level of a module."), + An_export_declaration_can_only_be_used_at_the_top_level_of_a_module: b(1474, 1, "An_export_declaration_can_only_be_used_at_the_top_level_of_a_module_1474", "An export declaration can only be used at the top level of a module."), + Control_what_method_is_used_to_detect_module_format_JS_files: b(1475, 3, "Control_what_method_is_used_to_detect_module_format_JS_files_1475", "Control what method is used to detect module-format JS files."), + auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node16_as_modules: b(1476, 3, "auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_w_1476", '"auto": Treat files with imports, exports, import.meta, jsx (with jsx: react-jsx), or esm format (with module: node16+) as modules.'), + An_instantiation_expression_cannot_be_followed_by_a_property_access: b(1477, 1, "An_instantiation_expression_cannot_be_followed_by_a_property_access_1477", "An instantiation expression cannot be followed by a property access."), + Identifier_or_string_literal_expected: b(1478, 1, "Identifier_or_string_literal_expected_1478", "Identifier or string literal expected."), + The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_referenced_file_is_an_ECMAScript_module_and_cannot_be_imported_with_require_Consider_writing_a_dynamic_import_0_call_instead: b(1479, 1, "The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_reference_1479", `The current file is a CommonJS module whose imports will produce 'require' calls; however, the referenced file is an ECMAScript module and cannot be imported with 'require'. Consider writing a dynamic 'import("{0}")' call instead.`), + To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_package_json_file_with_type_Colon_module: b(1480, 3, "To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_packag_1480", 'To convert this file to an ECMAScript module, change its file extension to \'{0}\' or create a local package.json file with `{ "type": "module" }`.'), + To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Colon_module_to_1: b(1481, 3, "To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Co_1481", `To convert this file to an ECMAScript module, change its file extension to '{0}', or add the field \`"type": "module"\` to '{1}'.`), + To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0: b(1482, 3, "To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0_1482", 'To convert this file to an ECMAScript module, add the field `"type": "module"` to \'{0}\'.'), + To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module: b(1483, 3, "To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module_1483", 'To convert this file to an ECMAScript module, create a local package.json file with `{ "type": "module" }`.'), + _0_is_a_type_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled: b(1484, 1, "_0_is_a_type_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled_1484", "'{0}' is a type and must be imported using a type-only import when 'verbatimModuleSyntax' is enabled."), + _0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled: b(1485, 1, "_0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_verbatimMo_1485", "'{0}' resolves to a type-only declaration and must be imported using a type-only import when 'verbatimModuleSyntax' is enabled."), + Decorator_used_before_export_here: b(1486, 1, "Decorator_used_before_export_here_1486", "Decorator used before 'export' here."), + Octal_escape_sequences_are_not_allowed_Use_the_syntax_0: b(1487, 1, "Octal_escape_sequences_are_not_allowed_Use_the_syntax_0_1487", "Octal escape sequences are not allowed. Use the syntax '{0}'."), + Escape_sequence_0_is_not_allowed: b(1488, 1, "Escape_sequence_0_is_not_allowed_1488", "Escape sequence '{0}' is not allowed."), + Decimals_with_leading_zeros_are_not_allowed: b(1489, 1, "Decimals_with_leading_zeros_are_not_allowed_1489", "Decimals with leading zeros are not allowed."), + File_appears_to_be_binary: b(1490, 1, "File_appears_to_be_binary_1490", "File appears to be binary."), + _0_modifier_cannot_appear_on_a_using_declaration: b(1491, 1, "_0_modifier_cannot_appear_on_a_using_declaration_1491", "'{0}' modifier cannot appear on a 'using' declaration."), + _0_declarations_may_not_have_binding_patterns: b(1492, 1, "_0_declarations_may_not_have_binding_patterns_1492", "'{0}' declarations may not have binding patterns."), + The_left_hand_side_of_a_for_in_statement_cannot_be_a_using_declaration: b(1493, 1, "The_left_hand_side_of_a_for_in_statement_cannot_be_a_using_declaration_1493", "The left-hand side of a 'for...in' statement cannot be a 'using' declaration."), + The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration: b(1494, 1, "The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration_1494", "The left-hand side of a 'for...in' statement cannot be an 'await using' declaration."), + _0_modifier_cannot_appear_on_an_await_using_declaration: b(1495, 1, "_0_modifier_cannot_appear_on_an_await_using_declaration_1495", "'{0}' modifier cannot appear on an 'await using' declaration."), + Identifier_string_literal_or_number_literal_expected: b(1496, 1, "Identifier_string_literal_or_number_literal_expected_1496", "Identifier, string literal, or number literal expected."), + Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator: b(1497, 1, "Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator_1497", "Expression must be enclosed in parentheses to be used as a decorator."), + Invalid_syntax_in_decorator: b(1498, 1, "Invalid_syntax_in_decorator_1498", "Invalid syntax in decorator."), + Unknown_regular_expression_flag: b(1499, 1, "Unknown_regular_expression_flag_1499", "Unknown regular expression flag."), + Duplicate_regular_expression_flag: b(1500, 1, "Duplicate_regular_expression_flag_1500", "Duplicate regular expression flag."), + This_regular_expression_flag_is_only_available_when_targeting_0_or_later: b(1501, 1, "This_regular_expression_flag_is_only_available_when_targeting_0_or_later_1501", "This regular expression flag is only available when targeting '{0}' or later."), + The_Unicode_u_flag_and_the_Unicode_Sets_v_flag_cannot_be_set_simultaneously: b(1502, 1, "The_Unicode_u_flag_and_the_Unicode_Sets_v_flag_cannot_be_set_simultaneously_1502", "The Unicode (u) flag and the Unicode Sets (v) flag cannot be set simultaneously."), + Named_capturing_groups_are_only_available_when_targeting_ES2018_or_later: b(1503, 1, "Named_capturing_groups_are_only_available_when_targeting_ES2018_or_later_1503", "Named capturing groups are only available when targeting 'ES2018' or later."), + Subpattern_flags_must_be_present_when_there_is_a_minus_sign: b(1504, 1, "Subpattern_flags_must_be_present_when_there_is_a_minus_sign_1504", "Subpattern flags must be present when there is a minus sign."), + Incomplete_quantifier_Digit_expected: b(1505, 1, "Incomplete_quantifier_Digit_expected_1505", "Incomplete quantifier. Digit expected."), + Numbers_out_of_order_in_quantifier: b(1506, 1, "Numbers_out_of_order_in_quantifier_1506", "Numbers out of order in quantifier."), + There_is_nothing_available_for_repetition: b(1507, 1, "There_is_nothing_available_for_repetition_1507", "There is nothing available for repetition."), + Unexpected_0_Did_you_mean_to_escape_it_with_backslash: b(1508, 1, "Unexpected_0_Did_you_mean_to_escape_it_with_backslash_1508", "Unexpected '{0}'. Did you mean to escape it with backslash?"), + This_regular_expression_flag_cannot_be_toggled_within_a_subpattern: b(1509, 1, "This_regular_expression_flag_cannot_be_toggled_within_a_subpattern_1509", "This regular expression flag cannot be toggled within a subpattern."), + k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets: b(1510, 1, "k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets_1510", "'\\k' must be followed by a capturing group name enclosed in angle brackets."), + q_is_only_available_inside_character_class: b(1511, 1, "q_is_only_available_inside_character_class_1511", "'\\q' is only available inside character class."), + c_must_be_followed_by_an_ASCII_letter: b(1512, 1, "c_must_be_followed_by_an_ASCII_letter_1512", "'\\c' must be followed by an ASCII letter."), + Undetermined_character_escape: b(1513, 1, "Undetermined_character_escape_1513", "Undetermined character escape."), + Expected_a_capturing_group_name: b(1514, 1, "Expected_a_capturing_group_name_1514", "Expected a capturing group name."), + Named_capturing_groups_with_the_same_name_must_be_mutually_exclusive_to_each_other: b(1515, 1, "Named_capturing_groups_with_the_same_name_must_be_mutually_exclusive_to_each_other_1515", "Named capturing groups with the same name must be mutually exclusive to each other."), + A_character_class_range_must_not_be_bounded_by_another_character_class: b(1516, 1, "A_character_class_range_must_not_be_bounded_by_another_character_class_1516", "A character class range must not be bounded by another character class."), + Range_out_of_order_in_character_class: b(1517, 1, "Range_out_of_order_in_character_class_1517", "Range out of order in character class."), + Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class: b(1518, 1, "Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_characte_1518", "Anything that would possibly match more than a single character is invalid inside a negated character class."), + Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead: b(1519, 1, "Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead_1519", "Operators must not be mixed within a character class. Wrap it in a nested class instead."), + Expected_a_class_set_operand: b(1520, 1, "Expected_a_class_set_operand_1520", "Expected a class set operand."), + q_must_be_followed_by_string_alternatives_enclosed_in_braces: b(1521, 1, "q_must_be_followed_by_string_alternatives_enclosed_in_braces_1521", "'\\q' must be followed by string alternatives enclosed in braces."), + A_character_class_must_not_contain_a_reserved_double_punctuator_Did_you_mean_to_escape_it_with_backslash: b(1522, 1, "A_character_class_must_not_contain_a_reserved_double_punctuator_Did_you_mean_to_escape_it_with_backs_1522", "A character class must not contain a reserved double punctuator. Did you mean to escape it with backslash?"), + Expected_a_Unicode_property_name: b(1523, 1, "Expected_a_Unicode_property_name_1523", "Expected a Unicode property name."), + Unknown_Unicode_property_name: b(1524, 1, "Unknown_Unicode_property_name_1524", "Unknown Unicode property name."), + Expected_a_Unicode_property_value: b(1525, 1, "Expected_a_Unicode_property_value_1525", "Expected a Unicode property value."), + Unknown_Unicode_property_value: b(1526, 1, "Unknown_Unicode_property_value_1526", "Unknown Unicode property value."), + Expected_a_Unicode_property_name_or_value: b(1527, 1, "Expected_a_Unicode_property_name_or_value_1527", "Expected a Unicode property name or value."), + Any_Unicode_property_that_would_possibly_match_more_than_a_single_character_is_only_available_when_the_Unicode_Sets_v_flag_is_set: b(1528, 1, "Any_Unicode_property_that_would_possibly_match_more_than_a_single_character_is_only_available_when_t_1528", "Any Unicode property that would possibly match more than a single character is only available when the Unicode Sets (v) flag is set."), + Unknown_Unicode_property_name_or_value: b(1529, 1, "Unknown_Unicode_property_name_or_value_1529", "Unknown Unicode property name or value."), + Unicode_property_value_expressions_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set: b(1530, 1, "Unicode_property_value_expressions_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v__1530", "Unicode property value expressions are only available when the Unicode (u) flag or the Unicode Sets (v) flag is set."), + _0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces: b(1531, 1, "_0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces_1531", "'\\{0}' must be followed by a Unicode property value expression enclosed in braces."), + There_is_no_capturing_group_named_0_in_this_regular_expression: b(1532, 1, "There_is_no_capturing_group_named_0_in_this_regular_expression_1532", "There is no capturing group named '{0}' in this regular expression."), + This_backreference_refers_to_a_group_that_does_not_exist_There_are_only_0_capturing_groups_in_this_regular_expression: b(1533, 1, "This_backreference_refers_to_a_group_that_does_not_exist_There_are_only_0_capturing_groups_in_this_r_1533", "This backreference refers to a group that does not exist. There are only {0} capturing groups in this regular expression."), + This_backreference_refers_to_a_group_that_does_not_exist_There_are_no_capturing_groups_in_this_regular_expression: b(1534, 1, "This_backreference_refers_to_a_group_that_does_not_exist_There_are_no_capturing_groups_in_this_regul_1534", "This backreference refers to a group that does not exist. There are no capturing groups in this regular expression."), + This_character_cannot_be_escaped_in_a_regular_expression: b(1535, 1, "This_character_cannot_be_escaped_in_a_regular_expression_1535", "This character cannot be escaped in a regular expression."), + Octal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class_If_this_was_intended_as_an_escape_sequence_use_the_syntax_0_instead: b(1536, 1, "Octal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class_If_this_was_intended__1536", "Octal escape sequences and backreferences are not allowed in a character class. If this was intended as an escape sequence, use the syntax '{0}' instead."), + Decimal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class: b(1537, 1, "Decimal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class_1537", "Decimal escape sequences and backreferences are not allowed in a character class."), + Unicode_escape_sequences_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set: b(1538, 1, "Unicode_escape_sequences_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_se_1538", "Unicode escape sequences are only available when the Unicode (u) flag or the Unicode Sets (v) flag is set."), + A_bigint_literal_cannot_be_used_as_a_property_name: b(1539, 1, "A_bigint_literal_cannot_be_used_as_a_property_name_1539", "A 'bigint' literal cannot be used as a property name."), + A_namespace_declaration_should_not_be_declared_using_the_module_keyword_Please_use_the_namespace_keyword_instead: b( + 1540, + 2, + "A_namespace_declaration_should_not_be_declared_using_the_module_keyword_Please_use_the_namespace_key_1540", + "A 'namespace' declaration should not be declared using the 'module' keyword. Please use the 'namespace' keyword instead.", + /*reportsUnnecessary*/ + void 0, + /*elidedInCompatabilityPyramid*/ + void 0, + /*reportsDeprecated*/ + !0 + ), + Type_only_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute: b(1541, 1, "Type_only_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribut_1541", "Type-only import of an ECMAScript module from a CommonJS module must have a 'resolution-mode' attribute."), + Type_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute: b(1542, 1, "Type_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute_1542", "Type import of an ECMAScript module from a CommonJS module must have a 'resolution-mode' attribute."), + Importing_a_JSON_file_into_an_ECMAScript_module_requires_a_type_Colon_json_import_attribute_when_module_is_set_to_0: b(1543, 1, "Importing_a_JSON_file_into_an_ECMAScript_module_requires_a_type_Colon_json_import_attribute_when_mod_1543", `Importing a JSON file into an ECMAScript module requires a 'type: "json"' import attribute when 'module' is set to '{0}'.`), + Named_imports_from_a_JSON_file_into_an_ECMAScript_module_are_not_allowed_when_module_is_set_to_0: b(1544, 1, "Named_imports_from_a_JSON_file_into_an_ECMAScript_module_are_not_allowed_when_module_is_set_to_0_1544", "Named imports from a JSON file into an ECMAScript module are not allowed when 'module' is set to '{0}'."), + using_declarations_are_not_allowed_in_ambient_contexts: b(1545, 1, "using_declarations_are_not_allowed_in_ambient_contexts_1545", "'using' declarations are not allowed in ambient contexts."), + await_using_declarations_are_not_allowed_in_ambient_contexts: b(1546, 1, "await_using_declarations_are_not_allowed_in_ambient_contexts_1546", "'await using' declarations are not allowed in ambient contexts."), + The_types_of_0_are_incompatible_between_these_types: b(2200, 1, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."), + The_types_returned_by_0_are_incompatible_between_these_types: b(2201, 1, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."), + Call_signature_return_types_0_and_1_are_incompatible: b( + 2202, + 1, + "Call_signature_return_types_0_and_1_are_incompatible_2202", + "Call signature return types '{0}' and '{1}' are incompatible.", + /*reportsUnnecessary*/ + void 0, + /*elidedInCompatabilityPyramid*/ + !0 + ), + Construct_signature_return_types_0_and_1_are_incompatible: b( + 2203, + 1, + "Construct_signature_return_types_0_and_1_are_incompatible_2203", + "Construct signature return types '{0}' and '{1}' are incompatible.", + /*reportsUnnecessary*/ + void 0, + /*elidedInCompatabilityPyramid*/ + !0 + ), + Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: b( + 2204, + 1, + "Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2204", + "Call signatures with no arguments have incompatible return types '{0}' and '{1}'.", + /*reportsUnnecessary*/ + void 0, + /*elidedInCompatabilityPyramid*/ + !0 + ), + Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: b( + 2205, + 1, + "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", + "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", + /*reportsUnnecessary*/ + void 0, + /*elidedInCompatabilityPyramid*/ + !0 + ), + The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: b(2206, 1, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."), + The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: b(2207, 1, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."), + This_type_parameter_might_need_an_extends_0_constraint: b(2208, 1, "This_type_parameter_might_need_an_extends_0_constraint_2208", "This type parameter might need an `extends {0}` constraint."), + The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: b(2209, 1, "The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_roo_2209", "The project root is ambiguous, but is required to resolve export map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."), + The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: b(2210, 1, "The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_roo_2210", "The project root is ambiguous, but is required to resolve import map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."), + Add_extends_constraint: b(2211, 3, "Add_extends_constraint_2211", "Add `extends` constraint."), + Add_extends_constraint_to_all_type_parameters: b(2212, 3, "Add_extends_constraint_to_all_type_parameters_2212", "Add `extends` constraint to all type parameters"), + Duplicate_identifier_0: b(2300, 1, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."), + Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: b(2301, 1, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."), + Static_members_cannot_reference_class_type_parameters: b(2302, 1, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."), + Circular_definition_of_import_alias_0: b(2303, 1, "Circular_definition_of_import_alias_0_2303", "Circular definition of import alias '{0}'."), + Cannot_find_name_0: b(2304, 1, "Cannot_find_name_0_2304", "Cannot find name '{0}'."), + Module_0_has_no_exported_member_1: b(2305, 1, "Module_0_has_no_exported_member_1_2305", "Module '{0}' has no exported member '{1}'."), + File_0_is_not_a_module: b(2306, 1, "File_0_is_not_a_module_2306", "File '{0}' is not a module."), + Cannot_find_module_0_or_its_corresponding_type_declarations: b(2307, 1, "Cannot_find_module_0_or_its_corresponding_type_declarations_2307", "Cannot find module '{0}' or its corresponding type declarations."), + Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity: b(2308, 1, "Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambig_2308", "Module {0} has already exported a member named '{1}'. Consider explicitly re-exporting to resolve the ambiguity."), + An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements: b(2309, 1, "An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements_2309", "An export assignment cannot be used in a module with other exported elements."), + Type_0_recursively_references_itself_as_a_base_type: b(2310, 1, "Type_0_recursively_references_itself_as_a_base_type_2310", "Type '{0}' recursively references itself as a base type."), + Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function: b(2311, 1, "Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function_2311", "Cannot find name '{0}'. Did you mean to write this in an async function?"), + An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members: b(2312, 1, "An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_me_2312", "An interface can only extend an object type or intersection of object types with statically known members."), + Type_parameter_0_has_a_circular_constraint: b(2313, 1, "Type_parameter_0_has_a_circular_constraint_2313", "Type parameter '{0}' has a circular constraint."), + Generic_type_0_requires_1_type_argument_s: b(2314, 1, "Generic_type_0_requires_1_type_argument_s_2314", "Generic type '{0}' requires {1} type argument(s)."), + Type_0_is_not_generic: b(2315, 1, "Type_0_is_not_generic_2315", "Type '{0}' is not generic."), + Global_type_0_must_be_a_class_or_interface_type: b(2316, 1, "Global_type_0_must_be_a_class_or_interface_type_2316", "Global type '{0}' must be a class or interface type."), + Global_type_0_must_have_1_type_parameter_s: b(2317, 1, "Global_type_0_must_have_1_type_parameter_s_2317", "Global type '{0}' must have {1} type parameter(s)."), + Cannot_find_global_type_0: b(2318, 1, "Cannot_find_global_type_0_2318", "Cannot find global type '{0}'."), + Named_property_0_of_types_1_and_2_are_not_identical: b(2319, 1, "Named_property_0_of_types_1_and_2_are_not_identical_2319", "Named property '{0}' of types '{1}' and '{2}' are not identical."), + Interface_0_cannot_simultaneously_extend_types_1_and_2: b(2320, 1, "Interface_0_cannot_simultaneously_extend_types_1_and_2_2320", "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}'."), + Excessive_stack_depth_comparing_types_0_and_1: b(2321, 1, "Excessive_stack_depth_comparing_types_0_and_1_2321", "Excessive stack depth comparing types '{0}' and '{1}'."), + Type_0_is_not_assignable_to_type_1: b(2322, 1, "Type_0_is_not_assignable_to_type_1_2322", "Type '{0}' is not assignable to type '{1}'."), + Cannot_redeclare_exported_variable_0: b(2323, 1, "Cannot_redeclare_exported_variable_0_2323", "Cannot redeclare exported variable '{0}'."), + Property_0_is_missing_in_type_1: b(2324, 1, "Property_0_is_missing_in_type_1_2324", "Property '{0}' is missing in type '{1}'."), + Property_0_is_private_in_type_1_but_not_in_type_2: b(2325, 1, "Property_0_is_private_in_type_1_but_not_in_type_2_2325", "Property '{0}' is private in type '{1}' but not in type '{2}'."), + Types_of_property_0_are_incompatible: b(2326, 1, "Types_of_property_0_are_incompatible_2326", "Types of property '{0}' are incompatible."), + Property_0_is_optional_in_type_1_but_required_in_type_2: b(2327, 1, "Property_0_is_optional_in_type_1_but_required_in_type_2_2327", "Property '{0}' is optional in type '{1}' but required in type '{2}'."), + Types_of_parameters_0_and_1_are_incompatible: b(2328, 1, "Types_of_parameters_0_and_1_are_incompatible_2328", "Types of parameters '{0}' and '{1}' are incompatible."), + Index_signature_for_type_0_is_missing_in_type_1: b(2329, 1, "Index_signature_for_type_0_is_missing_in_type_1_2329", "Index signature for type '{0}' is missing in type '{1}'."), + _0_and_1_index_signatures_are_incompatible: b(2330, 1, "_0_and_1_index_signatures_are_incompatible_2330", "'{0}' and '{1}' index signatures are incompatible."), + this_cannot_be_referenced_in_a_module_or_namespace_body: b(2331, 1, "this_cannot_be_referenced_in_a_module_or_namespace_body_2331", "'this' cannot be referenced in a module or namespace body."), + this_cannot_be_referenced_in_current_location: b(2332, 1, "this_cannot_be_referenced_in_current_location_2332", "'this' cannot be referenced in current location."), + this_cannot_be_referenced_in_a_static_property_initializer: b(2334, 1, "this_cannot_be_referenced_in_a_static_property_initializer_2334", "'this' cannot be referenced in a static property initializer."), + super_can_only_be_referenced_in_a_derived_class: b(2335, 1, "super_can_only_be_referenced_in_a_derived_class_2335", "'super' can only be referenced in a derived class."), + super_cannot_be_referenced_in_constructor_arguments: b(2336, 1, "super_cannot_be_referenced_in_constructor_arguments_2336", "'super' cannot be referenced in constructor arguments."), + Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors: b(2337, 1, "Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors_2337", "Super calls are not permitted outside constructors or in nested functions inside constructors."), + super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: b(2338, 1, "super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_der_2338", "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class."), + Property_0_does_not_exist_on_type_1: b(2339, 1, "Property_0_does_not_exist_on_type_1_2339", "Property '{0}' does not exist on type '{1}'."), + Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword: b(2340, 1, "Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword_2340", "Only public and protected methods of the base class are accessible via the 'super' keyword."), + Property_0_is_private_and_only_accessible_within_class_1: b(2341, 1, "Property_0_is_private_and_only_accessible_within_class_1_2341", "Property '{0}' is private and only accessible within class '{1}'."), + This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0: b(2343, 1, "This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_ve_2343", "This syntax requires an imported helper named '{1}' which does not exist in '{0}'. Consider upgrading your version of '{0}'."), + Type_0_does_not_satisfy_the_constraint_1: b(2344, 1, "Type_0_does_not_satisfy_the_constraint_1_2344", "Type '{0}' does not satisfy the constraint '{1}'."), + Argument_of_type_0_is_not_assignable_to_parameter_of_type_1: b(2345, 1, "Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_2345", "Argument of type '{0}' is not assignable to parameter of type '{1}'."), + Call_target_does_not_contain_any_signatures: b(2346, 1, "Call_target_does_not_contain_any_signatures_2346", "Call target does not contain any signatures."), + Untyped_function_calls_may_not_accept_type_arguments: b(2347, 1, "Untyped_function_calls_may_not_accept_type_arguments_2347", "Untyped function calls may not accept type arguments."), + Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: b(2348, 1, "Value_of_type_0_is_not_callable_Did_you_mean_to_include_new_2348", "Value of type '{0}' is not callable. Did you mean to include 'new'?"), + This_expression_is_not_callable: b(2349, 1, "This_expression_is_not_callable_2349", "This expression is not callable."), + Only_a_void_function_can_be_called_with_the_new_keyword: b(2350, 1, "Only_a_void_function_can_be_called_with_the_new_keyword_2350", "Only a void function can be called with the 'new' keyword."), + This_expression_is_not_constructable: b(2351, 1, "This_expression_is_not_constructable_2351", "This expression is not constructable."), + Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first: b(2352, 1, "Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the__2352", "Conversion of type '{0}' to type '{1}' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first."), + Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1: b(2353, 1, "Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1_2353", "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'."), + This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found: b(2354, 1, "This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found_2354", "This syntax requires an imported helper but module '{0}' cannot be found."), + A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value: b(2355, 1, "A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value_2355", "A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value."), + An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type: b(2356, 1, "An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type_2356", "An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type."), + The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access: b(2357, 1, "The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access_2357", "The operand of an increment or decrement operator must be a variable or a property access."), + The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: b(2358, 1, "The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_paramete_2358", "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter."), + The_right_hand_side_of_an_instanceof_expression_must_be_either_of_type_any_a_class_function_or_other_type_assignable_to_the_Function_interface_type_or_an_object_type_with_a_Symbol_hasInstance_method: b(2359, 1, "The_right_hand_side_of_an_instanceof_expression_must_be_either_of_type_any_a_class_function_or_other_2359", "The right-hand side of an 'instanceof' expression must be either of type 'any', a class, function, or other type assignable to the 'Function' interface type, or an object type with a 'Symbol.hasInstance' method."), + The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: b(2362, 1, "The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2362", "The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."), + The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: b(2363, 1, "The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2363", "The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."), + The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access: b(2364, 1, "The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access_2364", "The left-hand side of an assignment expression must be a variable or a property access."), + Operator_0_cannot_be_applied_to_types_1_and_2: b(2365, 1, "Operator_0_cannot_be_applied_to_types_1_and_2_2365", "Operator '{0}' cannot be applied to types '{1}' and '{2}'."), + Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined: b(2366, 1, "Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined_2366", "Function lacks ending return statement and return type does not include 'undefined'."), + This_comparison_appears_to_be_unintentional_because_the_types_0_and_1_have_no_overlap: b(2367, 1, "This_comparison_appears_to_be_unintentional_because_the_types_0_and_1_have_no_overlap_2367", "This comparison appears to be unintentional because the types '{0}' and '{1}' have no overlap."), + Type_parameter_name_cannot_be_0: b(2368, 1, "Type_parameter_name_cannot_be_0_2368", "Type parameter name cannot be '{0}'."), + A_parameter_property_is_only_allowed_in_a_constructor_implementation: b(2369, 1, "A_parameter_property_is_only_allowed_in_a_constructor_implementation_2369", "A parameter property is only allowed in a constructor implementation."), + A_rest_parameter_must_be_of_an_array_type: b(2370, 1, "A_rest_parameter_must_be_of_an_array_type_2370", "A rest parameter must be of an array type."), + A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation: b(2371, 1, "A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation_2371", "A parameter initializer is only allowed in a function or constructor implementation."), + Parameter_0_cannot_reference_itself: b(2372, 1, "Parameter_0_cannot_reference_itself_2372", "Parameter '{0}' cannot reference itself."), + Parameter_0_cannot_reference_identifier_1_declared_after_it: b(2373, 1, "Parameter_0_cannot_reference_identifier_1_declared_after_it_2373", "Parameter '{0}' cannot reference identifier '{1}' declared after it."), + Duplicate_index_signature_for_type_0: b(2374, 1, "Duplicate_index_signature_for_type_0_2374", "Duplicate index signature for type '{0}'."), + Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties: b(2375, 1, "Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefi_2375", "Type '{0}' is not assignable to type '{1}' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties."), + A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_class_contains_initialized_properties_parameter_properties_or_private_identifiers: b(2376, 1, "A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_2376", "A 'super' call must be the first statement in the constructor to refer to 'super' or 'this' when a derived class contains initialized properties, parameter properties, or private identifiers."), + Constructors_for_derived_classes_must_contain_a_super_call: b(2377, 1, "Constructors_for_derived_classes_must_contain_a_super_call_2377", "Constructors for derived classes must contain a 'super' call."), + A_get_accessor_must_return_a_value: b(2378, 1, "A_get_accessor_must_return_a_value_2378", "A 'get' accessor must return a value."), + Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties: b(2379, 1, "Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_tr_2379", "Argument of type '{0}' is not assignable to parameter of type '{1}' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties."), + Overload_signatures_must_all_be_exported_or_non_exported: b(2383, 1, "Overload_signatures_must_all_be_exported_or_non_exported_2383", "Overload signatures must all be exported or non-exported."), + Overload_signatures_must_all_be_ambient_or_non_ambient: b(2384, 1, "Overload_signatures_must_all_be_ambient_or_non_ambient_2384", "Overload signatures must all be ambient or non-ambient."), + Overload_signatures_must_all_be_public_private_or_protected: b(2385, 1, "Overload_signatures_must_all_be_public_private_or_protected_2385", "Overload signatures must all be public, private or protected."), + Overload_signatures_must_all_be_optional_or_required: b(2386, 1, "Overload_signatures_must_all_be_optional_or_required_2386", "Overload signatures must all be optional or required."), + Function_overload_must_be_static: b(2387, 1, "Function_overload_must_be_static_2387", "Function overload must be static."), + Function_overload_must_not_be_static: b(2388, 1, "Function_overload_must_not_be_static_2388", "Function overload must not be static."), + Function_implementation_name_must_be_0: b(2389, 1, "Function_implementation_name_must_be_0_2389", "Function implementation name must be '{0}'."), + Constructor_implementation_is_missing: b(2390, 1, "Constructor_implementation_is_missing_2390", "Constructor implementation is missing."), + Function_implementation_is_missing_or_not_immediately_following_the_declaration: b(2391, 1, "Function_implementation_is_missing_or_not_immediately_following_the_declaration_2391", "Function implementation is missing or not immediately following the declaration."), + Multiple_constructor_implementations_are_not_allowed: b(2392, 1, "Multiple_constructor_implementations_are_not_allowed_2392", "Multiple constructor implementations are not allowed."), + Duplicate_function_implementation: b(2393, 1, "Duplicate_function_implementation_2393", "Duplicate function implementation."), + This_overload_signature_is_not_compatible_with_its_implementation_signature: b(2394, 1, "This_overload_signature_is_not_compatible_with_its_implementation_signature_2394", "This overload signature is not compatible with its implementation signature."), + Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local: b(2395, 1, "Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local_2395", "Individual declarations in merged declaration '{0}' must be all exported or all local."), + Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters: b(2396, 1, "Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters_2396", "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters."), + Declaration_name_conflicts_with_built_in_global_identifier_0: b(2397, 1, "Declaration_name_conflicts_with_built_in_global_identifier_0_2397", "Declaration name conflicts with built-in global identifier '{0}'."), + constructor_cannot_be_used_as_a_parameter_property_name: b(2398, 1, "constructor_cannot_be_used_as_a_parameter_property_name_2398", "'constructor' cannot be used as a parameter property name."), + Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: b(2399, 1, "Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference_2399", "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference."), + Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: b(2400, 1, "Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference_2400", "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference."), + A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_initialized_properties_parameter_properties_or_private_identifiers: b(2401, 1, "A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_in_2401", "A 'super' call must be a root-level statement within a constructor of a derived class that contains initialized properties, parameter properties, or private identifiers."), + Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: b(2402, 1, "Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference_2402", "Expression resolves to '_super' that compiler uses to capture base class reference."), + Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: b(2403, 1, "Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_t_2403", "Subsequent variable declarations must have the same type. Variable '{0}' must be of type '{1}', but here has type '{2}'."), + The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation: b(2404, 1, "The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation_2404", "The left-hand side of a 'for...in' statement cannot use a type annotation."), + The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any: b(2405, 1, "The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any_2405", "The left-hand side of a 'for...in' statement must be of type 'string' or 'any'."), + The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access: b(2406, 1, "The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access_2406", "The left-hand side of a 'for...in' statement must be a variable or a property access."), + The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0: b(2407, 1, "The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_2407", "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter, but here has type '{0}'."), + Setters_cannot_return_a_value: b(2408, 1, "Setters_cannot_return_a_value_2408", "Setters cannot return a value."), + Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class: b(2409, 1, "Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class_2409", "Return type of constructor signature must be assignable to the instance type of the class."), + The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any: b(2410, 1, "The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any_2410", "The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'."), + Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target: b(2412, 1, "Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefi_2412", "Type '{0}' is not assignable to type '{1}' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the type of the target."), + Property_0_of_type_1_is_not_assignable_to_2_index_type_3: b(2411, 1, "Property_0_of_type_1_is_not_assignable_to_2_index_type_3_2411", "Property '{0}' of type '{1}' is not assignable to '{2}' index type '{3}'."), + _0_index_type_1_is_not_assignable_to_2_index_type_3: b(2413, 1, "_0_index_type_1_is_not_assignable_to_2_index_type_3_2413", "'{0}' index type '{1}' is not assignable to '{2}' index type '{3}'."), + Class_name_cannot_be_0: b(2414, 1, "Class_name_cannot_be_0_2414", "Class name cannot be '{0}'."), + Class_0_incorrectly_extends_base_class_1: b(2415, 1, "Class_0_incorrectly_extends_base_class_1_2415", "Class '{0}' incorrectly extends base class '{1}'."), + Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2: b(2416, 1, "Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2_2416", "Property '{0}' in type '{1}' is not assignable to the same property in base type '{2}'."), + Class_static_side_0_incorrectly_extends_base_class_static_side_1: b(2417, 1, "Class_static_side_0_incorrectly_extends_base_class_static_side_1_2417", "Class static side '{0}' incorrectly extends base class static side '{1}'."), + Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1: b(2418, 1, "Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1_2418", "Type of computed property's value is '{0}', which is not assignable to type '{1}'."), + Types_of_construct_signatures_are_incompatible: b(2419, 1, "Types_of_construct_signatures_are_incompatible_2419", "Types of construct signatures are incompatible."), + Class_0_incorrectly_implements_interface_1: b(2420, 1, "Class_0_incorrectly_implements_interface_1_2420", "Class '{0}' incorrectly implements interface '{1}'."), + A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members: b(2422, 1, "A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_memb_2422", "A class can only implement an object type or intersection of object types with statically known members."), + Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: b(2423, 1, "Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_access_2423", "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor."), + Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: b(2425, 1, "Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_functi_2425", "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function."), + Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: b(2426, 1, "Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_functi_2426", "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function."), + Interface_name_cannot_be_0: b(2427, 1, "Interface_name_cannot_be_0_2427", "Interface name cannot be '{0}'."), + All_declarations_of_0_must_have_identical_type_parameters: b(2428, 1, "All_declarations_of_0_must_have_identical_type_parameters_2428", "All declarations of '{0}' must have identical type parameters."), + Interface_0_incorrectly_extends_interface_1: b(2430, 1, "Interface_0_incorrectly_extends_interface_1_2430", "Interface '{0}' incorrectly extends interface '{1}'."), + Enum_name_cannot_be_0: b(2431, 1, "Enum_name_cannot_be_0_2431", "Enum name cannot be '{0}'."), + In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element: b(2432, 1, "In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enu_2432", "In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element."), + A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged: b(2433, 1, "A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merg_2433", "A namespace declaration cannot be in a different file from a class or function with which it is merged."), + A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged: b(2434, 1, "A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged_2434", "A namespace declaration cannot be located prior to a class or function with which it is merged."), + Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces: b(2435, 1, "Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces_2435", "Ambient modules cannot be nested in other modules or namespaces."), + Ambient_module_declaration_cannot_specify_relative_module_name: b(2436, 1, "Ambient_module_declaration_cannot_specify_relative_module_name_2436", "Ambient module declaration cannot specify relative module name."), + Module_0_is_hidden_by_a_local_declaration_with_the_same_name: b(2437, 1, "Module_0_is_hidden_by_a_local_declaration_with_the_same_name_2437", "Module '{0}' is hidden by a local declaration with the same name."), + Import_name_cannot_be_0: b(2438, 1, "Import_name_cannot_be_0_2438", "Import name cannot be '{0}'."), + Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name: b(2439, 1, "Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relati_2439", "Import or export declaration in an ambient module declaration cannot reference module through relative module name."), + Import_declaration_conflicts_with_local_declaration_of_0: b(2440, 1, "Import_declaration_conflicts_with_local_declaration_of_0_2440", "Import declaration conflicts with local declaration of '{0}'."), + Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module: b(2441, 1, "Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_2441", "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module."), + Types_have_separate_declarations_of_a_private_property_0: b(2442, 1, "Types_have_separate_declarations_of_a_private_property_0_2442", "Types have separate declarations of a private property '{0}'."), + Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2: b(2443, 1, "Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2_2443", "Property '{0}' is protected but type '{1}' is not a class derived from '{2}'."), + Property_0_is_protected_in_type_1_but_public_in_type_2: b(2444, 1, "Property_0_is_protected_in_type_1_but_public_in_type_2_2444", "Property '{0}' is protected in type '{1}' but public in type '{2}'."), + Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses: b(2445, 1, "Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses_2445", "Property '{0}' is protected and only accessible within class '{1}' and its subclasses."), + Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_This_is_an_instance_of_class_2: b(2446, 1, "Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_This_is_an_instance_of_cl_2446", "Property '{0}' is protected and only accessible through an instance of class '{1}'. This is an instance of class '{2}'."), + The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead: b(2447, 1, "The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead_2447", "The '{0}' operator is not allowed for boolean types. Consider using '{1}' instead."), + Block_scoped_variable_0_used_before_its_declaration: b(2448, 1, "Block_scoped_variable_0_used_before_its_declaration_2448", "Block-scoped variable '{0}' used before its declaration."), + Class_0_used_before_its_declaration: b(2449, 1, "Class_0_used_before_its_declaration_2449", "Class '{0}' used before its declaration."), + Enum_0_used_before_its_declaration: b(2450, 1, "Enum_0_used_before_its_declaration_2450", "Enum '{0}' used before its declaration."), + Cannot_redeclare_block_scoped_variable_0: b(2451, 1, "Cannot_redeclare_block_scoped_variable_0_2451", "Cannot redeclare block-scoped variable '{0}'."), + An_enum_member_cannot_have_a_numeric_name: b(2452, 1, "An_enum_member_cannot_have_a_numeric_name_2452", "An enum member cannot have a numeric name."), + Variable_0_is_used_before_being_assigned: b(2454, 1, "Variable_0_is_used_before_being_assigned_2454", "Variable '{0}' is used before being assigned."), + Type_alias_0_circularly_references_itself: b(2456, 1, "Type_alias_0_circularly_references_itself_2456", "Type alias '{0}' circularly references itself."), + Type_alias_name_cannot_be_0: b(2457, 1, "Type_alias_name_cannot_be_0_2457", "Type alias name cannot be '{0}'."), + An_AMD_module_cannot_have_multiple_name_assignments: b(2458, 1, "An_AMD_module_cannot_have_multiple_name_assignments_2458", "An AMD module cannot have multiple name assignments."), + Module_0_declares_1_locally_but_it_is_not_exported: b(2459, 1, "Module_0_declares_1_locally_but_it_is_not_exported_2459", "Module '{0}' declares '{1}' locally, but it is not exported."), + Module_0_declares_1_locally_but_it_is_exported_as_2: b(2460, 1, "Module_0_declares_1_locally_but_it_is_exported_as_2_2460", "Module '{0}' declares '{1}' locally, but it is exported as '{2}'."), + Type_0_is_not_an_array_type: b(2461, 1, "Type_0_is_not_an_array_type_2461", "Type '{0}' is not an array type."), + A_rest_element_must_be_last_in_a_destructuring_pattern: b(2462, 1, "A_rest_element_must_be_last_in_a_destructuring_pattern_2462", "A rest element must be last in a destructuring pattern."), + A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature: b(2463, 1, "A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature_2463", "A binding pattern parameter cannot be optional in an implementation signature."), + A_computed_property_name_must_be_of_type_string_number_symbol_or_any: b(2464, 1, "A_computed_property_name_must_be_of_type_string_number_symbol_or_any_2464", "A computed property name must be of type 'string', 'number', 'symbol', or 'any'."), + this_cannot_be_referenced_in_a_computed_property_name: b(2465, 1, "this_cannot_be_referenced_in_a_computed_property_name_2465", "'this' cannot be referenced in a computed property name."), + super_cannot_be_referenced_in_a_computed_property_name: b(2466, 1, "super_cannot_be_referenced_in_a_computed_property_name_2466", "'super' cannot be referenced in a computed property name."), + A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type: b(2467, 1, "A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type_2467", "A computed property name cannot reference a type parameter from its containing type."), + Cannot_find_global_value_0: b(2468, 1, "Cannot_find_global_value_0_2468", "Cannot find global value '{0}'."), + The_0_operator_cannot_be_applied_to_type_symbol: b(2469, 1, "The_0_operator_cannot_be_applied_to_type_symbol_2469", "The '{0}' operator cannot be applied to type 'symbol'."), + Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher: b(2472, 1, "Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher_2472", "Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher."), + Enum_declarations_must_all_be_const_or_non_const: b(2473, 1, "Enum_declarations_must_all_be_const_or_non_const_2473", "Enum declarations must all be const or non-const."), + const_enum_member_initializers_must_be_constant_expressions: b(2474, 1, "const_enum_member_initializers_must_be_constant_expressions_2474", "const enum member initializers must be constant expressions."), + const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query: b(2475, 1, "const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_im_2475", "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment or type query."), + A_const_enum_member_can_only_be_accessed_using_a_string_literal: b(2476, 1, "A_const_enum_member_can_only_be_accessed_using_a_string_literal_2476", "A const enum member can only be accessed using a string literal."), + const_enum_member_initializer_was_evaluated_to_a_non_finite_value: b(2477, 1, "const_enum_member_initializer_was_evaluated_to_a_non_finite_value_2477", "'const' enum member initializer was evaluated to a non-finite value."), + const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN: b(2478, 1, "const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN_2478", "'const' enum member initializer was evaluated to disallowed value 'NaN'."), + let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations: b(2480, 1, "let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations_2480", "'let' is not allowed to be used as a name in 'let' or 'const' declarations."), + Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1: b(2481, 1, "Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1_2481", "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'."), + The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation: b(2483, 1, "The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation_2483", "The left-hand side of a 'for...of' statement cannot use a type annotation."), + Export_declaration_conflicts_with_exported_declaration_of_0: b(2484, 1, "Export_declaration_conflicts_with_exported_declaration_of_0_2484", "Export declaration conflicts with exported declaration of '{0}'."), + The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access: b(2487, 1, "The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access_2487", "The left-hand side of a 'for...of' statement must be a variable or a property access."), + Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator: b(2488, 1, "Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator_2488", "Type '{0}' must have a '[Symbol.iterator]()' method that returns an iterator."), + An_iterator_must_have_a_next_method: b(2489, 1, "An_iterator_must_have_a_next_method_2489", "An iterator must have a 'next()' method."), + The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property: b(2490, 1, "The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property_2490", "The type returned by the '{0}()' method of an iterator must have a 'value' property."), + The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern: b(2491, 1, "The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern_2491", "The left-hand side of a 'for...in' statement cannot be a destructuring pattern."), + Cannot_redeclare_identifier_0_in_catch_clause: b(2492, 1, "Cannot_redeclare_identifier_0_in_catch_clause_2492", "Cannot redeclare identifier '{0}' in catch clause."), + Tuple_type_0_of_length_1_has_no_element_at_index_2: b(2493, 1, "Tuple_type_0_of_length_1_has_no_element_at_index_2_2493", "Tuple type '{0}' of length '{1}' has no element at index '{2}'."), + Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher: b(2494, 1, "Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher_2494", "Using a string in a 'for...of' statement is only supported in ECMAScript 5 and higher."), + Type_0_is_not_an_array_type_or_a_string_type: b(2495, 1, "Type_0_is_not_an_array_type_or_a_string_type_2495", "Type '{0}' is not an array type or a string type."), + The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES5_Consider_using_a_standard_function_expression: b(2496, 1, "The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES5_Consider_using_a_standard_func_2496", "The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression."), + This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export: b(2497, 1, "This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_2497", "This module can only be referenced with ECMAScript imports/exports by turning on the '{0}' flag and referencing its default export."), + Module_0_uses_export_and_cannot_be_used_with_export_Asterisk: b(2498, 1, "Module_0_uses_export_and_cannot_be_used_with_export_Asterisk_2498", "Module '{0}' uses 'export =' and cannot be used with 'export *'."), + An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: b(2499, 1, "An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments_2499", "An interface can only extend an identifier/qualified-name with optional type arguments."), + A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: b(2500, 1, "A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments_2500", "A class can only implement an identifier/qualified-name with optional type arguments."), + A_rest_element_cannot_contain_a_binding_pattern: b(2501, 1, "A_rest_element_cannot_contain_a_binding_pattern_2501", "A rest element cannot contain a binding pattern."), + _0_is_referenced_directly_or_indirectly_in_its_own_type_annotation: b(2502, 1, "_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation_2502", "'{0}' is referenced directly or indirectly in its own type annotation."), + Cannot_find_namespace_0: b(2503, 1, "Cannot_find_namespace_0_2503", "Cannot find namespace '{0}'."), + Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator: b(2504, 1, "Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator_2504", "Type '{0}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator."), + A_generator_cannot_have_a_void_type_annotation: b(2505, 1, "A_generator_cannot_have_a_void_type_annotation_2505", "A generator cannot have a 'void' type annotation."), + _0_is_referenced_directly_or_indirectly_in_its_own_base_expression: b(2506, 1, "_0_is_referenced_directly_or_indirectly_in_its_own_base_expression_2506", "'{0}' is referenced directly or indirectly in its own base expression."), + Type_0_is_not_a_constructor_function_type: b(2507, 1, "Type_0_is_not_a_constructor_function_type_2507", "Type '{0}' is not a constructor function type."), + No_base_constructor_has_the_specified_number_of_type_arguments: b(2508, 1, "No_base_constructor_has_the_specified_number_of_type_arguments_2508", "No base constructor has the specified number of type arguments."), + Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members: b(2509, 1, "Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_2509", "Base constructor return type '{0}' is not an object type or intersection of object types with statically known members."), + Base_constructors_must_all_have_the_same_return_type: b(2510, 1, "Base_constructors_must_all_have_the_same_return_type_2510", "Base constructors must all have the same return type."), + Cannot_create_an_instance_of_an_abstract_class: b(2511, 1, "Cannot_create_an_instance_of_an_abstract_class_2511", "Cannot create an instance of an abstract class."), + Overload_signatures_must_all_be_abstract_or_non_abstract: b(2512, 1, "Overload_signatures_must_all_be_abstract_or_non_abstract_2512", "Overload signatures must all be abstract or non-abstract."), + Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression: b(2513, 1, "Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression_2513", "Abstract method '{0}' in class '{1}' cannot be accessed via super expression."), + A_tuple_type_cannot_be_indexed_with_a_negative_value: b(2514, 1, "A_tuple_type_cannot_be_indexed_with_a_negative_value_2514", "A tuple type cannot be indexed with a negative value."), + Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: b(2515, 1, "Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2_2515", "Non-abstract class '{0}' does not implement inherited abstract member {1} from class '{2}'."), + All_declarations_of_an_abstract_method_must_be_consecutive: b(2516, 1, "All_declarations_of_an_abstract_method_must_be_consecutive_2516", "All declarations of an abstract method must be consecutive."), + Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type: b(2517, 1, "Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type_2517", "Cannot assign an abstract constructor type to a non-abstract constructor type."), + A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard: b(2518, 1, "A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard_2518", "A 'this'-based type guard is not compatible with a parameter-based type guard."), + An_async_iterator_must_have_a_next_method: b(2519, 1, "An_async_iterator_must_have_a_next_method_2519", "An async iterator must have a 'next()' method."), + Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: b(2520, 1, "Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions_2520", "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions."), + The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES5_Consider_using_a_standard_function_or_method: b(2522, 1, "The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES5_Consider_using_a_sta_2522", "The 'arguments' object cannot be referenced in an async function or method in ES5. Consider using a standard function or method."), + yield_expressions_cannot_be_used_in_a_parameter_initializer: b(2523, 1, "yield_expressions_cannot_be_used_in_a_parameter_initializer_2523", "'yield' expressions cannot be used in a parameter initializer."), + await_expressions_cannot_be_used_in_a_parameter_initializer: b(2524, 1, "await_expressions_cannot_be_used_in_a_parameter_initializer_2524", "'await' expressions cannot be used in a parameter initializer."), + A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface: b(2526, 1, "A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface_2526", "A 'this' type is available only in a non-static member of a class or interface."), + The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary: b(2527, 1, "The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary_2527", "The inferred type of '{0}' references an inaccessible '{1}' type. A type annotation is necessary."), + A_module_cannot_have_multiple_default_exports: b(2528, 1, "A_module_cannot_have_multiple_default_exports_2528", "A module cannot have multiple default exports."), + Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions: b(2529, 1, "Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_func_2529", "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module containing async functions."), + Property_0_is_incompatible_with_index_signature: b(2530, 1, "Property_0_is_incompatible_with_index_signature_2530", "Property '{0}' is incompatible with index signature."), + Object_is_possibly_null: b(2531, 1, "Object_is_possibly_null_2531", "Object is possibly 'null'."), + Object_is_possibly_undefined: b(2532, 1, "Object_is_possibly_undefined_2532", "Object is possibly 'undefined'."), + Object_is_possibly_null_or_undefined: b(2533, 1, "Object_is_possibly_null_or_undefined_2533", "Object is possibly 'null' or 'undefined'."), + A_function_returning_never_cannot_have_a_reachable_end_point: b(2534, 1, "A_function_returning_never_cannot_have_a_reachable_end_point_2534", "A function returning 'never' cannot have a reachable end point."), + Type_0_cannot_be_used_to_index_type_1: b(2536, 1, "Type_0_cannot_be_used_to_index_type_1_2536", "Type '{0}' cannot be used to index type '{1}'."), + Type_0_has_no_matching_index_signature_for_type_1: b(2537, 1, "Type_0_has_no_matching_index_signature_for_type_1_2537", "Type '{0}' has no matching index signature for type '{1}'."), + Type_0_cannot_be_used_as_an_index_type: b(2538, 1, "Type_0_cannot_be_used_as_an_index_type_2538", "Type '{0}' cannot be used as an index type."), + Cannot_assign_to_0_because_it_is_not_a_variable: b(2539, 1, "Cannot_assign_to_0_because_it_is_not_a_variable_2539", "Cannot assign to '{0}' because it is not a variable."), + Cannot_assign_to_0_because_it_is_a_read_only_property: b(2540, 1, "Cannot_assign_to_0_because_it_is_a_read_only_property_2540", "Cannot assign to '{0}' because it is a read-only property."), + Index_signature_in_type_0_only_permits_reading: b(2542, 1, "Index_signature_in_type_0_only_permits_reading_2542", "Index signature in type '{0}' only permits reading."), + Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_meta_property_reference: b(2543, 1, "Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_me_2543", "Duplicate identifier '_newTarget'. Compiler uses variable declaration '_newTarget' to capture 'new.target' meta-property reference."), + Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta_property_reference: b(2544, 1, "Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta__2544", "Expression resolves to variable declaration '_newTarget' that compiler uses to capture 'new.target' meta-property reference."), + A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any: b(2545, 1, "A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any_2545", "A mixin class must have a constructor with a single rest parameter of type 'any[]'."), + The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property: b(2547, 1, "The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_pro_2547", "The type returned by the '{0}()' method of an async iterator must be a promise for a type with a 'value' property."), + Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator: b(2548, 1, "Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator_2548", "Type '{0}' is not an array type or does not have a '[Symbol.iterator]()' method that returns an iterator."), + Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator: b(2549, 1, "Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns__2549", "Type '{0}' is not an array type or a string type or does not have a '[Symbol.iterator]()' method that returns an iterator."), + Property_0_does_not_exist_on_type_1_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2_or_later: b(2550, 1, "Property_0_does_not_exist_on_type_1_Do_you_need_to_change_your_target_library_Try_changing_the_lib_c_2550", "Property '{0}' does not exist on type '{1}'. Do you need to change your target library? Try changing the 'lib' compiler option to '{2}' or later."), + Property_0_does_not_exist_on_type_1_Did_you_mean_2: b(2551, 1, "Property_0_does_not_exist_on_type_1_Did_you_mean_2_2551", "Property '{0}' does not exist on type '{1}'. Did you mean '{2}'?"), + Cannot_find_name_0_Did_you_mean_1: b(2552, 1, "Cannot_find_name_0_Did_you_mean_1_2552", "Cannot find name '{0}'. Did you mean '{1}'?"), + Computed_values_are_not_permitted_in_an_enum_with_string_valued_members: b(2553, 1, "Computed_values_are_not_permitted_in_an_enum_with_string_valued_members_2553", "Computed values are not permitted in an enum with string valued members."), + Expected_0_arguments_but_got_1: b(2554, 1, "Expected_0_arguments_but_got_1_2554", "Expected {0} arguments, but got {1}."), + Expected_at_least_0_arguments_but_got_1: b(2555, 1, "Expected_at_least_0_arguments_but_got_1_2555", "Expected at least {0} arguments, but got {1}."), + A_spread_argument_must_either_have_a_tuple_type_or_be_passed_to_a_rest_parameter: b(2556, 1, "A_spread_argument_must_either_have_a_tuple_type_or_be_passed_to_a_rest_parameter_2556", "A spread argument must either have a tuple type or be passed to a rest parameter."), + Expected_0_type_arguments_but_got_1: b(2558, 1, "Expected_0_type_arguments_but_got_1_2558", "Expected {0} type arguments, but got {1}."), + Type_0_has_no_properties_in_common_with_type_1: b(2559, 1, "Type_0_has_no_properties_in_common_with_type_1_2559", "Type '{0}' has no properties in common with type '{1}'."), + Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it: b(2560, 1, "Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it_2560", "Value of type '{0}' has no properties in common with type '{1}'. Did you mean to call it?"), + Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2: b(2561, 1, "Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_writ_2561", "Object literal may only specify known properties, but '{0}' does not exist in type '{1}'. Did you mean to write '{2}'?"), + Base_class_expressions_cannot_reference_class_type_parameters: b(2562, 1, "Base_class_expressions_cannot_reference_class_type_parameters_2562", "Base class expressions cannot reference class type parameters."), + The_containing_function_or_module_body_is_too_large_for_control_flow_analysis: b(2563, 1, "The_containing_function_or_module_body_is_too_large_for_control_flow_analysis_2563", "The containing function or module body is too large for control flow analysis."), + Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor: b(2564, 1, "Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor_2564", "Property '{0}' has no initializer and is not definitely assigned in the constructor."), + Property_0_is_used_before_being_assigned: b(2565, 1, "Property_0_is_used_before_being_assigned_2565", "Property '{0}' is used before being assigned."), + A_rest_element_cannot_have_a_property_name: b(2566, 1, "A_rest_element_cannot_have_a_property_name_2566", "A rest element cannot have a property name."), + Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations: b(2567, 1, "Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations_2567", "Enum declarations can only merge with namespace or other enum declarations."), + Property_0_may_not_exist_on_type_1_Did_you_mean_2: b(2568, 1, "Property_0_may_not_exist_on_type_1_Did_you_mean_2_2568", "Property '{0}' may not exist on type '{1}'. Did you mean '{2}'?"), + Could_not_find_name_0_Did_you_mean_1: b(2570, 1, "Could_not_find_name_0_Did_you_mean_1_2570", "Could not find name '{0}'. Did you mean '{1}'?"), + Object_is_of_type_unknown: b(2571, 1, "Object_is_of_type_unknown_2571", "Object is of type 'unknown'."), + A_rest_element_type_must_be_an_array_type: b(2574, 1, "A_rest_element_type_must_be_an_array_type_2574", "A rest element type must be an array type."), + No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments: b(2575, 1, "No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments_2575", "No overload expects {0} arguments, but overloads do exist that expect either {1} or {2} arguments."), + Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead: b(2576, 1, "Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead_2576", "Property '{0}' does not exist on type '{1}'. Did you mean to access the static member '{2}' instead?"), + Return_type_annotation_circularly_references_itself: b(2577, 1, "Return_type_annotation_circularly_references_itself_2577", "Return type annotation circularly references itself."), + Unused_ts_expect_error_directive: b(2578, 1, "Unused_ts_expect_error_directive_2578", "Unused '@ts-expect-error' directive."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode: b(2580, 1, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashno_2580", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node`."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery: b(2581, 1, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slash_2581", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i --save-dev @types/jquery`."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha: b(2582, 1, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_type_2582", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i --save-dev @types/jest` or `npm i --save-dev @types/mocha`."), + Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_1_or_later: b(2583, 1, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2583", "Cannot find name '{0}'. Do you need to change your target library? Try changing the 'lib' compiler option to '{1}' or later."), + Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom: b(2584, 1, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2584", "Cannot find name '{0}'. Do you need to change your target library? Try changing the 'lib' compiler option to include 'dom'."), + _0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later: b(2585, 1, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_2585", "'{0}' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later."), + Cannot_assign_to_0_because_it_is_a_constant: b(2588, 1, "Cannot_assign_to_0_because_it_is_a_constant_2588", "Cannot assign to '{0}' because it is a constant."), + Type_instantiation_is_excessively_deep_and_possibly_infinite: b(2589, 1, "Type_instantiation_is_excessively_deep_and_possibly_infinite_2589", "Type instantiation is excessively deep and possibly infinite."), + Expression_produces_a_union_type_that_is_too_complex_to_represent: b(2590, 1, "Expression_produces_a_union_type_that_is_too_complex_to_represent_2590", "Expression produces a union type that is too complex to represent."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig: b(2591, 1, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashno_2591", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig: b(2592, 1, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slash_2592", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i --save-dev @types/jquery` and then add 'jquery' to the types field in your tsconfig."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig: b(2593, 1, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_type_2593", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i --save-dev @types/jest` or `npm i --save-dev @types/mocha` and then add 'jest' or 'mocha' to the types field in your tsconfig."), + This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag: b(2594, 1, "This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag_2594", "This module is declared with 'export =', and can only be used with a default import when using the '{0}' flag."), + _0_can_only_be_imported_by_using_a_default_import: b(2595, 1, "_0_can_only_be_imported_by_using_a_default_import_2595", "'{0}' can only be imported by using a default import."), + _0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import: b(2596, 1, "_0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import_2596", "'{0}' can only be imported by turning on the 'esModuleInterop' flag and using a default import."), + _0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import: b(2597, 1, "_0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import_2597", "'{0}' can only be imported by using a 'require' call or by using a default import."), + _0_can_only_be_imported_by_using_a_require_call_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import: b(2598, 1, "_0_can_only_be_imported_by_using_a_require_call_or_by_turning_on_the_esModuleInterop_flag_and_using__2598", "'{0}' can only be imported by using a 'require' call or by turning on the 'esModuleInterop' flag and using a default import."), + JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist: b(2602, 1, "JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist_2602", "JSX element implicitly has type 'any' because the global type 'JSX.Element' does not exist."), + Property_0_in_type_1_is_not_assignable_to_type_2: b(2603, 1, "Property_0_in_type_1_is_not_assignable_to_type_2_2603", "Property '{0}' in type '{1}' is not assignable to type '{2}'."), + JSX_element_type_0_does_not_have_any_construct_or_call_signatures: b(2604, 1, "JSX_element_type_0_does_not_have_any_construct_or_call_signatures_2604", "JSX element type '{0}' does not have any construct or call signatures."), + Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property: b(2606, 1, "Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property_2606", "Property '{0}' of JSX spread attribute is not assignable to target property."), + JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property: b(2607, 1, "JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property_2607", "JSX element class does not support attributes because it does not have a '{0}' property."), + The_global_type_JSX_0_may_not_have_more_than_one_property: b(2608, 1, "The_global_type_JSX_0_may_not_have_more_than_one_property_2608", "The global type 'JSX.{0}' may not have more than one property."), + JSX_spread_child_must_be_an_array_type: b(2609, 1, "JSX_spread_child_must_be_an_array_type_2609", "JSX spread child must be an array type."), + _0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property: b(2610, 1, "_0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property_2610", "'{0}' is defined as an accessor in class '{1}', but is overridden here in '{2}' as an instance property."), + _0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor: b(2611, 1, "_0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor_2611", "'{0}' is defined as a property in class '{1}', but is overridden here in '{2}' as an accessor."), + Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration: b(2612, 1, "Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_2612", "Property '{0}' will overwrite the base property in '{1}'. If this is intentional, add an initializer. Otherwise, add a 'declare' modifier or remove the redundant declaration."), + Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead: b(2613, 1, "Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead_2613", "Module '{0}' has no default export. Did you mean to use 'import { {1} } from {0}' instead?"), + Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead: b(2614, 1, "Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead_2614", "Module '{0}' has no exported member '{1}'. Did you mean to use 'import {1} from {0}' instead?"), + Type_of_property_0_circularly_references_itself_in_mapped_type_1: b(2615, 1, "Type_of_property_0_circularly_references_itself_in_mapped_type_1_2615", "Type of property '{0}' circularly references itself in mapped type '{1}'."), + _0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import: b(2616, 1, "_0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import_2616", "'{0}' can only be imported by using 'import {1} = require({2})' or a default import."), + _0_can_only_be_imported_by_using_import_1_require_2_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import: b(2617, 1, "_0_can_only_be_imported_by_using_import_1_require_2_or_by_turning_on_the_esModuleInterop_flag_and_us_2617", "'{0}' can only be imported by using 'import {1} = require({2})' or by turning on the 'esModuleInterop' flag and using a default import."), + Source_has_0_element_s_but_target_requires_1: b(2618, 1, "Source_has_0_element_s_but_target_requires_1_2618", "Source has {0} element(s) but target requires {1}."), + Source_has_0_element_s_but_target_allows_only_1: b(2619, 1, "Source_has_0_element_s_but_target_allows_only_1_2619", "Source has {0} element(s) but target allows only {1}."), + Target_requires_0_element_s_but_source_may_have_fewer: b(2620, 1, "Target_requires_0_element_s_but_source_may_have_fewer_2620", "Target requires {0} element(s) but source may have fewer."), + Target_allows_only_0_element_s_but_source_may_have_more: b(2621, 1, "Target_allows_only_0_element_s_but_source_may_have_more_2621", "Target allows only {0} element(s) but source may have more."), + Source_provides_no_match_for_required_element_at_position_0_in_target: b(2623, 1, "Source_provides_no_match_for_required_element_at_position_0_in_target_2623", "Source provides no match for required element at position {0} in target."), + Source_provides_no_match_for_variadic_element_at_position_0_in_target: b(2624, 1, "Source_provides_no_match_for_variadic_element_at_position_0_in_target_2624", "Source provides no match for variadic element at position {0} in target."), + Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target: b(2625, 1, "Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target_2625", "Variadic element at position {0} in source does not match element at position {1} in target."), + Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target: b(2626, 1, "Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target_2626", "Type at position {0} in source is not compatible with type at position {1} in target."), + Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target: b(2627, 1, "Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target_2627", "Type at positions {0} through {1} in source is not compatible with type at position {2} in target."), + Cannot_assign_to_0_because_it_is_an_enum: b(2628, 1, "Cannot_assign_to_0_because_it_is_an_enum_2628", "Cannot assign to '{0}' because it is an enum."), + Cannot_assign_to_0_because_it_is_a_class: b(2629, 1, "Cannot_assign_to_0_because_it_is_a_class_2629", "Cannot assign to '{0}' because it is a class."), + Cannot_assign_to_0_because_it_is_a_function: b(2630, 1, "Cannot_assign_to_0_because_it_is_a_function_2630", "Cannot assign to '{0}' because it is a function."), + Cannot_assign_to_0_because_it_is_a_namespace: b(2631, 1, "Cannot_assign_to_0_because_it_is_a_namespace_2631", "Cannot assign to '{0}' because it is a namespace."), + Cannot_assign_to_0_because_it_is_an_import: b(2632, 1, "Cannot_assign_to_0_because_it_is_an_import_2632", "Cannot assign to '{0}' because it is an import."), + JSX_property_access_expressions_cannot_include_JSX_namespace_names: b(2633, 1, "JSX_property_access_expressions_cannot_include_JSX_namespace_names_2633", "JSX property access expressions cannot include JSX namespace names"), + _0_index_signatures_are_incompatible: b(2634, 1, "_0_index_signatures_are_incompatible_2634", "'{0}' index signatures are incompatible."), + Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable: b(2635, 1, "Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable_2635", "Type '{0}' has no signatures for which the type argument list is applicable."), + Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation: b(2636, 1, "Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation_2636", "Type '{0}' is not assignable to type '{1}' as implied by variance annotation."), + Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types: b(2637, 1, "Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_t_2637", "Variance annotations are only supported in type aliases for object, function, constructor, and mapped types."), + Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operator: b(2638, 1, "Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operato_2638", "Type '{0}' may represent a primitive value, which is not permitted as the right operand of the 'in' operator."), + React_components_cannot_include_JSX_namespace_names: b(2639, 1, "React_components_cannot_include_JSX_namespace_names_2639", "React components cannot include JSX namespace names"), + Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity: b(2649, 1, "Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity_2649", "Cannot augment module '{0}' with value exports because it resolves to a non-module entity."), + Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1_and_2_more: b(2650, 1, "Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1_and__2650", "Non-abstract class expression is missing implementations for the following members of '{0}': {1} and {2} more."), + A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: b(2651, 1, "A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_memb_2651", "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums."), + Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: b(2652, 1, "Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_d_2652", "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead."), + Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1: b(2653, 1, "Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1_2653", "Non-abstract class expression does not implement inherited abstract member '{0}' from class '{1}'."), + Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2: b(2654, 1, "Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2_2654", "Non-abstract class '{0}' is missing implementations for the following members of '{1}': {2}."), + Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2_and_3_more: b(2655, 1, "Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2_and_3_more_2655", "Non-abstract class '{0}' is missing implementations for the following members of '{1}': {2} and {3} more."), + Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1: b(2656, 1, "Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1_2656", "Non-abstract class expression is missing implementations for the following members of '{0}': {1}."), + JSX_expressions_must_have_one_parent_element: b(2657, 1, "JSX_expressions_must_have_one_parent_element_2657", "JSX expressions must have one parent element."), + Type_0_provides_no_match_for_the_signature_1: b(2658, 1, "Type_0_provides_no_match_for_the_signature_1_2658", "Type '{0}' provides no match for the signature '{1}'."), + super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher: b(2659, 1, "super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_highe_2659", "'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher."), + super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions: b(2660, 1, "super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions_2660", "'super' can only be referenced in members of derived classes or object literal expressions."), + Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module: b(2661, 1, "Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module_2661", "Cannot export '{0}'. Only local declarations can be exported from a module."), + Cannot_find_name_0_Did_you_mean_the_static_member_1_0: b(2662, 1, "Cannot_find_name_0_Did_you_mean_the_static_member_1_0_2662", "Cannot find name '{0}'. Did you mean the static member '{1}.{0}'?"), + Cannot_find_name_0_Did_you_mean_the_instance_member_this_0: b(2663, 1, "Cannot_find_name_0_Did_you_mean_the_instance_member_this_0_2663", "Cannot find name '{0}'. Did you mean the instance member 'this.{0}'?"), + Invalid_module_name_in_augmentation_module_0_cannot_be_found: b(2664, 1, "Invalid_module_name_in_augmentation_module_0_cannot_be_found_2664", "Invalid module name in augmentation, module '{0}' cannot be found."), + Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented: b(2665, 1, "Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augm_2665", "Invalid module name in augmentation. Module '{0}' resolves to an untyped module at '{1}', which cannot be augmented."), + Exports_and_export_assignments_are_not_permitted_in_module_augmentations: b(2666, 1, "Exports_and_export_assignments_are_not_permitted_in_module_augmentations_2666", "Exports and export assignments are not permitted in module augmentations."), + Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module: b(2667, 1, "Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_mod_2667", "Imports are not permitted in module augmentations. Consider moving them to the enclosing external module."), + export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible: b(2668, 1, "export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always__2668", "'export' modifier cannot be applied to ambient modules and module augmentations since they are always visible."), + Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations: b(2669, 1, "Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_2669", "Augmentations for the global scope can only be directly nested in external modules or ambient module declarations."), + Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context: b(2670, 1, "Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambien_2670", "Augmentations for the global scope should have 'declare' modifier unless they appear in already ambient context."), + Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity: b(2671, 1, "Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity_2671", "Cannot augment module '{0}' because it resolves to a non-module entity."), + Cannot_assign_a_0_constructor_type_to_a_1_constructor_type: b(2672, 1, "Cannot_assign_a_0_constructor_type_to_a_1_constructor_type_2672", "Cannot assign a '{0}' constructor type to a '{1}' constructor type."), + Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration: b(2673, 1, "Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration_2673", "Constructor of class '{0}' is private and only accessible within the class declaration."), + Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration: b(2674, 1, "Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration_2674", "Constructor of class '{0}' is protected and only accessible within the class declaration."), + Cannot_extend_a_class_0_Class_constructor_is_marked_as_private: b(2675, 1, "Cannot_extend_a_class_0_Class_constructor_is_marked_as_private_2675", "Cannot extend a class '{0}'. Class constructor is marked as private."), + Accessors_must_both_be_abstract_or_non_abstract: b(2676, 1, "Accessors_must_both_be_abstract_or_non_abstract_2676", "Accessors must both be abstract or non-abstract."), + A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type: b(2677, 1, "A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type_2677", "A type predicate's type must be assignable to its parameter's type."), + Type_0_is_not_comparable_to_type_1: b(2678, 1, "Type_0_is_not_comparable_to_type_1_2678", "Type '{0}' is not comparable to type '{1}'."), + A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void: b(2679, 1, "A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void_2679", "A function that is called with the 'new' keyword cannot have a 'this' type that is 'void'."), + A_0_parameter_must_be_the_first_parameter: b(2680, 1, "A_0_parameter_must_be_the_first_parameter_2680", "A '{0}' parameter must be the first parameter."), + A_constructor_cannot_have_a_this_parameter: b(2681, 1, "A_constructor_cannot_have_a_this_parameter_2681", "A constructor cannot have a 'this' parameter."), + this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation: b(2683, 1, "this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_2683", "'this' implicitly has type 'any' because it does not have a type annotation."), + The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1: b(2684, 1, "The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1_2684", "The 'this' context of type '{0}' is not assignable to method's 'this' of type '{1}'."), + The_this_types_of_each_signature_are_incompatible: b(2685, 1, "The_this_types_of_each_signature_are_incompatible_2685", "The 'this' types of each signature are incompatible."), + _0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead: b(2686, 1, "_0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead_2686", "'{0}' refers to a UMD global, but the current file is a module. Consider adding an import instead."), + All_declarations_of_0_must_have_identical_modifiers: b(2687, 1, "All_declarations_of_0_must_have_identical_modifiers_2687", "All declarations of '{0}' must have identical modifiers."), + Cannot_find_type_definition_file_for_0: b(2688, 1, "Cannot_find_type_definition_file_for_0_2688", "Cannot find type definition file for '{0}'."), + Cannot_extend_an_interface_0_Did_you_mean_implements: b(2689, 1, "Cannot_extend_an_interface_0_Did_you_mean_implements_2689", "Cannot extend an interface '{0}'. Did you mean 'implements'?"), + _0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0: b(2690, 1, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0_2690", "'{0}' only refers to a type, but is being used as a value here. Did you mean to use '{1} in {0}'?"), + _0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible: b(2692, 1, "_0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible_2692", "'{0}' is a primitive, but '{1}' is a wrapper object. Prefer using '{0}' when possible."), + _0_only_refers_to_a_type_but_is_being_used_as_a_value_here: b(2693, 1, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_2693", "'{0}' only refers to a type, but is being used as a value here."), + Namespace_0_has_no_exported_member_1: b(2694, 1, "Namespace_0_has_no_exported_member_1_2694", "Namespace '{0}' has no exported member '{1}'."), + Left_side_of_comma_operator_is_unused_and_has_no_side_effects: b( + 2695, + 1, + "Left_side_of_comma_operator_is_unused_and_has_no_side_effects_2695", + "Left side of comma operator is unused and has no side effects.", + /*reportsUnnecessary*/ + !0 + ), + The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead: b(2696, 1, "The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead_2696", "The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?"), + An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option: b(2697, 1, "An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_in_2697", "An async function or method must return a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your '--lib' option."), + Spread_types_may_only_be_created_from_object_types: b(2698, 1, "Spread_types_may_only_be_created_from_object_types_2698", "Spread types may only be created from object types."), + Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1: b(2699, 1, "Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1_2699", "Static property '{0}' conflicts with built-in property 'Function.{0}' of constructor function '{1}'."), + Rest_types_may_only_be_created_from_object_types: b(2700, 1, "Rest_types_may_only_be_created_from_object_types_2700", "Rest types may only be created from object types."), + The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access: b(2701, 1, "The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access_2701", "The target of an object rest assignment must be a variable or a property access."), + _0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here: b(2702, 1, "_0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here_2702", "'{0}' only refers to a type, but is being used as a namespace here."), + The_operand_of_a_delete_operator_must_be_a_property_reference: b(2703, 1, "The_operand_of_a_delete_operator_must_be_a_property_reference_2703", "The operand of a 'delete' operator must be a property reference."), + The_operand_of_a_delete_operator_cannot_be_a_read_only_property: b(2704, 1, "The_operand_of_a_delete_operator_cannot_be_a_read_only_property_2704", "The operand of a 'delete' operator cannot be a read-only property."), + An_async_function_or_method_in_ES5_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option: b(2705, 1, "An_async_function_or_method_in_ES5_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_2705", "An async function or method in ES5 requires the 'Promise' constructor. Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your '--lib' option."), + Required_type_parameters_may_not_follow_optional_type_parameters: b(2706, 1, "Required_type_parameters_may_not_follow_optional_type_parameters_2706", "Required type parameters may not follow optional type parameters."), + Generic_type_0_requires_between_1_and_2_type_arguments: b(2707, 1, "Generic_type_0_requires_between_1_and_2_type_arguments_2707", "Generic type '{0}' requires between {1} and {2} type arguments."), + Cannot_use_namespace_0_as_a_value: b(2708, 1, "Cannot_use_namespace_0_as_a_value_2708", "Cannot use namespace '{0}' as a value."), + Cannot_use_namespace_0_as_a_type: b(2709, 1, "Cannot_use_namespace_0_as_a_type_2709", "Cannot use namespace '{0}' as a type."), + _0_are_specified_twice_The_attribute_named_0_will_be_overwritten: b(2710, 1, "_0_are_specified_twice_The_attribute_named_0_will_be_overwritten_2710", "'{0}' are specified twice. The attribute named '{0}' will be overwritten."), + A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option: b(2711, 1, "A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES20_2711", "A dynamic import call returns a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your '--lib' option."), + A_dynamic_import_call_in_ES5_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option: b(2712, 1, "A_dynamic_import_call_in_ES5_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_t_2712", "A dynamic import call in ES5 requires the 'Promise' constructor. Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your '--lib' option."), + Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1: b(2713, 1, "Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_p_2713", `Cannot access '{0}.{1}' because '{0}' is a type, but not a namespace. Did you mean to retrieve the type of the property '{1}' in '{0}' with '{0}["{1}"]'?`), + The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context: b(2714, 1, "The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context_2714", "The expression of an export assignment must be an identifier or qualified name in an ambient context."), + Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor: b(2715, 1, "Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor_2715", "Abstract property '{0}' in class '{1}' cannot be accessed in the constructor."), + Type_parameter_0_has_a_circular_default: b(2716, 1, "Type_parameter_0_has_a_circular_default_2716", "Type parameter '{0}' has a circular default."), + Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2: b(2717, 1, "Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_t_2717", "Subsequent property declarations must have the same type. Property '{0}' must be of type '{1}', but here has type '{2}'."), + Duplicate_property_0: b(2718, 1, "Duplicate_property_0_2718", "Duplicate property '{0}'."), + Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated: b(2719, 1, "Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated_2719", "Type '{0}' is not assignable to type '{1}'. Two different types with this name exist, but they are unrelated."), + Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass: b(2720, 1, "Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclas_2720", "Class '{0}' incorrectly implements class '{1}'. Did you mean to extend '{1}' and inherit its members as a subclass?"), + Cannot_invoke_an_object_which_is_possibly_null: b(2721, 1, "Cannot_invoke_an_object_which_is_possibly_null_2721", "Cannot invoke an object which is possibly 'null'."), + Cannot_invoke_an_object_which_is_possibly_undefined: b(2722, 1, "Cannot_invoke_an_object_which_is_possibly_undefined_2722", "Cannot invoke an object which is possibly 'undefined'."), + Cannot_invoke_an_object_which_is_possibly_null_or_undefined: b(2723, 1, "Cannot_invoke_an_object_which_is_possibly_null_or_undefined_2723", "Cannot invoke an object which is possibly 'null' or 'undefined'."), + _0_has_no_exported_member_named_1_Did_you_mean_2: b(2724, 1, "_0_has_no_exported_member_named_1_Did_you_mean_2_2724", "'{0}' has no exported member named '{1}'. Did you mean '{2}'?"), + Class_name_cannot_be_Object_when_targeting_ES5_and_above_with_module_0: b(2725, 1, "Class_name_cannot_be_Object_when_targeting_ES5_and_above_with_module_0_2725", "Class name cannot be 'Object' when targeting ES5 and above with module {0}."), + Cannot_find_lib_definition_for_0: b(2726, 1, "Cannot_find_lib_definition_for_0_2726", "Cannot find lib definition for '{0}'."), + Cannot_find_lib_definition_for_0_Did_you_mean_1: b(2727, 1, "Cannot_find_lib_definition_for_0_Did_you_mean_1_2727", "Cannot find lib definition for '{0}'. Did you mean '{1}'?"), + _0_is_declared_here: b(2728, 3, "_0_is_declared_here_2728", "'{0}' is declared here."), + Property_0_is_used_before_its_initialization: b(2729, 1, "Property_0_is_used_before_its_initialization_2729", "Property '{0}' is used before its initialization."), + An_arrow_function_cannot_have_a_this_parameter: b(2730, 1, "An_arrow_function_cannot_have_a_this_parameter_2730", "An arrow function cannot have a 'this' parameter."), + Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String: b(2731, 1, "Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_i_2731", "Implicit conversion of a 'symbol' to a 'string' will fail at runtime. Consider wrapping this expression in 'String(...)'."), + Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension: b(2732, 1, "Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension_2732", "Cannot find module '{0}'. Consider using '--resolveJsonModule' to import module with '.json' extension."), + Property_0_was_also_declared_here: b(2733, 1, "Property_0_was_also_declared_here_2733", "Property '{0}' was also declared here."), + Are_you_missing_a_semicolon: b(2734, 1, "Are_you_missing_a_semicolon_2734", "Are you missing a semicolon?"), + Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1: b(2735, 1, "Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1_2735", "Did you mean for '{0}' to be constrained to type 'new (...args: any[]) => {1}'?"), + Operator_0_cannot_be_applied_to_type_1: b(2736, 1, "Operator_0_cannot_be_applied_to_type_1_2736", "Operator '{0}' cannot be applied to type '{1}'."), + BigInt_literals_are_not_available_when_targeting_lower_than_ES2020: b(2737, 1, "BigInt_literals_are_not_available_when_targeting_lower_than_ES2020_2737", "BigInt literals are not available when targeting lower than ES2020."), + An_outer_value_of_this_is_shadowed_by_this_container: b(2738, 3, "An_outer_value_of_this_is_shadowed_by_this_container_2738", "An outer value of 'this' is shadowed by this container."), + Type_0_is_missing_the_following_properties_from_type_1_Colon_2: b(2739, 1, "Type_0_is_missing_the_following_properties_from_type_1_Colon_2_2739", "Type '{0}' is missing the following properties from type '{1}': {2}"), + Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more: b(2740, 1, "Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more_2740", "Type '{0}' is missing the following properties from type '{1}': {2}, and {3} more."), + Property_0_is_missing_in_type_1_but_required_in_type_2: b(2741, 1, "Property_0_is_missing_in_type_1_but_required_in_type_2_2741", "Property '{0}' is missing in type '{1}' but required in type '{2}'."), + The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary: b(2742, 1, "The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_a_2742", "The inferred type of '{0}' cannot be named without a reference to '{1}'. This is likely not portable. A type annotation is necessary."), + No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments: b(2743, 1, "No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments_2743", "No overload expects {0} type arguments, but overloads do exist that expect either {1} or {2} type arguments."), + Type_parameter_defaults_can_only_reference_previously_declared_type_parameters: b(2744, 1, "Type_parameter_defaults_can_only_reference_previously_declared_type_parameters_2744", "Type parameter defaults can only reference previously declared type parameters."), + This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided: b(2745, 1, "This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_pr_2745", "This JSX tag's '{0}' prop expects type '{1}' which requires multiple children, but only a single child was provided."), + This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided: b(2746, 1, "This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided_2746", "This JSX tag's '{0}' prop expects a single child of type '{1}', but multiple children were provided."), + _0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2: b(2747, 1, "_0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_t_2747", "'{0}' components don't accept text as child elements. Text in JSX has the type 'string', but the expected type of '{1}' is '{2}'."), + Cannot_access_ambient_const_enums_when_0_is_enabled: b(2748, 1, "Cannot_access_ambient_const_enums_when_0_is_enabled_2748", "Cannot access ambient const enums when '{0}' is enabled."), + _0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0: b(2749, 1, "_0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0_2749", "'{0}' refers to a value, but is being used as a type here. Did you mean 'typeof {0}'?"), + The_implementation_signature_is_declared_here: b(2750, 1, "The_implementation_signature_is_declared_here_2750", "The implementation signature is declared here."), + Circularity_originates_in_type_at_this_location: b(2751, 1, "Circularity_originates_in_type_at_this_location_2751", "Circularity originates in type at this location."), + The_first_export_default_is_here: b(2752, 1, "The_first_export_default_is_here_2752", "The first export default is here."), + Another_export_default_is_here: b(2753, 1, "Another_export_default_is_here_2753", "Another export default is here."), + super_may_not_use_type_arguments: b(2754, 1, "super_may_not_use_type_arguments_2754", "'super' may not use type arguments."), + No_constituent_of_type_0_is_callable: b(2755, 1, "No_constituent_of_type_0_is_callable_2755", "No constituent of type '{0}' is callable."), + Not_all_constituents_of_type_0_are_callable: b(2756, 1, "Not_all_constituents_of_type_0_are_callable_2756", "Not all constituents of type '{0}' are callable."), + Type_0_has_no_call_signatures: b(2757, 1, "Type_0_has_no_call_signatures_2757", "Type '{0}' has no call signatures."), + Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_other: b(2758, 1, "Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_2758", "Each member of the union type '{0}' has signatures, but none of those signatures are compatible with each other."), + No_constituent_of_type_0_is_constructable: b(2759, 1, "No_constituent_of_type_0_is_constructable_2759", "No constituent of type '{0}' is constructable."), + Not_all_constituents_of_type_0_are_constructable: b(2760, 1, "Not_all_constituents_of_type_0_are_constructable_2760", "Not all constituents of type '{0}' are constructable."), + Type_0_has_no_construct_signatures: b(2761, 1, "Type_0_has_no_construct_signatures_2761", "Type '{0}' has no construct signatures."), + Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_with_each_other: b(2762, 1, "Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_2762", "Each member of the union type '{0}' has construct signatures, but none of those signatures are compatible with each other."), + Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0: b(2763, 1, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_s_2763", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but for-of will always send '{0}'."), + Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0: b(2764, 1, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_al_2764", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but array spread will always send '{0}'."), + Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0: b(2765, 1, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring__2765", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but array destructuring will always send '{0}'."), + Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0: b(2766, 1, "Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_co_2766", "Cannot delegate iteration to value because the 'next' method of its iterator expects type '{1}', but the containing generator will always send '{0}'."), + The_0_property_of_an_iterator_must_be_a_method: b(2767, 1, "The_0_property_of_an_iterator_must_be_a_method_2767", "The '{0}' property of an iterator must be a method."), + The_0_property_of_an_async_iterator_must_be_a_method: b(2768, 1, "The_0_property_of_an_async_iterator_must_be_a_method_2768", "The '{0}' property of an async iterator must be a method."), + No_overload_matches_this_call: b(2769, 1, "No_overload_matches_this_call_2769", "No overload matches this call."), + The_last_overload_gave_the_following_error: b(2770, 1, "The_last_overload_gave_the_following_error_2770", "The last overload gave the following error."), + The_last_overload_is_declared_here: b(2771, 1, "The_last_overload_is_declared_here_2771", "The last overload is declared here."), + Overload_0_of_1_2_gave_the_following_error: b(2772, 1, "Overload_0_of_1_2_gave_the_following_error_2772", "Overload {0} of {1}, '{2}', gave the following error."), + Did_you_forget_to_use_await: b(2773, 1, "Did_you_forget_to_use_await_2773", "Did you forget to use 'await'?"), + This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead: b(2774, 1, "This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_2774", "This condition will always return true since this function is always defined. Did you mean to call it instead?"), + Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation: b(2775, 1, "Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation_2775", "Assertions require every name in the call target to be declared with an explicit type annotation."), + Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name: b(2776, 1, "Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name_2776", "Assertions require the call target to be an identifier or qualified name."), + The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access: b(2777, 1, "The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access_2777", "The operand of an increment or decrement operator may not be an optional property access."), + The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access: b(2778, 1, "The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access_2778", "The target of an object rest assignment may not be an optional property access."), + The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access: b(2779, 1, "The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access_2779", "The left-hand side of an assignment expression may not be an optional property access."), + The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access: b(2780, 1, "The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access_2780", "The left-hand side of a 'for...in' statement may not be an optional property access."), + The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access: b(2781, 1, "The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access_2781", "The left-hand side of a 'for...of' statement may not be an optional property access."), + _0_needs_an_explicit_type_annotation: b(2782, 3, "_0_needs_an_explicit_type_annotation_2782", "'{0}' needs an explicit type annotation."), + _0_is_specified_more_than_once_so_this_usage_will_be_overwritten: b(2783, 1, "_0_is_specified_more_than_once_so_this_usage_will_be_overwritten_2783", "'{0}' is specified more than once, so this usage will be overwritten."), + get_and_set_accessors_cannot_declare_this_parameters: b(2784, 1, "get_and_set_accessors_cannot_declare_this_parameters_2784", "'get' and 'set' accessors cannot declare 'this' parameters."), + This_spread_always_overwrites_this_property: b(2785, 1, "This_spread_always_overwrites_this_property_2785", "This spread always overwrites this property."), + _0_cannot_be_used_as_a_JSX_component: b(2786, 1, "_0_cannot_be_used_as_a_JSX_component_2786", "'{0}' cannot be used as a JSX component."), + Its_return_type_0_is_not_a_valid_JSX_element: b(2787, 1, "Its_return_type_0_is_not_a_valid_JSX_element_2787", "Its return type '{0}' is not a valid JSX element."), + Its_instance_type_0_is_not_a_valid_JSX_element: b(2788, 1, "Its_instance_type_0_is_not_a_valid_JSX_element_2788", "Its instance type '{0}' is not a valid JSX element."), + Its_element_type_0_is_not_a_valid_JSX_element: b(2789, 1, "Its_element_type_0_is_not_a_valid_JSX_element_2789", "Its element type '{0}' is not a valid JSX element."), + The_operand_of_a_delete_operator_must_be_optional: b(2790, 1, "The_operand_of_a_delete_operator_must_be_optional_2790", "The operand of a 'delete' operator must be optional."), + Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_later: b(2791, 1, "Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_lat_2791", "Exponentiation cannot be performed on 'bigint' values unless the 'target' option is set to 'es2016' or later."), + Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option: b(2792, 1, "Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_t_2792", "Cannot find module '{0}'. Did you mean to set the 'moduleResolution' option to 'nodenext', or to add aliases to the 'paths' option?"), + The_call_would_have_succeeded_against_this_implementation_but_implementation_signatures_of_overloads_are_not_externally_visible: b(2793, 1, "The_call_would_have_succeeded_against_this_implementation_but_implementation_signatures_of_overloads_2793", "The call would have succeeded against this implementation, but implementation signatures of overloads are not externally visible."), + Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise: b(2794, 1, "Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise_2794", "Expected {0} arguments, but got {1}. Did you forget to include 'void' in your type argument to 'Promise'?"), + The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types: b(2795, 1, "The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types_2795", "The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types."), + It_is_likely_that_you_are_missing_a_comma_to_separate_these_two_template_expressions_They_form_a_tagged_template_expression_which_cannot_be_invoked: b(2796, 1, "It_is_likely_that_you_are_missing_a_comma_to_separate_these_two_template_expressions_They_form_a_tag_2796", "It is likely that you are missing a comma to separate these two template expressions. They form a tagged template expression which cannot be invoked."), + A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_be_declared_abstract: b(2797, 1, "A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_2797", "A mixin class that extends from a type variable containing an abstract construct signature must also be declared 'abstract'."), + The_declaration_was_marked_as_deprecated_here: b(2798, 1, "The_declaration_was_marked_as_deprecated_here_2798", "The declaration was marked as deprecated here."), + Type_produces_a_tuple_type_that_is_too_large_to_represent: b(2799, 1, "Type_produces_a_tuple_type_that_is_too_large_to_represent_2799", "Type produces a tuple type that is too large to represent."), + Expression_produces_a_tuple_type_that_is_too_large_to_represent: b(2800, 1, "Expression_produces_a_tuple_type_that_is_too_large_to_represent_2800", "Expression produces a tuple type that is too large to represent."), + This_condition_will_always_return_true_since_this_0_is_always_defined: b(2801, 1, "This_condition_will_always_return_true_since_this_0_is_always_defined_2801", "This condition will always return true since this '{0}' is always defined."), + Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher: b(2802, 1, "Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es201_2802", "Type '{0}' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher."), + Cannot_assign_to_private_method_0_Private_methods_are_not_writable: b(2803, 1, "Cannot_assign_to_private_method_0_Private_methods_are_not_writable_2803", "Cannot assign to private method '{0}'. Private methods are not writable."), + Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name: b(2804, 1, "Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name_2804", "Duplicate identifier '{0}'. Static and instance elements cannot share the same private name."), + Private_accessor_was_defined_without_a_getter: b(2806, 1, "Private_accessor_was_defined_without_a_getter_2806", "Private accessor was defined without a getter."), + This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0: b(2807, 1, "This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_o_2807", "This syntax requires an imported helper named '{1}' with {2} parameters, which is not compatible with the one in '{0}'. Consider upgrading your version of '{0}'."), + A_get_accessor_must_be_at_least_as_accessible_as_the_setter: b(2808, 1, "A_get_accessor_must_be_at_least_as_accessible_as_the_setter_2808", "A get accessor must be at least as accessible as the setter"), + Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_whole_assignment_in_parentheses: b(2809, 1, "Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_d_2809", "Declaration or statement expected. This '=' follows a block of statements, so if you intended to write a destructuring assignment, you might need to wrap the whole assignment in parentheses."), + Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments: b(2810, 1, "Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_2810", "Expected 1 argument, but got 0. 'new Promise()' needs a JSDoc hint to produce a 'resolve' that can be called without arguments."), + Initializer_for_property_0: b(2811, 1, "Initializer_for_property_0_2811", "Initializer for property '{0}'"), + Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom: b(2812, 1, "Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom_2812", "Property '{0}' does not exist on type '{1}'. Try changing the 'lib' compiler option to include 'dom'."), + Class_declaration_cannot_implement_overload_list_for_0: b(2813, 1, "Class_declaration_cannot_implement_overload_list_for_0_2813", "Class declaration cannot implement overload list for '{0}'."), + Function_with_bodies_can_only_merge_with_classes_that_are_ambient: b(2814, 1, "Function_with_bodies_can_only_merge_with_classes_that_are_ambient_2814", "Function with bodies can only merge with classes that are ambient."), + arguments_cannot_be_referenced_in_property_initializers_or_class_static_initialization_blocks: b(2815, 1, "arguments_cannot_be_referenced_in_property_initializers_or_class_static_initialization_blocks_2815", "'arguments' cannot be referenced in property initializers or class static initialization blocks."), + Cannot_use_this_in_a_static_property_initializer_of_a_decorated_class: b(2816, 1, "Cannot_use_this_in_a_static_property_initializer_of_a_decorated_class_2816", "Cannot use 'this' in a static property initializer of a decorated class."), + Property_0_has_no_initializer_and_is_not_definitely_assigned_in_a_class_static_block: b(2817, 1, "Property_0_has_no_initializer_and_is_not_definitely_assigned_in_a_class_static_block_2817", "Property '{0}' has no initializer and is not definitely assigned in a class static block."), + Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializers: b(2818, 1, "Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializer_2818", "Duplicate identifier '{0}'. Compiler reserves name '{1}' when emitting 'super' references in static initializers."), + Namespace_name_cannot_be_0: b(2819, 1, "Namespace_name_cannot_be_0_2819", "Namespace name cannot be '{0}'."), + Type_0_is_not_assignable_to_type_1_Did_you_mean_2: b(2820, 1, "Type_0_is_not_assignable_to_type_1_Did_you_mean_2_2820", "Type '{0}' is not assignable to type '{1}'. Did you mean '{2}'?"), + Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_node18_node20_nodenext_or_preserve: b(2821, 1, "Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_node18_node20_nodenext__2821", "Import assertions are only supported when the '--module' option is set to 'esnext', 'node18', 'node20', 'nodenext', or 'preserve'."), + Import_assertions_cannot_be_used_with_type_only_imports_or_exports: b(2822, 1, "Import_assertions_cannot_be_used_with_type_only_imports_or_exports_2822", "Import assertions cannot be used with type-only imports or exports."), + Import_attributes_are_only_supported_when_the_module_option_is_set_to_esnext_node18_node20_nodenext_or_preserve: b(2823, 1, "Import_attributes_are_only_supported_when_the_module_option_is_set_to_esnext_node18_node20_nodenext__2823", "Import attributes are only supported when the '--module' option is set to 'esnext', 'node18', 'node20', 'nodenext', or 'preserve'."), + Cannot_find_namespace_0_Did_you_mean_1: b(2833, 1, "Cannot_find_namespace_0_Did_you_mean_1_2833", "Cannot find namespace '{0}'. Did you mean '{1}'?"), + Relative_import_paths_need_explicit_file_extensions_in_ECMAScript_imports_when_moduleResolution_is_node16_or_nodenext_Consider_adding_an_extension_to_the_import_path: b(2834, 1, "Relative_import_paths_need_explicit_file_extensions_in_ECMAScript_imports_when_moduleResolution_is_n_2834", "Relative import paths need explicit file extensions in ECMAScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Consider adding an extension to the import path."), + Relative_import_paths_need_explicit_file_extensions_in_ECMAScript_imports_when_moduleResolution_is_node16_or_nodenext_Did_you_mean_0: b(2835, 1, "Relative_import_paths_need_explicit_file_extensions_in_ECMAScript_imports_when_moduleResolution_is_n_2835", "Relative import paths need explicit file extensions in ECMAScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Did you mean '{0}'?"), + Import_assertions_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls: b(2836, 1, "Import_assertions_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls_2836", "Import assertions are not allowed on statements that compile to CommonJS 'require' calls."), + Import_assertion_values_must_be_string_literal_expressions: b(2837, 1, "Import_assertion_values_must_be_string_literal_expressions_2837", "Import assertion values must be string literal expressions."), + All_declarations_of_0_must_have_identical_constraints: b(2838, 1, "All_declarations_of_0_must_have_identical_constraints_2838", "All declarations of '{0}' must have identical constraints."), + This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value: b(2839, 1, "This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value_2839", "This condition will always return '{0}' since JavaScript compares objects by reference, not value."), + An_interface_cannot_extend_a_primitive_type_like_0_It_can_only_extend_other_named_object_types: b(2840, 1, "An_interface_cannot_extend_a_primitive_type_like_0_It_can_only_extend_other_named_object_types_2840", "An interface cannot extend a primitive type like '{0}'. It can only extend other named object types."), + _0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation: b(2842, 1, "_0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation_2842", "'{0}' is an unused renaming of '{1}'. Did you intend to use it as a type annotation?"), + We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here: b(2843, 1, "We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here_2843", "We can only write a type for '{0}' by adding a type for the entire parameter here."), + Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: b(2844, 1, "Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2844", "Type of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."), + This_condition_will_always_return_0: b(2845, 1, "This_condition_will_always_return_0_2845", "This condition will always return '{0}'."), + A_declaration_file_cannot_be_imported_without_import_type_Did_you_mean_to_import_an_implementation_file_0_instead: b(2846, 1, "A_declaration_file_cannot_be_imported_without_import_type_Did_you_mean_to_import_an_implementation_f_2846", "A declaration file cannot be imported without 'import type'. Did you mean to import an implementation file '{0}' instead?"), + The_right_hand_side_of_an_instanceof_expression_must_not_be_an_instantiation_expression: b(2848, 1, "The_right_hand_side_of_an_instanceof_expression_must_not_be_an_instantiation_expression_2848", "The right-hand side of an 'instanceof' expression must not be an instantiation expression."), + Target_signature_provides_too_few_arguments_Expected_0_or_more_but_got_1: b(2849, 1, "Target_signature_provides_too_few_arguments_Expected_0_or_more_but_got_1_2849", "Target signature provides too few arguments. Expected {0} or more, but got {1}."), + The_initializer_of_a_using_declaration_must_be_either_an_object_with_a_Symbol_dispose_method_or_be_null_or_undefined: b(2850, 1, "The_initializer_of_a_using_declaration_must_be_either_an_object_with_a_Symbol_dispose_method_or_be_n_2850", "The initializer of a 'using' declaration must be either an object with a '[Symbol.dispose]()' method, or be 'null' or 'undefined'."), + The_initializer_of_an_await_using_declaration_must_be_either_an_object_with_a_Symbol_asyncDispose_or_Symbol_dispose_method_or_be_null_or_undefined: b(2851, 1, "The_initializer_of_an_await_using_declaration_must_be_either_an_object_with_a_Symbol_asyncDispose_or_2851", "The initializer of an 'await using' declaration must be either an object with a '[Symbol.asyncDispose]()' or '[Symbol.dispose]()' method, or be 'null' or 'undefined'."), + await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: b(2852, 1, "await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_2852", "'await using' statements are only allowed within async functions and at the top levels of modules."), + await_using_statements_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module: b(2853, 1, "await_using_statements_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_th_2853", "'await using' statements are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module."), + Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher: b(2854, 1, "Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_sys_2854", "Top-level 'await using' statements are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', 'node18', 'node20', 'nodenext', or 'preserve', and the 'target' option is set to 'es2017' or higher."), + Class_field_0_defined_by_the_parent_class_is_not_accessible_in_the_child_class_via_super: b(2855, 1, "Class_field_0_defined_by_the_parent_class_is_not_accessible_in_the_child_class_via_super_2855", "Class field '{0}' defined by the parent class is not accessible in the child class via super."), + Import_attributes_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls: b(2856, 1, "Import_attributes_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls_2856", "Import attributes are not allowed on statements that compile to CommonJS 'require' calls."), + Import_attributes_cannot_be_used_with_type_only_imports_or_exports: b(2857, 1, "Import_attributes_cannot_be_used_with_type_only_imports_or_exports_2857", "Import attributes cannot be used with type-only imports or exports."), + Import_attribute_values_must_be_string_literal_expressions: b(2858, 1, "Import_attribute_values_must_be_string_literal_expressions_2858", "Import attribute values must be string literal expressions."), + Excessive_complexity_comparing_types_0_and_1: b(2859, 1, "Excessive_complexity_comparing_types_0_and_1_2859", "Excessive complexity comparing types '{0}' and '{1}'."), + The_left_hand_side_of_an_instanceof_expression_must_be_assignable_to_the_first_argument_of_the_right_hand_side_s_Symbol_hasInstance_method: b(2860, 1, "The_left_hand_side_of_an_instanceof_expression_must_be_assignable_to_the_first_argument_of_the_right_2860", "The left-hand side of an 'instanceof' expression must be assignable to the first argument of the right-hand side's '[Symbol.hasInstance]' method."), + An_object_s_Symbol_hasInstance_method_must_return_a_boolean_value_for_it_to_be_used_on_the_right_hand_side_of_an_instanceof_expression: b(2861, 1, "An_object_s_Symbol_hasInstance_method_must_return_a_boolean_value_for_it_to_be_used_on_the_right_han_2861", "An object's '[Symbol.hasInstance]' method must return a boolean value for it to be used on the right-hand side of an 'instanceof' expression."), + Type_0_is_generic_and_can_only_be_indexed_for_reading: b(2862, 1, "Type_0_is_generic_and_can_only_be_indexed_for_reading_2862", "Type '{0}' is generic and can only be indexed for reading."), + A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values: b(2863, 1, "A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values_2863", "A class cannot extend a primitive type like '{0}'. Classes can only extend constructable values."), + A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types: b(2864, 1, "A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types_2864", "A class cannot implement a primitive type like '{0}'. It can only implement other named object types."), + Import_0_conflicts_with_local_value_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled: b(2865, 1, "Import_0_conflicts_with_local_value_so_must_be_declared_with_a_type_only_import_when_isolatedModules_2865", "Import '{0}' conflicts with local value, so must be declared with a type-only import when 'isolatedModules' is enabled."), + Import_0_conflicts_with_global_value_used_in_this_file_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled: b(2866, 1, "Import_0_conflicts_with_global_value_used_in_this_file_so_must_be_declared_with_a_type_only_import_w_2866", "Import '{0}' conflicts with global value used in this file, so must be declared with a type-only import when 'isolatedModules' is enabled."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_Bun_Try_npm_i_save_dev_types_Slashbun: b(2867, 1, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_Bun_Try_npm_i_save_dev_types_Slashbun_2867", "Cannot find name '{0}'. Do you need to install type definitions for Bun? Try `npm i --save-dev @types/bun`."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_Bun_Try_npm_i_save_dev_types_Slashbun_and_then_add_bun_to_the_types_field_in_your_tsconfig: b(2868, 1, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_Bun_Try_npm_i_save_dev_types_Slashbun_2868", "Cannot find name '{0}'. Do you need to install type definitions for Bun? Try `npm i --save-dev @types/bun` and then add 'bun' to the types field in your tsconfig."), + Right_operand_of_is_unreachable_because_the_left_operand_is_never_nullish: b(2869, 1, "Right_operand_of_is_unreachable_because_the_left_operand_is_never_nullish_2869", "Right operand of ?? is unreachable because the left operand is never nullish."), + This_binary_expression_is_never_nullish_Are_you_missing_parentheses: b(2870, 1, "This_binary_expression_is_never_nullish_Are_you_missing_parentheses_2870", "This binary expression is never nullish. Are you missing parentheses?"), + This_expression_is_always_nullish: b(2871, 1, "This_expression_is_always_nullish_2871", "This expression is always nullish."), + This_kind_of_expression_is_always_truthy: b(2872, 1, "This_kind_of_expression_is_always_truthy_2872", "This kind of expression is always truthy."), + This_kind_of_expression_is_always_falsy: b(2873, 1, "This_kind_of_expression_is_always_falsy_2873", "This kind of expression is always falsy."), + This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found: b(2874, 1, "This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found_2874", "This JSX tag requires '{0}' to be in scope, but it could not be found."), + This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed: b(2875, 1, "This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_fo_2875", "This JSX tag requires the module path '{0}' to exist, but none could be found. Make sure you have types for the appropriate package installed."), + This_relative_import_path_is_unsafe_to_rewrite_because_it_looks_like_a_file_name_but_actually_resolves_to_0: b(2876, 1, "This_relative_import_path_is_unsafe_to_rewrite_because_it_looks_like_a_file_name_but_actually_resolv_2876", 'This relative import path is unsafe to rewrite because it looks like a file name, but actually resolves to "{0}".'), + This_import_uses_a_0_extension_to_resolve_to_an_input_TypeScript_file_but_will_not_be_rewritten_during_emit_because_it_is_not_a_relative_path: b(2877, 1, "This_import_uses_a_0_extension_to_resolve_to_an_input_TypeScript_file_but_will_not_be_rewritten_duri_2877", "This import uses a '{0}' extension to resolve to an input TypeScript file, but will not be rewritten during emit because it is not a relative path."), + This_import_path_is_unsafe_to_rewrite_because_it_resolves_to_another_project_and_the_relative_path_between_the_projects_output_files_is_not_the_same_as_the_relative_path_between_its_input_files: b(2878, 1, "This_import_path_is_unsafe_to_rewrite_because_it_resolves_to_another_project_and_the_relative_path_b_2878", "This import path is unsafe to rewrite because it resolves to another project, and the relative path between the projects' output files is not the same as the relative path between its input files."), + Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found: b(2879, 1, "Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found_2879", "Using JSX fragments requires fragment factory '{0}' to be in scope, but it could not be found."), + Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert: b(2880, 1, "Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert_2880", "Import assertions have been replaced by import attributes. Use 'with' instead of 'assert'."), + This_expression_is_never_nullish: b(2881, 1, "This_expression_is_never_nullish_2881", "This expression is never nullish."), + Import_declaration_0_is_using_private_name_1: b(4e3, 1, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."), + Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: b(4002, 1, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."), + Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: b(4004, 1, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."), + Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: b(4006, 1, "Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1_4006", "Type parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'."), + Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: b(4008, 1, "Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1_4008", "Type parameter '{0}' of call signature from exported interface has or is using private name '{1}'."), + Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: b(4010, 1, "Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1_4010", "Type parameter '{0}' of public static method from exported class has or is using private name '{1}'."), + Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: b(4012, 1, "Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1_4012", "Type parameter '{0}' of public method from exported class has or is using private name '{1}'."), + Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: b(4014, 1, "Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1_4014", "Type parameter '{0}' of method from exported interface has or is using private name '{1}'."), + Type_parameter_0_of_exported_function_has_or_is_using_private_name_1: b(4016, 1, "Type_parameter_0_of_exported_function_has_or_is_using_private_name_1_4016", "Type parameter '{0}' of exported function has or is using private name '{1}'."), + Implements_clause_of_exported_class_0_has_or_is_using_private_name_1: b(4019, 1, "Implements_clause_of_exported_class_0_has_or_is_using_private_name_1_4019", "Implements clause of exported class '{0}' has or is using private name '{1}'."), + extends_clause_of_exported_class_0_has_or_is_using_private_name_1: b(4020, 1, "extends_clause_of_exported_class_0_has_or_is_using_private_name_1_4020", "'extends' clause of exported class '{0}' has or is using private name '{1}'."), + extends_clause_of_exported_class_has_or_is_using_private_name_0: b(4021, 1, "extends_clause_of_exported_class_has_or_is_using_private_name_0_4021", "'extends' clause of exported class has or is using private name '{0}'."), + extends_clause_of_exported_interface_0_has_or_is_using_private_name_1: b(4022, 1, "extends_clause_of_exported_interface_0_has_or_is_using_private_name_1_4022", "'extends' clause of exported interface '{0}' has or is using private name '{1}'."), + Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: b(4023, 1, "Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4023", "Exported variable '{0}' has or is using name '{1}' from external module {2} but cannot be named."), + Exported_variable_0_has_or_is_using_name_1_from_private_module_2: b(4024, 1, "Exported_variable_0_has_or_is_using_name_1_from_private_module_2_4024", "Exported variable '{0}' has or is using name '{1}' from private module '{2}'."), + Exported_variable_0_has_or_is_using_private_name_1: b(4025, 1, "Exported_variable_0_has_or_is_using_private_name_1_4025", "Exported variable '{0}' has or is using private name '{1}'."), + Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: b(4026, 1, "Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot__4026", "Public static property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), + Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: b(4027, 1, "Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4027", "Public static property '{0}' of exported class has or is using name '{1}' from private module '{2}'."), + Public_static_property_0_of_exported_class_has_or_is_using_private_name_1: b(4028, 1, "Public_static_property_0_of_exported_class_has_or_is_using_private_name_1_4028", "Public static property '{0}' of exported class has or is using private name '{1}'."), + Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: b(4029, 1, "Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_name_4029", "Public property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), + Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: b(4030, 1, "Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4030", "Public property '{0}' of exported class has or is using name '{1}' from private module '{2}'."), + Public_property_0_of_exported_class_has_or_is_using_private_name_1: b(4031, 1, "Public_property_0_of_exported_class_has_or_is_using_private_name_1_4031", "Public property '{0}' of exported class has or is using private name '{1}'."), + Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: b(4032, 1, "Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2_4032", "Property '{0}' of exported interface has or is using name '{1}' from private module '{2}'."), + Property_0_of_exported_interface_has_or_is_using_private_name_1: b(4033, 1, "Property_0_of_exported_interface_has_or_is_using_private_name_1_4033", "Property '{0}' of exported interface has or is using private name '{1}'."), + Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: b(4034, 1, "Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_mod_4034", "Parameter type of public static setter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1: b(4035, 1, "Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1_4035", "Parameter type of public static setter '{0}' from exported class has or is using private name '{1}'."), + Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: b(4036, 1, "Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2_4036", "Parameter type of public setter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1: b(4037, 1, "Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1_4037", "Parameter type of public setter '{0}' from exported class has or is using private name '{1}'."), + Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: b(4038, 1, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_modul_4038", "Return type of public static getter '{0}' from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: b(4039, 1, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_4039", "Return type of public static getter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), + Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1: b(4040, 1, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1_4040", "Return type of public static getter '{0}' from exported class has or is using private name '{1}'."), + Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: b(4041, 1, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_4041", "Return type of public getter '{0}' from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: b(4042, 1, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2_4042", "Return type of public getter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), + Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1: b(4043, 1, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1_4043", "Return type of public getter '{0}' from exported class has or is using private name '{1}'."), + Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: b(4044, 1, "Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_mod_4044", "Return type of constructor signature from exported interface has or is using name '{0}' from private module '{1}'."), + Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0: b(4045, 1, "Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0_4045", "Return type of constructor signature from exported interface has or is using private name '{0}'."), + Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: b(4046, 1, "Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4046", "Return type of call signature from exported interface has or is using name '{0}' from private module '{1}'."), + Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0: b(4047, 1, "Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0_4047", "Return type of call signature from exported interface has or is using private name '{0}'."), + Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: b(4048, 1, "Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4048", "Return type of index signature from exported interface has or is using name '{0}' from private module '{1}'."), + Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0: b(4049, 1, "Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0_4049", "Return type of index signature from exported interface has or is using private name '{0}'."), + Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: b(4050, 1, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module__4050", "Return type of public static method from exported class has or is using name '{0}' from external module {1} but cannot be named."), + Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: b(4051, 1, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1_4051", "Return type of public static method from exported class has or is using name '{0}' from private module '{1}'."), + Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0: b(4052, 1, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0_4052", "Return type of public static method from exported class has or is using private name '{0}'."), + Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: b(4053, 1, "Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_c_4053", "Return type of public method from exported class has or is using name '{0}' from external module {1} but cannot be named."), + Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: b(4054, 1, "Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1_4054", "Return type of public method from exported class has or is using name '{0}' from private module '{1}'."), + Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0: b(4055, 1, "Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0_4055", "Return type of public method from exported class has or is using private name '{0}'."), + Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1: b(4056, 1, "Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4056", "Return type of method from exported interface has or is using name '{0}' from private module '{1}'."), + Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0: b(4057, 1, "Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0_4057", "Return type of method from exported interface has or is using private name '{0}'."), + Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: b(4058, 1, "Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named_4058", "Return type of exported function has or is using name '{0}' from external module {1} but cannot be named."), + Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1: b(4059, 1, "Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1_4059", "Return type of exported function has or is using name '{0}' from private module '{1}'."), + Return_type_of_exported_function_has_or_is_using_private_name_0: b(4060, 1, "Return_type_of_exported_function_has_or_is_using_private_name_0_4060", "Return type of exported function has or is using private name '{0}'."), + Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: b(4061, 1, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_can_4061", "Parameter '{0}' of constructor from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2: b(4062, 1, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2_4062", "Parameter '{0}' of constructor from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1: b(4063, 1, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1_4063", "Parameter '{0}' of constructor from exported class has or is using private name '{1}'."), + Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: b(4064, 1, "Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_mod_4064", "Parameter '{0}' of constructor signature from exported interface has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: b(4065, 1, "Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1_4065", "Parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'."), + Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: b(4066, 1, "Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4066", "Parameter '{0}' of call signature from exported interface has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: b(4067, 1, "Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1_4067", "Parameter '{0}' of call signature from exported interface has or is using private name '{1}'."), + Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: b(4068, 1, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module__4068", "Parameter '{0}' of public static method from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: b(4069, 1, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2_4069", "Parameter '{0}' of public static method from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: b(4070, 1, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1_4070", "Parameter '{0}' of public static method from exported class has or is using private name '{1}'."), + Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: b(4071, 1, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_c_4071", "Parameter '{0}' of public method from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: b(4072, 1, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2_4072", "Parameter '{0}' of public method from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: b(4073, 1, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1_4073", "Parameter '{0}' of public method from exported class has or is using private name '{1}'."), + Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2: b(4074, 1, "Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4074", "Parameter '{0}' of method from exported interface has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: b(4075, 1, "Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1_4075", "Parameter '{0}' of method from exported interface has or is using private name '{1}'."), + Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: b(4076, 1, "Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4076", "Parameter '{0}' of exported function has or is using name '{1}' from external module {2} but cannot be named."), + Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2: b(4077, 1, "Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2_4077", "Parameter '{0}' of exported function has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_exported_function_has_or_is_using_private_name_1: b(4078, 1, "Parameter_0_of_exported_function_has_or_is_using_private_name_1_4078", "Parameter '{0}' of exported function has or is using private name '{1}'."), + Exported_type_alias_0_has_or_is_using_private_name_1: b(4081, 1, "Exported_type_alias_0_has_or_is_using_private_name_1_4081", "Exported type alias '{0}' has or is using private name '{1}'."), + Default_export_of_the_module_has_or_is_using_private_name_0: b(4082, 1, "Default_export_of_the_module_has_or_is_using_private_name_0_4082", "Default export of the module has or is using private name '{0}'."), + Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1: b(4083, 1, "Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1_4083", "Type parameter '{0}' of exported type alias has or is using private name '{1}'."), + Exported_type_alias_0_has_or_is_using_private_name_1_from_module_2: b(4084, 1, "Exported_type_alias_0_has_or_is_using_private_name_1_from_module_2_4084", "Exported type alias '{0}' has or is using private name '{1}' from module {2}."), + Extends_clause_for_inferred_type_0_has_or_is_using_private_name_1: b(4085, 1, "Extends_clause_for_inferred_type_0_has_or_is_using_private_name_1_4085", "Extends clause for inferred type '{0}' has or is using private name '{1}'."), + Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: b(4091, 1, "Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4091", "Parameter '{0}' of index signature from exported interface has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1: b(4092, 1, "Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1_4092", "Parameter '{0}' of index signature from exported interface has or is using private name '{1}'."), + Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected: b(4094, 1, "Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094", "Property '{0}' of exported anonymous class type may not be private or protected."), + Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: b(4095, 1, "Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_4095", "Public static method '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), + Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: b(4096, 1, "Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4096", "Public static method '{0}' of exported class has or is using name '{1}' from private module '{2}'."), + Public_static_method_0_of_exported_class_has_or_is_using_private_name_1: b(4097, 1, "Public_static_method_0_of_exported_class_has_or_is_using_private_name_1_4097", "Public static method '{0}' of exported class has or is using private name '{1}'."), + Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: b(4098, 1, "Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4098", "Public method '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), + Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: b(4099, 1, "Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4099", "Public method '{0}' of exported class has or is using name '{1}' from private module '{2}'."), + Public_method_0_of_exported_class_has_or_is_using_private_name_1: b(4100, 1, "Public_method_0_of_exported_class_has_or_is_using_private_name_1_4100", "Public method '{0}' of exported class has or is using private name '{1}'."), + Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: b(4101, 1, "Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2_4101", "Method '{0}' of exported interface has or is using name '{1}' from private module '{2}'."), + Method_0_of_exported_interface_has_or_is_using_private_name_1: b(4102, 1, "Method_0_of_exported_interface_has_or_is_using_private_name_1_4102", "Method '{0}' of exported interface has or is using private name '{1}'."), + Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1: b(4103, 1, "Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1_4103", "Type parameter '{0}' of exported mapped object type is using private name '{1}'."), + The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1: b(4104, 1, "The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1_4104", "The type '{0}' is 'readonly' and cannot be assigned to the mutable type '{1}'."), + Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter: b(4105, 1, "Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter_4105", "Private or protected member '{0}' cannot be accessed on a type parameter."), + Parameter_0_of_accessor_has_or_is_using_private_name_1: b(4106, 1, "Parameter_0_of_accessor_has_or_is_using_private_name_1_4106", "Parameter '{0}' of accessor has or is using private name '{1}'."), + Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2: b(4107, 1, "Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2_4107", "Parameter '{0}' of accessor has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: b(4108, 1, "Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4108", "Parameter '{0}' of accessor has or is using name '{1}' from external module '{2}' but cannot be named."), + Type_arguments_for_0_circularly_reference_themselves: b(4109, 1, "Type_arguments_for_0_circularly_reference_themselves_4109", "Type arguments for '{0}' circularly reference themselves."), + Tuple_type_arguments_circularly_reference_themselves: b(4110, 1, "Tuple_type_arguments_circularly_reference_themselves_4110", "Tuple type arguments circularly reference themselves."), + Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0: b(4111, 1, "Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0_4111", "Property '{0}' comes from an index signature, so it must be accessed with ['{0}']."), + This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class: b(4112, 1, "This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another__4112", "This member cannot have an 'override' modifier because its containing class '{0}' does not extend another class."), + This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0: b(4113, 1, "This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_4113", "This member cannot have an 'override' modifier because it is not declared in the base class '{0}'."), + This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0: b(4114, 1, "This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0_4114", "This member must have an 'override' modifier because it overrides a member in the base class '{0}'."), + This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0: b(4115, 1, "This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0_4115", "This parameter property must have an 'override' modifier because it overrides a member in base class '{0}'."), + This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0: b(4116, 1, "This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared__4116", "This member must have an 'override' modifier because it overrides an abstract method that is declared in the base class '{0}'."), + This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1: b(4117, 1, "This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you__4117", "This member cannot have an 'override' modifier because it is not declared in the base class '{0}'. Did you mean '{1}'?"), + The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized: b(4118, 1, "The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized_4118", "The type of this node cannot be serialized because its property '{0}' cannot be serialized."), + This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0: b(4119, 1, "This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_4119", "This member must have a JSDoc comment with an '@override' tag because it overrides a member in the base class '{0}'."), + This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0: b(4120, 1, "This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_4120", "This parameter property must have a JSDoc comment with an '@override' tag because it overrides a member in the base class '{0}'."), + This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class: b(4121, 1, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_4121", "This member cannot have a JSDoc comment with an '@override' tag because its containing class '{0}' does not extend another class."), + This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0: b(4122, 1, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base__4122", "This member cannot have a JSDoc comment with an '@override' tag because it is not declared in the base class '{0}'."), + This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1: b(4123, 1, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base__4123", "This member cannot have a JSDoc comment with an 'override' tag because it is not declared in the base class '{0}'. Did you mean '{1}'?"), + Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: b(4124, 1, "Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_w_4124", "Compiler option '{0}' of value '{1}' is unstable. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."), + Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given: b(4125, 1, "Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given_4125", "Each declaration of '{0}.{1}' differs in its value, where '{2}' was expected but '{3}' was given."), + One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value: b(4126, 1, "One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value_4126", "One value of '{0}.{1}' is the string '{2}', and the other is assumed to be an unknown numeric value."), + This_member_cannot_have_an_override_modifier_because_its_name_is_dynamic: b(4127, 1, "This_member_cannot_have_an_override_modifier_because_its_name_is_dynamic_4127", "This member cannot have an 'override' modifier because its name is dynamic."), + This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_name_is_dynamic: b(4128, 1, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_name_is_dynamic_4128", "This member cannot have a JSDoc comment with an '@override' tag because its name is dynamic."), + The_current_host_does_not_support_the_0_option: b(5001, 1, "The_current_host_does_not_support_the_0_option_5001", "The current host does not support the '{0}' option."), + Cannot_find_the_common_subdirectory_path_for_the_input_files: b(5009, 1, "Cannot_find_the_common_subdirectory_path_for_the_input_files_5009", "Cannot find the common subdirectory path for the input files."), + File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: b(5010, 1, "File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0_5010", "File specification cannot end in a recursive directory wildcard ('**'): '{0}'."), + Cannot_read_file_0_Colon_1: b(5012, 1, "Cannot_read_file_0_Colon_1_5012", "Cannot read file '{0}': {1}."), + Unknown_compiler_option_0: b(5023, 1, "Unknown_compiler_option_0_5023", "Unknown compiler option '{0}'."), + Compiler_option_0_requires_a_value_of_type_1: b(5024, 1, "Compiler_option_0_requires_a_value_of_type_1_5024", "Compiler option '{0}' requires a value of type {1}."), + Unknown_compiler_option_0_Did_you_mean_1: b(5025, 1, "Unknown_compiler_option_0_Did_you_mean_1_5025", "Unknown compiler option '{0}'. Did you mean '{1}'?"), + Could_not_write_file_0_Colon_1: b(5033, 1, "Could_not_write_file_0_Colon_1_5033", "Could not write file '{0}': {1}."), + Option_project_cannot_be_mixed_with_source_files_on_a_command_line: b(5042, 1, "Option_project_cannot_be_mixed_with_source_files_on_a_command_line_5042", "Option 'project' cannot be mixed with source files on a command line."), + Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher: b(5047, 1, "Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES_5047", "Option 'isolatedModules' can only be used when either option '--module' is provided or option 'target' is 'ES2015' or higher."), + Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided: b(5051, 1, "Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided_5051", "Option '{0} can only be used when either option '--inlineSourceMap' or option '--sourceMap' is provided."), + Option_0_cannot_be_specified_without_specifying_option_1: b(5052, 1, "Option_0_cannot_be_specified_without_specifying_option_1_5052", "Option '{0}' cannot be specified without specifying option '{1}'."), + Option_0_cannot_be_specified_with_option_1: b(5053, 1, "Option_0_cannot_be_specified_with_option_1_5053", "Option '{0}' cannot be specified with option '{1}'."), + A_tsconfig_json_file_is_already_defined_at_Colon_0: b(5054, 1, "A_tsconfig_json_file_is_already_defined_at_Colon_0_5054", "A 'tsconfig.json' file is already defined at: '{0}'."), + Cannot_write_file_0_because_it_would_overwrite_input_file: b(5055, 1, "Cannot_write_file_0_because_it_would_overwrite_input_file_5055", "Cannot write file '{0}' because it would overwrite input file."), + Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files: b(5056, 1, "Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files_5056", "Cannot write file '{0}' because it would be overwritten by multiple input files."), + Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0: b(5057, 1, "Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0_5057", "Cannot find a tsconfig.json file at the specified directory: '{0}'."), + The_specified_path_does_not_exist_Colon_0: b(5058, 1, "The_specified_path_does_not_exist_Colon_0_5058", "The specified path does not exist: '{0}'."), + Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier: b(5059, 1, "Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier_5059", "Invalid value for '--reactNamespace'. '{0}' is not a valid identifier."), + Pattern_0_can_have_at_most_one_Asterisk_character: b(5061, 1, "Pattern_0_can_have_at_most_one_Asterisk_character_5061", "Pattern '{0}' can have at most one '*' character."), + Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character: b(5062, 1, "Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character_5062", "Substitution '{0}' in pattern '{1}' can have at most one '*' character."), + Substitutions_for_pattern_0_should_be_an_array: b(5063, 1, "Substitutions_for_pattern_0_should_be_an_array_5063", "Substitutions for pattern '{0}' should be an array."), + Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2: b(5064, 1, "Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2_5064", "Substitution '{0}' for pattern '{1}' has incorrect type, expected 'string', got '{2}'."), + File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: b(5065, 1, "File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildca_5065", "File specification cannot contain a parent directory ('..') that appears after a recursive directory wildcard ('**'): '{0}'."), + Substitutions_for_pattern_0_shouldn_t_be_an_empty_array: b(5066, 1, "Substitutions_for_pattern_0_shouldn_t_be_an_empty_array_5066", "Substitutions for pattern '{0}' shouldn't be an empty array."), + Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name: b(5067, 1, "Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name_5067", "Invalid value for 'jsxFactory'. '{0}' is not a valid identifier or qualified-name."), + Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript_files_Learn_more_at_https_Colon_Slash_Slashaka_ms_Slashtsconfig: b(5068, 1, "Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript__5068", "Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig."), + Option_0_cannot_be_specified_without_specifying_option_1_or_option_2: b(5069, 1, "Option_0_cannot_be_specified_without_specifying_option_1_or_option_2_5069", "Option '{0}' cannot be specified without specifying option '{1}' or option '{2}'."), + Option_resolveJsonModule_cannot_be_specified_when_moduleResolution_is_set_to_classic: b(5070, 1, "Option_resolveJsonModule_cannot_be_specified_when_moduleResolution_is_set_to_classic_5070", "Option '--resolveJsonModule' cannot be specified when 'moduleResolution' is set to 'classic'."), + Option_resolveJsonModule_cannot_be_specified_when_module_is_set_to_none_system_or_umd: b(5071, 1, "Option_resolveJsonModule_cannot_be_specified_when_module_is_set_to_none_system_or_umd_5071", "Option '--resolveJsonModule' cannot be specified when 'module' is set to 'none', 'system', or 'umd'."), + Unknown_build_option_0: b(5072, 1, "Unknown_build_option_0_5072", "Unknown build option '{0}'."), + Build_option_0_requires_a_value_of_type_1: b(5073, 1, "Build_option_0_requires_a_value_of_type_1_5073", "Build option '{0}' requires a value of type {1}."), + Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified: b(5074, 1, "Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBui_5074", "Option '--incremental' can only be specified using tsconfig, emitting to single file or when option '--tsBuildInfoFile' is specified."), + _0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2: b(5075, 1, "_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_5075", "'{0}' is assignable to the constraint of type '{1}', but '{1}' could be instantiated with a different subtype of constraint '{2}'."), + _0_and_1_operations_cannot_be_mixed_without_parentheses: b(5076, 1, "_0_and_1_operations_cannot_be_mixed_without_parentheses_5076", "'{0}' and '{1}' operations cannot be mixed without parentheses."), + Unknown_build_option_0_Did_you_mean_1: b(5077, 1, "Unknown_build_option_0_Did_you_mean_1_5077", "Unknown build option '{0}'. Did you mean '{1}'?"), + Unknown_watch_option_0: b(5078, 1, "Unknown_watch_option_0_5078", "Unknown watch option '{0}'."), + Unknown_watch_option_0_Did_you_mean_1: b(5079, 1, "Unknown_watch_option_0_Did_you_mean_1_5079", "Unknown watch option '{0}'. Did you mean '{1}'?"), + Watch_option_0_requires_a_value_of_type_1: b(5080, 1, "Watch_option_0_requires_a_value_of_type_1_5080", "Watch option '{0}' requires a value of type {1}."), + Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0: b(5081, 1, "Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0_5081", "Cannot find a tsconfig.json file at the current directory: {0}."), + _0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1: b(5082, 1, "_0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1_5082", "'{0}' could be instantiated with an arbitrary type which could be unrelated to '{1}'."), + Cannot_read_file_0: b(5083, 1, "Cannot_read_file_0_5083", "Cannot read file '{0}'."), + A_tuple_member_cannot_be_both_optional_and_rest: b(5085, 1, "A_tuple_member_cannot_be_both_optional_and_rest_5085", "A tuple member cannot be both optional and rest."), + A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type: b(5086, 1, "A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_c_5086", "A labeled tuple element is declared as optional with a question mark after the name and before the colon, rather than after the type."), + A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type: b(5087, 1, "A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type_5087", "A labeled tuple element is declared as rest with a '...' before the name, rather than before the type."), + The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialized_A_type_annotation_is_necessary: b(5088, 1, "The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialize_5088", "The inferred type of '{0}' references a type with a cyclic structure which cannot be trivially serialized. A type annotation is necessary."), + Option_0_cannot_be_specified_when_option_jsx_is_1: b(5089, 1, "Option_0_cannot_be_specified_when_option_jsx_is_1_5089", "Option '{0}' cannot be specified when option 'jsx' is '{1}'."), + Non_relative_paths_are_not_allowed_when_baseUrl_is_not_set_Did_you_forget_a_leading_Slash: b(5090, 1, "Non_relative_paths_are_not_allowed_when_baseUrl_is_not_set_Did_you_forget_a_leading_Slash_5090", "Non-relative paths are not allowed when 'baseUrl' is not set. Did you forget a leading './'?"), + Option_preserveConstEnums_cannot_be_disabled_when_0_is_enabled: b(5091, 1, "Option_preserveConstEnums_cannot_be_disabled_when_0_is_enabled_5091", "Option 'preserveConstEnums' cannot be disabled when '{0}' is enabled."), + The_root_value_of_a_0_file_must_be_an_object: b(5092, 1, "The_root_value_of_a_0_file_must_be_an_object_5092", "The root value of a '{0}' file must be an object."), + Compiler_option_0_may_only_be_used_with_build: b(5093, 1, "Compiler_option_0_may_only_be_used_with_build_5093", "Compiler option '--{0}' may only be used with '--build'."), + Compiler_option_0_may_not_be_used_with_build: b(5094, 1, "Compiler_option_0_may_not_be_used_with_build_5094", "Compiler option '--{0}' may not be used with '--build'."), + Option_0_can_only_be_used_when_module_is_set_to_preserve_or_to_es2015_or_later: b(5095, 1, "Option_0_can_only_be_used_when_module_is_set_to_preserve_or_to_es2015_or_later_5095", "Option '{0}' can only be used when 'module' is set to 'preserve' or to 'es2015' or later."), + Option_allowImportingTsExtensions_can_only_be_used_when_either_noEmit_or_emitDeclarationOnly_is_set: b(5096, 1, "Option_allowImportingTsExtensions_can_only_be_used_when_either_noEmit_or_emitDeclarationOnly_is_set_5096", "Option 'allowImportingTsExtensions' can only be used when either 'noEmit' or 'emitDeclarationOnly' is set."), + An_import_path_can_only_end_with_a_0_extension_when_allowImportingTsExtensions_is_enabled: b(5097, 1, "An_import_path_can_only_end_with_a_0_extension_when_allowImportingTsExtensions_is_enabled_5097", "An import path can only end with a '{0}' extension when 'allowImportingTsExtensions' is enabled."), + Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler: b(5098, 1, "Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler_5098", "Option '{0}' can only be used when 'moduleResolution' is set to 'node16', 'nodenext', or 'bundler'."), + Option_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_compilerOption_ignoreDeprecations_Colon_2_to_silence_this_error: b(5101, 1, "Option_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_compilerOption_ignoreDeprec_5101", `Option '{0}' is deprecated and will stop functioning in TypeScript {1}. Specify compilerOption '"ignoreDeprecations": "{2}"' to silence this error.`), + Option_0_has_been_removed_Please_remove_it_from_your_configuration: b(5102, 1, "Option_0_has_been_removed_Please_remove_it_from_your_configuration_5102", "Option '{0}' has been removed. Please remove it from your configuration."), + Invalid_value_for_ignoreDeprecations: b(5103, 1, "Invalid_value_for_ignoreDeprecations_5103", "Invalid value for '--ignoreDeprecations'."), + Option_0_is_redundant_and_cannot_be_specified_with_option_1: b(5104, 1, "Option_0_is_redundant_and_cannot_be_specified_with_option_1_5104", "Option '{0}' is redundant and cannot be specified with option '{1}'."), + Option_verbatimModuleSyntax_cannot_be_used_when_module_is_set_to_UMD_AMD_or_System: b(5105, 1, "Option_verbatimModuleSyntax_cannot_be_used_when_module_is_set_to_UMD_AMD_or_System_5105", "Option 'verbatimModuleSyntax' cannot be used when 'module' is set to 'UMD', 'AMD', or 'System'."), + Use_0_instead: b(5106, 3, "Use_0_instead_5106", "Use '{0}' instead."), + Option_0_1_is_deprecated_and_will_stop_functioning_in_TypeScript_2_Specify_compilerOption_ignoreDeprecations_Colon_3_to_silence_this_error: b(5107, 1, "Option_0_1_is_deprecated_and_will_stop_functioning_in_TypeScript_2_Specify_compilerOption_ignoreDepr_5107", `Option '{0}={1}' is deprecated and will stop functioning in TypeScript {2}. Specify compilerOption '"ignoreDeprecations": "{3}"' to silence this error.`), + Option_0_1_has_been_removed_Please_remove_it_from_your_configuration: b(5108, 1, "Option_0_1_has_been_removed_Please_remove_it_from_your_configuration_5108", "Option '{0}={1}' has been removed. Please remove it from your configuration."), + Option_moduleResolution_must_be_set_to_0_or_left_unspecified_when_option_module_is_set_to_1: b(5109, 1, "Option_moduleResolution_must_be_set_to_0_or_left_unspecified_when_option_module_is_set_to_1_5109", "Option 'moduleResolution' must be set to '{0}' (or left unspecified) when option 'module' is set to '{1}'."), + Option_module_must_be_set_to_0_when_option_moduleResolution_is_set_to_1: b(5110, 1, "Option_module_must_be_set_to_0_when_option_moduleResolution_is_set_to_1_5110", "Option 'module' must be set to '{0}' when option 'moduleResolution' is set to '{1}'."), + Generates_a_sourcemap_for_each_corresponding_d_ts_file: b(6e3, 3, "Generates_a_sourcemap_for_each_corresponding_d_ts_file_6000", "Generates a sourcemap for each corresponding '.d.ts' file."), + Concatenate_and_emit_output_to_single_file: b(6001, 3, "Concatenate_and_emit_output_to_single_file_6001", "Concatenate and emit output to single file."), + Generates_corresponding_d_ts_file: b(6002, 3, "Generates_corresponding_d_ts_file_6002", "Generates corresponding '.d.ts' file."), + Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations: b(6004, 3, "Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations_6004", "Specify the location where debugger should locate TypeScript files instead of source locations."), + Watch_input_files: b(6005, 3, "Watch_input_files_6005", "Watch input files."), + Redirect_output_structure_to_the_directory: b(6006, 3, "Redirect_output_structure_to_the_directory_6006", "Redirect output structure to the directory."), + Do_not_erase_const_enum_declarations_in_generated_code: b(6007, 3, "Do_not_erase_const_enum_declarations_in_generated_code_6007", "Do not erase const enum declarations in generated code."), + Do_not_emit_outputs_if_any_errors_were_reported: b(6008, 3, "Do_not_emit_outputs_if_any_errors_were_reported_6008", "Do not emit outputs if any errors were reported."), + Do_not_emit_comments_to_output: b(6009, 3, "Do_not_emit_comments_to_output_6009", "Do not emit comments to output."), + Do_not_emit_outputs: b(6010, 3, "Do_not_emit_outputs_6010", "Do not emit outputs."), + Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typechecking: b(6011, 3, "Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typech_6011", "Allow default imports from modules with no default export. This does not affect code emit, just typechecking."), + Skip_type_checking_of_declaration_files: b(6012, 3, "Skip_type_checking_of_declaration_files_6012", "Skip type checking of declaration files."), + Do_not_resolve_the_real_path_of_symlinks: b(6013, 3, "Do_not_resolve_the_real_path_of_symlinks_6013", "Do not resolve the real path of symlinks."), + Only_emit_d_ts_declaration_files: b(6014, 3, "Only_emit_d_ts_declaration_files_6014", "Only emit '.d.ts' declaration files."), + Specify_ECMAScript_target_version: b(6015, 3, "Specify_ECMAScript_target_version_6015", "Specify ECMAScript target version."), + Specify_module_code_generation: b(6016, 3, "Specify_module_code_generation_6016", "Specify module code generation."), + Print_this_message: b(6017, 3, "Print_this_message_6017", "Print this message."), + Print_the_compiler_s_version: b(6019, 3, "Print_the_compiler_s_version_6019", "Print the compiler's version."), + Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json: b(6020, 3, "Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json_6020", "Compile the project given the path to its configuration file, or to a folder with a 'tsconfig.json'."), + Syntax_Colon_0: b(6023, 3, "Syntax_Colon_0_6023", "Syntax: {0}"), + options: b(6024, 3, "options_6024", "options"), + file: b(6025, 3, "file_6025", "file"), + Examples_Colon_0: b(6026, 3, "Examples_Colon_0_6026", "Examples: {0}"), + Options_Colon: b(6027, 3, "Options_Colon_6027", "Options:"), + Version_0: b(6029, 3, "Version_0_6029", "Version {0}"), + Insert_command_line_options_and_files_from_a_file: b(6030, 3, "Insert_command_line_options_and_files_from_a_file_6030", "Insert command line options and files from a file."), + Starting_compilation_in_watch_mode: b(6031, 3, "Starting_compilation_in_watch_mode_6031", "Starting compilation in watch mode..."), + File_change_detected_Starting_incremental_compilation: b(6032, 3, "File_change_detected_Starting_incremental_compilation_6032", "File change detected. Starting incremental compilation..."), + KIND: b(6034, 3, "KIND_6034", "KIND"), + FILE: b(6035, 3, "FILE_6035", "FILE"), + VERSION: b(6036, 3, "VERSION_6036", "VERSION"), + LOCATION: b(6037, 3, "LOCATION_6037", "LOCATION"), + DIRECTORY: b(6038, 3, "DIRECTORY_6038", "DIRECTORY"), + STRATEGY: b(6039, 3, "STRATEGY_6039", "STRATEGY"), + FILE_OR_DIRECTORY: b(6040, 3, "FILE_OR_DIRECTORY_6040", "FILE OR DIRECTORY"), + Errors_Files: b(6041, 3, "Errors_Files_6041", "Errors Files"), + Generates_corresponding_map_file: b(6043, 3, "Generates_corresponding_map_file_6043", "Generates corresponding '.map' file."), + Compiler_option_0_expects_an_argument: b(6044, 1, "Compiler_option_0_expects_an_argument_6044", "Compiler option '{0}' expects an argument."), + Unterminated_quoted_string_in_response_file_0: b(6045, 1, "Unterminated_quoted_string_in_response_file_0_6045", "Unterminated quoted string in response file '{0}'."), + Argument_for_0_option_must_be_Colon_1: b(6046, 1, "Argument_for_0_option_must_be_Colon_1_6046", "Argument for '{0}' option must be: {1}."), + Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1: b(6048, 1, "Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1_6048", "Locale must be of the form or -. For example '{0}' or '{1}'."), + Unable_to_open_file_0: b(6050, 1, "Unable_to_open_file_0_6050", "Unable to open file '{0}'."), + Corrupted_locale_file_0: b(6051, 1, "Corrupted_locale_file_0_6051", "Corrupted locale file {0}."), + Raise_error_on_expressions_and_declarations_with_an_implied_any_type: b(6052, 3, "Raise_error_on_expressions_and_declarations_with_an_implied_any_type_6052", "Raise error on expressions and declarations with an implied 'any' type."), + File_0_not_found: b(6053, 1, "File_0_not_found_6053", "File '{0}' not found."), + File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1: b(6054, 1, "File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1_6054", "File '{0}' has an unsupported extension. The only supported extensions are {1}."), + Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: b(6055, 3, "Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures_6055", "Suppress noImplicitAny errors for indexing objects lacking index signatures."), + Do_not_emit_declarations_for_code_that_has_an_internal_annotation: b(6056, 3, "Do_not_emit_declarations_for_code_that_has_an_internal_annotation_6056", "Do not emit declarations for code that has an '@internal' annotation."), + Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir: b(6058, 3, "Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir_6058", "Specify the root directory of input files. Use to control the output directory structure with --outDir."), + File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files: b(6059, 1, "File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files_6059", "File '{0}' is not under 'rootDir' '{1}'. 'rootDir' is expected to contain all source files."), + Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: b(6060, 3, "Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix_6060", "Specify the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)."), + NEWLINE: b(6061, 3, "NEWLINE_6061", "NEWLINE"), + Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line: b(6064, 1, "Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line_6064", "Option '{0}' can only be specified in 'tsconfig.json' file or set to 'null' on command line."), + Enables_experimental_support_for_ES7_decorators: b(6065, 3, "Enables_experimental_support_for_ES7_decorators_6065", "Enables experimental support for ES7 decorators."), + Enables_experimental_support_for_emitting_type_metadata_for_decorators: b(6066, 3, "Enables_experimental_support_for_emitting_type_metadata_for_decorators_6066", "Enables experimental support for emitting type metadata for decorators."), + Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file: b(6070, 3, "Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file_6070", "Initializes a TypeScript project and creates a tsconfig.json file."), + Successfully_created_a_tsconfig_json_file: b(6071, 3, "Successfully_created_a_tsconfig_json_file_6071", "Successfully created a tsconfig.json file."), + Suppress_excess_property_checks_for_object_literals: b(6072, 3, "Suppress_excess_property_checks_for_object_literals_6072", "Suppress excess property checks for object literals."), + Stylize_errors_and_messages_using_color_and_context_experimental: b(6073, 3, "Stylize_errors_and_messages_using_color_and_context_experimental_6073", "Stylize errors and messages using color and context (experimental)."), + Do_not_report_errors_on_unused_labels: b(6074, 3, "Do_not_report_errors_on_unused_labels_6074", "Do not report errors on unused labels."), + Report_error_when_not_all_code_paths_in_function_return_a_value: b(6075, 3, "Report_error_when_not_all_code_paths_in_function_return_a_value_6075", "Report error when not all code paths in function return a value."), + Report_errors_for_fallthrough_cases_in_switch_statement: b(6076, 3, "Report_errors_for_fallthrough_cases_in_switch_statement_6076", "Report errors for fallthrough cases in switch statement."), + Do_not_report_errors_on_unreachable_code: b(6077, 3, "Do_not_report_errors_on_unreachable_code_6077", "Do not report errors on unreachable code."), + Disallow_inconsistently_cased_references_to_the_same_file: b(6078, 3, "Disallow_inconsistently_cased_references_to_the_same_file_6078", "Disallow inconsistently-cased references to the same file."), + Specify_library_files_to_be_included_in_the_compilation: b(6079, 3, "Specify_library_files_to_be_included_in_the_compilation_6079", "Specify library files to be included in the compilation."), + Specify_JSX_code_generation: b(6080, 3, "Specify_JSX_code_generation_6080", "Specify JSX code generation."), + Only_amd_and_system_modules_are_supported_alongside_0: b(6082, 1, "Only_amd_and_system_modules_are_supported_alongside_0_6082", "Only 'amd' and 'system' modules are supported alongside --{0}."), + Base_directory_to_resolve_non_absolute_module_names: b(6083, 3, "Base_directory_to_resolve_non_absolute_module_names_6083", "Base directory to resolve non-absolute module names."), + Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react_JSX_emit: b(6084, 3, "Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react__6084", "[Deprecated] Use '--jsxFactory' instead. Specify the object invoked for createElement when targeting 'react' JSX emit"), + Enable_tracing_of_the_name_resolution_process: b(6085, 3, "Enable_tracing_of_the_name_resolution_process_6085", "Enable tracing of the name resolution process."), + Resolving_module_0_from_1: b(6086, 3, "Resolving_module_0_from_1_6086", "======== Resolving module '{0}' from '{1}'. ========"), + Explicitly_specified_module_resolution_kind_Colon_0: b(6087, 3, "Explicitly_specified_module_resolution_kind_Colon_0_6087", "Explicitly specified module resolution kind: '{0}'."), + Module_resolution_kind_is_not_specified_using_0: b(6088, 3, "Module_resolution_kind_is_not_specified_using_0_6088", "Module resolution kind is not specified, using '{0}'."), + Module_name_0_was_successfully_resolved_to_1: b(6089, 3, "Module_name_0_was_successfully_resolved_to_1_6089", "======== Module name '{0}' was successfully resolved to '{1}'. ========"), + Module_name_0_was_not_resolved: b(6090, 3, "Module_name_0_was_not_resolved_6090", "======== Module name '{0}' was not resolved. ========"), + paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0: b(6091, 3, "paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0_6091", "'paths' option is specified, looking for a pattern to match module name '{0}'."), + Module_name_0_matched_pattern_1: b(6092, 3, "Module_name_0_matched_pattern_1_6092", "Module name '{0}', matched pattern '{1}'."), + Trying_substitution_0_candidate_module_location_Colon_1: b(6093, 3, "Trying_substitution_0_candidate_module_location_Colon_1_6093", "Trying substitution '{0}', candidate module location: '{1}'."), + Resolving_module_name_0_relative_to_base_url_1_2: b(6094, 3, "Resolving_module_name_0_relative_to_base_url_1_2_6094", "Resolving module name '{0}' relative to base url '{1}' - '{2}'."), + Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_types_Colon_1: b(6095, 3, "Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_types_Colon_1_6095", "Loading module as file / folder, candidate module location '{0}', target file types: {1}."), + File_0_does_not_exist: b(6096, 3, "File_0_does_not_exist_6096", "File '{0}' does not exist."), + File_0_exists_use_it_as_a_name_resolution_result: b(6097, 3, "File_0_exists_use_it_as_a_name_resolution_result_6097", "File '{0}' exists - use it as a name resolution result."), + Loading_module_0_from_node_modules_folder_target_file_types_Colon_1: b(6098, 3, "Loading_module_0_from_node_modules_folder_target_file_types_Colon_1_6098", "Loading module '{0}' from 'node_modules' folder, target file types: {1}."), + Found_package_json_at_0: b(6099, 3, "Found_package_json_at_0_6099", "Found 'package.json' at '{0}'."), + package_json_does_not_have_a_0_field: b(6100, 3, "package_json_does_not_have_a_0_field_6100", "'package.json' does not have a '{0}' field."), + package_json_has_0_field_1_that_references_2: b(6101, 3, "package_json_has_0_field_1_that_references_2_6101", "'package.json' has '{0}' field '{1}' that references '{2}'."), + Allow_javascript_files_to_be_compiled: b(6102, 3, "Allow_javascript_files_to_be_compiled_6102", "Allow javascript files to be compiled."), + Checking_if_0_is_the_longest_matching_prefix_for_1_2: b(6104, 3, "Checking_if_0_is_the_longest_matching_prefix_for_1_2_6104", "Checking if '{0}' is the longest matching prefix for '{1}' - '{2}'."), + Expected_type_of_0_field_in_package_json_to_be_1_got_2: b(6105, 3, "Expected_type_of_0_field_in_package_json_to_be_1_got_2_6105", "Expected type of '{0}' field in 'package.json' to be '{1}', got '{2}'."), + baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1: b(6106, 3, "baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1_6106", "'baseUrl' option is set to '{0}', using this value to resolve non-relative module name '{1}'."), + rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0: b(6107, 3, "rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0_6107", "'rootDirs' option is set, using it to resolve relative module name '{0}'."), + Longest_matching_prefix_for_0_is_1: b(6108, 3, "Longest_matching_prefix_for_0_is_1_6108", "Longest matching prefix for '{0}' is '{1}'."), + Loading_0_from_the_root_dir_1_candidate_location_2: b(6109, 3, "Loading_0_from_the_root_dir_1_candidate_location_2_6109", "Loading '{0}' from the root dir '{1}', candidate location '{2}'."), + Trying_other_entries_in_rootDirs: b(6110, 3, "Trying_other_entries_in_rootDirs_6110", "Trying other entries in 'rootDirs'."), + Module_resolution_using_rootDirs_has_failed: b(6111, 3, "Module_resolution_using_rootDirs_has_failed_6111", "Module resolution using 'rootDirs' has failed."), + Do_not_emit_use_strict_directives_in_module_output: b(6112, 3, "Do_not_emit_use_strict_directives_in_module_output_6112", "Do not emit 'use strict' directives in module output."), + Enable_strict_null_checks: b(6113, 3, "Enable_strict_null_checks_6113", "Enable strict null checks."), + Unknown_option_excludes_Did_you_mean_exclude: b(6114, 1, "Unknown_option_excludes_Did_you_mean_exclude_6114", "Unknown option 'excludes'. Did you mean 'exclude'?"), + Raise_error_on_this_expressions_with_an_implied_any_type: b(6115, 3, "Raise_error_on_this_expressions_with_an_implied_any_type_6115", "Raise error on 'this' expressions with an implied 'any' type."), + Resolving_type_reference_directive_0_containing_file_1_root_directory_2: b(6116, 3, "Resolving_type_reference_directive_0_containing_file_1_root_directory_2_6116", "======== Resolving type reference directive '{0}', containing file '{1}', root directory '{2}'. ========"), + Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2: b(6119, 3, "Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2_6119", "======== Type reference directive '{0}' was successfully resolved to '{1}', primary: {2}. ========"), + Type_reference_directive_0_was_not_resolved: b(6120, 3, "Type_reference_directive_0_was_not_resolved_6120", "======== Type reference directive '{0}' was not resolved. ========"), + Resolving_with_primary_search_path_0: b(6121, 3, "Resolving_with_primary_search_path_0_6121", "Resolving with primary search path '{0}'."), + Root_directory_cannot_be_determined_skipping_primary_search_paths: b(6122, 3, "Root_directory_cannot_be_determined_skipping_primary_search_paths_6122", "Root directory cannot be determined, skipping primary search paths."), + Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set: b(6123, 3, "Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set_6123", "======== Resolving type reference directive '{0}', containing file '{1}', root directory not set. ========"), + Type_declaration_files_to_be_included_in_compilation: b(6124, 3, "Type_declaration_files_to_be_included_in_compilation_6124", "Type declaration files to be included in compilation."), + Looking_up_in_node_modules_folder_initial_location_0: b(6125, 3, "Looking_up_in_node_modules_folder_initial_location_0_6125", "Looking up in 'node_modules' folder, initial location '{0}'."), + Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder: b(6126, 3, "Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_mod_6126", "Containing file is not specified and root directory cannot be determined, skipping lookup in 'node_modules' folder."), + Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1: b(6127, 3, "Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1_6127", "======== Resolving type reference directive '{0}', containing file not set, root directory '{1}'. ========"), + Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set: b(6128, 3, "Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set_6128", "======== Resolving type reference directive '{0}', containing file not set, root directory not set. ========"), + Resolving_real_path_for_0_result_1: b(6130, 3, "Resolving_real_path_for_0_result_1_6130", "Resolving real path for '{0}', result '{1}'."), + Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system: b(6131, 1, "Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system_6131", "Cannot compile modules using option '{0}' unless the '--module' flag is 'amd' or 'system'."), + File_name_0_has_a_1_extension_stripping_it: b(6132, 3, "File_name_0_has_a_1_extension_stripping_it_6132", "File name '{0}' has a '{1}' extension - stripping it."), + _0_is_declared_but_its_value_is_never_read: b( + 6133, + 1, + "_0_is_declared_but_its_value_is_never_read_6133", + "'{0}' is declared but its value is never read.", + /*reportsUnnecessary*/ + !0 + ), + Report_errors_on_unused_locals: b(6134, 3, "Report_errors_on_unused_locals_6134", "Report errors on unused locals."), + Report_errors_on_unused_parameters: b(6135, 3, "Report_errors_on_unused_parameters_6135", "Report errors on unused parameters."), + The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files: b(6136, 3, "The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files_6136", "The maximum dependency depth to search under node_modules and load JavaScript files."), + Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1: b(6137, 1, "Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1_6137", "Cannot import type declaration files. Consider importing '{0}' instead of '{1}'."), + Property_0_is_declared_but_its_value_is_never_read: b( + 6138, + 1, + "Property_0_is_declared_but_its_value_is_never_read_6138", + "Property '{0}' is declared but its value is never read.", + /*reportsUnnecessary*/ + !0 + ), + Import_emit_helpers_from_tslib: b(6139, 3, "Import_emit_helpers_from_tslib_6139", "Import emit helpers from 'tslib'."), + Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2: b(6140, 1, "Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using__6140", "Auto discovery for typings is enabled in project '{0}'. Running extra resolution pass for module '{1}' using cache location '{2}'."), + Parse_in_strict_mode_and_emit_use_strict_for_each_source_file: b(6141, 3, "Parse_in_strict_mode_and_emit_use_strict_for_each_source_file_6141", 'Parse in strict mode and emit "use strict" for each source file.'), + Module_0_was_resolved_to_1_but_jsx_is_not_set: b(6142, 1, "Module_0_was_resolved_to_1_but_jsx_is_not_set_6142", "Module '{0}' was resolved to '{1}', but '--jsx' is not set."), + Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1: b(6144, 3, "Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1_6144", "Module '{0}' was resolved as locally declared ambient module in file '{1}'."), + Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h: b(6146, 3, "Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h_6146", "Specify the JSX factory function to use when targeting 'react' JSX emit, e.g. 'React.createElement' or 'h'."), + Resolution_for_module_0_was_found_in_cache_from_location_1: b(6147, 3, "Resolution_for_module_0_was_found_in_cache_from_location_1_6147", "Resolution for module '{0}' was found in cache from location '{1}'."), + Directory_0_does_not_exist_skipping_all_lookups_in_it: b(6148, 3, "Directory_0_does_not_exist_skipping_all_lookups_in_it_6148", "Directory '{0}' does not exist, skipping all lookups in it."), + Show_diagnostic_information: b(6149, 3, "Show_diagnostic_information_6149", "Show diagnostic information."), + Show_verbose_diagnostic_information: b(6150, 3, "Show_verbose_diagnostic_information_6150", "Show verbose diagnostic information."), + Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file: b(6151, 3, "Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file_6151", "Emit a single file with source maps instead of having a separate file."), + Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap_to_be_set: b(6152, 3, "Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap__6152", "Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set."), + Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule: b(6153, 3, "Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule_6153", "Transpile each file as a separate module (similar to 'ts.transpileModule')."), + Print_names_of_generated_files_part_of_the_compilation: b(6154, 3, "Print_names_of_generated_files_part_of_the_compilation_6154", "Print names of generated files part of the compilation."), + Print_names_of_files_part_of_the_compilation: b(6155, 3, "Print_names_of_files_part_of_the_compilation_6155", "Print names of files part of the compilation."), + The_locale_used_when_displaying_messages_to_the_user_e_g_en_us: b(6156, 3, "The_locale_used_when_displaying_messages_to_the_user_e_g_en_us_6156", "The locale used when displaying messages to the user (e.g. 'en-us')"), + Do_not_generate_custom_helper_functions_like_extends_in_compiled_output: b(6157, 3, "Do_not_generate_custom_helper_functions_like_extends_in_compiled_output_6157", "Do not generate custom helper functions like '__extends' in compiled output."), + Do_not_include_the_default_library_file_lib_d_ts: b(6158, 3, "Do_not_include_the_default_library_file_lib_d_ts_6158", "Do not include the default library file (lib.d.ts)."), + Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files: b(6159, 3, "Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files_6159", "Do not add triple-slash references or imported modules to the list of compiled files."), + Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files: b(6160, 3, "Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files_6160", "[Deprecated] Use '--skipLibCheck' instead. Skip type checking of default library declaration files."), + List_of_folders_to_include_type_definitions_from: b(6161, 3, "List_of_folders_to_include_type_definitions_from_6161", "List of folders to include type definitions from."), + Disable_size_limitations_on_JavaScript_projects: b(6162, 3, "Disable_size_limitations_on_JavaScript_projects_6162", "Disable size limitations on JavaScript projects."), + The_character_set_of_the_input_files: b(6163, 3, "The_character_set_of_the_input_files_6163", "The character set of the input files."), + Skipping_module_0_that_looks_like_an_absolute_URI_target_file_types_Colon_1: b(6164, 3, "Skipping_module_0_that_looks_like_an_absolute_URI_target_file_types_Colon_1_6164", "Skipping module '{0}' that looks like an absolute URI, target file types: {1}."), + Do_not_truncate_error_messages: b(6165, 3, "Do_not_truncate_error_messages_6165", "Do not truncate error messages."), + Output_directory_for_generated_declaration_files: b(6166, 3, "Output_directory_for_generated_declaration_files_6166", "Output directory for generated declaration files."), + A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl: b(6167, 3, "A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl_6167", "A series of entries which re-map imports to lookup locations relative to the 'baseUrl'."), + List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime: b(6168, 3, "List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime_6168", "List of root folders whose combined content represents the structure of the project at runtime."), + Show_all_compiler_options: b(6169, 3, "Show_all_compiler_options_6169", "Show all compiler options."), + Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file: b(6170, 3, "Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file_6170", "[Deprecated] Use '--outFile' instead. Concatenate and emit output to single file"), + Command_line_Options: b(6171, 3, "Command_line_Options_6171", "Command-line Options"), + Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5: b(6179, 3, "Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5_6179", "Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5'."), + Enable_all_strict_type_checking_options: b(6180, 3, "Enable_all_strict_type_checking_options_6180", "Enable all strict type-checking options."), + Scoped_package_detected_looking_in_0: b(6182, 3, "Scoped_package_detected_looking_in_0_6182", "Scoped package detected, looking in '{0}'"), + Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2: b(6183, 3, "Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_6183", "Reusing resolution of module '{0}' from '{1}' of old program, it was successfully resolved to '{2}'."), + Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3: b(6184, 3, "Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package__6184", "Reusing resolution of module '{0}' from '{1}' of old program, it was successfully resolved to '{2}' with Package ID '{3}'."), + Enable_strict_checking_of_function_types: b(6186, 3, "Enable_strict_checking_of_function_types_6186", "Enable strict checking of function types."), + Enable_strict_checking_of_property_initialization_in_classes: b(6187, 3, "Enable_strict_checking_of_property_initialization_in_classes_6187", "Enable strict checking of property initialization in classes."), + Numeric_separators_are_not_allowed_here: b(6188, 1, "Numeric_separators_are_not_allowed_here_6188", "Numeric separators are not allowed here."), + Multiple_consecutive_numeric_separators_are_not_permitted: b(6189, 1, "Multiple_consecutive_numeric_separators_are_not_permitted_6189", "Multiple consecutive numeric separators are not permitted."), + Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen: b(6191, 3, "Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen_6191", "Whether to keep outdated console output in watch mode instead of clearing the screen."), + All_imports_in_import_declaration_are_unused: b( + 6192, + 1, + "All_imports_in_import_declaration_are_unused_6192", + "All imports in import declaration are unused.", + /*reportsUnnecessary*/ + !0 + ), + Found_1_error_Watching_for_file_changes: b(6193, 3, "Found_1_error_Watching_for_file_changes_6193", "Found 1 error. Watching for file changes."), + Found_0_errors_Watching_for_file_changes: b(6194, 3, "Found_0_errors_Watching_for_file_changes_6194", "Found {0} errors. Watching for file changes."), + Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols: b(6195, 3, "Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols_6195", "Resolve 'keyof' to string valued property names only (no numbers or symbols)."), + _0_is_declared_but_never_used: b( + 6196, + 1, + "_0_is_declared_but_never_used_6196", + "'{0}' is declared but never used.", + /*reportsUnnecessary*/ + !0 + ), + Include_modules_imported_with_json_extension: b(6197, 3, "Include_modules_imported_with_json_extension_6197", "Include modules imported with '.json' extension"), + All_destructured_elements_are_unused: b( + 6198, + 1, + "All_destructured_elements_are_unused_6198", + "All destructured elements are unused.", + /*reportsUnnecessary*/ + !0 + ), + All_variables_are_unused: b( + 6199, + 1, + "All_variables_are_unused_6199", + "All variables are unused.", + /*reportsUnnecessary*/ + !0 + ), + Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0: b(6200, 1, "Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0_6200", "Definitions of the following identifiers conflict with those in another file: {0}"), + Conflicts_are_in_this_file: b(6201, 3, "Conflicts_are_in_this_file_6201", "Conflicts are in this file."), + Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0: b(6202, 1, "Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0_6202", "Project references may not form a circular graph. Cycle detected: {0}"), + _0_was_also_declared_here: b(6203, 3, "_0_was_also_declared_here_6203", "'{0}' was also declared here."), + and_here: b(6204, 3, "and_here_6204", "and here."), + All_type_parameters_are_unused: b(6205, 1, "All_type_parameters_are_unused_6205", "All type parameters are unused."), + package_json_has_a_typesVersions_field_with_version_specific_path_mappings: b(6206, 3, "package_json_has_a_typesVersions_field_with_version_specific_path_mappings_6206", "'package.json' has a 'typesVersions' field with version-specific path mappings."), + package_json_does_not_have_a_typesVersions_entry_that_matches_version_0: b(6207, 3, "package_json_does_not_have_a_typesVersions_entry_that_matches_version_0_6207", "'package.json' does not have a 'typesVersions' entry that matches version '{0}'."), + package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2: b(6208, 3, "package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_ma_6208", "'package.json' has a 'typesVersions' entry '{0}' that matches compiler version '{1}', looking for a pattern to match module name '{2}'."), + package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range: b(6209, 3, "package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range_6209", "'package.json' has a 'typesVersions' entry '{0}' that is not a valid semver range."), + An_argument_for_0_was_not_provided: b(6210, 3, "An_argument_for_0_was_not_provided_6210", "An argument for '{0}' was not provided."), + An_argument_matching_this_binding_pattern_was_not_provided: b(6211, 3, "An_argument_matching_this_binding_pattern_was_not_provided_6211", "An argument matching this binding pattern was not provided."), + Did_you_mean_to_call_this_expression: b(6212, 3, "Did_you_mean_to_call_this_expression_6212", "Did you mean to call this expression?"), + Did_you_mean_to_use_new_with_this_expression: b(6213, 3, "Did_you_mean_to_use_new_with_this_expression_6213", "Did you mean to use 'new' with this expression?"), + Enable_strict_bind_call_and_apply_methods_on_functions: b(6214, 3, "Enable_strict_bind_call_and_apply_methods_on_functions_6214", "Enable strict 'bind', 'call', and 'apply' methods on functions."), + Using_compiler_options_of_project_reference_redirect_0: b(6215, 3, "Using_compiler_options_of_project_reference_redirect_0_6215", "Using compiler options of project reference redirect '{0}'."), + Found_1_error: b(6216, 3, "Found_1_error_6216", "Found 1 error."), + Found_0_errors: b(6217, 3, "Found_0_errors_6217", "Found {0} errors."), + Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2: b(6218, 3, "Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2_6218", "======== Module name '{0}' was successfully resolved to '{1}' with Package ID '{2}'. ========"), + Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3: b(6219, 3, "Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3_6219", "======== Type reference directive '{0}' was successfully resolved to '{1}' with Package ID '{2}', primary: {3}. ========"), + package_json_had_a_falsy_0_field: b(6220, 3, "package_json_had_a_falsy_0_field_6220", "'package.json' had a falsy '{0}' field."), + Disable_use_of_source_files_instead_of_declaration_files_from_referenced_projects: b(6221, 3, "Disable_use_of_source_files_instead_of_declaration_files_from_referenced_projects_6221", "Disable use of source files instead of declaration files from referenced projects."), + Emit_class_fields_with_Define_instead_of_Set: b(6222, 3, "Emit_class_fields_with_Define_instead_of_Set_6222", "Emit class fields with Define instead of Set."), + Generates_a_CPU_profile: b(6223, 3, "Generates_a_CPU_profile_6223", "Generates a CPU profile."), + Disable_solution_searching_for_this_project: b(6224, 3, "Disable_solution_searching_for_this_project_6224", "Disable solution searching for this project."), + Specify_strategy_for_watching_file_Colon_FixedPollingInterval_default_PriorityPollingInterval_DynamicPriorityPolling_FixedChunkSizePolling_UseFsEvents_UseFsEventsOnParentDirectory: b(6225, 3, "Specify_strategy_for_watching_file_Colon_FixedPollingInterval_default_PriorityPollingInterval_Dynami_6225", "Specify strategy for watching file: 'FixedPollingInterval' (default), 'PriorityPollingInterval', 'DynamicPriorityPolling', 'FixedChunkSizePolling', 'UseFsEvents', 'UseFsEventsOnParentDirectory'."), + Specify_strategy_for_watching_directory_on_platforms_that_don_t_support_recursive_watching_natively_Colon_UseFsEvents_default_FixedPollingInterval_DynamicPriorityPolling_FixedChunkSizePolling: b(6226, 3, "Specify_strategy_for_watching_directory_on_platforms_that_don_t_support_recursive_watching_natively__6226", "Specify strategy for watching directory on platforms that don't support recursive watching natively: 'UseFsEvents' (default), 'FixedPollingInterval', 'DynamicPriorityPolling', 'FixedChunkSizePolling'."), + Specify_strategy_for_creating_a_polling_watch_when_it_fails_to_create_using_file_system_events_Colon_FixedInterval_default_PriorityInterval_DynamicPriority_FixedChunkSize: b(6227, 3, "Specify_strategy_for_creating_a_polling_watch_when_it_fails_to_create_using_file_system_events_Colon_6227", "Specify strategy for creating a polling watch when it fails to create using file system events: 'FixedInterval' (default), 'PriorityInterval', 'DynamicPriority', 'FixedChunkSize'."), + Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3: b(6229, 1, "Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3_6229", "Tag '{0}' expects at least '{1}' arguments, but the JSX factory '{2}' provides at most '{3}'."), + Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line: b(6230, 1, "Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line_6230", "Option '{0}' can only be specified in 'tsconfig.json' file or set to 'false' or 'null' on command line."), + Could_not_resolve_the_path_0_with_the_extensions_Colon_1: b(6231, 1, "Could_not_resolve_the_path_0_with_the_extensions_Colon_1_6231", "Could not resolve the path '{0}' with the extensions: {1}."), + Declaration_augments_declaration_in_another_file_This_cannot_be_serialized: b(6232, 1, "Declaration_augments_declaration_in_another_file_This_cannot_be_serialized_6232", "Declaration augments declaration in another file. This cannot be serialized."), + This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_file: b(6233, 1, "This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_fil_6233", "This is the declaration being augmented. Consider moving the augmenting declaration into the same file."), + This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without: b(6234, 1, "This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without_6234", "This expression is not callable because it is a 'get' accessor. Did you mean to use it without '()'?"), + Disable_loading_referenced_projects: b(6235, 3, "Disable_loading_referenced_projects_6235", "Disable loading referenced projects."), + Arguments_for_the_rest_parameter_0_were_not_provided: b(6236, 1, "Arguments_for_the_rest_parameter_0_were_not_provided_6236", "Arguments for the rest parameter '{0}' were not provided."), + Generates_an_event_trace_and_a_list_of_types: b(6237, 3, "Generates_an_event_trace_and_a_list_of_types_6237", "Generates an event trace and a list of types."), + Specify_the_module_specifier_to_be_used_to_import_the_jsx_and_jsxs_factory_functions_from_eg_react: b(6238, 1, "Specify_the_module_specifier_to_be_used_to_import_the_jsx_and_jsxs_factory_functions_from_eg_react_6238", "Specify the module specifier to be used to import the 'jsx' and 'jsxs' factory functions from. eg, react"), + File_0_exists_according_to_earlier_cached_lookups: b(6239, 3, "File_0_exists_according_to_earlier_cached_lookups_6239", "File '{0}' exists according to earlier cached lookups."), + File_0_does_not_exist_according_to_earlier_cached_lookups: b(6240, 3, "File_0_does_not_exist_according_to_earlier_cached_lookups_6240", "File '{0}' does not exist according to earlier cached lookups."), + Resolution_for_type_reference_directive_0_was_found_in_cache_from_location_1: b(6241, 3, "Resolution_for_type_reference_directive_0_was_found_in_cache_from_location_1_6241", "Resolution for type reference directive '{0}' was found in cache from location '{1}'."), + Resolving_type_reference_directive_0_containing_file_1: b(6242, 3, "Resolving_type_reference_directive_0_containing_file_1_6242", "======== Resolving type reference directive '{0}', containing file '{1}'. ========"), + Interpret_optional_property_types_as_written_rather_than_adding_undefined: b(6243, 3, "Interpret_optional_property_types_as_written_rather_than_adding_undefined_6243", "Interpret optional property types as written, rather than adding 'undefined'."), + Modules: b(6244, 3, "Modules_6244", "Modules"), + File_Management: b(6245, 3, "File_Management_6245", "File Management"), + Emit: b(6246, 3, "Emit_6246", "Emit"), + JavaScript_Support: b(6247, 3, "JavaScript_Support_6247", "JavaScript Support"), + Type_Checking: b(6248, 3, "Type_Checking_6248", "Type Checking"), + Editor_Support: b(6249, 3, "Editor_Support_6249", "Editor Support"), + Watch_and_Build_Modes: b(6250, 3, "Watch_and_Build_Modes_6250", "Watch and Build Modes"), + Compiler_Diagnostics: b(6251, 3, "Compiler_Diagnostics_6251", "Compiler Diagnostics"), + Interop_Constraints: b(6252, 3, "Interop_Constraints_6252", "Interop Constraints"), + Backwards_Compatibility: b(6253, 3, "Backwards_Compatibility_6253", "Backwards Compatibility"), + Language_and_Environment: b(6254, 3, "Language_and_Environment_6254", "Language and Environment"), + Projects: b(6255, 3, "Projects_6255", "Projects"), + Output_Formatting: b(6256, 3, "Output_Formatting_6256", "Output Formatting"), + Completeness: b(6257, 3, "Completeness_6257", "Completeness"), + _0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file: b(6258, 1, "_0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file_6258", "'{0}' should be set inside the 'compilerOptions' object of the config json file"), + Found_1_error_in_0: b(6259, 3, "Found_1_error_in_0_6259", "Found 1 error in {0}"), + Found_0_errors_in_the_same_file_starting_at_Colon_1: b(6260, 3, "Found_0_errors_in_the_same_file_starting_at_Colon_1_6260", "Found {0} errors in the same file, starting at: {1}"), + Found_0_errors_in_1_files: b(6261, 3, "Found_0_errors_in_1_files_6261", "Found {0} errors in {1} files."), + File_name_0_has_a_1_extension_looking_up_2_instead: b(6262, 3, "File_name_0_has_a_1_extension_looking_up_2_instead_6262", "File name '{0}' has a '{1}' extension - looking up '{2}' instead."), + Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set: b(6263, 1, "Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set_6263", "Module '{0}' was resolved to '{1}', but '--allowArbitraryExtensions' is not set."), + Enable_importing_files_with_any_extension_provided_a_declaration_file_is_present: b(6264, 3, "Enable_importing_files_with_any_extension_provided_a_declaration_file_is_present_6264", "Enable importing files with any extension, provided a declaration file is present."), + Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_node_modules_folder: b(6265, 3, "Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_no_6265", "Resolving type reference directive for program that specifies custom typeRoots, skipping lookup in 'node_modules' folder."), + Option_0_can_only_be_specified_on_command_line: b(6266, 1, "Option_0_can_only_be_specified_on_command_line_6266", "Option '{0}' can only be specified on command line."), + Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve: b(6270, 3, "Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve_6270", "Directory '{0}' has no containing package.json scope. Imports will not resolve."), + Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1: b(6271, 3, "Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6271", "Import specifier '{0}' does not exist in package.json scope at path '{1}'."), + Invalid_import_specifier_0_has_no_possible_resolutions: b(6272, 3, "Invalid_import_specifier_0_has_no_possible_resolutions_6272", "Invalid import specifier '{0}' has no possible resolutions."), + package_json_scope_0_has_no_imports_defined: b(6273, 3, "package_json_scope_0_has_no_imports_defined_6273", "package.json scope '{0}' has no imports defined."), + package_json_scope_0_explicitly_maps_specifier_1_to_null: b(6274, 3, "package_json_scope_0_explicitly_maps_specifier_1_to_null_6274", "package.json scope '{0}' explicitly maps specifier '{1}' to null."), + package_json_scope_0_has_invalid_type_for_target_of_specifier_1: b(6275, 3, "package_json_scope_0_has_invalid_type_for_target_of_specifier_1_6275", "package.json scope '{0}' has invalid type for target of specifier '{1}'"), + Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1: b(6276, 3, "Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6276", "Export specifier '{0}' does not exist in package.json scope at path '{1}'."), + Resolution_of_non_relative_name_failed_trying_with_modern_Node_resolution_features_disabled_to_see_if_npm_library_needs_configuration_update: b(6277, 3, "Resolution_of_non_relative_name_failed_trying_with_modern_Node_resolution_features_disabled_to_see_i_6277", "Resolution of non-relative name failed; trying with modern Node resolution features disabled to see if npm library needs configuration update."), + There_are_types_at_0_but_this_result_could_not_be_resolved_when_respecting_package_json_exports_The_1_library_may_need_to_update_its_package_json_or_typings: b(6278, 3, "There_are_types_at_0_but_this_result_could_not_be_resolved_when_respecting_package_json_exports_The__6278", `There are types at '{0}', but this result could not be resolved when respecting package.json "exports". The '{1}' library may need to update its package.json or typings.`), + Resolution_of_non_relative_name_failed_trying_with_moduleResolution_bundler_to_see_if_project_may_need_configuration_update: b(6279, 3, "Resolution_of_non_relative_name_failed_trying_with_moduleResolution_bundler_to_see_if_project_may_ne_6279", "Resolution of non-relative name failed; trying with '--moduleResolution bundler' to see if project may need configuration update."), + There_are_types_at_0_but_this_result_could_not_be_resolved_under_your_current_moduleResolution_setting_Consider_updating_to_node16_nodenext_or_bundler: b(6280, 3, "There_are_types_at_0_but_this_result_could_not_be_resolved_under_your_current_moduleResolution_setti_6280", "There are types at '{0}', but this result could not be resolved under your current 'moduleResolution' setting. Consider updating to 'node16', 'nodenext', or 'bundler'."), + package_json_has_a_peerDependencies_field: b(6281, 3, "package_json_has_a_peerDependencies_field_6281", "'package.json' has a 'peerDependencies' field."), + Found_peerDependency_0_with_1_version: b(6282, 3, "Found_peerDependency_0_with_1_version_6282", "Found peerDependency '{0}' with '{1}' version."), + Failed_to_find_peerDependency_0: b(6283, 3, "Failed_to_find_peerDependency_0_6283", "Failed to find peerDependency '{0}'."), + File_Layout: b(6284, 3, "File_Layout_6284", "File Layout"), + Environment_Settings: b(6285, 3, "Environment_Settings_6285", "Environment Settings"), + See_also_https_Colon_Slash_Slashaka_ms_Slashtsconfig_Slashmodule: b(6286, 3, "See_also_https_Colon_Slash_Slashaka_ms_Slashtsconfig_Slashmodule_6286", "See also https://aka.ms/tsconfig/module"), + For_nodejs_Colon: b(6287, 3, "For_nodejs_Colon_6287", "For nodejs:"), + and_npm_install_D_types_Slashnode: b(6290, 3, "and_npm_install_D_types_Slashnode_6290", "and npm install -D @types/node"), + Other_Outputs: b(6291, 3, "Other_Outputs_6291", "Other Outputs"), + Stricter_Typechecking_Options: b(6292, 3, "Stricter_Typechecking_Options_6292", "Stricter Typechecking Options"), + Style_Options: b(6293, 3, "Style_Options_6293", "Style Options"), + Recommended_Options: b(6294, 3, "Recommended_Options_6294", "Recommended Options"), + Enable_project_compilation: b(6302, 3, "Enable_project_compilation_6302", "Enable project compilation"), + Composite_projects_may_not_disable_declaration_emit: b(6304, 1, "Composite_projects_may_not_disable_declaration_emit_6304", "Composite projects may not disable declaration emit."), + Output_file_0_has_not_been_built_from_source_file_1: b(6305, 1, "Output_file_0_has_not_been_built_from_source_file_1_6305", "Output file '{0}' has not been built from source file '{1}'."), + Referenced_project_0_must_have_setting_composite_Colon_true: b(6306, 1, "Referenced_project_0_must_have_setting_composite_Colon_true_6306", `Referenced project '{0}' must have setting "composite": true.`), + File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_include_pattern: b(6307, 1, "File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_includ_6307", "File '{0}' is not listed within the file list of project '{1}'. Projects must list all files or use an 'include' pattern."), + Referenced_project_0_may_not_disable_emit: b(6310, 1, "Referenced_project_0_may_not_disable_emit_6310", "Referenced project '{0}' may not disable emit."), + Project_0_is_out_of_date_because_output_1_is_older_than_input_2: b(6350, 3, "Project_0_is_out_of_date_because_output_1_is_older_than_input_2_6350", "Project '{0}' is out of date because output '{1}' is older than input '{2}'"), + Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2: b(6351, 3, "Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2_6351", "Project '{0}' is up to date because newest input '{1}' is older than output '{2}'"), + Project_0_is_out_of_date_because_output_file_1_does_not_exist: b(6352, 3, "Project_0_is_out_of_date_because_output_file_1_does_not_exist_6352", "Project '{0}' is out of date because output file '{1}' does not exist"), + Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date: b(6353, 3, "Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date_6353", "Project '{0}' is out of date because its dependency '{1}' is out of date"), + Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies: b(6354, 3, "Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies_6354", "Project '{0}' is up to date with .d.ts files from its dependencies"), + Projects_in_this_build_Colon_0: b(6355, 3, "Projects_in_this_build_Colon_0_6355", "Projects in this build: {0}"), + A_non_dry_build_would_delete_the_following_files_Colon_0: b(6356, 3, "A_non_dry_build_would_delete_the_following_files_Colon_0_6356", "A non-dry build would delete the following files: {0}"), + A_non_dry_build_would_build_project_0: b(6357, 3, "A_non_dry_build_would_build_project_0_6357", "A non-dry build would build project '{0}'"), + Building_project_0: b(6358, 3, "Building_project_0_6358", "Building project '{0}'..."), + Updating_output_timestamps_of_project_0: b(6359, 3, "Updating_output_timestamps_of_project_0_6359", "Updating output timestamps of project '{0}'..."), + Project_0_is_up_to_date: b(6361, 3, "Project_0_is_up_to_date_6361", "Project '{0}' is up to date"), + Skipping_build_of_project_0_because_its_dependency_1_has_errors: b(6362, 3, "Skipping_build_of_project_0_because_its_dependency_1_has_errors_6362", "Skipping build of project '{0}' because its dependency '{1}' has errors"), + Project_0_can_t_be_built_because_its_dependency_1_has_errors: b(6363, 3, "Project_0_can_t_be_built_because_its_dependency_1_has_errors_6363", "Project '{0}' can't be built because its dependency '{1}' has errors"), + Build_one_or_more_projects_and_their_dependencies_if_out_of_date: b(6364, 3, "Build_one_or_more_projects_and_their_dependencies_if_out_of_date_6364", "Build one or more projects and their dependencies, if out of date"), + Delete_the_outputs_of_all_projects: b(6365, 3, "Delete_the_outputs_of_all_projects_6365", "Delete the outputs of all projects."), + Show_what_would_be_built_or_deleted_if_specified_with_clean: b(6367, 3, "Show_what_would_be_built_or_deleted_if_specified_with_clean_6367", "Show what would be built (or deleted, if specified with '--clean')"), + Option_build_must_be_the_first_command_line_argument: b(6369, 1, "Option_build_must_be_the_first_command_line_argument_6369", "Option '--build' must be the first command line argument."), + Options_0_and_1_cannot_be_combined: b(6370, 1, "Options_0_and_1_cannot_be_combined_6370", "Options '{0}' and '{1}' cannot be combined."), + Updating_unchanged_output_timestamps_of_project_0: b(6371, 3, "Updating_unchanged_output_timestamps_of_project_0_6371", "Updating unchanged output timestamps of project '{0}'..."), + A_non_dry_build_would_update_timestamps_for_output_of_project_0: b(6374, 3, "A_non_dry_build_would_update_timestamps_for_output_of_project_0_6374", "A non-dry build would update timestamps for output of project '{0}'"), + Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1: b(6377, 1, "Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1_6377", "Cannot write file '{0}' because it will overwrite '.tsbuildinfo' file generated by referenced project '{1}'"), + Composite_projects_may_not_disable_incremental_compilation: b(6379, 1, "Composite_projects_may_not_disable_incremental_compilation_6379", "Composite projects may not disable incremental compilation."), + Specify_file_to_store_incremental_compilation_information: b(6380, 3, "Specify_file_to_store_incremental_compilation_information_6380", "Specify file to store incremental compilation information"), + Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_current_version_2: b(6381, 3, "Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_curren_6381", "Project '{0}' is out of date because output for it was generated with version '{1}' that differs with current version '{2}'"), + Skipping_build_of_project_0_because_its_dependency_1_was_not_built: b(6382, 3, "Skipping_build_of_project_0_because_its_dependency_1_was_not_built_6382", "Skipping build of project '{0}' because its dependency '{1}' was not built"), + Project_0_can_t_be_built_because_its_dependency_1_was_not_built: b(6383, 3, "Project_0_can_t_be_built_because_its_dependency_1_was_not_built_6383", "Project '{0}' can't be built because its dependency '{1}' was not built"), + Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it: b(6384, 3, "Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_di_6384", "Have recompiles in '--incremental' and '--watch' assume that changes within a file will only affect files directly depending on it."), + _0_is_deprecated: b( + 6385, + 2, + "_0_is_deprecated_6385", + "'{0}' is deprecated.", + /*reportsUnnecessary*/ + void 0, + /*elidedInCompatabilityPyramid*/ + void 0, + /*reportsDeprecated*/ + !0 + ), + Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_native_implementation_of_the_Web_Performance_API_could_not_be_found: b(6386, 3, "Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_nativ_6386", "Performance timings for '--diagnostics' or '--extendedDiagnostics' are not available in this session. A native implementation of the Web Performance API could not be found."), + The_signature_0_of_1_is_deprecated: b( + 6387, + 2, + "The_signature_0_of_1_is_deprecated_6387", + "The signature '{0}' of '{1}' is deprecated.", + /*reportsUnnecessary*/ + void 0, + /*elidedInCompatabilityPyramid*/ + void 0, + /*reportsDeprecated*/ + !0 + ), + Project_0_is_being_forcibly_rebuilt: b(6388, 3, "Project_0_is_being_forcibly_rebuilt_6388", "Project '{0}' is being forcibly rebuilt"), + Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved: b(6389, 3, "Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved_6389", "Reusing resolution of module '{0}' from '{1}' of old program, it was not resolved."), + Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2: b(6390, 3, "Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved__6390", "Reusing resolution of type reference directive '{0}' from '{1}' of old program, it was successfully resolved to '{2}'."), + Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3: b(6391, 3, "Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved__6391", "Reusing resolution of type reference directive '{0}' from '{1}' of old program, it was successfully resolved to '{2}' with Package ID '{3}'."), + Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved: b(6392, 3, "Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved_6392", "Reusing resolution of type reference directive '{0}' from '{1}' of old program, it was not resolved."), + Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3: b(6393, 3, "Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_6393", "Reusing resolution of module '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}'."), + Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4: b(6394, 3, "Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_6394", "Reusing resolution of module '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}' with Package ID '{4}'."), + Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_not_resolved: b(6395, 3, "Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_not_resolved_6395", "Reusing resolution of module '{0}' from '{1}' found in cache from location '{2}', it was not resolved."), + Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3: b(6396, 3, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_succes_6396", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}'."), + Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4: b(6397, 3, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_succes_6397", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}' with Package ID '{4}'."), + Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_resolved: b(6398, 3, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_re_6398", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was not resolved."), + Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_were_not_emitted: b(6399, 3, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_were_not_emitte_6399", "Project '{0}' is out of date because buildinfo file '{1}' indicates that some of the changes were not emitted"), + Project_0_is_up_to_date_but_needs_to_update_timestamps_of_output_files_that_are_older_than_input_files: b(6400, 3, "Project_0_is_up_to_date_but_needs_to_update_timestamps_of_output_files_that_are_older_than_input_fil_6400", "Project '{0}' is up to date but needs to update timestamps of output files that are older than input files"), + Project_0_is_out_of_date_because_there_was_error_reading_file_1: b(6401, 3, "Project_0_is_out_of_date_because_there_was_error_reading_file_1_6401", "Project '{0}' is out of date because there was error reading file '{1}'"), + Resolving_in_0_mode_with_conditions_1: b(6402, 3, "Resolving_in_0_mode_with_conditions_1_6402", "Resolving in {0} mode with conditions {1}."), + Matched_0_condition_1: b(6403, 3, "Matched_0_condition_1_6403", "Matched '{0}' condition '{1}'."), + Using_0_subpath_1_with_target_2: b(6404, 3, "Using_0_subpath_1_with_target_2_6404", "Using '{0}' subpath '{1}' with target '{2}'."), + Saw_non_matching_condition_0: b(6405, 3, "Saw_non_matching_condition_0_6405", "Saw non-matching condition '{0}'."), + Project_0_is_out_of_date_because_buildinfo_file_1_indicates_there_is_change_in_compilerOptions: b(6406, 3, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_there_is_change_in_compilerOptions_6406", "Project '{0}' is out of date because buildinfo file '{1}' indicates there is change in compilerOptions"), + Allow_imports_to_include_TypeScript_file_extensions_Requires_moduleResolution_bundler_and_either_noEmit_or_emitDeclarationOnly_to_be_set: b(6407, 3, "Allow_imports_to_include_TypeScript_file_extensions_Requires_moduleResolution_bundler_and_either_noE_6407", "Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set."), + Use_the_package_json_exports_field_when_resolving_package_imports: b(6408, 3, "Use_the_package_json_exports_field_when_resolving_package_imports_6408", "Use the package.json 'exports' field when resolving package imports."), + Use_the_package_json_imports_field_when_resolving_imports: b(6409, 3, "Use_the_package_json_imports_field_when_resolving_imports_6409", "Use the package.json 'imports' field when resolving imports."), + Conditions_to_set_in_addition_to_the_resolver_specific_defaults_when_resolving_imports: b(6410, 3, "Conditions_to_set_in_addition_to_the_resolver_specific_defaults_when_resolving_imports_6410", "Conditions to set in addition to the resolver-specific defaults when resolving imports."), + true_when_moduleResolution_is_node16_nodenext_or_bundler_otherwise_false: b(6411, 3, "true_when_moduleResolution_is_node16_nodenext_or_bundler_otherwise_false_6411", "`true` when 'moduleResolution' is 'node16', 'nodenext', or 'bundler'; otherwise `false`."), + Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_file_2_was_root_file_of_compilation_but_not_any_more: b(6412, 3, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_file_2_was_root_file_of_compilation_6412", "Project '{0}' is out of date because buildinfo file '{1}' indicates that file '{2}' was root file of compilation but not any more."), + Entering_conditional_exports: b(6413, 3, "Entering_conditional_exports_6413", "Entering conditional exports."), + Resolved_under_condition_0: b(6414, 3, "Resolved_under_condition_0_6414", "Resolved under condition '{0}'."), + Failed_to_resolve_under_condition_0: b(6415, 3, "Failed_to_resolve_under_condition_0_6415", "Failed to resolve under condition '{0}'."), + Exiting_conditional_exports: b(6416, 3, "Exiting_conditional_exports_6416", "Exiting conditional exports."), + Searching_all_ancestor_node_modules_directories_for_preferred_extensions_Colon_0: b(6417, 3, "Searching_all_ancestor_node_modules_directories_for_preferred_extensions_Colon_0_6417", "Searching all ancestor node_modules directories for preferred extensions: {0}."), + Searching_all_ancestor_node_modules_directories_for_fallback_extensions_Colon_0: b(6418, 3, "Searching_all_ancestor_node_modules_directories_for_fallback_extensions_Colon_0_6418", "Searching all ancestor node_modules directories for fallback extensions: {0}."), + Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_program_needs_to_report_errors: b(6419, 3, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_program_needs_to_report_errors_6419", "Project '{0}' is out of date because buildinfo file '{1}' indicates that program needs to report errors."), + Project_0_is_out_of_date_because_1: b(6420, 3, "Project_0_is_out_of_date_because_1_6420", "Project '{0}' is out of date because {1}."), + Rewrite_ts_tsx_mts_and_cts_file_extensions_in_relative_import_paths_to_their_JavaScript_equivalent_in_output_files: b(6421, 3, "Rewrite_ts_tsx_mts_and_cts_file_extensions_in_relative_import_paths_to_their_JavaScript_equivalent_i_6421", "Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files."), + The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: b(6500, 3, "The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1_6500", "The expected type comes from property '{0}' which is declared here on type '{1}'"), + The_expected_type_comes_from_this_index_signature: b(6501, 3, "The_expected_type_comes_from_this_index_signature_6501", "The expected type comes from this index signature."), + The_expected_type_comes_from_the_return_type_of_this_signature: b(6502, 3, "The_expected_type_comes_from_the_return_type_of_this_signature_6502", "The expected type comes from the return type of this signature."), + Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing: b(6503, 3, "Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing_6503", "Print names of files that are part of the compilation and then stop processing."), + File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option: b(6504, 1, "File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option_6504", "File '{0}' is a JavaScript file. Did you mean to enable the 'allowJs' option?"), + Print_names_of_files_and_the_reason_they_are_part_of_the_compilation: b(6505, 3, "Print_names_of_files_and_the_reason_they_are_part_of_the_compilation_6505", "Print names of files and the reason they are part of the compilation."), + Consider_adding_a_declare_modifier_to_this_class: b(6506, 3, "Consider_adding_a_declare_modifier_to_this_class_6506", "Consider adding a 'declare' modifier to this class."), + Allow_JavaScript_files_to_be_a_part_of_your_program_Use_the_checkJs_option_to_get_errors_from_these_files: b(6600, 3, "Allow_JavaScript_files_to_be_a_part_of_your_program_Use_the_checkJs_option_to_get_errors_from_these__6600", "Allow JavaScript files to be a part of your program. Use the 'checkJs' option to get errors from these files."), + Allow_import_x_from_y_when_a_module_doesn_t_have_a_default_export: b(6601, 3, "Allow_import_x_from_y_when_a_module_doesn_t_have_a_default_export_6601", "Allow 'import x from y' when a module doesn't have a default export."), + Allow_accessing_UMD_globals_from_modules: b(6602, 3, "Allow_accessing_UMD_globals_from_modules_6602", "Allow accessing UMD globals from modules."), + Disable_error_reporting_for_unreachable_code: b(6603, 3, "Disable_error_reporting_for_unreachable_code_6603", "Disable error reporting for unreachable code."), + Disable_error_reporting_for_unused_labels: b(6604, 3, "Disable_error_reporting_for_unused_labels_6604", "Disable error reporting for unused labels."), + Ensure_use_strict_is_always_emitted: b(6605, 3, "Ensure_use_strict_is_always_emitted_6605", "Ensure 'use strict' is always emitted."), + Have_recompiles_in_projects_that_use_incremental_and_watch_mode_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it: b(6606, 3, "Have_recompiles_in_projects_that_use_incremental_and_watch_mode_assume_that_changes_within_a_file_wi_6606", "Have recompiles in projects that use 'incremental' and 'watch' mode assume that changes within a file will only affect files directly depending on it."), + Specify_the_base_directory_to_resolve_non_relative_module_names: b(6607, 3, "Specify_the_base_directory_to_resolve_non_relative_module_names_6607", "Specify the base directory to resolve non-relative module names."), + No_longer_supported_In_early_versions_manually_set_the_text_encoding_for_reading_files: b(6608, 3, "No_longer_supported_In_early_versions_manually_set_the_text_encoding_for_reading_files_6608", "No longer supported. In early versions, manually set the text encoding for reading files."), + Enable_error_reporting_in_type_checked_JavaScript_files: b(6609, 3, "Enable_error_reporting_in_type_checked_JavaScript_files_6609", "Enable error reporting in type-checked JavaScript files."), + Enable_constraints_that_allow_a_TypeScript_project_to_be_used_with_project_references: b(6611, 3, "Enable_constraints_that_allow_a_TypeScript_project_to_be_used_with_project_references_6611", "Enable constraints that allow a TypeScript project to be used with project references."), + Generate_d_ts_files_from_TypeScript_and_JavaScript_files_in_your_project: b(6612, 3, "Generate_d_ts_files_from_TypeScript_and_JavaScript_files_in_your_project_6612", "Generate .d.ts files from TypeScript and JavaScript files in your project."), + Specify_the_output_directory_for_generated_declaration_files: b(6613, 3, "Specify_the_output_directory_for_generated_declaration_files_6613", "Specify the output directory for generated declaration files."), + Create_sourcemaps_for_d_ts_files: b(6614, 3, "Create_sourcemaps_for_d_ts_files_6614", "Create sourcemaps for d.ts files."), + Output_compiler_performance_information_after_building: b(6615, 3, "Output_compiler_performance_information_after_building_6615", "Output compiler performance information after building."), + Disables_inference_for_type_acquisition_by_looking_at_filenames_in_a_project: b(6616, 3, "Disables_inference_for_type_acquisition_by_looking_at_filenames_in_a_project_6616", "Disables inference for type acquisition by looking at filenames in a project."), + Reduce_the_number_of_projects_loaded_automatically_by_TypeScript: b(6617, 3, "Reduce_the_number_of_projects_loaded_automatically_by_TypeScript_6617", "Reduce the number of projects loaded automatically by TypeScript."), + Remove_the_20mb_cap_on_total_source_code_size_for_JavaScript_files_in_the_TypeScript_language_server: b(6618, 3, "Remove_the_20mb_cap_on_total_source_code_size_for_JavaScript_files_in_the_TypeScript_language_server_6618", "Remove the 20mb cap on total source code size for JavaScript files in the TypeScript language server."), + Opt_a_project_out_of_multi_project_reference_checking_when_editing: b(6619, 3, "Opt_a_project_out_of_multi_project_reference_checking_when_editing_6619", "Opt a project out of multi-project reference checking when editing."), + Disable_preferring_source_files_instead_of_declaration_files_when_referencing_composite_projects: b(6620, 3, "Disable_preferring_source_files_instead_of_declaration_files_when_referencing_composite_projects_6620", "Disable preferring source files instead of declaration files when referencing composite projects."), + Emit_more_compliant_but_verbose_and_less_performant_JavaScript_for_iteration: b(6621, 3, "Emit_more_compliant_but_verbose_and_less_performant_JavaScript_for_iteration_6621", "Emit more compliant, but verbose and less performant JavaScript for iteration."), + Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files: b(6622, 3, "Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files_6622", "Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files."), + Only_output_d_ts_files_and_not_JavaScript_files: b(6623, 3, "Only_output_d_ts_files_and_not_JavaScript_files_6623", "Only output d.ts files and not JavaScript files."), + Emit_design_type_metadata_for_decorated_declarations_in_source_files: b(6624, 3, "Emit_design_type_metadata_for_decorated_declarations_in_source_files_6624", "Emit design-type metadata for decorated declarations in source files."), + Disable_the_type_acquisition_for_JavaScript_projects: b(6625, 3, "Disable_the_type_acquisition_for_JavaScript_projects_6625", "Disable the type acquisition for JavaScript projects"), + Emit_additional_JavaScript_to_ease_support_for_importing_CommonJS_modules_This_enables_allowSyntheticDefaultImports_for_type_compatibility: b(6626, 3, "Emit_additional_JavaScript_to_ease_support_for_importing_CommonJS_modules_This_enables_allowSyntheti_6626", "Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility."), + Filters_results_from_the_include_option: b(6627, 3, "Filters_results_from_the_include_option_6627", "Filters results from the `include` option."), + Remove_a_list_of_directories_from_the_watch_process: b(6628, 3, "Remove_a_list_of_directories_from_the_watch_process_6628", "Remove a list of directories from the watch process."), + Remove_a_list_of_files_from_the_watch_mode_s_processing: b(6629, 3, "Remove_a_list_of_files_from_the_watch_mode_s_processing_6629", "Remove a list of files from the watch mode's processing."), + Enable_experimental_support_for_legacy_experimental_decorators: b(6630, 3, "Enable_experimental_support_for_legacy_experimental_decorators_6630", "Enable experimental support for legacy experimental decorators."), + Print_files_read_during_the_compilation_including_why_it_was_included: b(6631, 3, "Print_files_read_during_the_compilation_including_why_it_was_included_6631", "Print files read during the compilation including why it was included."), + Output_more_detailed_compiler_performance_information_after_building: b(6632, 3, "Output_more_detailed_compiler_performance_information_after_building_6632", "Output more detailed compiler performance information after building."), + Specify_one_or_more_path_or_node_module_references_to_base_configuration_files_from_which_settings_are_inherited: b(6633, 3, "Specify_one_or_more_path_or_node_module_references_to_base_configuration_files_from_which_settings_a_6633", "Specify one or more path or node module references to base configuration files from which settings are inherited."), + Specify_what_approach_the_watcher_should_use_if_the_system_runs_out_of_native_file_watchers: b(6634, 3, "Specify_what_approach_the_watcher_should_use_if_the_system_runs_out_of_native_file_watchers_6634", "Specify what approach the watcher should use if the system runs out of native file watchers."), + Include_a_list_of_files_This_does_not_support_glob_patterns_as_opposed_to_include: b(6635, 3, "Include_a_list_of_files_This_does_not_support_glob_patterns_as_opposed_to_include_6635", "Include a list of files. This does not support glob patterns, as opposed to `include`."), + Build_all_projects_including_those_that_appear_to_be_up_to_date: b(6636, 3, "Build_all_projects_including_those_that_appear_to_be_up_to_date_6636", "Build all projects, including those that appear to be up to date."), + Ensure_that_casing_is_correct_in_imports: b(6637, 3, "Ensure_that_casing_is_correct_in_imports_6637", "Ensure that casing is correct in imports."), + Emit_a_v8_CPU_profile_of_the_compiler_run_for_debugging: b(6638, 3, "Emit_a_v8_CPU_profile_of_the_compiler_run_for_debugging_6638", "Emit a v8 CPU profile of the compiler run for debugging."), + Allow_importing_helper_functions_from_tslib_once_per_project_instead_of_including_them_per_file: b(6639, 3, "Allow_importing_helper_functions_from_tslib_once_per_project_instead_of_including_them_per_file_6639", "Allow importing helper functions from tslib once per project, instead of including them per-file."), + Skip_building_downstream_projects_on_error_in_upstream_project: b(6640, 3, "Skip_building_downstream_projects_on_error_in_upstream_project_6640", "Skip building downstream projects on error in upstream project."), + Specify_a_list_of_glob_patterns_that_match_files_to_be_included_in_compilation: b(6641, 3, "Specify_a_list_of_glob_patterns_that_match_files_to_be_included_in_compilation_6641", "Specify a list of glob patterns that match files to be included in compilation."), + Save_tsbuildinfo_files_to_allow_for_incremental_compilation_of_projects: b(6642, 3, "Save_tsbuildinfo_files_to_allow_for_incremental_compilation_of_projects_6642", "Save .tsbuildinfo files to allow for incremental compilation of projects."), + Include_sourcemap_files_inside_the_emitted_JavaScript: b(6643, 3, "Include_sourcemap_files_inside_the_emitted_JavaScript_6643", "Include sourcemap files inside the emitted JavaScript."), + Include_source_code_in_the_sourcemaps_inside_the_emitted_JavaScript: b(6644, 3, "Include_source_code_in_the_sourcemaps_inside_the_emitted_JavaScript_6644", "Include source code in the sourcemaps inside the emitted JavaScript."), + Ensure_that_each_file_can_be_safely_transpiled_without_relying_on_other_imports: b(6645, 3, "Ensure_that_each_file_can_be_safely_transpiled_without_relying_on_other_imports_6645", "Ensure that each file can be safely transpiled without relying on other imports."), + Specify_what_JSX_code_is_generated: b(6646, 3, "Specify_what_JSX_code_is_generated_6646", "Specify what JSX code is generated."), + Specify_the_JSX_factory_function_used_when_targeting_React_JSX_emit_e_g_React_createElement_or_h: b(6647, 3, "Specify_the_JSX_factory_function_used_when_targeting_React_JSX_emit_e_g_React_createElement_or_h_6647", "Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'."), + Specify_the_JSX_Fragment_reference_used_for_fragments_when_targeting_React_JSX_emit_e_g_React_Fragment_or_Fragment: b(6648, 3, "Specify_the_JSX_Fragment_reference_used_for_fragments_when_targeting_React_JSX_emit_e_g_React_Fragme_6648", "Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'."), + Specify_module_specifier_used_to_import_the_JSX_factory_functions_when_using_jsx_Colon_react_jsx_Asterisk: b(6649, 3, "Specify_module_specifier_used_to_import_the_JSX_factory_functions_when_using_jsx_Colon_react_jsx_Ast_6649", "Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'."), + Make_keyof_only_return_strings_instead_of_string_numbers_or_symbols_Legacy_option: b(6650, 3, "Make_keyof_only_return_strings_instead_of_string_numbers_or_symbols_Legacy_option_6650", "Make keyof only return strings instead of string, numbers or symbols. Legacy option."), + Specify_a_set_of_bundled_library_declaration_files_that_describe_the_target_runtime_environment: b(6651, 3, "Specify_a_set_of_bundled_library_declaration_files_that_describe_the_target_runtime_environment_6651", "Specify a set of bundled library declaration files that describe the target runtime environment."), + Print_the_names_of_emitted_files_after_a_compilation: b(6652, 3, "Print_the_names_of_emitted_files_after_a_compilation_6652", "Print the names of emitted files after a compilation."), + Print_all_of_the_files_read_during_the_compilation: b(6653, 3, "Print_all_of_the_files_read_during_the_compilation_6653", "Print all of the files read during the compilation."), + Set_the_language_of_the_messaging_from_TypeScript_This_does_not_affect_emit: b(6654, 3, "Set_the_language_of_the_messaging_from_TypeScript_This_does_not_affect_emit_6654", "Set the language of the messaging from TypeScript. This does not affect emit."), + Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: b(6655, 3, "Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations_6655", "Specify the location where debugger should locate map files instead of generated locations."), + Specify_the_maximum_folder_depth_used_for_checking_JavaScript_files_from_node_modules_Only_applicable_with_allowJs: b(6656, 3, "Specify_the_maximum_folder_depth_used_for_checking_JavaScript_files_from_node_modules_Only_applicabl_6656", "Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'."), + Specify_what_module_code_is_generated: b(6657, 3, "Specify_what_module_code_is_generated_6657", "Specify what module code is generated."), + Specify_how_TypeScript_looks_up_a_file_from_a_given_module_specifier: b(6658, 3, "Specify_how_TypeScript_looks_up_a_file_from_a_given_module_specifier_6658", "Specify how TypeScript looks up a file from a given module specifier."), + Set_the_newline_character_for_emitting_files: b(6659, 3, "Set_the_newline_character_for_emitting_files_6659", "Set the newline character for emitting files."), + Disable_emitting_files_from_a_compilation: b(6660, 3, "Disable_emitting_files_from_a_compilation_6660", "Disable emitting files from a compilation."), + Disable_generating_custom_helper_functions_like_extends_in_compiled_output: b(6661, 3, "Disable_generating_custom_helper_functions_like_extends_in_compiled_output_6661", "Disable generating custom helper functions like '__extends' in compiled output."), + Disable_emitting_files_if_any_type_checking_errors_are_reported: b(6662, 3, "Disable_emitting_files_if_any_type_checking_errors_are_reported_6662", "Disable emitting files if any type checking errors are reported."), + Disable_truncating_types_in_error_messages: b(6663, 3, "Disable_truncating_types_in_error_messages_6663", "Disable truncating types in error messages."), + Enable_error_reporting_for_fallthrough_cases_in_switch_statements: b(6664, 3, "Enable_error_reporting_for_fallthrough_cases_in_switch_statements_6664", "Enable error reporting for fallthrough cases in switch statements."), + Enable_error_reporting_for_expressions_and_declarations_with_an_implied_any_type: b(6665, 3, "Enable_error_reporting_for_expressions_and_declarations_with_an_implied_any_type_6665", "Enable error reporting for expressions and declarations with an implied 'any' type."), + Ensure_overriding_members_in_derived_classes_are_marked_with_an_override_modifier: b(6666, 3, "Ensure_overriding_members_in_derived_classes_are_marked_with_an_override_modifier_6666", "Ensure overriding members in derived classes are marked with an override modifier."), + Enable_error_reporting_for_codepaths_that_do_not_explicitly_return_in_a_function: b(6667, 3, "Enable_error_reporting_for_codepaths_that_do_not_explicitly_return_in_a_function_6667", "Enable error reporting for codepaths that do not explicitly return in a function."), + Enable_error_reporting_when_this_is_given_the_type_any: b(6668, 3, "Enable_error_reporting_when_this_is_given_the_type_any_6668", "Enable error reporting when 'this' is given the type 'any'."), + Disable_adding_use_strict_directives_in_emitted_JavaScript_files: b(6669, 3, "Disable_adding_use_strict_directives_in_emitted_JavaScript_files_6669", "Disable adding 'use strict' directives in emitted JavaScript files."), + Disable_including_any_library_files_including_the_default_lib_d_ts: b(6670, 3, "Disable_including_any_library_files_including_the_default_lib_d_ts_6670", "Disable including any library files, including the default lib.d.ts."), + Enforces_using_indexed_accessors_for_keys_declared_using_an_indexed_type: b(6671, 3, "Enforces_using_indexed_accessors_for_keys_declared_using_an_indexed_type_6671", "Enforces using indexed accessors for keys declared using an indexed type."), + Disallow_import_s_require_s_or_reference_s_from_expanding_the_number_of_files_TypeScript_should_add_to_a_project: b(6672, 3, "Disallow_import_s_require_s_or_reference_s_from_expanding_the_number_of_files_TypeScript_should_add__6672", "Disallow 'import's, 'require's or ''s from expanding the number of files TypeScript should add to a project."), + Disable_strict_checking_of_generic_signatures_in_function_types: b(6673, 3, "Disable_strict_checking_of_generic_signatures_in_function_types_6673", "Disable strict checking of generic signatures in function types."), + Add_undefined_to_a_type_when_accessed_using_an_index: b(6674, 3, "Add_undefined_to_a_type_when_accessed_using_an_index_6674", "Add 'undefined' to a type when accessed using an index."), + Enable_error_reporting_when_local_variables_aren_t_read: b(6675, 3, "Enable_error_reporting_when_local_variables_aren_t_read_6675", "Enable error reporting when local variables aren't read."), + Raise_an_error_when_a_function_parameter_isn_t_read: b(6676, 3, "Raise_an_error_when_a_function_parameter_isn_t_read_6676", "Raise an error when a function parameter isn't read."), + Deprecated_setting_Use_outFile_instead: b(6677, 3, "Deprecated_setting_Use_outFile_instead_6677", "Deprecated setting. Use 'outFile' instead."), + Specify_an_output_folder_for_all_emitted_files: b(6678, 3, "Specify_an_output_folder_for_all_emitted_files_6678", "Specify an output folder for all emitted files."), + Specify_a_file_that_bundles_all_outputs_into_one_JavaScript_file_If_declaration_is_true_also_designates_a_file_that_bundles_all_d_ts_output: b(6679, 3, "Specify_a_file_that_bundles_all_outputs_into_one_JavaScript_file_If_declaration_is_true_also_designa_6679", "Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output."), + Specify_a_set_of_entries_that_re_map_imports_to_additional_lookup_locations: b(6680, 3, "Specify_a_set_of_entries_that_re_map_imports_to_additional_lookup_locations_6680", "Specify a set of entries that re-map imports to additional lookup locations."), + Specify_a_list_of_language_service_plugins_to_include: b(6681, 3, "Specify_a_list_of_language_service_plugins_to_include_6681", "Specify a list of language service plugins to include."), + Disable_erasing_const_enum_declarations_in_generated_code: b(6682, 3, "Disable_erasing_const_enum_declarations_in_generated_code_6682", "Disable erasing 'const enum' declarations in generated code."), + Disable_resolving_symlinks_to_their_realpath_This_correlates_to_the_same_flag_in_node: b(6683, 3, "Disable_resolving_symlinks_to_their_realpath_This_correlates_to_the_same_flag_in_node_6683", "Disable resolving symlinks to their realpath. This correlates to the same flag in node."), + Disable_wiping_the_console_in_watch_mode: b(6684, 3, "Disable_wiping_the_console_in_watch_mode_6684", "Disable wiping the console in watch mode."), + Enable_color_and_formatting_in_TypeScript_s_output_to_make_compiler_errors_easier_to_read: b(6685, 3, "Enable_color_and_formatting_in_TypeScript_s_output_to_make_compiler_errors_easier_to_read_6685", "Enable color and formatting in TypeScript's output to make compiler errors easier to read."), + Specify_the_object_invoked_for_createElement_This_only_applies_when_targeting_react_JSX_emit: b(6686, 3, "Specify_the_object_invoked_for_createElement_This_only_applies_when_targeting_react_JSX_emit_6686", "Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit."), + Specify_an_array_of_objects_that_specify_paths_for_projects_Used_in_project_references: b(6687, 3, "Specify_an_array_of_objects_that_specify_paths_for_projects_Used_in_project_references_6687", "Specify an array of objects that specify paths for projects. Used in project references."), + Disable_emitting_comments: b(6688, 3, "Disable_emitting_comments_6688", "Disable emitting comments."), + Enable_importing_json_files: b(6689, 3, "Enable_importing_json_files_6689", "Enable importing .json files."), + Specify_the_root_folder_within_your_source_files: b(6690, 3, "Specify_the_root_folder_within_your_source_files_6690", "Specify the root folder within your source files."), + Allow_multiple_folders_to_be_treated_as_one_when_resolving_modules: b(6691, 3, "Allow_multiple_folders_to_be_treated_as_one_when_resolving_modules_6691", "Allow multiple folders to be treated as one when resolving modules."), + Skip_type_checking_d_ts_files_that_are_included_with_TypeScript: b(6692, 3, "Skip_type_checking_d_ts_files_that_are_included_with_TypeScript_6692", "Skip type checking .d.ts files that are included with TypeScript."), + Skip_type_checking_all_d_ts_files: b(6693, 3, "Skip_type_checking_all_d_ts_files_6693", "Skip type checking all .d.ts files."), + Create_source_map_files_for_emitted_JavaScript_files: b(6694, 3, "Create_source_map_files_for_emitted_JavaScript_files_6694", "Create source map files for emitted JavaScript files."), + Specify_the_root_path_for_debuggers_to_find_the_reference_source_code: b(6695, 3, "Specify_the_root_path_for_debuggers_to_find_the_reference_source_code_6695", "Specify the root path for debuggers to find the reference source code."), + Check_that_the_arguments_for_bind_call_and_apply_methods_match_the_original_function: b(6697, 3, "Check_that_the_arguments_for_bind_call_and_apply_methods_match_the_original_function_6697", "Check that the arguments for 'bind', 'call', and 'apply' methods match the original function."), + When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible: b(6698, 3, "When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible_6698", "When assigning functions, check to ensure parameters and the return values are subtype-compatible."), + When_type_checking_take_into_account_null_and_undefined: b(6699, 3, "When_type_checking_take_into_account_null_and_undefined_6699", "When type checking, take into account 'null' and 'undefined'."), + Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor: b(6700, 3, "Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor_6700", "Check for class properties that are declared but not set in the constructor."), + Disable_emitting_declarations_that_have_internal_in_their_JSDoc_comments: b(6701, 3, "Disable_emitting_declarations_that_have_internal_in_their_JSDoc_comments_6701", "Disable emitting declarations that have '@internal' in their JSDoc comments."), + Disable_reporting_of_excess_property_errors_during_the_creation_of_object_literals: b(6702, 3, "Disable_reporting_of_excess_property_errors_during_the_creation_of_object_literals_6702", "Disable reporting of excess property errors during the creation of object literals."), + Suppress_noImplicitAny_errors_when_indexing_objects_that_lack_index_signatures: b(6703, 3, "Suppress_noImplicitAny_errors_when_indexing_objects_that_lack_index_signatures_6703", "Suppress 'noImplicitAny' errors when indexing objects that lack index signatures."), + Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively: b(6704, 3, "Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_supp_6704", "Synchronously call callbacks and update the state of directory watchers on platforms that don`t support recursive watching natively."), + Set_the_JavaScript_language_version_for_emitted_JavaScript_and_include_compatible_library_declarations: b(6705, 3, "Set_the_JavaScript_language_version_for_emitted_JavaScript_and_include_compatible_library_declaratio_6705", "Set the JavaScript language version for emitted JavaScript and include compatible library declarations."), + Log_paths_used_during_the_moduleResolution_process: b(6706, 3, "Log_paths_used_during_the_moduleResolution_process_6706", "Log paths used during the 'moduleResolution' process."), + Specify_the_path_to_tsbuildinfo_incremental_compilation_file: b(6707, 3, "Specify_the_path_to_tsbuildinfo_incremental_compilation_file_6707", "Specify the path to .tsbuildinfo incremental compilation file."), + Specify_options_for_automatic_acquisition_of_declaration_files: b(6709, 3, "Specify_options_for_automatic_acquisition_of_declaration_files_6709", "Specify options for automatic acquisition of declaration files."), + Specify_multiple_folders_that_act_like_Slashnode_modules_Slash_types: b(6710, 3, "Specify_multiple_folders_that_act_like_Slashnode_modules_Slash_types_6710", "Specify multiple folders that act like './node_modules/@types'."), + Specify_type_package_names_to_be_included_without_being_referenced_in_a_source_file: b(6711, 3, "Specify_type_package_names_to_be_included_without_being_referenced_in_a_source_file_6711", "Specify type package names to be included without being referenced in a source file."), + Emit_ECMAScript_standard_compliant_class_fields: b(6712, 3, "Emit_ECMAScript_standard_compliant_class_fields_6712", "Emit ECMAScript-standard-compliant class fields."), + Enable_verbose_logging: b(6713, 3, "Enable_verbose_logging_6713", "Enable verbose logging."), + Specify_how_directories_are_watched_on_systems_that_lack_recursive_file_watching_functionality: b(6714, 3, "Specify_how_directories_are_watched_on_systems_that_lack_recursive_file_watching_functionality_6714", "Specify how directories are watched on systems that lack recursive file-watching functionality."), + Specify_how_the_TypeScript_watch_mode_works: b(6715, 3, "Specify_how_the_TypeScript_watch_mode_works_6715", "Specify how the TypeScript watch mode works."), + Require_undeclared_properties_from_index_signatures_to_use_element_accesses: b(6717, 3, "Require_undeclared_properties_from_index_signatures_to_use_element_accesses_6717", "Require undeclared properties from index signatures to use element accesses."), + Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: b(6718, 3, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_6718", "Specify emit/checking behavior for imports that are only used for types."), + Require_sufficient_annotation_on_exports_so_other_tools_can_trivially_generate_declaration_files: b(6719, 3, "Require_sufficient_annotation_on_exports_so_other_tools_can_trivially_generate_declaration_files_6719", "Require sufficient annotation on exports so other tools can trivially generate declaration files."), + Built_in_iterators_are_instantiated_with_a_TReturn_type_of_undefined_instead_of_any: b(6720, 3, "Built_in_iterators_are_instantiated_with_a_TReturn_type_of_undefined_instead_of_any_6720", "Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'."), + Do_not_allow_runtime_constructs_that_are_not_part_of_ECMAScript: b(6721, 3, "Do_not_allow_runtime_constructs_that_are_not_part_of_ECMAScript_6721", "Do not allow runtime constructs that are not part of ECMAScript."), + Default_catch_clause_variables_as_unknown_instead_of_any: b(6803, 3, "Default_catch_clause_variables_as_unknown_instead_of_any_6803", "Default catch clause variables as 'unknown' instead of 'any'."), + Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_in_the_output_file_s_format_based_on_the_module_setting: b(6804, 3, "Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_i_6804", "Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting."), + Disable_full_type_checking_only_critical_parse_and_emit_errors_will_be_reported: b(6805, 3, "Disable_full_type_checking_only_critical_parse_and_emit_errors_will_be_reported_6805", "Disable full type checking (only critical parse and emit errors will be reported)."), + Check_side_effect_imports: b(6806, 3, "Check_side_effect_imports_6806", "Check side effect imports."), + This_operation_can_be_simplified_This_shift_is_identical_to_0_1_2: b(6807, 1, "This_operation_can_be_simplified_This_shift_is_identical_to_0_1_2_6807", "This operation can be simplified. This shift is identical to `{0} {1} {2}`."), + Enable_lib_replacement: b(6808, 3, "Enable_lib_replacement_6808", "Enable lib replacement."), + one_of_Colon: b(6900, 3, "one_of_Colon_6900", "one of:"), + one_or_more_Colon: b(6901, 3, "one_or_more_Colon_6901", "one or more:"), + type_Colon: b(6902, 3, "type_Colon_6902", "type:"), + default_Colon: b(6903, 3, "default_Colon_6903", "default:"), + module_system_or_esModuleInterop: b(6904, 3, "module_system_or_esModuleInterop_6904", 'module === "system" or esModuleInterop'), + false_unless_strict_is_set: b(6905, 3, "false_unless_strict_is_set_6905", "`false`, unless `strict` is set"), + false_unless_composite_is_set: b(6906, 3, "false_unless_composite_is_set_6906", "`false`, unless `composite` is set"), + node_modules_bower_components_jspm_packages_plus_the_value_of_outDir_if_one_is_specified: b(6907, 3, "node_modules_bower_components_jspm_packages_plus_the_value_of_outDir_if_one_is_specified_6907", '`["node_modules", "bower_components", "jspm_packages"]`, plus the value of `outDir` if one is specified.'), + if_files_is_specified_otherwise_Asterisk_Asterisk_Slash_Asterisk: b(6908, 3, "if_files_is_specified_otherwise_Asterisk_Asterisk_Slash_Asterisk_6908", '`[]` if `files` is specified, otherwise `["**/*"]`'), + true_if_composite_false_otherwise: b(6909, 3, "true_if_composite_false_otherwise_6909", "`true` if `composite`, `false` otherwise"), + module_AMD_or_UMD_or_System_or_ES6_then_Classic_Otherwise_Node: b(69010, 3, "module_AMD_or_UMD_or_System_or_ES6_then_Classic_Otherwise_Node_69010", "module === `AMD` or `UMD` or `System` or `ES6`, then `Classic`, Otherwise `Node`"), + Computed_from_the_list_of_input_files: b(6911, 3, "Computed_from_the_list_of_input_files_6911", "Computed from the list of input files"), + Platform_specific: b(6912, 3, "Platform_specific_6912", "Platform specific"), + You_can_learn_about_all_of_the_compiler_options_at_0: b(6913, 3, "You_can_learn_about_all_of_the_compiler_options_at_0_6913", "You can learn about all of the compiler options at {0}"), + Including_watch_w_will_start_watching_the_current_project_for_the_file_changes_Once_set_you_can_config_watch_mode_with_Colon: b(6914, 3, "Including_watch_w_will_start_watching_the_current_project_for_the_file_changes_Once_set_you_can_conf_6914", "Including --watch, -w will start watching the current project for the file changes. Once set, you can config watch mode with:"), + Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_trigger_building_composite_projects_which_you_can_learn_more_about_at_0: b(6915, 3, "Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_tr_6915", "Using --build, -b will make tsc behave more like a build orchestrator than a compiler. This is used to trigger building composite projects which you can learn more about at {0}"), + COMMON_COMMANDS: b(6916, 3, "COMMON_COMMANDS_6916", "COMMON COMMANDS"), + ALL_COMPILER_OPTIONS: b(6917, 3, "ALL_COMPILER_OPTIONS_6917", "ALL COMPILER OPTIONS"), + WATCH_OPTIONS: b(6918, 3, "WATCH_OPTIONS_6918", "WATCH OPTIONS"), + BUILD_OPTIONS: b(6919, 3, "BUILD_OPTIONS_6919", "BUILD OPTIONS"), + COMMON_COMPILER_OPTIONS: b(6920, 3, "COMMON_COMPILER_OPTIONS_6920", "COMMON COMPILER OPTIONS"), + COMMAND_LINE_FLAGS: b(6921, 3, "COMMAND_LINE_FLAGS_6921", "COMMAND LINE FLAGS"), + tsc_Colon_The_TypeScript_Compiler: b(6922, 3, "tsc_Colon_The_TypeScript_Compiler_6922", "tsc: The TypeScript Compiler"), + Compiles_the_current_project_tsconfig_json_in_the_working_directory: b(6923, 3, "Compiles_the_current_project_tsconfig_json_in_the_working_directory_6923", "Compiles the current project (tsconfig.json in the working directory.)"), + Ignoring_tsconfig_json_compiles_the_specified_files_with_default_compiler_options: b(6924, 3, "Ignoring_tsconfig_json_compiles_the_specified_files_with_default_compiler_options_6924", "Ignoring tsconfig.json, compiles the specified files with default compiler options."), + Build_a_composite_project_in_the_working_directory: b(6925, 3, "Build_a_composite_project_in_the_working_directory_6925", "Build a composite project in the working directory."), + Creates_a_tsconfig_json_with_the_recommended_settings_in_the_working_directory: b(6926, 3, "Creates_a_tsconfig_json_with_the_recommended_settings_in_the_working_directory_6926", "Creates a tsconfig.json with the recommended settings in the working directory."), + Compiles_the_TypeScript_project_located_at_the_specified_path: b(6927, 3, "Compiles_the_TypeScript_project_located_at_the_specified_path_6927", "Compiles the TypeScript project located at the specified path."), + An_expanded_version_of_this_information_showing_all_possible_compiler_options: b(6928, 3, "An_expanded_version_of_this_information_showing_all_possible_compiler_options_6928", "An expanded version of this information, showing all possible compiler options"), + Compiles_the_current_project_with_additional_settings: b(6929, 3, "Compiles_the_current_project_with_additional_settings_6929", "Compiles the current project, with additional settings."), + true_for_ES2022_and_above_including_ESNext: b(6930, 3, "true_for_ES2022_and_above_including_ESNext_6930", "`true` for ES2022 and above, including ESNext."), + List_of_file_name_suffixes_to_search_when_resolving_a_module: b(6931, 1, "List_of_file_name_suffixes_to_search_when_resolving_a_module_6931", "List of file name suffixes to search when resolving a module."), + Variable_0_implicitly_has_an_1_type: b(7005, 1, "Variable_0_implicitly_has_an_1_type_7005", "Variable '{0}' implicitly has an '{1}' type."), + Parameter_0_implicitly_has_an_1_type: b(7006, 1, "Parameter_0_implicitly_has_an_1_type_7006", "Parameter '{0}' implicitly has an '{1}' type."), + Member_0_implicitly_has_an_1_type: b(7008, 1, "Member_0_implicitly_has_an_1_type_7008", "Member '{0}' implicitly has an '{1}' type."), + new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type: b(7009, 1, "new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type_7009", "'new' expression, whose target lacks a construct signature, implicitly has an 'any' type."), + _0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type: b(7010, 1, "_0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type_7010", "'{0}', which lacks return-type annotation, implicitly has an '{1}' return type."), + Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: b(7011, 1, "Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type_7011", "Function expression, which lacks return-type annotation, implicitly has an '{0}' return type."), + This_overload_implicitly_returns_the_type_0_because_it_lacks_a_return_type_annotation: b(7012, 1, "This_overload_implicitly_returns_the_type_0_because_it_lacks_a_return_type_annotation_7012", "This overload implicitly returns the type '{0}' because it lacks a return type annotation."), + Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: b(7013, 1, "Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type_7013", "Construct signature, which lacks return-type annotation, implicitly has an 'any' return type."), + Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: b(7014, 1, "Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type_7014", "Function type, which lacks return-type annotation, implicitly has an '{0}' return type."), + Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number: b(7015, 1, "Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number_7015", "Element implicitly has an 'any' type because index expression is not of type 'number'."), + Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type: b(7016, 1, "Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type_7016", "Could not find a declaration file for module '{0}'. '{1}' implicitly has an 'any' type."), + Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature: b(7017, 1, "Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_7017", "Element implicitly has an 'any' type because type '{0}' has no index signature."), + Object_literal_s_property_0_implicitly_has_an_1_type: b(7018, 1, "Object_literal_s_property_0_implicitly_has_an_1_type_7018", "Object literal's property '{0}' implicitly has an '{1}' type."), + Rest_parameter_0_implicitly_has_an_any_type: b(7019, 1, "Rest_parameter_0_implicitly_has_an_any_type_7019", "Rest parameter '{0}' implicitly has an 'any[]' type."), + Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: b(7020, 1, "Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type_7020", "Call signature, which lacks return-type annotation, implicitly has an 'any' return type."), + _0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer: b(7022, 1, "_0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or__7022", "'{0}' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer."), + _0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: b(7023, 1, "_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_reference_7023", "'{0}' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions."), + Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: b(7024, 1, "Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_ref_7024", "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions."), + Generator_implicitly_has_yield_type_0_Consider_supplying_a_return_type_annotation: b(7025, 1, "Generator_implicitly_has_yield_type_0_Consider_supplying_a_return_type_annotation_7025", "Generator implicitly has yield type '{0}'. Consider supplying a return type annotation."), + JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: b(7026, 1, "JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists_7026", "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists."), + Unreachable_code_detected: b( + 7027, + 1, + "Unreachable_code_detected_7027", + "Unreachable code detected.", + /*reportsUnnecessary*/ + !0 + ), + Unused_label: b( + 7028, + 1, + "Unused_label_7028", + "Unused label.", + /*reportsUnnecessary*/ + !0 + ), + Fallthrough_case_in_switch: b(7029, 1, "Fallthrough_case_in_switch_7029", "Fallthrough case in switch."), + Not_all_code_paths_return_a_value: b(7030, 1, "Not_all_code_paths_return_a_value_7030", "Not all code paths return a value."), + Binding_element_0_implicitly_has_an_1_type: b(7031, 1, "Binding_element_0_implicitly_has_an_1_type_7031", "Binding element '{0}' implicitly has an '{1}' type."), + Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation: b(7032, 1, "Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation_7032", "Property '{0}' implicitly has type 'any', because its set accessor lacks a parameter type annotation."), + Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation: b(7033, 1, "Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation_7033", "Property '{0}' implicitly has type 'any', because its get accessor lacks a return type annotation."), + Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined: b(7034, 1, "Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined_7034", "Variable '{0}' implicitly has type '{1}' in some locations where its type cannot be determined."), + Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0: b(7035, 1, "Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare__7035", "Try `npm i --save-dev @types/{1}` if it exists or add a new declaration (.d.ts) file containing `declare module '{0}';`"), + Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0: b(7036, 1, "Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0_7036", "Dynamic import's specifier must be of type 'string', but here has type '{0}'."), + Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for_all_imports_Implies_allowSyntheticDefaultImports: b(7037, 3, "Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for__7037", "Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'."), + Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead: b(7038, 3, "Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cau_7038", "Type originates at this import. A namespace-style import cannot be called or constructed, and will cause a failure at runtime. Consider using a default import or import require here instead."), + Mapped_object_type_implicitly_has_an_any_template_type: b(7039, 1, "Mapped_object_type_implicitly_has_an_any_template_type_7039", "Mapped object type implicitly has an 'any' template type."), + If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1: b(7040, 1, "If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_S_7040", "If the '{0}' package actually exposes this module, consider sending a pull request to amend 'https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/{1}'"), + The_containing_arrow_function_captures_the_global_value_of_this: b(7041, 1, "The_containing_arrow_function_captures_the_global_value_of_this_7041", "The containing arrow function captures the global value of 'this'."), + Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used: b(7042, 1, "Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used_7042", "Module '{0}' was resolved to '{1}', but '--resolveJsonModule' is not used."), + Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: b(7043, 2, "Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7043", "Variable '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."), + Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: b(7044, 2, "Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7044", "Parameter '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."), + Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: b(7045, 2, "Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7045", "Member '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."), + Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage: b(7046, 2, "Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage_7046", "Variable '{0}' implicitly has type '{1}' in some locations, but a better type may be inferred from usage."), + Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage: b(7047, 2, "Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage_7047", "Rest parameter '{0}' implicitly has an 'any[]' type, but a better type may be inferred from usage."), + Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage: b(7048, 2, "Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage_7048", "Property '{0}' implicitly has type 'any', but a better type for its get accessor may be inferred from usage."), + Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage: b(7049, 2, "Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage_7049", "Property '{0}' implicitly has type 'any', but a better type for its set accessor may be inferred from usage."), + _0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage: b(7050, 2, "_0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage_7050", "'{0}' implicitly has an '{1}' return type, but a better type may be inferred from usage."), + Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1: b(7051, 1, "Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1_7051", "Parameter has a name but no type. Did you mean '{0}: {1}'?"), + Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1: b(7052, 1, "Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1_7052", "Element implicitly has an 'any' type because type '{0}' has no index signature. Did you mean to call '{1}'?"), + Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1: b(7053, 1, "Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1_7053", "Element implicitly has an 'any' type because expression of type '{0}' can't be used to index type '{1}'."), + No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1: b(7054, 1, "No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1_7054", "No index signature with a parameter of type '{0}' was found on type '{1}'."), + _0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type: b(7055, 1, "_0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type_7055", "'{0}', which lacks return-type annotation, implicitly has an '{1}' yield type."), + The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_type_annotation_is_needed: b(7056, 1, "The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_ty_7056", "The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed."), + yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation: b(7057, 1, "yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_t_7057", "'yield' expression implicitly results in an 'any' type because its containing generator lacks a return-type annotation."), + If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_declare_module_1: b(7058, 1, "If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_decl_7058", "If the '{0}' package actually exposes this module, try adding a new declaration (.d.ts) file containing `declare module '{1}';`"), + This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead: b(7059, 1, "This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead_7059", "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead."), + This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint: b(7060, 1, "This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_cons_7060", "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma or explicit constraint."), + A_mapped_type_may_not_declare_properties_or_methods: b(7061, 1, "A_mapped_type_may_not_declare_properties_or_methods_7061", "A mapped type may not declare properties or methods."), + You_cannot_rename_this_element: b(8e3, 1, "You_cannot_rename_this_element_8000", "You cannot rename this element."), + You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: b(8001, 1, "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", "You cannot rename elements that are defined in the standard TypeScript library."), + import_can_only_be_used_in_TypeScript_files: b(8002, 1, "import_can_only_be_used_in_TypeScript_files_8002", "'import ... =' can only be used in TypeScript files."), + export_can_only_be_used_in_TypeScript_files: b(8003, 1, "export_can_only_be_used_in_TypeScript_files_8003", "'export =' can only be used in TypeScript files."), + Type_parameter_declarations_can_only_be_used_in_TypeScript_files: b(8004, 1, "Type_parameter_declarations_can_only_be_used_in_TypeScript_files_8004", "Type parameter declarations can only be used in TypeScript files."), + implements_clauses_can_only_be_used_in_TypeScript_files: b(8005, 1, "implements_clauses_can_only_be_used_in_TypeScript_files_8005", "'implements' clauses can only be used in TypeScript files."), + _0_declarations_can_only_be_used_in_TypeScript_files: b(8006, 1, "_0_declarations_can_only_be_used_in_TypeScript_files_8006", "'{0}' declarations can only be used in TypeScript files."), + Type_aliases_can_only_be_used_in_TypeScript_files: b(8008, 1, "Type_aliases_can_only_be_used_in_TypeScript_files_8008", "Type aliases can only be used in TypeScript files."), + The_0_modifier_can_only_be_used_in_TypeScript_files: b(8009, 1, "The_0_modifier_can_only_be_used_in_TypeScript_files_8009", "The '{0}' modifier can only be used in TypeScript files."), + Type_annotations_can_only_be_used_in_TypeScript_files: b(8010, 1, "Type_annotations_can_only_be_used_in_TypeScript_files_8010", "Type annotations can only be used in TypeScript files."), + Type_arguments_can_only_be_used_in_TypeScript_files: b(8011, 1, "Type_arguments_can_only_be_used_in_TypeScript_files_8011", "Type arguments can only be used in TypeScript files."), + Parameter_modifiers_can_only_be_used_in_TypeScript_files: b(8012, 1, "Parameter_modifiers_can_only_be_used_in_TypeScript_files_8012", "Parameter modifiers can only be used in TypeScript files."), + Non_null_assertions_can_only_be_used_in_TypeScript_files: b(8013, 1, "Non_null_assertions_can_only_be_used_in_TypeScript_files_8013", "Non-null assertions can only be used in TypeScript files."), + Type_assertion_expressions_can_only_be_used_in_TypeScript_files: b(8016, 1, "Type_assertion_expressions_can_only_be_used_in_TypeScript_files_8016", "Type assertion expressions can only be used in TypeScript files."), + Signature_declarations_can_only_be_used_in_TypeScript_files: b(8017, 1, "Signature_declarations_can_only_be_used_in_TypeScript_files_8017", "Signature declarations can only be used in TypeScript files."), + Report_errors_in_js_files: b(8019, 3, "Report_errors_in_js_files_8019", "Report errors in .js files."), + JSDoc_types_can_only_be_used_inside_documentation_comments: b(8020, 1, "JSDoc_types_can_only_be_used_inside_documentation_comments_8020", "JSDoc types can only be used inside documentation comments."), + JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags: b(8021, 1, "JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags_8021", "JSDoc '@typedef' tag should either have a type annotation or be followed by '@property' or '@member' tags."), + JSDoc_0_is_not_attached_to_a_class: b(8022, 1, "JSDoc_0_is_not_attached_to_a_class_8022", "JSDoc '@{0}' is not attached to a class."), + JSDoc_0_1_does_not_match_the_extends_2_clause: b(8023, 1, "JSDoc_0_1_does_not_match_the_extends_2_clause_8023", "JSDoc '@{0} {1}' does not match the 'extends {2}' clause."), + JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name: b(8024, 1, "JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_8024", "JSDoc '@param' tag has name '{0}', but there is no parameter with that name."), + Class_declarations_cannot_have_more_than_one_augments_or_extends_tag: b(8025, 1, "Class_declarations_cannot_have_more_than_one_augments_or_extends_tag_8025", "Class declarations cannot have more than one '@augments' or '@extends' tag."), + Expected_0_type_arguments_provide_these_with_an_extends_tag: b(8026, 1, "Expected_0_type_arguments_provide_these_with_an_extends_tag_8026", "Expected {0} type arguments; provide these with an '@extends' tag."), + Expected_0_1_type_arguments_provide_these_with_an_extends_tag: b(8027, 1, "Expected_0_1_type_arguments_provide_these_with_an_extends_tag_8027", "Expected {0}-{1} type arguments; provide these with an '@extends' tag."), + JSDoc_may_only_appear_in_the_last_parameter_of_a_signature: b(8028, 1, "JSDoc_may_only_appear_in_the_last_parameter_of_a_signature_8028", "JSDoc '...' may only appear in the last parameter of a signature."), + JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type: b(8029, 1, "JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_h_8029", "JSDoc '@param' tag has name '{0}', but there is no parameter with that name. It would match 'arguments' if it had an array type."), + The_type_of_a_function_declaration_must_match_the_function_s_signature: b(8030, 1, "The_type_of_a_function_declaration_must_match_the_function_s_signature_8030", "The type of a function declaration must match the function's signature."), + You_cannot_rename_a_module_via_a_global_import: b(8031, 1, "You_cannot_rename_a_module_via_a_global_import_8031", "You cannot rename a module via a global import."), + Qualified_name_0_is_not_allowed_without_a_leading_param_object_1: b(8032, 1, "Qualified_name_0_is_not_allowed_without_a_leading_param_object_1_8032", "Qualified name '{0}' is not allowed without a leading '@param {object} {1}'."), + A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags: b(8033, 1, "A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags_8033", "A JSDoc '@typedef' comment may not contain multiple '@type' tags."), + The_tag_was_first_specified_here: b(8034, 1, "The_tag_was_first_specified_here_8034", "The tag was first specified here."), + You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder: b(8035, 1, "You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder_8035", "You cannot rename elements that are defined in a 'node_modules' folder."), + You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder: b(8036, 1, "You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder_8036", "You cannot rename elements that are defined in another 'node_modules' folder."), + Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files: b(8037, 1, "Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files_8037", "Type satisfaction expressions can only be used in TypeScript files."), + Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export: b(8038, 1, "Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export_8038", "Decorators may not appear after 'export' or 'export default' if they also appear before 'export'."), + A_JSDoc_template_tag_may_not_follow_a_typedef_callback_or_overload_tag: b(8039, 1, "A_JSDoc_template_tag_may_not_follow_a_typedef_callback_or_overload_tag_8039", "A JSDoc '@template' tag may not follow a '@typedef', '@callback', or '@overload' tag"), + Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit: b(9005, 1, "Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_9005", "Declaration emit for this file requires using private name '{0}'. An explicit type annotation may unblock declaration emit."), + Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit: b(9006, 1, "Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotati_9006", "Declaration emit for this file requires using private name '{0}' from module '{1}'. An explicit type annotation may unblock declaration emit."), + Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations: b(9007, 1, "Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations_9007", "Function must have an explicit return type annotation with --isolatedDeclarations."), + Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations: b(9008, 1, "Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations_9008", "Method must have an explicit return type annotation with --isolatedDeclarations."), + At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations: b(9009, 1, "At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations_9009", "At least one accessor must have an explicit type annotation with --isolatedDeclarations."), + Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations: b(9010, 1, "Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations_9010", "Variable must have an explicit type annotation with --isolatedDeclarations."), + Parameter_must_have_an_explicit_type_annotation_with_isolatedDeclarations: b(9011, 1, "Parameter_must_have_an_explicit_type_annotation_with_isolatedDeclarations_9011", "Parameter must have an explicit type annotation with --isolatedDeclarations."), + Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations: b(9012, 1, "Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations_9012", "Property must have an explicit type annotation with --isolatedDeclarations."), + Expression_type_can_t_be_inferred_with_isolatedDeclarations: b(9013, 1, "Expression_type_can_t_be_inferred_with_isolatedDeclarations_9013", "Expression type can't be inferred with --isolatedDeclarations."), + Computed_properties_must_be_number_or_string_literals_variables_or_dotted_expressions_with_isolatedDeclarations: b(9014, 1, "Computed_properties_must_be_number_or_string_literals_variables_or_dotted_expressions_with_isolatedD_9014", "Computed properties must be number or string literals, variables or dotted expressions with --isolatedDeclarations."), + Objects_that_contain_spread_assignments_can_t_be_inferred_with_isolatedDeclarations: b(9015, 1, "Objects_that_contain_spread_assignments_can_t_be_inferred_with_isolatedDeclarations_9015", "Objects that contain spread assignments can't be inferred with --isolatedDeclarations."), + Objects_that_contain_shorthand_properties_can_t_be_inferred_with_isolatedDeclarations: b(9016, 1, "Objects_that_contain_shorthand_properties_can_t_be_inferred_with_isolatedDeclarations_9016", "Objects that contain shorthand properties can't be inferred with --isolatedDeclarations."), + Only_const_arrays_can_be_inferred_with_isolatedDeclarations: b(9017, 1, "Only_const_arrays_can_be_inferred_with_isolatedDeclarations_9017", "Only const arrays can be inferred with --isolatedDeclarations."), + Arrays_with_spread_elements_can_t_inferred_with_isolatedDeclarations: b(9018, 1, "Arrays_with_spread_elements_can_t_inferred_with_isolatedDeclarations_9018", "Arrays with spread elements can't inferred with --isolatedDeclarations."), + Binding_elements_can_t_be_exported_directly_with_isolatedDeclarations: b(9019, 1, "Binding_elements_can_t_be_exported_directly_with_isolatedDeclarations_9019", "Binding elements can't be exported directly with --isolatedDeclarations."), + Enum_member_initializers_must_be_computable_without_references_to_external_symbols_with_isolatedDeclarations: b(9020, 1, "Enum_member_initializers_must_be_computable_without_references_to_external_symbols_with_isolatedDecl_9020", "Enum member initializers must be computable without references to external symbols with --isolatedDeclarations."), + Extends_clause_can_t_contain_an_expression_with_isolatedDeclarations: b(9021, 1, "Extends_clause_can_t_contain_an_expression_with_isolatedDeclarations_9021", "Extends clause can't contain an expression with --isolatedDeclarations."), + Inference_from_class_expressions_is_not_supported_with_isolatedDeclarations: b(9022, 1, "Inference_from_class_expressions_is_not_supported_with_isolatedDeclarations_9022", "Inference from class expressions is not supported with --isolatedDeclarations."), + Assigning_properties_to_functions_without_declaring_them_is_not_supported_with_isolatedDeclarations_Add_an_explicit_declaration_for_the_properties_assigned_to_this_function: b(9023, 1, "Assigning_properties_to_functions_without_declaring_them_is_not_supported_with_isolatedDeclarations__9023", "Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function."), + Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_supported_with_isolatedDeclarations: b(9025, 1, "Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_sup_9025", "Declaration emit for this parameter requires implicitly adding undefined to its type. This is not supported with --isolatedDeclarations."), + Declaration_emit_for_this_file_requires_preserving_this_import_for_augmentations_This_is_not_supported_with_isolatedDeclarations: b(9026, 1, "Declaration_emit_for_this_file_requires_preserving_this_import_for_augmentations_This_is_not_support_9026", "Declaration emit for this file requires preserving this import for augmentations. This is not supported with --isolatedDeclarations."), + Add_a_type_annotation_to_the_variable_0: b(9027, 1, "Add_a_type_annotation_to_the_variable_0_9027", "Add a type annotation to the variable {0}."), + Add_a_type_annotation_to_the_parameter_0: b(9028, 1, "Add_a_type_annotation_to_the_parameter_0_9028", "Add a type annotation to the parameter {0}."), + Add_a_type_annotation_to_the_property_0: b(9029, 1, "Add_a_type_annotation_to_the_property_0_9029", "Add a type annotation to the property {0}."), + Add_a_return_type_to_the_function_expression: b(9030, 1, "Add_a_return_type_to_the_function_expression_9030", "Add a return type to the function expression."), + Add_a_return_type_to_the_function_declaration: b(9031, 1, "Add_a_return_type_to_the_function_declaration_9031", "Add a return type to the function declaration."), + Add_a_return_type_to_the_get_accessor_declaration: b(9032, 1, "Add_a_return_type_to_the_get_accessor_declaration_9032", "Add a return type to the get accessor declaration."), + Add_a_type_to_parameter_of_the_set_accessor_declaration: b(9033, 1, "Add_a_type_to_parameter_of_the_set_accessor_declaration_9033", "Add a type to parameter of the set accessor declaration."), + Add_a_return_type_to_the_method: b(9034, 1, "Add_a_return_type_to_the_method_9034", "Add a return type to the method"), + Add_satisfies_and_a_type_assertion_to_this_expression_satisfies_T_as_T_to_make_the_type_explicit: b(9035, 1, "Add_satisfies_and_a_type_assertion_to_this_expression_satisfies_T_as_T_to_make_the_type_explicit_9035", "Add satisfies and a type assertion to this expression (satisfies T as T) to make the type explicit."), + Move_the_expression_in_default_export_to_a_variable_and_add_a_type_annotation_to_it: b(9036, 1, "Move_the_expression_in_default_export_to_a_variable_and_add_a_type_annotation_to_it_9036", "Move the expression in default export to a variable and add a type annotation to it."), + Default_exports_can_t_be_inferred_with_isolatedDeclarations: b(9037, 1, "Default_exports_can_t_be_inferred_with_isolatedDeclarations_9037", "Default exports can't be inferred with --isolatedDeclarations."), + Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations: b(9038, 1, "Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations_9038", "Computed property names on class or object literals cannot be inferred with --isolatedDeclarations."), + Type_containing_private_name_0_can_t_be_used_with_isolatedDeclarations: b(9039, 1, "Type_containing_private_name_0_can_t_be_used_with_isolatedDeclarations_9039", "Type containing private name '{0}' can't be used with --isolatedDeclarations."), + JSX_attributes_must_only_be_assigned_a_non_empty_expression: b(17e3, 1, "JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000", "JSX attributes must only be assigned a non-empty 'expression'."), + JSX_elements_cannot_have_multiple_attributes_with_the_same_name: b(17001, 1, "JSX_elements_cannot_have_multiple_attributes_with_the_same_name_17001", "JSX elements cannot have multiple attributes with the same name."), + Expected_corresponding_JSX_closing_tag_for_0: b(17002, 1, "Expected_corresponding_JSX_closing_tag_for_0_17002", "Expected corresponding JSX closing tag for '{0}'."), + Cannot_use_JSX_unless_the_jsx_flag_is_provided: b(17004, 1, "Cannot_use_JSX_unless_the_jsx_flag_is_provided_17004", "Cannot use JSX unless the '--jsx' flag is provided."), + A_constructor_cannot_contain_a_super_call_when_its_class_extends_null: b(17005, 1, "A_constructor_cannot_contain_a_super_call_when_its_class_extends_null_17005", "A constructor cannot contain a 'super' call when its class extends 'null'."), + An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses: b(17006, 1, "An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_ex_17006", "An unary expression with the '{0}' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses."), + A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses: b(17007, 1, "A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Con_17007", "A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses."), + JSX_element_0_has_no_corresponding_closing_tag: b(17008, 1, "JSX_element_0_has_no_corresponding_closing_tag_17008", "JSX element '{0}' has no corresponding closing tag."), + super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class: b(17009, 1, "super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class_17009", "'super' must be called before accessing 'this' in the constructor of a derived class."), + Unknown_type_acquisition_option_0: b(17010, 1, "Unknown_type_acquisition_option_0_17010", "Unknown type acquisition option '{0}'."), + super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class: b(17011, 1, "super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class_17011", "'super' must be called before accessing a property of 'super' in the constructor of a derived class."), + _0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2: b(17012, 1, "_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2_17012", "'{0}' is not a valid meta-property for keyword '{1}'. Did you mean '{2}'?"), + Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor: b(17013, 1, "Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constru_17013", "Meta-property '{0}' is only allowed in the body of a function declaration, function expression, or constructor."), + JSX_fragment_has_no_corresponding_closing_tag: b(17014, 1, "JSX_fragment_has_no_corresponding_closing_tag_17014", "JSX fragment has no corresponding closing tag."), + Expected_corresponding_closing_tag_for_JSX_fragment: b(17015, 1, "Expected_corresponding_closing_tag_for_JSX_fragment_17015", "Expected corresponding closing tag for JSX fragment."), + The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_compiler_option: b(17016, 1, "The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_com_17016", "The 'jsxFragmentFactory' compiler option must be provided to use JSX fragments with the 'jsxFactory' compiler option."), + An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments: b(17017, 1, "An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments_17017", "An @jsxFrag pragma is required when using an @jsx pragma with JSX fragments."), + Unknown_type_acquisition_option_0_Did_you_mean_1: b(17018, 1, "Unknown_type_acquisition_option_0_Did_you_mean_1_17018", "Unknown type acquisition option '{0}'. Did you mean '{1}'?"), + _0_at_the_end_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1: b(17019, 1, "_0_at_the_end_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1_17019", "'{0}' at the end of a type is not valid TypeScript syntax. Did you mean to write '{1}'?"), + _0_at_the_start_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1: b(17020, 1, "_0_at_the_start_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1_17020", "'{0}' at the start of a type is not valid TypeScript syntax. Did you mean to write '{1}'?"), + Unicode_escape_sequence_cannot_appear_here: b(17021, 1, "Unicode_escape_sequence_cannot_appear_here_17021", "Unicode escape sequence cannot appear here."), + Circularity_detected_while_resolving_configuration_Colon_0: b(18e3, 1, "Circularity_detected_while_resolving_configuration_Colon_0_18000", "Circularity detected while resolving configuration: {0}"), + The_files_list_in_config_file_0_is_empty: b(18002, 1, "The_files_list_in_config_file_0_is_empty_18002", "The 'files' list in config file '{0}' is empty."), + No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2: b(18003, 1, "No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2_18003", "No inputs were found in config file '{0}'. Specified 'include' paths were '{1}' and 'exclude' paths were '{2}'."), + File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module: b(80001, 2, "File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module_80001", "File is a CommonJS module; it may be converted to an ES module."), + This_constructor_function_may_be_converted_to_a_class_declaration: b(80002, 2, "This_constructor_function_may_be_converted_to_a_class_declaration_80002", "This constructor function may be converted to a class declaration."), + Import_may_be_converted_to_a_default_import: b(80003, 2, "Import_may_be_converted_to_a_default_import_80003", "Import may be converted to a default import."), + JSDoc_types_may_be_moved_to_TypeScript_types: b(80004, 2, "JSDoc_types_may_be_moved_to_TypeScript_types_80004", "JSDoc types may be moved to TypeScript types."), + require_call_may_be_converted_to_an_import: b(80005, 2, "require_call_may_be_converted_to_an_import_80005", "'require' call may be converted to an import."), + This_may_be_converted_to_an_async_function: b(80006, 2, "This_may_be_converted_to_an_async_function_80006", "This may be converted to an async function."), + await_has_no_effect_on_the_type_of_this_expression: b(80007, 2, "await_has_no_effect_on_the_type_of_this_expression_80007", "'await' has no effect on the type of this expression."), + Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers: b(80008, 2, "Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accur_80008", "Numeric literals with absolute values equal to 2^53 or greater are too large to be represented accurately as integers."), + JSDoc_typedef_may_be_converted_to_TypeScript_type: b(80009, 2, "JSDoc_typedef_may_be_converted_to_TypeScript_type_80009", "JSDoc typedef may be converted to TypeScript type."), + JSDoc_typedefs_may_be_converted_to_TypeScript_types: b(80010, 2, "JSDoc_typedefs_may_be_converted_to_TypeScript_types_80010", "JSDoc typedefs may be converted to TypeScript types."), + Add_missing_super_call: b(90001, 3, "Add_missing_super_call_90001", "Add missing 'super()' call"), + Make_super_call_the_first_statement_in_the_constructor: b(90002, 3, "Make_super_call_the_first_statement_in_the_constructor_90002", "Make 'super()' call the first statement in the constructor"), + Change_extends_to_implements: b(90003, 3, "Change_extends_to_implements_90003", "Change 'extends' to 'implements'"), + Remove_unused_declaration_for_Colon_0: b(90004, 3, "Remove_unused_declaration_for_Colon_0_90004", "Remove unused declaration for: '{0}'"), + Remove_import_from_0: b(90005, 3, "Remove_import_from_0_90005", "Remove import from '{0}'"), + Implement_interface_0: b(90006, 3, "Implement_interface_0_90006", "Implement interface '{0}'"), + Implement_inherited_abstract_class: b(90007, 3, "Implement_inherited_abstract_class_90007", "Implement inherited abstract class"), + Add_0_to_unresolved_variable: b(90008, 3, "Add_0_to_unresolved_variable_90008", "Add '{0}.' to unresolved variable"), + Remove_variable_statement: b(90010, 3, "Remove_variable_statement_90010", "Remove variable statement"), + Remove_template_tag: b(90011, 3, "Remove_template_tag_90011", "Remove template tag"), + Remove_type_parameters: b(90012, 3, "Remove_type_parameters_90012", "Remove type parameters"), + Import_0_from_1: b(90013, 3, "Import_0_from_1_90013", `Import '{0}' from "{1}"`), + Change_0_to_1: b(90014, 3, "Change_0_to_1_90014", "Change '{0}' to '{1}'"), + Declare_property_0: b(90016, 3, "Declare_property_0_90016", "Declare property '{0}'"), + Add_index_signature_for_property_0: b(90017, 3, "Add_index_signature_for_property_0_90017", "Add index signature for property '{0}'"), + Disable_checking_for_this_file: b(90018, 3, "Disable_checking_for_this_file_90018", "Disable checking for this file"), + Ignore_this_error_message: b(90019, 3, "Ignore_this_error_message_90019", "Ignore this error message"), + Initialize_property_0_in_the_constructor: b(90020, 3, "Initialize_property_0_in_the_constructor_90020", "Initialize property '{0}' in the constructor"), + Initialize_static_property_0: b(90021, 3, "Initialize_static_property_0_90021", "Initialize static property '{0}'"), + Change_spelling_to_0: b(90022, 3, "Change_spelling_to_0_90022", "Change spelling to '{0}'"), + Declare_method_0: b(90023, 3, "Declare_method_0_90023", "Declare method '{0}'"), + Declare_static_method_0: b(90024, 3, "Declare_static_method_0_90024", "Declare static method '{0}'"), + Prefix_0_with_an_underscore: b(90025, 3, "Prefix_0_with_an_underscore_90025", "Prefix '{0}' with an underscore"), + Rewrite_as_the_indexed_access_type_0: b(90026, 3, "Rewrite_as_the_indexed_access_type_0_90026", "Rewrite as the indexed access type '{0}'"), + Declare_static_property_0: b(90027, 3, "Declare_static_property_0_90027", "Declare static property '{0}'"), + Call_decorator_expression: b(90028, 3, "Call_decorator_expression_90028", "Call decorator expression"), + Add_async_modifier_to_containing_function: b(90029, 3, "Add_async_modifier_to_containing_function_90029", "Add async modifier to containing function"), + Replace_infer_0_with_unknown: b(90030, 3, "Replace_infer_0_with_unknown_90030", "Replace 'infer {0}' with 'unknown'"), + Replace_all_unused_infer_with_unknown: b(90031, 3, "Replace_all_unused_infer_with_unknown_90031", "Replace all unused 'infer' with 'unknown'"), + Add_parameter_name: b(90034, 3, "Add_parameter_name_90034", "Add parameter name"), + Declare_private_property_0: b(90035, 3, "Declare_private_property_0_90035", "Declare private property '{0}'"), + Replace_0_with_Promise_1: b(90036, 3, "Replace_0_with_Promise_1_90036", "Replace '{0}' with 'Promise<{1}>'"), + Fix_all_incorrect_return_type_of_an_async_functions: b(90037, 3, "Fix_all_incorrect_return_type_of_an_async_functions_90037", "Fix all incorrect return type of an async functions"), + Declare_private_method_0: b(90038, 3, "Declare_private_method_0_90038", "Declare private method '{0}'"), + Remove_unused_destructuring_declaration: b(90039, 3, "Remove_unused_destructuring_declaration_90039", "Remove unused destructuring declaration"), + Remove_unused_declarations_for_Colon_0: b(90041, 3, "Remove_unused_declarations_for_Colon_0_90041", "Remove unused declarations for: '{0}'"), + Declare_a_private_field_named_0: b(90053, 3, "Declare_a_private_field_named_0_90053", "Declare a private field named '{0}'."), + Includes_imports_of_types_referenced_by_0: b(90054, 3, "Includes_imports_of_types_referenced_by_0_90054", "Includes imports of types referenced by '{0}'"), + Remove_type_from_import_declaration_from_0: b(90055, 3, "Remove_type_from_import_declaration_from_0_90055", `Remove 'type' from import declaration from "{0}"`), + Remove_type_from_import_of_0_from_1: b(90056, 3, "Remove_type_from_import_of_0_from_1_90056", `Remove 'type' from import of '{0}' from "{1}"`), + Add_import_from_0: b(90057, 3, "Add_import_from_0_90057", 'Add import from "{0}"'), + Update_import_from_0: b(90058, 3, "Update_import_from_0_90058", 'Update import from "{0}"'), + Export_0_from_module_1: b(90059, 3, "Export_0_from_module_1_90059", "Export '{0}' from module '{1}'"), + Export_all_referenced_locals: b(90060, 3, "Export_all_referenced_locals_90060", "Export all referenced locals"), + Update_modifiers_of_0: b(90061, 3, "Update_modifiers_of_0_90061", "Update modifiers of '{0}'"), + Add_annotation_of_type_0: b(90062, 3, "Add_annotation_of_type_0_90062", "Add annotation of type '{0}'"), + Add_return_type_0: b(90063, 3, "Add_return_type_0_90063", "Add return type '{0}'"), + Extract_base_class_to_variable: b(90064, 3, "Extract_base_class_to_variable_90064", "Extract base class to variable"), + Extract_default_export_to_variable: b(90065, 3, "Extract_default_export_to_variable_90065", "Extract default export to variable"), + Extract_binding_expressions_to_variable: b(90066, 3, "Extract_binding_expressions_to_variable_90066", "Extract binding expressions to variable"), + Add_all_missing_type_annotations: b(90067, 3, "Add_all_missing_type_annotations_90067", "Add all missing type annotations"), + Add_satisfies_and_an_inline_type_assertion_with_0: b(90068, 3, "Add_satisfies_and_an_inline_type_assertion_with_0_90068", "Add satisfies and an inline type assertion with '{0}'"), + Extract_to_variable_and_replace_with_0_as_typeof_0: b(90069, 3, "Extract_to_variable_and_replace_with_0_as_typeof_0_90069", "Extract to variable and replace with '{0} as typeof {0}'"), + Mark_array_literal_as_const: b(90070, 3, "Mark_array_literal_as_const_90070", "Mark array literal as const"), + Annotate_types_of_properties_expando_function_in_a_namespace: b(90071, 3, "Annotate_types_of_properties_expando_function_in_a_namespace_90071", "Annotate types of properties expando function in a namespace"), + Convert_function_to_an_ES2015_class: b(95001, 3, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"), + Convert_0_to_1_in_0: b(95003, 3, "Convert_0_to_1_in_0_95003", "Convert '{0}' to '{1} in {0}'"), + Extract_to_0_in_1: b(95004, 3, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"), + Extract_function: b(95005, 3, "Extract_function_95005", "Extract function"), + Extract_constant: b(95006, 3, "Extract_constant_95006", "Extract constant"), + Extract_to_0_in_enclosing_scope: b(95007, 3, "Extract_to_0_in_enclosing_scope_95007", "Extract to {0} in enclosing scope"), + Extract_to_0_in_1_scope: b(95008, 3, "Extract_to_0_in_1_scope_95008", "Extract to {0} in {1} scope"), + Annotate_with_type_from_JSDoc: b(95009, 3, "Annotate_with_type_from_JSDoc_95009", "Annotate with type from JSDoc"), + Infer_type_of_0_from_usage: b(95011, 3, "Infer_type_of_0_from_usage_95011", "Infer type of '{0}' from usage"), + Infer_parameter_types_from_usage: b(95012, 3, "Infer_parameter_types_from_usage_95012", "Infer parameter types from usage"), + Convert_to_default_import: b(95013, 3, "Convert_to_default_import_95013", "Convert to default import"), + Install_0: b(95014, 3, "Install_0_95014", "Install '{0}'"), + Replace_import_with_0: b(95015, 3, "Replace_import_with_0_95015", "Replace import with '{0}'."), + Use_synthetic_default_member: b(95016, 3, "Use_synthetic_default_member_95016", "Use synthetic 'default' member."), + Convert_to_ES_module: b(95017, 3, "Convert_to_ES_module_95017", "Convert to ES module"), + Add_undefined_type_to_property_0: b(95018, 3, "Add_undefined_type_to_property_0_95018", "Add 'undefined' type to property '{0}'"), + Add_initializer_to_property_0: b(95019, 3, "Add_initializer_to_property_0_95019", "Add initializer to property '{0}'"), + Add_definite_assignment_assertion_to_property_0: b(95020, 3, "Add_definite_assignment_assertion_to_property_0_95020", "Add definite assignment assertion to property '{0}'"), + Convert_all_type_literals_to_mapped_type: b(95021, 3, "Convert_all_type_literals_to_mapped_type_95021", "Convert all type literals to mapped type"), + Add_all_missing_members: b(95022, 3, "Add_all_missing_members_95022", "Add all missing members"), + Infer_all_types_from_usage: b(95023, 3, "Infer_all_types_from_usage_95023", "Infer all types from usage"), + Delete_all_unused_declarations: b(95024, 3, "Delete_all_unused_declarations_95024", "Delete all unused declarations"), + Prefix_all_unused_declarations_with_where_possible: b(95025, 3, "Prefix_all_unused_declarations_with_where_possible_95025", "Prefix all unused declarations with '_' where possible"), + Fix_all_detected_spelling_errors: b(95026, 3, "Fix_all_detected_spelling_errors_95026", "Fix all detected spelling errors"), + Add_initializers_to_all_uninitialized_properties: b(95027, 3, "Add_initializers_to_all_uninitialized_properties_95027", "Add initializers to all uninitialized properties"), + Add_definite_assignment_assertions_to_all_uninitialized_properties: b(95028, 3, "Add_definite_assignment_assertions_to_all_uninitialized_properties_95028", "Add definite assignment assertions to all uninitialized properties"), + Add_undefined_type_to_all_uninitialized_properties: b(95029, 3, "Add_undefined_type_to_all_uninitialized_properties_95029", "Add undefined type to all uninitialized properties"), + Change_all_jsdoc_style_types_to_TypeScript: b(95030, 3, "Change_all_jsdoc_style_types_to_TypeScript_95030", "Change all jsdoc-style types to TypeScript"), + Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types: b(95031, 3, "Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types_95031", "Change all jsdoc-style types to TypeScript (and add '| undefined' to nullable types)"), + Implement_all_unimplemented_interfaces: b(95032, 3, "Implement_all_unimplemented_interfaces_95032", "Implement all unimplemented interfaces"), + Install_all_missing_types_packages: b(95033, 3, "Install_all_missing_types_packages_95033", "Install all missing types packages"), + Rewrite_all_as_indexed_access_types: b(95034, 3, "Rewrite_all_as_indexed_access_types_95034", "Rewrite all as indexed access types"), + Convert_all_to_default_imports: b(95035, 3, "Convert_all_to_default_imports_95035", "Convert all to default imports"), + Make_all_super_calls_the_first_statement_in_their_constructor: b(95036, 3, "Make_all_super_calls_the_first_statement_in_their_constructor_95036", "Make all 'super()' calls the first statement in their constructor"), + Add_qualifier_to_all_unresolved_variables_matching_a_member_name: b(95037, 3, "Add_qualifier_to_all_unresolved_variables_matching_a_member_name_95037", "Add qualifier to all unresolved variables matching a member name"), + Change_all_extended_interfaces_to_implements: b(95038, 3, "Change_all_extended_interfaces_to_implements_95038", "Change all extended interfaces to 'implements'"), + Add_all_missing_super_calls: b(95039, 3, "Add_all_missing_super_calls_95039", "Add all missing super calls"), + Implement_all_inherited_abstract_classes: b(95040, 3, "Implement_all_inherited_abstract_classes_95040", "Implement all inherited abstract classes"), + Add_all_missing_async_modifiers: b(95041, 3, "Add_all_missing_async_modifiers_95041", "Add all missing 'async' modifiers"), + Add_ts_ignore_to_all_error_messages: b(95042, 3, "Add_ts_ignore_to_all_error_messages_95042", "Add '@ts-ignore' to all error messages"), + Annotate_everything_with_types_from_JSDoc: b(95043, 3, "Annotate_everything_with_types_from_JSDoc_95043", "Annotate everything with types from JSDoc"), + Add_to_all_uncalled_decorators: b(95044, 3, "Add_to_all_uncalled_decorators_95044", "Add '()' to all uncalled decorators"), + Convert_all_constructor_functions_to_classes: b(95045, 3, "Convert_all_constructor_functions_to_classes_95045", "Convert all constructor functions to classes"), + Generate_get_and_set_accessors: b(95046, 3, "Generate_get_and_set_accessors_95046", "Generate 'get' and 'set' accessors"), + Convert_require_to_import: b(95047, 3, "Convert_require_to_import_95047", "Convert 'require' to 'import'"), + Convert_all_require_to_import: b(95048, 3, "Convert_all_require_to_import_95048", "Convert all 'require' to 'import'"), + Move_to_a_new_file: b(95049, 3, "Move_to_a_new_file_95049", "Move to a new file"), + Remove_unreachable_code: b(95050, 3, "Remove_unreachable_code_95050", "Remove unreachable code"), + Remove_all_unreachable_code: b(95051, 3, "Remove_all_unreachable_code_95051", "Remove all unreachable code"), + Add_missing_typeof: b(95052, 3, "Add_missing_typeof_95052", "Add missing 'typeof'"), + Remove_unused_label: b(95053, 3, "Remove_unused_label_95053", "Remove unused label"), + Remove_all_unused_labels: b(95054, 3, "Remove_all_unused_labels_95054", "Remove all unused labels"), + Convert_0_to_mapped_object_type: b(95055, 3, "Convert_0_to_mapped_object_type_95055", "Convert '{0}' to mapped object type"), + Convert_namespace_import_to_named_imports: b(95056, 3, "Convert_namespace_import_to_named_imports_95056", "Convert namespace import to named imports"), + Convert_named_imports_to_namespace_import: b(95057, 3, "Convert_named_imports_to_namespace_import_95057", "Convert named imports to namespace import"), + Add_or_remove_braces_in_an_arrow_function: b(95058, 3, "Add_or_remove_braces_in_an_arrow_function_95058", "Add or remove braces in an arrow function"), + Add_braces_to_arrow_function: b(95059, 3, "Add_braces_to_arrow_function_95059", "Add braces to arrow function"), + Remove_braces_from_arrow_function: b(95060, 3, "Remove_braces_from_arrow_function_95060", "Remove braces from arrow function"), + Convert_default_export_to_named_export: b(95061, 3, "Convert_default_export_to_named_export_95061", "Convert default export to named export"), + Convert_named_export_to_default_export: b(95062, 3, "Convert_named_export_to_default_export_95062", "Convert named export to default export"), + Add_missing_enum_member_0: b(95063, 3, "Add_missing_enum_member_0_95063", "Add missing enum member '{0}'"), + Add_all_missing_imports: b(95064, 3, "Add_all_missing_imports_95064", "Add all missing imports"), + Convert_to_async_function: b(95065, 3, "Convert_to_async_function_95065", "Convert to async function"), + Convert_all_to_async_functions: b(95066, 3, "Convert_all_to_async_functions_95066", "Convert all to async functions"), + Add_missing_call_parentheses: b(95067, 3, "Add_missing_call_parentheses_95067", "Add missing call parentheses"), + Add_all_missing_call_parentheses: b(95068, 3, "Add_all_missing_call_parentheses_95068", "Add all missing call parentheses"), + Add_unknown_conversion_for_non_overlapping_types: b(95069, 3, "Add_unknown_conversion_for_non_overlapping_types_95069", "Add 'unknown' conversion for non-overlapping types"), + Add_unknown_to_all_conversions_of_non_overlapping_types: b(95070, 3, "Add_unknown_to_all_conversions_of_non_overlapping_types_95070", "Add 'unknown' to all conversions of non-overlapping types"), + Add_missing_new_operator_to_call: b(95071, 3, "Add_missing_new_operator_to_call_95071", "Add missing 'new' operator to call"), + Add_missing_new_operator_to_all_calls: b(95072, 3, "Add_missing_new_operator_to_all_calls_95072", "Add missing 'new' operator to all calls"), + Add_names_to_all_parameters_without_names: b(95073, 3, "Add_names_to_all_parameters_without_names_95073", "Add names to all parameters without names"), + Enable_the_experimentalDecorators_option_in_your_configuration_file: b(95074, 3, "Enable_the_experimentalDecorators_option_in_your_configuration_file_95074", "Enable the 'experimentalDecorators' option in your configuration file"), + Convert_parameters_to_destructured_object: b(95075, 3, "Convert_parameters_to_destructured_object_95075", "Convert parameters to destructured object"), + Extract_type: b(95077, 3, "Extract_type_95077", "Extract type"), + Extract_to_type_alias: b(95078, 3, "Extract_to_type_alias_95078", "Extract to type alias"), + Extract_to_typedef: b(95079, 3, "Extract_to_typedef_95079", "Extract to typedef"), + Infer_this_type_of_0_from_usage: b(95080, 3, "Infer_this_type_of_0_from_usage_95080", "Infer 'this' type of '{0}' from usage"), + Add_const_to_unresolved_variable: b(95081, 3, "Add_const_to_unresolved_variable_95081", "Add 'const' to unresolved variable"), + Add_const_to_all_unresolved_variables: b(95082, 3, "Add_const_to_all_unresolved_variables_95082", "Add 'const' to all unresolved variables"), + Add_await: b(95083, 3, "Add_await_95083", "Add 'await'"), + Add_await_to_initializer_for_0: b(95084, 3, "Add_await_to_initializer_for_0_95084", "Add 'await' to initializer for '{0}'"), + Fix_all_expressions_possibly_missing_await: b(95085, 3, "Fix_all_expressions_possibly_missing_await_95085", "Fix all expressions possibly missing 'await'"), + Remove_unnecessary_await: b(95086, 3, "Remove_unnecessary_await_95086", "Remove unnecessary 'await'"), + Remove_all_unnecessary_uses_of_await: b(95087, 3, "Remove_all_unnecessary_uses_of_await_95087", "Remove all unnecessary uses of 'await'"), + Enable_the_jsx_flag_in_your_configuration_file: b(95088, 3, "Enable_the_jsx_flag_in_your_configuration_file_95088", "Enable the '--jsx' flag in your configuration file"), + Add_await_to_initializers: b(95089, 3, "Add_await_to_initializers_95089", "Add 'await' to initializers"), + Extract_to_interface: b(95090, 3, "Extract_to_interface_95090", "Extract to interface"), + Convert_to_a_bigint_numeric_literal: b(95091, 3, "Convert_to_a_bigint_numeric_literal_95091", "Convert to a bigint numeric literal"), + Convert_all_to_bigint_numeric_literals: b(95092, 3, "Convert_all_to_bigint_numeric_literals_95092", "Convert all to bigint numeric literals"), + Convert_const_to_let: b(95093, 3, "Convert_const_to_let_95093", "Convert 'const' to 'let'"), + Prefix_with_declare: b(95094, 3, "Prefix_with_declare_95094", "Prefix with 'declare'"), + Prefix_all_incorrect_property_declarations_with_declare: b(95095, 3, "Prefix_all_incorrect_property_declarations_with_declare_95095", "Prefix all incorrect property declarations with 'declare'"), + Convert_to_template_string: b(95096, 3, "Convert_to_template_string_95096", "Convert to template string"), + Add_export_to_make_this_file_into_a_module: b(95097, 3, "Add_export_to_make_this_file_into_a_module_95097", "Add 'export {}' to make this file into a module"), + Set_the_target_option_in_your_configuration_file_to_0: b(95098, 3, "Set_the_target_option_in_your_configuration_file_to_0_95098", "Set the 'target' option in your configuration file to '{0}'"), + Set_the_module_option_in_your_configuration_file_to_0: b(95099, 3, "Set_the_module_option_in_your_configuration_file_to_0_95099", "Set the 'module' option in your configuration file to '{0}'"), + Convert_invalid_character_to_its_html_entity_code: b(95100, 3, "Convert_invalid_character_to_its_html_entity_code_95100", "Convert invalid character to its html entity code"), + Convert_all_invalid_characters_to_HTML_entity_code: b(95101, 3, "Convert_all_invalid_characters_to_HTML_entity_code_95101", "Convert all invalid characters to HTML entity code"), + Convert_all_const_to_let: b(95102, 3, "Convert_all_const_to_let_95102", "Convert all 'const' to 'let'"), + Convert_function_expression_0_to_arrow_function: b(95105, 3, "Convert_function_expression_0_to_arrow_function_95105", "Convert function expression '{0}' to arrow function"), + Convert_function_declaration_0_to_arrow_function: b(95106, 3, "Convert_function_declaration_0_to_arrow_function_95106", "Convert function declaration '{0}' to arrow function"), + Fix_all_implicit_this_errors: b(95107, 3, "Fix_all_implicit_this_errors_95107", "Fix all implicit-'this' errors"), + Wrap_invalid_character_in_an_expression_container: b(95108, 3, "Wrap_invalid_character_in_an_expression_container_95108", "Wrap invalid character in an expression container"), + Wrap_all_invalid_characters_in_an_expression_container: b(95109, 3, "Wrap_all_invalid_characters_in_an_expression_container_95109", "Wrap all invalid characters in an expression container"), + Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_to_read_more_about_this_file: b(95110, 3, "Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_to_read_more_about_this_file_95110", "Visit https://aka.ms/tsconfig to read more about this file"), + Add_a_return_statement: b(95111, 3, "Add_a_return_statement_95111", "Add a return statement"), + Remove_braces_from_arrow_function_body: b(95112, 3, "Remove_braces_from_arrow_function_body_95112", "Remove braces from arrow function body"), + Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal: b(95113, 3, "Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal_95113", "Wrap the following body with parentheses which should be an object literal"), + Add_all_missing_return_statement: b(95114, 3, "Add_all_missing_return_statement_95114", "Add all missing return statement"), + Remove_braces_from_all_arrow_function_bodies_with_relevant_issues: b(95115, 3, "Remove_braces_from_all_arrow_function_bodies_with_relevant_issues_95115", "Remove braces from all arrow function bodies with relevant issues"), + Wrap_all_object_literal_with_parentheses: b(95116, 3, "Wrap_all_object_literal_with_parentheses_95116", "Wrap all object literal with parentheses"), + Move_labeled_tuple_element_modifiers_to_labels: b(95117, 3, "Move_labeled_tuple_element_modifiers_to_labels_95117", "Move labeled tuple element modifiers to labels"), + Convert_overload_list_to_single_signature: b(95118, 3, "Convert_overload_list_to_single_signature_95118", "Convert overload list to single signature"), + Generate_get_and_set_accessors_for_all_overriding_properties: b(95119, 3, "Generate_get_and_set_accessors_for_all_overriding_properties_95119", "Generate 'get' and 'set' accessors for all overriding properties"), + Wrap_in_JSX_fragment: b(95120, 3, "Wrap_in_JSX_fragment_95120", "Wrap in JSX fragment"), + Wrap_all_unparented_JSX_in_JSX_fragment: b(95121, 3, "Wrap_all_unparented_JSX_in_JSX_fragment_95121", "Wrap all unparented JSX in JSX fragment"), + Convert_arrow_function_or_function_expression: b(95122, 3, "Convert_arrow_function_or_function_expression_95122", "Convert arrow function or function expression"), + Convert_to_anonymous_function: b(95123, 3, "Convert_to_anonymous_function_95123", "Convert to anonymous function"), + Convert_to_named_function: b(95124, 3, "Convert_to_named_function_95124", "Convert to named function"), + Convert_to_arrow_function: b(95125, 3, "Convert_to_arrow_function_95125", "Convert to arrow function"), + Remove_parentheses: b(95126, 3, "Remove_parentheses_95126", "Remove parentheses"), + Could_not_find_a_containing_arrow_function: b(95127, 3, "Could_not_find_a_containing_arrow_function_95127", "Could not find a containing arrow function"), + Containing_function_is_not_an_arrow_function: b(95128, 3, "Containing_function_is_not_an_arrow_function_95128", "Containing function is not an arrow function"), + Could_not_find_export_statement: b(95129, 3, "Could_not_find_export_statement_95129", "Could not find export statement"), + This_file_already_has_a_default_export: b(95130, 3, "This_file_already_has_a_default_export_95130", "This file already has a default export"), + Could_not_find_import_clause: b(95131, 3, "Could_not_find_import_clause_95131", "Could not find import clause"), + Could_not_find_namespace_import_or_named_imports: b(95132, 3, "Could_not_find_namespace_import_or_named_imports_95132", "Could not find namespace import or named imports"), + Selection_is_not_a_valid_type_node: b(95133, 3, "Selection_is_not_a_valid_type_node_95133", "Selection is not a valid type node"), + No_type_could_be_extracted_from_this_type_node: b(95134, 3, "No_type_could_be_extracted_from_this_type_node_95134", "No type could be extracted from this type node"), + Could_not_find_property_for_which_to_generate_accessor: b(95135, 3, "Could_not_find_property_for_which_to_generate_accessor_95135", "Could not find property for which to generate accessor"), + Name_is_not_valid: b(95136, 3, "Name_is_not_valid_95136", "Name is not valid"), + Can_only_convert_property_with_modifier: b(95137, 3, "Can_only_convert_property_with_modifier_95137", "Can only convert property with modifier"), + Switch_each_misused_0_to_1: b(95138, 3, "Switch_each_misused_0_to_1_95138", "Switch each misused '{0}' to '{1}'"), + Convert_to_optional_chain_expression: b(95139, 3, "Convert_to_optional_chain_expression_95139", "Convert to optional chain expression"), + Could_not_find_convertible_access_expression: b(95140, 3, "Could_not_find_convertible_access_expression_95140", "Could not find convertible access expression"), + Could_not_find_matching_access_expressions: b(95141, 3, "Could_not_find_matching_access_expressions_95141", "Could not find matching access expressions"), + Can_only_convert_logical_AND_access_chains: b(95142, 3, "Can_only_convert_logical_AND_access_chains_95142", "Can only convert logical AND access chains"), + Add_void_to_Promise_resolved_without_a_value: b(95143, 3, "Add_void_to_Promise_resolved_without_a_value_95143", "Add 'void' to Promise resolved without a value"), + Add_void_to_all_Promises_resolved_without_a_value: b(95144, 3, "Add_void_to_all_Promises_resolved_without_a_value_95144", "Add 'void' to all Promises resolved without a value"), + Use_element_access_for_0: b(95145, 3, "Use_element_access_for_0_95145", "Use element access for '{0}'"), + Use_element_access_for_all_undeclared_properties: b(95146, 3, "Use_element_access_for_all_undeclared_properties_95146", "Use element access for all undeclared properties."), + Delete_all_unused_imports: b(95147, 3, "Delete_all_unused_imports_95147", "Delete all unused imports"), + Infer_function_return_type: b(95148, 3, "Infer_function_return_type_95148", "Infer function return type"), + Return_type_must_be_inferred_from_a_function: b(95149, 3, "Return_type_must_be_inferred_from_a_function_95149", "Return type must be inferred from a function"), + Could_not_determine_function_return_type: b(95150, 3, "Could_not_determine_function_return_type_95150", "Could not determine function return type"), + Could_not_convert_to_arrow_function: b(95151, 3, "Could_not_convert_to_arrow_function_95151", "Could not convert to arrow function"), + Could_not_convert_to_named_function: b(95152, 3, "Could_not_convert_to_named_function_95152", "Could not convert to named function"), + Could_not_convert_to_anonymous_function: b(95153, 3, "Could_not_convert_to_anonymous_function_95153", "Could not convert to anonymous function"), + Can_only_convert_string_concatenations_and_string_literals: b(95154, 3, "Can_only_convert_string_concatenations_and_string_literals_95154", "Can only convert string concatenations and string literals"), + Selection_is_not_a_valid_statement_or_statements: b(95155, 3, "Selection_is_not_a_valid_statement_or_statements_95155", "Selection is not a valid statement or statements"), + Add_missing_function_declaration_0: b(95156, 3, "Add_missing_function_declaration_0_95156", "Add missing function declaration '{0}'"), + Add_all_missing_function_declarations: b(95157, 3, "Add_all_missing_function_declarations_95157", "Add all missing function declarations"), + Method_not_implemented: b(95158, 3, "Method_not_implemented_95158", "Method not implemented."), + Function_not_implemented: b(95159, 3, "Function_not_implemented_95159", "Function not implemented."), + Add_override_modifier: b(95160, 3, "Add_override_modifier_95160", "Add 'override' modifier"), + Remove_override_modifier: b(95161, 3, "Remove_override_modifier_95161", "Remove 'override' modifier"), + Add_all_missing_override_modifiers: b(95162, 3, "Add_all_missing_override_modifiers_95162", "Add all missing 'override' modifiers"), + Remove_all_unnecessary_override_modifiers: b(95163, 3, "Remove_all_unnecessary_override_modifiers_95163", "Remove all unnecessary 'override' modifiers"), + Can_only_convert_named_export: b(95164, 3, "Can_only_convert_named_export_95164", "Can only convert named export"), + Add_missing_properties: b(95165, 3, "Add_missing_properties_95165", "Add missing properties"), + Add_all_missing_properties: b(95166, 3, "Add_all_missing_properties_95166", "Add all missing properties"), + Add_missing_attributes: b(95167, 3, "Add_missing_attributes_95167", "Add missing attributes"), + Add_all_missing_attributes: b(95168, 3, "Add_all_missing_attributes_95168", "Add all missing attributes"), + Add_undefined_to_optional_property_type: b(95169, 3, "Add_undefined_to_optional_property_type_95169", "Add 'undefined' to optional property type"), + Convert_named_imports_to_default_import: b(95170, 3, "Convert_named_imports_to_default_import_95170", "Convert named imports to default import"), + Delete_unused_param_tag_0: b(95171, 3, "Delete_unused_param_tag_0_95171", "Delete unused '@param' tag '{0}'"), + Delete_all_unused_param_tags: b(95172, 3, "Delete_all_unused_param_tags_95172", "Delete all unused '@param' tags"), + Rename_param_tag_name_0_to_1: b(95173, 3, "Rename_param_tag_name_0_to_1_95173", "Rename '@param' tag name '{0}' to '{1}'"), + Use_0: b(95174, 3, "Use_0_95174", "Use `{0}`."), + Use_Number_isNaN_in_all_conditions: b(95175, 3, "Use_Number_isNaN_in_all_conditions_95175", "Use `Number.isNaN` in all conditions."), + Convert_typedef_to_TypeScript_type: b(95176, 3, "Convert_typedef_to_TypeScript_type_95176", "Convert typedef to TypeScript type."), + Convert_all_typedef_to_TypeScript_types: b(95177, 3, "Convert_all_typedef_to_TypeScript_types_95177", "Convert all typedef to TypeScript types."), + Move_to_file: b(95178, 3, "Move_to_file_95178", "Move to file"), + Cannot_move_to_file_selected_file_is_invalid: b(95179, 3, "Cannot_move_to_file_selected_file_is_invalid_95179", "Cannot move to file, selected file is invalid"), + Use_import_type: b(95180, 3, "Use_import_type_95180", "Use 'import type'"), + Use_type_0: b(95181, 3, "Use_type_0_95181", "Use 'type {0}'"), + Fix_all_with_type_only_imports: b(95182, 3, "Fix_all_with_type_only_imports_95182", "Fix all with type-only imports"), + Cannot_move_statements_to_the_selected_file: b(95183, 3, "Cannot_move_statements_to_the_selected_file_95183", "Cannot move statements to the selected file"), + Inline_variable: b(95184, 3, "Inline_variable_95184", "Inline variable"), + Could_not_find_variable_to_inline: b(95185, 3, "Could_not_find_variable_to_inline_95185", "Could not find variable to inline."), + Variables_with_multiple_declarations_cannot_be_inlined: b(95186, 3, "Variables_with_multiple_declarations_cannot_be_inlined_95186", "Variables with multiple declarations cannot be inlined."), + Add_missing_comma_for_object_member_completion_0: b(95187, 3, "Add_missing_comma_for_object_member_completion_0_95187", "Add missing comma for object member completion '{0}'."), + Add_missing_parameter_to_0: b(95188, 3, "Add_missing_parameter_to_0_95188", "Add missing parameter to '{0}'"), + Add_missing_parameters_to_0: b(95189, 3, "Add_missing_parameters_to_0_95189", "Add missing parameters to '{0}'"), + Add_all_missing_parameters: b(95190, 3, "Add_all_missing_parameters_95190", "Add all missing parameters"), + Add_optional_parameter_to_0: b(95191, 3, "Add_optional_parameter_to_0_95191", "Add optional parameter to '{0}'"), + Add_optional_parameters_to_0: b(95192, 3, "Add_optional_parameters_to_0_95192", "Add optional parameters to '{0}'"), + Add_all_optional_parameters: b(95193, 3, "Add_all_optional_parameters_95193", "Add all optional parameters"), + Wrap_in_parentheses: b(95194, 3, "Wrap_in_parentheses_95194", "Wrap in parentheses"), + Wrap_all_invalid_decorator_expressions_in_parentheses: b(95195, 3, "Wrap_all_invalid_decorator_expressions_in_parentheses_95195", "Wrap all invalid decorator expressions in parentheses"), + Add_resolution_mode_import_attribute: b(95196, 3, "Add_resolution_mode_import_attribute_95196", "Add 'resolution-mode' import attribute"), + Add_resolution_mode_import_attribute_to_all_type_only_imports_that_need_it: b(95197, 3, "Add_resolution_mode_import_attribute_to_all_type_only_imports_that_need_it_95197", "Add 'resolution-mode' import attribute to all type-only imports that need it"), + No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: b(18004, 1, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."), + Classes_may_not_have_a_field_named_constructor: b(18006, 1, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."), + JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: b(18007, 1, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"), + Private_identifiers_cannot_be_used_as_parameters: b(18009, 1, "Private_identifiers_cannot_be_used_as_parameters_18009", "Private identifiers cannot be used as parameters."), + An_accessibility_modifier_cannot_be_used_with_a_private_identifier: b(18010, 1, "An_accessibility_modifier_cannot_be_used_with_a_private_identifier_18010", "An accessibility modifier cannot be used with a private identifier."), + The_operand_of_a_delete_operator_cannot_be_a_private_identifier: b(18011, 1, "The_operand_of_a_delete_operator_cannot_be_a_private_identifier_18011", "The operand of a 'delete' operator cannot be a private identifier."), + constructor_is_a_reserved_word: b(18012, 1, "constructor_is_a_reserved_word_18012", "'#constructor' is a reserved word."), + Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier: b(18013, 1, "Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier_18013", "Property '{0}' is not accessible outside class '{1}' because it has a private identifier."), + The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_private_identifier_with_the_same_spelling: b(18014, 1, "The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_priv_18014", "The property '{0}' cannot be accessed on type '{1}' within this class because it is shadowed by another private identifier with the same spelling."), + Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2: b(18015, 1, "Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2_18015", "Property '{0}' in type '{1}' refers to a different member that cannot be accessed from within type '{2}'."), + Private_identifiers_are_not_allowed_outside_class_bodies: b(18016, 1, "Private_identifiers_are_not_allowed_outside_class_bodies_18016", "Private identifiers are not allowed outside class bodies."), + The_shadowing_declaration_of_0_is_defined_here: b(18017, 1, "The_shadowing_declaration_of_0_is_defined_here_18017", "The shadowing declaration of '{0}' is defined here"), + The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here: b(18018, 1, "The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here_18018", "The declaration of '{0}' that you probably intended to use is defined here"), + _0_modifier_cannot_be_used_with_a_private_identifier: b(18019, 1, "_0_modifier_cannot_be_used_with_a_private_identifier_18019", "'{0}' modifier cannot be used with a private identifier."), + An_enum_member_cannot_be_named_with_a_private_identifier: b(18024, 1, "An_enum_member_cannot_be_named_with_a_private_identifier_18024", "An enum member cannot be named with a private identifier."), + can_only_be_used_at_the_start_of_a_file: b(18026, 1, "can_only_be_used_at_the_start_of_a_file_18026", "'#!' can only be used at the start of a file."), + Compiler_reserves_name_0_when_emitting_private_identifier_downlevel: b(18027, 1, "Compiler_reserves_name_0_when_emitting_private_identifier_downlevel_18027", "Compiler reserves name '{0}' when emitting private identifier downlevel."), + Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher: b(18028, 1, "Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher_18028", "Private identifiers are only available when targeting ECMAScript 2015 and higher."), + Private_identifiers_are_not_allowed_in_variable_declarations: b(18029, 1, "Private_identifiers_are_not_allowed_in_variable_declarations_18029", "Private identifiers are not allowed in variable declarations."), + An_optional_chain_cannot_contain_private_identifiers: b(18030, 1, "An_optional_chain_cannot_contain_private_identifiers_18030", "An optional chain cannot contain private identifiers."), + The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents: b(18031, 1, "The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituent_18031", "The intersection '{0}' was reduced to 'never' because property '{1}' has conflicting types in some constituents."), + The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some: b(18032, 1, "The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_pr_18032", "The intersection '{0}' was reduced to 'never' because property '{1}' exists in multiple constituents and is private in some."), + Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values: b(18033, 1, "Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values_18033", "Type '{0}' is not assignable to type '{1}' as required for computed enum member values."), + Specify_the_JSX_fragment_factory_function_to_use_when_targeting_react_JSX_emit_with_jsxFactory_compiler_option_is_specified_e_g_Fragment: b(18034, 3, "Specify_the_JSX_fragment_factory_function_to_use_when_targeting_react_JSX_emit_with_jsxFactory_compi_18034", "Specify the JSX fragment factory function to use when targeting 'react' JSX emit with 'jsxFactory' compiler option is specified, e.g. 'Fragment'."), + Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name: b(18035, 1, "Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name_18035", "Invalid value for 'jsxFragmentFactory'. '{0}' is not a valid identifier or qualified-name."), + Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator: b(18036, 1, "Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_dec_18036", "Class decorators can't be used with static private identifier. Consider removing the experimental decorator."), + await_expression_cannot_be_used_inside_a_class_static_block: b(18037, 1, "await_expression_cannot_be_used_inside_a_class_static_block_18037", "'await' expression cannot be used inside a class static block."), + for_await_loops_cannot_be_used_inside_a_class_static_block: b(18038, 1, "for_await_loops_cannot_be_used_inside_a_class_static_block_18038", "'for await' loops cannot be used inside a class static block."), + Invalid_use_of_0_It_cannot_be_used_inside_a_class_static_block: b(18039, 1, "Invalid_use_of_0_It_cannot_be_used_inside_a_class_static_block_18039", "Invalid use of '{0}'. It cannot be used inside a class static block."), + A_return_statement_cannot_be_used_inside_a_class_static_block: b(18041, 1, "A_return_statement_cannot_be_used_inside_a_class_static_block_18041", "A 'return' statement cannot be used inside a class static block."), + _0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation: b(18042, 1, "_0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation_18042", "'{0}' is a type and cannot be imported in JavaScript files. Use '{1}' in a JSDoc type annotation."), + Types_cannot_appear_in_export_declarations_in_JavaScript_files: b(18043, 1, "Types_cannot_appear_in_export_declarations_in_JavaScript_files_18043", "Types cannot appear in export declarations in JavaScript files."), + _0_is_automatically_exported_here: b(18044, 3, "_0_is_automatically_exported_here_18044", "'{0}' is automatically exported here."), + Properties_with_the_accessor_modifier_are_only_available_when_targeting_ECMAScript_2015_and_higher: b(18045, 1, "Properties_with_the_accessor_modifier_are_only_available_when_targeting_ECMAScript_2015_and_higher_18045", "Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher."), + _0_is_of_type_unknown: b(18046, 1, "_0_is_of_type_unknown_18046", "'{0}' is of type 'unknown'."), + _0_is_possibly_null: b(18047, 1, "_0_is_possibly_null_18047", "'{0}' is possibly 'null'."), + _0_is_possibly_undefined: b(18048, 1, "_0_is_possibly_undefined_18048", "'{0}' is possibly 'undefined'."), + _0_is_possibly_null_or_undefined: b(18049, 1, "_0_is_possibly_null_or_undefined_18049", "'{0}' is possibly 'null' or 'undefined'."), + The_value_0_cannot_be_used_here: b(18050, 1, "The_value_0_cannot_be_used_here_18050", "The value '{0}' cannot be used here."), + Compiler_option_0_cannot_be_given_an_empty_string: b(18051, 1, "Compiler_option_0_cannot_be_given_an_empty_string_18051", "Compiler option '{0}' cannot be given an empty string."), + Its_type_0_is_not_a_valid_JSX_element_type: b(18053, 1, "Its_type_0_is_not_a_valid_JSX_element_type_18053", "Its type '{0}' is not a valid JSX element type."), + await_using_statements_cannot_be_used_inside_a_class_static_block: b(18054, 1, "await_using_statements_cannot_be_used_inside_a_class_static_block_18054", "'await using' statements cannot be used inside a class static block."), + _0_has_a_string_type_but_must_have_syntactically_recognizable_string_syntax_when_isolatedModules_is_enabled: b(18055, 1, "_0_has_a_string_type_but_must_have_syntactically_recognizable_string_syntax_when_isolatedModules_is__18055", "'{0}' has a string type, but must have syntactically recognizable string syntax when 'isolatedModules' is enabled."), + Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is_enabled: b(18056, 1, "Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is__18056", "Enum member following a non-literal numeric member must have an initializer when 'isolatedModules' is enabled."), + String_literal_import_and_export_names_are_not_supported_when_the_module_flag_is_set_to_es2015_or_es2020: b(18057, 1, "String_literal_import_and_export_names_are_not_supported_when_the_module_flag_is_set_to_es2015_or_es_18057", "String literal import and export names are not supported when the '--module' flag is set to 'es2015' or 'es2020'."), + Default_imports_are_not_allowed_in_a_deferred_import: b(18058, 1, "Default_imports_are_not_allowed_in_a_deferred_import_18058", "Default imports are not allowed in a deferred import."), + Named_imports_are_not_allowed_in_a_deferred_import: b(18059, 1, "Named_imports_are_not_allowed_in_a_deferred_import_18059", "Named imports are not allowed in a deferred import."), + Deferred_imports_are_only_supported_when_the_module_flag_is_set_to_esnext_or_preserve: b(18060, 1, "Deferred_imports_are_only_supported_when_the_module_flag_is_set_to_esnext_or_preserve_18060", "Deferred imports are only supported when the '--module' flag is set to 'esnext' or 'preserve'."), + _0_is_not_a_valid_meta_property_for_keyword_import_Did_you_mean_meta_or_defer: b(18061, 1, "_0_is_not_a_valid_meta_property_for_keyword_import_Did_you_mean_meta_or_defer_18061", "'{0}' is not a valid meta-property for keyword 'import'. Did you mean 'meta' or 'defer'?") + }; + function v_(e) { + return e >= 80; + } + function RY(e) { + return e === 32 || v_(e); + } + var f7 = { + abstract: 128, + accessor: 129, + any: 133, + as: 130, + asserts: 131, + assert: 132, + bigint: 163, + boolean: 136, + break: 83, + case: 84, + catch: 85, + class: 86, + continue: 88, + const: 87, + constructor: 137, + debugger: 89, + declare: 138, + default: 90, + defer: 166, + delete: 91, + do: 92, + else: 93, + enum: 94, + export: 95, + extends: 96, + false: 97, + finally: 98, + for: 99, + from: 161, + function: 100, + get: 139, + if: 101, + implements: 119, + import: 102, + in: 103, + infer: 140, + instanceof: 104, + interface: 120, + intrinsic: 141, + is: 142, + keyof: 143, + let: 121, + module: 144, + namespace: 145, + never: 146, + new: 105, + null: 106, + number: 150, + object: 151, + package: 122, + private: 123, + protected: 124, + public: 125, + override: 164, + out: 147, + readonly: 148, + require: 149, + global: 162, + return: 107, + satisfies: 152, + set: 153, + static: 126, + string: 154, + super: 108, + switch: 109, + symbol: 155, + this: 110, + throw: 111, + true: 112, + try: 113, + type: 156, + typeof: 114, + undefined: 157, + unique: 158, + unknown: 159, + using: 160, + var: 115, + void: 116, + while: 117, + with: 118, + yield: 127, + async: 134, + await: 135, + of: 165 + /* OfKeyword */ + }, jFe = new Map(Object.entries(f7)), Hge = new Map(Object.entries({ + ...f7, + "{": 19, + "}": 20, + "(": 21, + ")": 22, + "[": 23, + "]": 24, + ".": 25, + "...": 26, + ";": 27, + ",": 28, + "<": 30, + ">": 32, + "<=": 33, + ">=": 34, + "==": 35, + "!=": 36, + "===": 37, + "!==": 38, + "=>": 39, + "+": 40, + "-": 41, + "**": 43, + "*": 42, + "/": 44, + "%": 45, + "++": 46, + "--": 47, + "<<": 48, + ">": 49, + ">>>": 50, + "&": 51, + "|": 52, + "^": 53, + "!": 54, + "~": 55, + "&&": 56, + "||": 57, + "?": 58, + "??": 61, + "?.": 29, + ":": 59, + "=": 64, + "+=": 65, + "-=": 66, + "*=": 67, + "**=": 68, + "/=": 69, + "%=": 70, + "<<=": 71, + ">>=": 72, + ">>>=": 73, + "&=": 74, + "|=": 75, + "^=": 79, + "||=": 76, + "&&=": 77, + "??=": 78, + "@": 60, + "#": 63, + "`": 62 + /* BacktickToken */ + })), Gge = /* @__PURE__ */ new Map([ + [ + 100, + 1 + /* HasIndices */ + ], + [ + 103, + 2 + /* Global */ + ], + [ + 105, + 4 + /* IgnoreCase */ + ], + [ + 109, + 8 + /* Multiline */ + ], + [ + 115, + 16 + /* DotAll */ + ], + [ + 117, + 32 + /* Unicode */ + ], + [ + 118, + 64 + /* UnicodeSets */ + ], + [ + 121, + 128 + /* Sticky */ + ] + ]), BFe = /* @__PURE__ */ new Map([ + [1, El.RegularExpressionFlagsHasIndices], + [16, El.RegularExpressionFlagsDotAll], + [32, El.RegularExpressionFlagsUnicode], + [64, El.RegularExpressionFlagsUnicodeSets], + [128, El.RegularExpressionFlagsSticky] + ]), JFe = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6e3, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43e3, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500], zFe = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6e3, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43e3, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500], WFe = [65, 90, 97, 122, 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 895, 895, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1488, 1514, 1519, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2144, 2154, 2160, 2183, 2185, 2190, 2208, 2249, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2432, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2556, 2556, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2809, 2809, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3133, 3160, 3162, 3165, 3165, 3168, 3169, 3200, 3200, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3293, 3294, 3296, 3297, 3313, 3314, 3332, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3412, 3414, 3423, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5905, 5919, 5937, 5952, 5969, 5984, 5996, 5998, 6e3, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6264, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6430, 6480, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6988, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7401, 7404, 7406, 7411, 7413, 7414, 7418, 7418, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12443, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12735, 12784, 12799, 13312, 19903, 19968, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42653, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42954, 42960, 42961, 42963, 42963, 42965, 42969, 42994, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43261, 43262, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43488, 43492, 43494, 43503, 43514, 43518, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43646, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43881, 43888, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66176, 66204, 66208, 66256, 66304, 66335, 66349, 66378, 66384, 66421, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 66928, 66938, 66940, 66954, 66956, 66962, 66964, 66965, 66967, 66977, 66979, 66993, 66995, 67001, 67003, 67004, 67072, 67382, 67392, 67413, 67424, 67431, 67456, 67461, 67463, 67504, 67506, 67514, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68096, 68112, 68115, 68117, 68119, 68121, 68149, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68324, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68899, 69248, 69289, 69296, 69297, 69376, 69404, 69415, 69415, 69424, 69445, 69488, 69505, 69552, 69572, 69600, 69622, 69635, 69687, 69745, 69746, 69749, 69749, 69763, 69807, 69840, 69864, 69891, 69926, 69956, 69956, 69959, 69959, 69968, 70002, 70006, 70006, 70019, 70066, 70081, 70084, 70106, 70106, 70108, 70108, 70144, 70161, 70163, 70187, 70207, 70208, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70366, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70461, 70461, 70480, 70480, 70493, 70497, 70656, 70708, 70727, 70730, 70751, 70753, 70784, 70831, 70852, 70853, 70855, 70855, 71040, 71086, 71128, 71131, 71168, 71215, 71236, 71236, 71296, 71338, 71352, 71352, 71424, 71450, 71488, 71494, 71680, 71723, 71840, 71903, 71935, 71942, 71945, 71945, 71948, 71955, 71957, 71958, 71960, 71983, 71999, 71999, 72001, 72001, 72096, 72103, 72106, 72144, 72161, 72161, 72163, 72163, 72192, 72192, 72203, 72242, 72250, 72250, 72272, 72272, 72284, 72329, 72349, 72349, 72368, 72440, 72704, 72712, 72714, 72750, 72768, 72768, 72818, 72847, 72960, 72966, 72968, 72969, 72971, 73008, 73030, 73030, 73056, 73061, 73063, 73064, 73066, 73097, 73112, 73112, 73440, 73458, 73474, 73474, 73476, 73488, 73490, 73523, 73648, 73648, 73728, 74649, 74752, 74862, 74880, 75075, 77712, 77808, 77824, 78895, 78913, 78918, 82944, 83526, 92160, 92728, 92736, 92766, 92784, 92862, 92880, 92909, 92928, 92975, 92992, 92995, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94032, 94032, 94099, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101589, 101632, 101640, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 122624, 122654, 122661, 122666, 122928, 122989, 123136, 123180, 123191, 123197, 123214, 123214, 123536, 123565, 123584, 123627, 124112, 124139, 124896, 124902, 124904, 124907, 124909, 124910, 124912, 124926, 124928, 125124, 125184, 125251, 125259, 125259, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173791, 173824, 177977, 177984, 178205, 178208, 183969, 183984, 191456, 191472, 192093, 194560, 195101, 196608, 201546, 201552, 205743], UFe = [48, 57, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 183, 183, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 895, 895, 902, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1519, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2045, 2045, 2048, 2093, 2112, 2139, 2144, 2154, 2160, 2183, 2185, 2190, 2200, 2273, 2275, 2403, 2406, 2415, 2417, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2556, 2556, 2558, 2558, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2809, 2815, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2901, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3072, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3132, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3162, 3165, 3165, 3168, 3171, 3174, 3183, 3200, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3293, 3294, 3296, 3299, 3302, 3311, 3313, 3315, 3328, 3340, 3342, 3344, 3346, 3396, 3398, 3400, 3402, 3406, 3412, 3415, 3423, 3427, 3430, 3439, 3450, 3455, 3457, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3558, 3567, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3773, 3776, 3780, 3782, 3782, 3784, 3790, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4969, 4977, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5909, 5919, 5940, 5952, 5971, 5984, 5996, 5998, 6e3, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6159, 6169, 6176, 6264, 6272, 6314, 6320, 6389, 6400, 6430, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6618, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6832, 6845, 6847, 6862, 6912, 6988, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7376, 7378, 7380, 7418, 7424, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12447, 12449, 12543, 12549, 12591, 12593, 12686, 12704, 12735, 12784, 12799, 13312, 19903, 19968, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42737, 42775, 42783, 42786, 42888, 42891, 42954, 42960, 42961, 42963, 42963, 42965, 42969, 42994, 43047, 43052, 43052, 43072, 43123, 43136, 43205, 43216, 43225, 43232, 43255, 43259, 43259, 43261, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43488, 43518, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43881, 43888, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65071, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66045, 66045, 66176, 66204, 66208, 66256, 66272, 66272, 66304, 66335, 66349, 66378, 66384, 66426, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66720, 66729, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 66928, 66938, 66940, 66954, 66956, 66962, 66964, 66965, 66967, 66977, 66979, 66993, 66995, 67001, 67003, 67004, 67072, 67382, 67392, 67413, 67424, 67431, 67456, 67461, 67463, 67504, 67506, 67514, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68099, 68101, 68102, 68108, 68115, 68117, 68119, 68121, 68149, 68152, 68154, 68159, 68159, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68326, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68903, 68912, 68921, 69248, 69289, 69291, 69292, 69296, 69297, 69373, 69404, 69415, 69415, 69424, 69456, 69488, 69509, 69552, 69572, 69600, 69622, 69632, 69702, 69734, 69749, 69759, 69818, 69826, 69826, 69840, 69864, 69872, 69881, 69888, 69940, 69942, 69951, 69956, 69959, 69968, 70003, 70006, 70006, 70016, 70084, 70089, 70092, 70094, 70106, 70108, 70108, 70144, 70161, 70163, 70199, 70206, 70209, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70378, 70384, 70393, 70400, 70403, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70459, 70468, 70471, 70472, 70475, 70477, 70480, 70480, 70487, 70487, 70493, 70499, 70502, 70508, 70512, 70516, 70656, 70730, 70736, 70745, 70750, 70753, 70784, 70853, 70855, 70855, 70864, 70873, 71040, 71093, 71096, 71104, 71128, 71133, 71168, 71232, 71236, 71236, 71248, 71257, 71296, 71352, 71360, 71369, 71424, 71450, 71453, 71467, 71472, 71481, 71488, 71494, 71680, 71738, 71840, 71913, 71935, 71942, 71945, 71945, 71948, 71955, 71957, 71958, 71960, 71989, 71991, 71992, 71995, 72003, 72016, 72025, 72096, 72103, 72106, 72151, 72154, 72161, 72163, 72164, 72192, 72254, 72263, 72263, 72272, 72345, 72349, 72349, 72368, 72440, 72704, 72712, 72714, 72758, 72760, 72768, 72784, 72793, 72818, 72847, 72850, 72871, 72873, 72886, 72960, 72966, 72968, 72969, 72971, 73014, 73018, 73018, 73020, 73021, 73023, 73031, 73040, 73049, 73056, 73061, 73063, 73064, 73066, 73102, 73104, 73105, 73107, 73112, 73120, 73129, 73440, 73462, 73472, 73488, 73490, 73530, 73534, 73538, 73552, 73561, 73648, 73648, 73728, 74649, 74752, 74862, 74880, 75075, 77712, 77808, 77824, 78895, 78912, 78933, 82944, 83526, 92160, 92728, 92736, 92766, 92768, 92777, 92784, 92862, 92864, 92873, 92880, 92909, 92912, 92916, 92928, 92982, 92992, 92995, 93008, 93017, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94031, 94087, 94095, 94111, 94176, 94177, 94179, 94180, 94192, 94193, 94208, 100343, 100352, 101589, 101632, 101640, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 113821, 113822, 118528, 118573, 118576, 118598, 119141, 119145, 119149, 119154, 119163, 119170, 119173, 119179, 119210, 119213, 119362, 119364, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 120782, 120831, 121344, 121398, 121403, 121452, 121461, 121461, 121476, 121476, 121499, 121503, 121505, 121519, 122624, 122654, 122661, 122666, 122880, 122886, 122888, 122904, 122907, 122913, 122915, 122916, 122918, 122922, 122928, 122989, 123023, 123023, 123136, 123180, 123184, 123197, 123200, 123209, 123214, 123214, 123536, 123566, 123584, 123641, 124112, 124153, 124896, 124902, 124904, 124907, 124909, 124910, 124912, 124926, 124928, 125124, 125136, 125142, 125184, 125259, 125264, 125273, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 130032, 130041, 131072, 173791, 173824, 177977, 177984, 178205, 178208, 183969, 183984, 191456, 191472, 192093, 194560, 195101, 196608, 201546, 201552, 205743, 917760, 917999], VFe = /^\/\/\/?\s*@(ts-expect-error|ts-ignore)/, qFe = /^(?:\/|\*)*\s*@(ts-expect-error|ts-ignore)/, HFe = /@(?:see|link)/i; + function xj(e, t) { + if (e < t[0]) + return !1; + let n = 0, i = t.length, s; + for (; n + 1 < i; ) { + if (s = n + (i - n) / 2, s -= s % 2, t[s] <= e && e <= t[s + 1]) + return !0; + e < t[s] ? i = s : n = s + 2; + } + return !1; + } + function p7(e, t) { + return t >= 2 ? xj(e, WFe) : xj(e, JFe); + } + function GFe(e, t) { + return t >= 2 ? xj(e, UFe) : xj(e, zFe); + } + function $ge(e) { + const t = []; + return e.forEach((n, i) => { + t[n] = i; + }), t; + } + var $Fe = $ge(Hge); + function qs(e) { + return $Fe[e]; + } + function Q2(e) { + return Hge.get(e); + } + var XFe = $ge(Gge); + function Xge(e) { + return XFe[e]; + } + function kj(e) { + return Gge.get(e); + } + function nx(e) { + const t = []; + let n = 0, i = 0; + for (; n < e.length; ) { + const s = e.charCodeAt(n); + switch (n++, s) { + case 13: + e.charCodeAt(n) === 10 && n++; + // falls through + case 10: + t.push(i), i = n; + break; + default: + s > 127 && Cu(s) && (t.push(i), i = n); + break; + } + } + return t.push(i), t; + } + function GP(e, t, n, i) { + return e.getPositionOfLineAndCharacter ? e.getPositionOfLineAndCharacter(t, n, i) : d7(kg(e), t, n, e.text, i); + } + function d7(e, t, n, i, s) { + (t < 0 || t >= e.length) && (s ? t = t < 0 ? 0 : t >= e.length ? e.length - 1 : t : E.fail(`Bad line number. Line: ${t}, lineStarts.length: ${e.length} , line map is correct? ${i !== void 0 ? Tf(e, nx(i)) : "unknown"}`)); + const o = e[t] + n; + return s ? o > e[t + 1] ? e[t + 1] : typeof i == "string" && o > i.length ? i.length : o : (t < e.length - 1 ? E.assert(o < e[t + 1]) : i !== void 0 && E.assert(o <= i.length), o); + } + function kg(e) { + return e.lineMap || (e.lineMap = nx(e.text)); + } + function CC(e, t) { + const n = dD(e, t); + return { + line: n, + character: t - e[n] + }; + } + function dD(e, t, n) { + let i = py(e, t, go, ho, n); + return i < 0 && (i = ~i - 1, E.assert(i !== -1, "position cannot precede the beginning of the file")), i; + } + function mD(e, t, n) { + if (t === n) return 0; + const i = kg(e), s = Math.min(t, n), o = s === n, c = o ? t : n, _ = dD(i, s), u = dD(i, c, _); + return o ? _ - u : u - _; + } + function js(e, t) { + return CC(kg(e), t); + } + function Cg(e) { + return im(e) || Cu(e); + } + function im(e) { + return e === 32 || e === 9 || e === 11 || e === 12 || e === 160 || e === 133 || e === 5760 || e >= 8192 && e <= 8203 || e === 8239 || e === 8287 || e === 12288 || e === 65279; + } + function Cu(e) { + return e === 10 || e === 13 || e === 8232 || e === 8233; + } + function EC(e) { + return e >= 48 && e <= 57; + } + function jY(e) { + return EC(e) || e >= 65 && e <= 70 || e >= 97 && e <= 102; + } + function BY(e) { + return e >= 65 && e <= 90 || e >= 97 && e <= 122; + } + function Qge(e) { + return BY(e) || EC(e) || e === 95; + } + function JY(e) { + return e >= 48 && e <= 55; + } + function zY(e, t) { + const n = e.charCodeAt(t); + switch (n) { + case 13: + case 10: + case 9: + case 11: + case 12: + case 32: + case 47: + // starts of normal trivia + // falls through + case 60: + case 124: + case 61: + case 62: + return !0; + case 35: + return t === 0; + default: + return n > 127; + } + } + function oa(e, t, n, i, s) { + if (Nd(t)) + return t; + let o = !1; + for (; ; ) { + const c = e.charCodeAt(t); + switch (c) { + case 13: + e.charCodeAt(t + 1) === 10 && t++; + // falls through + case 10: + if (t++, n) + return t; + o = !!s; + continue; + case 9: + case 11: + case 12: + case 32: + t++; + continue; + case 47: + if (i) + break; + if (e.charCodeAt(t + 1) === 47) { + for (t += 2; t < e.length && !Cu(e.charCodeAt(t)); ) + t++; + o = !1; + continue; + } + if (e.charCodeAt(t + 1) === 42) { + for (t += 2; t < e.length; ) { + if (e.charCodeAt(t) === 42 && e.charCodeAt(t + 1) === 47) { + t += 2; + break; + } + t++; + } + o = !1; + continue; + } + break; + case 60: + case 124: + case 61: + case 62: + if (gD(e, t)) { + t = $P(e, t), o = !1; + continue; + } + break; + case 35: + if (t === 0 && Yge(e, t)) { + t = Zge(e, t), o = !1; + continue; + } + break; + case 42: + if (o) { + t++, o = !1; + continue; + } + break; + default: + if (c > 127 && Cg(c)) { + t++; + continue; + } + break; + } + return t; + } + } + var Cj = 7; + function gD(e, t) { + if (E.assert(t >= 0), t === 0 || Cu(e.charCodeAt(t - 1))) { + const n = e.charCodeAt(t); + if (t + Cj < e.length) { + for (let i = 0; i < Cj; i++) + if (e.charCodeAt(t + i) !== n) + return !1; + return n === 61 || e.charCodeAt(t + Cj) === 32; + } + } + return !1; + } + function $P(e, t, n) { + n && n(p.Merge_conflict_marker_encountered, t, Cj); + const i = e.charCodeAt(t), s = e.length; + if (i === 60 || i === 62) + for (; t < s && !Cu(e.charCodeAt(t)); ) + t++; + else + for (E.assert( + i === 124 || i === 61 + /* equals */ + ); t < s; ) { + const o = e.charCodeAt(t); + if ((o === 61 || o === 62) && o !== i && gD(e, t)) + break; + t++; + } + return t; + } + var WY = /^#!.*/; + function Yge(e, t) { + return E.assert(t === 0), WY.test(e); + } + function Zge(e, t) { + const n = WY.exec(e)[0]; + return t = t + n.length, t; + } + function Ej(e, t, n, i, s, o, c) { + let _, u, g, m, h = !1, S = i, T = c; + if (n === 0) { + S = !0; + const k = m7(t); + k && (n = k.length); + } + e: + for (; n >= 0 && n < t.length; ) { + const k = t.charCodeAt(n); + switch (k) { + case 13: + t.charCodeAt(n + 1) === 10 && n++; + // falls through + case 10: + if (n++, i) + break e; + S = !0, h && (m = !0); + continue; + case 9: + case 11: + case 12: + case 32: + n++; + continue; + case 47: + const D = t.charCodeAt(n + 1); + let P = !1; + if (D === 47 || D === 42) { + const A = D === 47 ? 2 : 3, O = n; + if (n += 2, D === 47) + for (; n < t.length; ) { + if (Cu(t.charCodeAt(n))) { + P = !0; + break; + } + n++; + } + else + for (; n < t.length; ) { + if (t.charCodeAt(n) === 42 && t.charCodeAt(n + 1) === 47) { + n += 2; + break; + } + n++; + } + if (S) { + if (h && (T = s(_, u, g, m, o, T), !e && T)) + return T; + _ = O, u = n, g = A, m = P, h = !0; + } + continue; + } + break e; + default: + if (k > 127 && Cg(k)) { + h && Cu(k) && (m = !0), n++; + continue; + } + break e; + } + } + return h && (T = s(_, u, g, m, o, T)), T; + } + function XP(e, t, n, i) { + return Ej( + /*reduce*/ + !1, + e, + t, + /*trailing*/ + !1, + n, + i + ); + } + function QP(e, t, n, i) { + return Ej( + /*reduce*/ + !1, + e, + t, + /*trailing*/ + !0, + n, + i + ); + } + function UY(e, t, n, i, s) { + return Ej( + /*reduce*/ + !0, + e, + t, + /*trailing*/ + !1, + n, + i, + s + ); + } + function VY(e, t, n, i, s) { + return Ej( + /*reduce*/ + !0, + e, + t, + /*trailing*/ + !0, + n, + i, + s + ); + } + function Kge(e, t, n, i, s, o = []) { + return o.push({ kind: n, pos: e, end: t, hasTrailingNewLine: i }), o; + } + function Eg(e, t) { + return UY( + e, + t, + Kge, + /*state*/ + void 0, + /*initial*/ + void 0 + ); + } + function Sy(e, t) { + return VY( + e, + t, + Kge, + /*state*/ + void 0, + /*initial*/ + void 0 + ); + } + function m7(e) { + const t = WY.exec(e); + if (t) + return t[0]; + } + function Vm(e, t) { + return BY(e) || e === 36 || e === 95 || e > 127 && p7(e, t); + } + function hh(e, t, n) { + return Qge(e) || e === 36 || // "-" and ":" are valid in JSX Identifiers + (n === 1 ? e === 45 || e === 58 : !1) || e > 127 && GFe(e, t); + } + function R_(e, t, n) { + let i = hD(e, 0); + if (!Vm(i, t)) + return !1; + for (let s = Cd(i); s < e.length; s += Cd(i)) + if (!hh(i = hD(e, s), t, n)) + return !1; + return !0; + } + function Dg(e, t, n = 0, i, s, o, c) { + var _ = i, u, g, m, h, S, T, k, D, P = 0, A = 0, O = 0; + Ds(_, o, c); + var F = { + getTokenFullStart: () => m, + getStartPos: () => m, + getTokenEnd: () => u, + getTextPos: () => u, + getToken: () => S, + getTokenStart: () => h, + getTokenPos: () => h, + getTokenText: () => _.substring(h, u), + getTokenValue: () => T, + hasUnicodeEscape: () => (k & 1024) !== 0, + hasExtendedUnicodeEscape: () => (k & 8) !== 0, + hasPrecedingLineBreak: () => (k & 1) !== 0, + hasPrecedingJSDocComment: () => (k & 2) !== 0, + hasPrecedingJSDocLeadingAsterisks: () => (k & 32768) !== 0, + isIdentifier: () => S === 80 || S > 118, + isReservedWord: () => S >= 83 && S <= 118, + isUnterminated: () => (k & 4) !== 0, + getCommentDirectives: () => D, + getNumericLiteralFlags: () => k & 25584, + getTokenFlags: () => k, + reScanGreaterToken: Ee, + reScanAsteriskEqualsToken: Ce, + reScanSlashToken: Ve, + reScanTemplateToken: st, + reScanTemplateHeadOrNoSubstitutionTemplate: Wt, + scanJsxIdentifier: ai, + scanJsxAttributeValue: fi, + reScanJsxAttributeValue: pn, + reScanJsxToken: Jr, + reScanLessThanToken: ui, + reScanHashToken: Ji, + reScanQuestionToken: Dt, + reScanInvalidIdentifier: ie, + scanJsxToken: Mn, + scanJsDocToken: Je, + scanJSDocCommentTextToken: _i, + scan: ne, + getText: Un, + clearCommentDirectives: ki, + setText: Ds, + setScriptTarget: yr, + setLanguageVariant: bs, + setScriptKind: Xe, + setJSDocParsingMode: Et, + setOnError: Ks, + resetTokenState: re, + setTextPos: re, + setSkipJsDocLeadingAsterisks: it, + tryScan: Jn, + lookAhead: qr, + scanRange: er + }; + return E.isDebugging && Object.defineProperty(F, "__debugShowCurrentPositionInText", { + get: () => { + const Y = F.getText(); + return Y.slice(0, F.getTokenFullStart()) + "║" + Y.slice(F.getTokenFullStart()); + } + }), F; + function R(Y) { + return hD(_, Y); + } + function B(Y) { + return Y >= 0 && Y < g ? R(Y) : -1; + } + function U(Y) { + return _.charCodeAt(Y); + } + function $(Y) { + return Y >= 0 && Y < g ? U(Y) : -1; + } + function W(Y, Ae = u, $e, Ke) { + if (s) { + const Tt = u; + u = Ae, s(Y, $e || 0, Ke), u = Tt; + } + } + function _e() { + let Y = u, Ae = !1, $e = !1, Ke = ""; + for (; ; ) { + const Tt = U(u); + if (Tt === 95) { + k |= 512, Ae ? (Ae = !1, $e = !0, Ke += _.substring(Y, u)) : (k |= 16384, W($e ? p.Multiple_consecutive_numeric_separators_are_not_permitted : p.Numeric_separators_are_not_allowed_here, u, 1)), u++, Y = u; + continue; + } + if (EC(Tt)) { + Ae = !0, $e = !1, u++; + continue; + } + break; + } + return U(u - 1) === 95 && (k |= 16384, W(p.Numeric_separators_are_not_allowed_here, u - 1, 1)), Ke + _.substring(Y, u); + } + function K() { + let Y = u, Ae; + if (U(u) === 48) + if (u++, U(u) === 95) + k |= 16896, W(p.Numeric_separators_are_not_allowed_here, u, 1), u--, Ae = _e(); + else if (!ae()) + k |= 8192, Ae = "" + +T; + else if (!T) + Ae = "0"; + else { + T = "" + parseInt(T, 8), k |= 32; + const mt = S === 41, pt = (mt ? "-" : "") + "0o" + (+T).toString(8); + return mt && Y--, W(p.Octal_literals_are_not_allowed_Use_the_syntax_0, Y, u - Y, pt), 9; + } + else + Ae = _e(); + let $e, Ke; + U(u) === 46 && (u++, $e = _e()); + let Tt = u; + if (U(u) === 69 || U(u) === 101) { + u++, k |= 16, (U(u) === 43 || U(u) === 45) && u++; + const mt = u, pt = _e(); + pt ? (Ke = _.substring(Tt, mt) + pt, Tt = u) : W(p.Digit_expected); + } + let Le; + if (k & 512 ? (Le = Ae, $e && (Le += "." + $e), Ke && (Le += Ke)) : Le = _.substring(Y, Tt), k & 8192) + return W(p.Decimals_with_leading_zeros_are_not_allowed, Y, Tt - Y), T = "" + +Le, 9; + if ($e !== void 0 || k & 16) + return V(Y, $e === void 0 && !!(k & 16)), T = "" + +Le, 9; + { + T = Le; + const mt = Ye(); + return V(Y), mt; + } + } + function V(Y, Ae) { + if (!Vm(R(u), e)) + return; + const $e = u, { length: Ke } = pe(); + Ke === 1 && _[$e] === "n" ? W(Ae ? p.A_bigint_literal_cannot_use_exponential_notation : p.A_bigint_literal_must_be_an_integer, Y, $e - Y + 1) : (W(p.An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal, $e, Ke), u = $e); + } + function ae() { + const Y = u; + let Ae = !0; + for (; EC($(u)); ) + JY(U(u)) || (Ae = !1), u++; + return T = _.substring(Y, u), Ae; + } + function se(Y, Ae) { + const $e = fe( + /*minCount*/ + Y, + /*scanAsManyAsPossible*/ + !1, + Ae + ); + return $e ? parseInt($e, 16) : -1; + } + function ce(Y, Ae) { + return fe( + /*minCount*/ + Y, + /*scanAsManyAsPossible*/ + !0, + Ae + ); + } + function fe(Y, Ae, $e) { + let Ke = [], Tt = !1, Le = !1; + for (; Ke.length < Y || Ae; ) { + let mt = U(u); + if ($e && mt === 95) { + k |= 512, Tt ? (Tt = !1, Le = !0) : W(Le ? p.Multiple_consecutive_numeric_separators_are_not_permitted : p.Numeric_separators_are_not_allowed_here, u, 1), u++; + continue; + } + if (Tt = $e, mt >= 65 && mt <= 70) + mt += 32; + else if (!(mt >= 48 && mt <= 57 || mt >= 97 && mt <= 102)) + break; + Ke.push(mt), u++, Le = !1; + } + return Ke.length < Y && (Ke = []), U(u - 1) === 95 && W(p.Numeric_separators_are_not_allowed_here, u - 1, 1), String.fromCharCode(...Ke); + } + function he(Y = !1) { + const Ae = U(u); + u++; + let $e = "", Ke = u; + for (; ; ) { + if (u >= g) { + $e += _.substring(Ke, u), k |= 4, W(p.Unterminated_string_literal); + break; + } + const Tt = U(u); + if (Tt === Ae) { + $e += _.substring(Ke, u), u++; + break; + } + if (Tt === 92 && !Y) { + $e += _.substring(Ke, u), $e += be( + 3 + /* ReportErrors */ + ), Ke = u; + continue; + } + if ((Tt === 10 || Tt === 13) && !Y) { + $e += _.substring(Ke, u), k |= 4, W(p.Unterminated_string_literal); + break; + } + u++; + } + return $e; + } + function q(Y) { + const Ae = U(u) === 96; + u++; + let $e = u, Ke = "", Tt; + for (; ; ) { + if (u >= g) { + Ke += _.substring($e, u), k |= 4, W(p.Unterminated_template_literal), Tt = Ae ? 15 : 18; + break; + } + const Le = U(u); + if (Le === 96) { + Ke += _.substring($e, u), u++, Tt = Ae ? 15 : 18; + break; + } + if (Le === 36 && u + 1 < g && U(u + 1) === 123) { + Ke += _.substring($e, u), u += 2, Tt = Ae ? 16 : 17; + break; + } + if (Le === 92) { + Ke += _.substring($e, u), Ke += be(1 | (Y ? 2 : 0)), $e = u; + continue; + } + if (Le === 13) { + Ke += _.substring($e, u), u++, u < g && U(u) === 10 && u++, Ke += ` +`, $e = u; + continue; + } + u++; + } + return E.assert(Tt !== void 0), T = Ke, Tt; + } + function be(Y) { + const Ae = u; + if (u++, u >= g) + return W(p.Unexpected_end_of_text), ""; + const $e = U(u); + switch (u++, $e) { + case 48: + if (u >= g || !EC(U(u))) + return "\0"; + // '\01', '\011' + // falls through + case 49: + case 50: + case 51: + u < g && JY(U(u)) && u++; + // '\17', '\177' + // falls through + case 52: + case 53: + case 54: + case 55: + if (u < g && JY(U(u)) && u++, k |= 2048, Y & 6) { + const Le = parseInt(_.substring(Ae + 1, u), 8); + return Y & 4 && !(Y & 32) && $e !== 48 ? W(p.Octal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class_If_this_was_intended_as_an_escape_sequence_use_the_syntax_0_instead, Ae, u - Ae, "\\x" + Le.toString(16).padStart(2, "0")) : W(p.Octal_escape_sequences_are_not_allowed_Use_the_syntax_0, Ae, u - Ae, "\\x" + Le.toString(16).padStart(2, "0")), String.fromCharCode(Le); + } + return _.substring(Ae, u); + case 56: + case 57: + return k |= 2048, Y & 6 ? (Y & 4 && !(Y & 32) ? W(p.Decimal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class, Ae, u - Ae) : W(p.Escape_sequence_0_is_not_allowed, Ae, u - Ae, _.substring(Ae, u)), String.fromCharCode($e)) : _.substring(Ae, u); + case 98: + return "\b"; + case 116: + return " "; + case 110: + return ` +`; + case 118: + return "\v"; + case 102: + return "\f"; + case 114: + return "\r"; + case 39: + return "'"; + case 34: + return '"'; + case 117: + if (u < g && U(u) === 123) { + u -= 2; + const Le = je(!!(Y & 6)); + return Y & 17 || (k |= 2048, Y & 6 && W(p.Unicode_escape_sequences_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set, Ae, u - Ae)), Le; + } + for (; u < Ae + 6; u++) + if (!(u < g && jY(U(u)))) + return k |= 2048, Y & 6 && W(p.Hexadecimal_digit_expected), _.substring(Ae, u); + k |= 1024; + const Ke = parseInt(_.substring(Ae + 2, u), 16), Tt = String.fromCharCode(Ke); + if (Y & 16 && Ke >= 55296 && Ke <= 56319 && u + 6 < g && _.substring(u, u + 2) === "\\u" && U(u + 2) !== 123) { + const Le = u; + let mt = u + 2; + for (; mt < Le + 6; mt++) + if (!jY(U(mt))) + return Tt; + const pt = parseInt(_.substring(Le + 2, mt), 16); + if (pt >= 56320 && pt <= 57343) + return u = mt, Tt + String.fromCharCode(pt); + } + return Tt; + case 120: + for (; u < Ae + 4; u++) + if (!(u < g && jY(U(u)))) + return k |= 2048, Y & 6 && W(p.Hexadecimal_digit_expected), _.substring(Ae, u); + return k |= 4096, String.fromCharCode(parseInt(_.substring(Ae + 2, u), 16)); + // when encountering a LineContinuation (i.e. a backslash and a line terminator sequence), + // the line terminator is interpreted to be "the empty code unit sequence". + case 13: + u < g && U(u) === 10 && u++; + // falls through + case 10: + case 8232: + case 8233: + return ""; + default: + return (Y & 16 || Y & 4 && !(Y & 8) && hh($e, e)) && W(p.This_character_cannot_be_escaped_in_a_regular_expression, u - 2, 2), String.fromCharCode($e); + } + } + function je(Y) { + const Ae = u; + u += 3; + const $e = u, Ke = ce( + 1, + /*canHaveSeparators*/ + !1 + ), Tt = Ke ? parseInt(Ke, 16) : -1; + let Le = !1; + return Tt < 0 ? (Y && W(p.Hexadecimal_digit_expected), Le = !0) : Tt > 1114111 && (Y && W(p.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive, $e, u - $e), Le = !0), u >= g ? (Y && W(p.Unexpected_end_of_text), Le = !0) : U(u) === 125 ? u++ : (Y && W(p.Unterminated_Unicode_escape_sequence), Le = !0), Le ? (k |= 2048, _.substring(Ae, u)) : (k |= 8, yD(Tt)); + } + function me() { + if (u + 5 < g && U(u + 1) === 117) { + const Y = u; + u += 2; + const Ae = se( + 4, + /*canHaveSeparators*/ + !1 + ); + return u = Y, Ae; + } + return -1; + } + function Z() { + if (R(u + 1) === 117 && R(u + 2) === 123) { + const Y = u; + u += 3; + const Ae = ce( + 1, + /*canHaveSeparators*/ + !1 + ), $e = Ae ? parseInt(Ae, 16) : -1; + return u = Y, $e; + } + return -1; + } + function pe() { + let Y = "", Ae = u; + for (; u < g; ) { + let $e = R(u); + if (hh($e, e)) + u += Cd($e); + else if ($e === 92) { + if ($e = Z(), $e >= 0 && hh($e, e)) { + Y += je( + /*shouldEmitInvalidEscapeError*/ + !0 + ), Ae = u; + continue; + } + if ($e = me(), !($e >= 0 && hh($e, e))) + break; + k |= 1024, Y += _.substring(Ae, u), Y += yD($e), u += 6, Ae = u; + } else + break; + } + return Y += _.substring(Ae, u), Y; + } + function Te() { + const Y = T.length; + if (Y >= 2 && Y <= 12) { + const Ae = T.charCodeAt(0); + if (Ae >= 97 && Ae <= 122) { + const $e = jFe.get(T); + if ($e !== void 0) + return S = $e; + } + } + return S = 80; + } + function Fe(Y) { + let Ae = "", $e = !1, Ke = !1; + for (; ; ) { + const Tt = U(u); + if (Tt === 95) { + k |= 512, $e ? ($e = !1, Ke = !0) : W(Ke ? p.Multiple_consecutive_numeric_separators_are_not_permitted : p.Numeric_separators_are_not_allowed_here, u, 1), u++; + continue; + } + if ($e = !0, !EC(Tt) || Tt - 48 >= Y) + break; + Ae += _[u], u++, Ke = !1; + } + return U(u - 1) === 95 && W(p.Numeric_separators_are_not_allowed_here, u - 1, 1), Ae; + } + function Ye() { + return U(u) === 110 ? (T += "n", k & 384 && (T = g4(T) + "n"), u++, 10) : (T = "" + (k & 128 ? parseInt(T.slice(2), 2) : k & 256 ? parseInt(T.slice(2), 8) : +T), 9); + } + function ne() { + for (m = u, k = 0; ; ) { + if (h = u, u >= g) + return S = 1; + const Y = R(u); + if (u === 0 && Y === 35 && Yge(_, u)) { + if (u = Zge(_, u), t) + continue; + return S = 6; + } + switch (Y) { + case 10: + case 13: + if (k |= 1, t) { + u++; + continue; + } else + return Y === 13 && u + 1 < g && U(u + 1) === 10 ? u += 2 : u++, S = 4; + case 9: + case 11: + case 12: + case 32: + case 160: + case 5760: + case 8192: + case 8193: + case 8194: + case 8195: + case 8196: + case 8197: + case 8198: + case 8199: + case 8200: + case 8201: + case 8202: + case 8203: + case 8239: + case 8287: + case 12288: + case 65279: + if (t) { + u++; + continue; + } else { + for (; u < g && im(U(u)); ) + u++; + return S = 5; + } + case 33: + return U(u + 1) === 61 ? U(u + 2) === 61 ? (u += 3, S = 38) : (u += 2, S = 36) : (u++, S = 54); + case 34: + case 39: + return T = he(), S = 11; + case 96: + return S = q( + /*shouldEmitInvalidEscapeError*/ + !1 + ); + case 37: + return U(u + 1) === 61 ? (u += 2, S = 70) : (u++, S = 45); + case 38: + return U(u + 1) === 38 ? U(u + 2) === 61 ? (u += 3, S = 77) : (u += 2, S = 56) : U(u + 1) === 61 ? (u += 2, S = 74) : (u++, S = 51); + case 40: + return u++, S = 21; + case 41: + return u++, S = 22; + case 42: + if (U(u + 1) === 61) + return u += 2, S = 67; + if (U(u + 1) === 42) + return U(u + 2) === 61 ? (u += 3, S = 68) : (u += 2, S = 43); + if (u++, P && (k & 32768) === 0 && k & 1) { + k |= 32768; + continue; + } + return S = 42; + case 43: + return U(u + 1) === 43 ? (u += 2, S = 46) : U(u + 1) === 61 ? (u += 2, S = 65) : (u++, S = 40); + case 44: + return u++, S = 28; + case 45: + return U(u + 1) === 45 ? (u += 2, S = 47) : U(u + 1) === 61 ? (u += 2, S = 66) : (u++, S = 41); + case 46: + return EC(U(u + 1)) ? (K(), S = 9) : U(u + 1) === 46 && U(u + 2) === 46 ? (u += 3, S = 26) : (u++, S = 25); + case 47: + if (U(u + 1) === 47) { + for (u += 2; u < g && !Cu(U(u)); ) + u++; + if (D = tr( + D, + _.slice(h, u), + VFe, + h + ), t) + continue; + return S = 2; + } + if (U(u + 1) === 42) { + u += 2; + const mt = U(u) === 42 && U(u + 1) !== 47; + let pt = !1, Ct = h; + for (; u < g; ) { + const qe = U(u); + if (qe === 42 && U(u + 1) === 47) { + u += 2, pt = !0; + break; + } + u++, Cu(qe) && (Ct = u, k |= 1); + } + if (mt && Se() && (k |= 2), D = tr(D, _.slice(Ct, u), qFe, Ct), pt || W(p.Asterisk_Slash_expected), t) + continue; + return pt || (k |= 4), S = 3; + } + return U(u + 1) === 61 ? (u += 2, S = 69) : (u++, S = 44); + case 48: + if (u + 2 < g && (U(u + 1) === 88 || U(u + 1) === 120)) + return u += 2, T = ce( + 1, + /*canHaveSeparators*/ + !0 + ), T || (W(p.Hexadecimal_digit_expected), T = "0"), T = "0x" + T, k |= 64, S = Ye(); + if (u + 2 < g && (U(u + 1) === 66 || U(u + 1) === 98)) + return u += 2, T = Fe( + /* base */ + 2 + ), T || (W(p.Binary_digit_expected), T = "0"), T = "0b" + T, k |= 128, S = Ye(); + if (u + 2 < g && (U(u + 1) === 79 || U(u + 1) === 111)) + return u += 2, T = Fe( + /* base */ + 8 + ), T || (W(p.Octal_digit_expected), T = "0"), T = "0o" + T, k |= 256, S = Ye(); + // falls through + case 49: + case 50: + case 51: + case 52: + case 53: + case 54: + case 55: + case 56: + case 57: + return S = K(); + case 58: + return u++, S = 59; + case 59: + return u++, S = 27; + case 60: + if (gD(_, u)) { + if (u = $P(_, u, W), t) + continue; + return S = 7; + } + return U(u + 1) === 60 ? U(u + 2) === 61 ? (u += 3, S = 71) : (u += 2, S = 48) : U(u + 1) === 61 ? (u += 2, S = 33) : n === 1 && U(u + 1) === 47 && U(u + 2) !== 42 ? (u += 2, S = 31) : (u++, S = 30); + case 61: + if (gD(_, u)) { + if (u = $P(_, u, W), t) + continue; + return S = 7; + } + return U(u + 1) === 61 ? U(u + 2) === 61 ? (u += 3, S = 37) : (u += 2, S = 35) : U(u + 1) === 62 ? (u += 2, S = 39) : (u++, S = 64); + case 62: + if (gD(_, u)) { + if (u = $P(_, u, W), t) + continue; + return S = 7; + } + return u++, S = 32; + case 63: + return U(u + 1) === 46 && !EC(U(u + 2)) ? (u += 2, S = 29) : U(u + 1) === 63 ? U(u + 2) === 61 ? (u += 3, S = 78) : (u += 2, S = 61) : (u++, S = 58); + case 91: + return u++, S = 23; + case 93: + return u++, S = 24; + case 94: + return U(u + 1) === 61 ? (u += 2, S = 79) : (u++, S = 53); + case 123: + return u++, S = 19; + case 124: + if (gD(_, u)) { + if (u = $P(_, u, W), t) + continue; + return S = 7; + } + return U(u + 1) === 124 ? U(u + 2) === 61 ? (u += 3, S = 76) : (u += 2, S = 57) : U(u + 1) === 61 ? (u += 2, S = 75) : (u++, S = 52); + case 125: + return u++, S = 20; + case 126: + return u++, S = 55; + case 64: + return u++, S = 60; + case 92: + const Ae = Z(); + if (Ae >= 0 && Vm(Ae, e)) + return T = je( + /*shouldEmitInvalidEscapeError*/ + !0 + ) + pe(), S = Te(); + const $e = me(); + return $e >= 0 && Vm($e, e) ? (u += 6, k |= 1024, T = String.fromCharCode($e) + pe(), S = Te()) : (W(p.Invalid_character), u++, S = 0); + case 35: + if (u !== 0 && _[u + 1] === "!") + return W(p.can_only_be_used_at_the_start_of_a_file, u, 2), u++, S = 0; + const Ke = R(u + 1); + if (Ke === 92) { + u++; + const mt = Z(); + if (mt >= 0 && Vm(mt, e)) + return T = "#" + je( + /*shouldEmitInvalidEscapeError*/ + !0 + ) + pe(), S = 81; + const pt = me(); + if (pt >= 0 && Vm(pt, e)) + return u += 6, k |= 1024, T = "#" + String.fromCharCode(pt) + pe(), S = 81; + u--; + } + return Vm(Ke, e) ? (u++, Ne(Ke, e)) : (T = "#", W(p.Invalid_character, u++, Cd(Y))), S = 81; + case 65533: + return W(p.File_appears_to_be_binary, 0, 0), u = g, S = 8; + default: + const Tt = Ne(Y, e); + if (Tt) + return S = Tt; + if (im(Y)) { + u += Cd(Y); + continue; + } else if (Cu(Y)) { + k |= 1, u += Cd(Y); + continue; + } + const Le = Cd(Y); + return W(p.Invalid_character, u, Le), u += Le, S = 0; + } + } + } + function Se() { + switch (O) { + case 0: + return !0; + case 1: + return !1; + } + return A !== 3 && A !== 4 ? !0 : O === 3 ? !1 : HFe.test(_.slice(m, u)); + } + function ie() { + E.assert(S === 0, "'reScanInvalidIdentifier' should only be called when the current token is 'SyntaxKind.Unknown'."), u = h = m, k = 0; + const Y = R(u), Ae = Ne( + Y, + 99 + /* ESNext */ + ); + return Ae ? S = Ae : (u += Cd(Y), S); + } + function Ne(Y, Ae) { + let $e = Y; + if (Vm($e, Ae)) { + for (u += Cd($e); u < g && hh($e = R(u), Ae); ) u += Cd($e); + return T = _.substring(h, u), $e === 92 && (T += pe()), Te(); + } + } + function Ee() { + if (S === 32) { + if (U(u) === 62) + return U(u + 1) === 62 ? U(u + 2) === 61 ? (u += 3, S = 73) : (u += 2, S = 50) : U(u + 1) === 61 ? (u += 2, S = 72) : (u++, S = 49); + if (U(u) === 61) + return u++, S = 34; + } + return S; + } + function Ce() { + return E.assert(S === 67, "'reScanAsteriskEqualsToken' should only be called on a '*='"), u = h + 1, S = 64; + } + function Ve(Y) { + if (S === 44 || S === 69) { + const Ae = h + 1; + u = Ae; + let $e = !1, Ke = !1, Tt = !1; + for (; ; ) { + const mt = $(u); + if (mt === -1 || Cu(mt)) { + k |= 4; + break; + } + if ($e) + $e = !1; + else { + if (mt === 47 && !Tt) + break; + mt === 91 ? Tt = !0 : mt === 92 ? $e = !0 : mt === 93 ? Tt = !1 : !Tt && mt === 40 && $(u + 1) === 63 && $(u + 2) === 60 && $(u + 3) !== 61 && $(u + 3) !== 33 && (Ke = !0); + } + u++; + } + const Le = u; + if (k & 4) { + u = Ae, $e = !1; + let mt = 0, pt = !1, Ct = 0; + for (; u < Le; ) { + const qe = U(u); + if ($e) + $e = !1; + else if (qe === 92) + $e = !0; + else if (qe === 91) + mt++; + else if (qe === 93 && mt) + mt--; + else if (!mt) { + if (qe === 123) + pt = !0; + else if (qe === 125 && pt) + pt = !1; + else if (!pt) { + if (qe === 40) + Ct++; + else if (qe === 41 && Ct) + Ct--; + else if (qe === 41 || qe === 93 || qe === 125) + break; + } + } + u++; + } + for (; Cg($(u - 1)) || $(u - 1) === 59; ) u--; + W(p.Unterminated_regular_expression_literal, h, u - h); + } else { + u++; + let mt = 0; + for (; ; ) { + const pt = B(u); + if (pt === -1 || !hh(pt, e)) + break; + const Ct = Cd(pt); + if (Y) { + const qe = kj(pt); + qe === void 0 ? W(p.Unknown_regular_expression_flag, u, Ct) : mt & qe ? W(p.Duplicate_regular_expression_flag, u, Ct) : ((mt | qe) & 96) === 96 ? W(p.The_Unicode_u_flag_and_the_Unicode_Sets_v_flag_cannot_be_set_simultaneously, u, Ct) : (mt |= qe, Bt(qe, Ct)); + } + u += Ct; + } + Y && er(Ae, Le - Ae, () => { + St( + mt, + /*annexB*/ + !0, + Ke + ); + }); + } + T = _.substring(h, u), S = 14; + } + return S; + } + function St(Y, Ae, $e) { + var Ke = !!(Y & 64), Tt = !!(Y & 96), Le = Tt || !1, mt = !1, pt = 0, Ct, qe, Lt, rn = [], Pe; + function yt(kt) { + for (; ; ) { + if (rn.push(Pe), Pe = void 0, ue(kt), Pe = rn.pop(), $(u) !== 124) + return; + u++; + } + } + function ue(kt) { + let cr = !1; + for (; ; ) { + const fr = u, vr = $(u); + switch (vr) { + case -1: + return; + case 94: + case 36: + u++, cr = !1; + break; + case 92: + switch (u++, $(u)) { + case 98: + case 66: + u++, cr = !1; + break; + default: + ye(), cr = !0; + break; + } + break; + case 40: + if (u++, $(u) === 63) + switch (u++, $(u)) { + case 61: + case 33: + u++, cr = !Le; + break; + case 60: + const Fs = u; + switch (u++, $(u)) { + case 61: + case 33: + u++, cr = !1; + break; + default: + Mt( + /*isReference*/ + !1 + ), nr( + 62 + /* greaterThan */ + ), e < 5 && W(p.Named_capturing_groups_are_only_available_when_targeting_ES2018_or_later, Fs, u - Fs), pt++, cr = !0; + break; + } + break; + default: + const Rs = u, ds = M( + 0 + /* None */ + ); + $(u) === 45 && (u++, M(ds), u === Rs + 1 && W(p.Subpattern_flags_must_be_present_when_there_is_a_minus_sign, Rs, u - Rs)), nr( + 58 + /* colon */ + ), cr = !0; + break; + } + else + pt++, cr = !0; + yt( + /*isInGroup*/ + !0 + ), nr( + 41 + /* closeParen */ + ); + break; + case 123: + u++; + const Xt = u; + ae(); + const oi = T; + if (!Le && !oi) { + cr = !0; + break; + } + if ($(u) === 44) { + u++, ae(); + const Fs = T; + if (oi) + Fs && Number.parseInt(oi) > Number.parseInt(Fs) && (Le || $(u) === 125) && W(p.Numbers_out_of_order_in_quantifier, Xt, u - Xt); + else if (Fs || $(u) === 125) + W(p.Incomplete_quantifier_Digit_expected, Xt, 0); + else { + W(p.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, fr, 1, String.fromCharCode(vr)), cr = !0; + break; + } + } else if (!oi) { + Le && W(p.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, fr, 1, String.fromCharCode(vr)), cr = !0; + break; + } + if ($(u) !== 125) + if (Le) + W(p._0_expected, u, 0, "}"), u--; + else { + cr = !0; + break; + } + // falls through + case 42: + case 43: + case 63: + u++, $(u) === 63 && u++, cr || W(p.There_is_nothing_available_for_repetition, fr, u - fr), cr = !1; + break; + case 46: + u++, cr = !0; + break; + case 91: + u++, Ke ? wt() : at(), nr( + 93 + /* closeBracket */ + ), cr = !0; + break; + case 41: + if (kt) + return; + // falls through + case 93: + case 125: + (Le || vr === 41) && W(p.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, u, 1, String.fromCharCode(vr)), u++, cr = !0; + break; + case 47: + case 124: + return; + default: + _r(), cr = !0; + break; + } + } + } + function M(kt) { + for (; ; ) { + const cr = B(u); + if (cr === -1 || !hh(cr, e)) + break; + const fr = Cd(cr), vr = kj(cr); + vr === void 0 ? W(p.Unknown_regular_expression_flag, u, fr) : kt & vr ? W(p.Duplicate_regular_expression_flag, u, fr) : vr & 28 ? (kt |= vr, Bt(vr, fr)) : W(p.This_regular_expression_flag_cannot_be_toggled_within_a_subpattern, u, fr), u += fr; + } + return kt; + } + function ye() { + switch (E.assertEqual( + U(u - 1), + 92 + /* backslash */ + ), $(u)) { + case 107: + u++, $(u) === 60 ? (u++, Mt( + /*isReference*/ + !0 + ), nr( + 62 + /* greaterThan */ + )) : (Le || $e) && W(p.k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets, u - 2, 2); + break; + case 113: + if (Ke) { + u++, W(p.q_is_only_available_inside_character_class, u - 2, 2); + break; + } + // falls through + default: + E.assert(Nt() || Q() || dt( + /*atomEscape*/ + !0 + )); + break; + } + } + function Q() { + E.assertEqual( + U(u - 1), + 92 + /* backslash */ + ); + const kt = $(u); + if (kt >= 49 && kt <= 57) { + const cr = u; + return ae(), Lt = Er(Lt, { pos: cr, end: u, value: +T }), !0; + } + return !1; + } + function dt(kt) { + E.assertEqual( + U(u - 1), + 92 + /* backslash */ + ); + let cr = $(u); + switch (cr) { + case -1: + return W(p.Undetermined_character_escape, u - 1, 1), "\\"; + case 99: + if (u++, cr = $(u), BY(cr)) + return u++, String.fromCharCode(cr & 31); + if (Le) + W(p.c_must_be_followed_by_an_ASCII_letter, u - 2, 2); + else if (kt) + return u--, "\\"; + return String.fromCharCode(cr); + case 94: + case 36: + case 47: + case 92: + case 46: + case 42: + case 43: + case 63: + case 40: + case 41: + case 91: + case 93: + case 123: + case 125: + case 124: + return u++, String.fromCharCode(cr); + default: + return u--, be( + 12 | (Tt ? 16 : 0) | (kt ? 32 : 0) + ); + } + } + function Mt(kt) { + E.assertEqual( + U(u - 1), + 60 + /* lessThan */ + ), h = u, Ne(B(u), e), u === h ? W(p.Expected_a_capturing_group_name) : kt ? qe = Er(qe, { pos: h, end: u, name: T }) : Pe?.has(T) || rn.some((cr) => cr?.has(T)) ? W(p.Named_capturing_groups_with_the_same_name_must_be_mutually_exclusive_to_each_other, h, u - h) : (Pe ?? (Pe = /* @__PURE__ */ new Set()), Pe.add(T), Ct ?? (Ct = /* @__PURE__ */ new Set()), Ct.add(T)); + } + function ke(kt) { + return kt === 93 || kt === -1 || u >= g; + } + function at() { + for (E.assertEqual( + U(u - 1), + 91 + /* openBracket */ + ), $(u) === 94 && u++; ; ) { + const kt = $(u); + if (ke(kt)) + return; + const cr = u, fr = vt(); + if ($(u) === 45) { + u++; + const vr = $(u); + if (ke(vr)) + return; + !fr && Le && W(p.A_character_class_range_must_not_be_bounded_by_another_character_class, cr, u - 1 - cr); + const Xt = u, oi = vt(); + if (!oi && Le) { + W(p.A_character_class_range_must_not_be_bounded_by_another_character_class, Xt, u - Xt); + continue; + } + if (!fr) + continue; + const Fs = hD(fr, 0), Rs = hD(oi, 0); + fr.length === Cd(Fs) && oi.length === Cd(Rs) && Fs > Rs && W(p.Range_out_of_order_in_character_class, cr, u - cr); + } + } + } + function wt() { + E.assertEqual( + U(u - 1), + 91 + /* openBracket */ + ); + let kt = !1; + $(u) === 94 && (u++, kt = !0); + let cr = !1, fr = $(u); + if (ke(fr)) + return; + let vr = u, Xt; + switch (_.slice(u, u + 2)) { + // TODO: don't use slice + case "--": + case "&&": + W(p.Expected_a_class_set_operand), mt = !1; + break; + default: + Xt = Rr(); + break; + } + switch ($(u)) { + case 45: + if ($(u + 1) === 45) { + kt && mt && W(p.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, vr, u - vr), cr = mt, Zr( + 3 + /* ClassSubtraction */ + ), mt = !kt && cr; + return; + } + break; + case 38: + if ($(u + 1) === 38) { + Zr( + 2 + /* ClassIntersection */ + ), kt && mt && W(p.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, vr, u - vr), cr = mt, mt = !kt && cr; + return; + } else + W(p.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, u, 1, String.fromCharCode(fr)); + break; + default: + kt && mt && W(p.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, vr, u - vr), cr = mt; + break; + } + for (; fr = $(u), fr !== -1; ) { + switch (fr) { + case 45: + if (u++, fr = $(u), ke(fr)) { + mt = !kt && cr; + return; + } + if (fr === 45) { + u++, W(p.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, u - 2, 2), vr = u - 2, Xt = _.slice(vr, u); + continue; + } else { + Xt || W(p.A_character_class_range_must_not_be_bounded_by_another_character_class, vr, u - 1 - vr); + const oi = u, Fs = Rr(); + if (kt && mt && W(p.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, oi, u - oi), cr || (cr = mt), !Fs) { + W(p.A_character_class_range_must_not_be_bounded_by_another_character_class, oi, u - oi); + break; + } + if (!Xt) + break; + const Rs = hD(Xt, 0), ds = hD(Fs, 0); + Xt.length === Cd(Rs) && Fs.length === Cd(ds) && Rs > ds && W(p.Range_out_of_order_in_character_class, vr, u - vr); + } + break; + case 38: + vr = u, u++, $(u) === 38 ? (u++, W(p.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, u - 2, 2), $(u) === 38 && (W(p.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, u, 1, String.fromCharCode(fr)), u++)) : W(p.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, u - 1, 1, String.fromCharCode(fr)), Xt = _.slice(vr, u); + continue; + } + if (ke($(u))) + break; + switch (vr = u, _.slice(u, u + 2)) { + // TODO: don't use slice + case "--": + case "&&": + W(p.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, u, 2), u += 2, Xt = _.slice(vr, u); + break; + default: + Xt = Rr(); + break; + } + } + mt = !kt && cr; + } + function Zr(kt) { + let cr = mt; + for (; ; ) { + let fr = $(u); + if (ke(fr)) + break; + switch (fr) { + case 45: + u++, $(u) === 45 ? (u++, kt !== 3 && W(p.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, u - 2, 2)) : W(p.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, u - 1, 1); + break; + case 38: + u++, $(u) === 38 ? (u++, kt !== 2 && W(p.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, u - 2, 2), $(u) === 38 && (W(p.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, u, 1, String.fromCharCode(fr)), u++)) : W(p.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, u - 1, 1, String.fromCharCode(fr)); + break; + default: + switch (kt) { + case 3: + W(p._0_expected, u, 0, "--"); + break; + case 2: + W(p._0_expected, u, 0, "&&"); + break; + } + break; + } + if (fr = $(u), ke(fr)) { + W(p.Expected_a_class_set_operand); + break; + } + Rr(), cr && (cr = mt); + } + mt = cr; + } + function Rr() { + switch (mt = !1, $(u)) { + case -1: + return ""; + case 91: + return u++, wt(), nr( + 93 + /* closeBracket */ + ), ""; + case 92: + if (u++, Nt()) + return ""; + if ($(u) === 113) + return u++, $(u) === 123 ? (u++, Pr(), nr( + 125 + /* closeBrace */ + ), "") : (W(p.q_must_be_followed_by_string_alternatives_enclosed_in_braces, u - 2, 2), "q"); + u--; + // falls through + default: + return rt(); + } + } + function Pr() { + E.assertEqual( + U(u - 1), + 123 + /* openBrace */ + ); + let kt = 0; + for (; ; ) + switch ($(u)) { + case -1: + return; + case 125: + kt !== 1 && (mt = !0); + return; + case 124: + kt !== 1 && (mt = !0), u++, o = u, kt = 0; + break; + default: + rt(), kt++; + break; + } + } + function rt() { + const kt = $(u); + if (kt === -1) + return ""; + if (kt === 92) { + u++; + const cr = $(u); + switch (cr) { + case 98: + return u++, "\b"; + case 38: + case 45: + case 33: + case 35: + case 37: + case 44: + case 58: + case 59: + case 60: + case 61: + case 62: + case 64: + case 96: + case 126: + return u++, String.fromCharCode(cr); + default: + return dt( + /*atomEscape*/ + !1 + ); + } + } else if (kt === $(u + 1)) + switch (kt) { + case 38: + case 33: + case 35: + case 37: + case 42: + case 43: + case 44: + case 46: + case 58: + case 59: + case 60: + case 61: + case 62: + case 63: + case 64: + case 96: + case 126: + return W(p.A_character_class_must_not_contain_a_reserved_double_punctuator_Did_you_mean_to_escape_it_with_backslash, u, 2), u += 2, _.substring(u - 2, u); + } + switch (kt) { + case 47: + case 40: + case 41: + case 91: + case 93: + case 123: + case 125: + case 45: + case 124: + return W(p.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, u, 1, String.fromCharCode(kt)), u++, String.fromCharCode(kt); + } + return _r(); + } + function vt() { + if ($(u) === 92) { + u++; + const kt = $(u); + switch (kt) { + case 98: + return u++, "\b"; + case 45: + return u++, String.fromCharCode(kt); + default: + return Nt() ? "" : dt( + /*atomEscape*/ + !1 + ); + } + } else + return _r(); + } + function Nt() { + E.assertEqual( + U(u - 1), + 92 + /* backslash */ + ); + let kt = !1; + const cr = u - 1, fr = $(u); + switch (fr) { + case 100: + case 68: + case 115: + case 83: + case 119: + case 87: + return u++, !0; + case 80: + kt = !0; + // falls through + case 112: + if (u++, $(u) === 123) { + u++; + const vr = u, Xt = Jt(); + if ($(u) === 61) { + const oi = ehe.get(Xt); + if (u === vr) + W(p.Expected_a_Unicode_property_name); + else if (oi === void 0) { + W(p.Unknown_Unicode_property_name, vr, u - vr); + const ds = Sb(Xt, ehe.keys(), go); + ds && W(p.Did_you_mean_0, vr, u - vr, ds); + } + u++; + const Fs = u, Rs = Jt(); + if (u === Fs) + W(p.Expected_a_Unicode_property_value); + else if (oi !== void 0 && !YP[oi].has(Rs)) { + W(p.Unknown_Unicode_property_value, Fs, u - Fs); + const ds = Sb(Rs, YP[oi], go); + ds && W(p.Did_you_mean_0, Fs, u - Fs, ds); + } + } else if (u === vr) + W(p.Expected_a_Unicode_property_name_or_value); + else if (rhe.has(Xt)) + Ke ? kt ? W(p.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, vr, u - vr) : mt = !0 : W(p.Any_Unicode_property_that_would_possibly_match_more_than_a_single_character_is_only_available_when_the_Unicode_Sets_v_flag_is_set, vr, u - vr); + else if (!YP.General_Category.has(Xt) && !the.has(Xt)) { + W(p.Unknown_Unicode_property_name_or_value, vr, u - vr); + const oi = Sb(Xt, [...YP.General_Category, ...the, ...rhe], go); + oi && W(p.Did_you_mean_0, vr, u - vr, oi); + } + nr( + 125 + /* closeBrace */ + ), Tt || W(p.Unicode_property_value_expressions_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set, cr, u - cr); + } else if (Le) + W(p._0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces, u - 2, 2, String.fromCharCode(fr)); + else + return u--, !1; + return !0; + } + return !1; + } + function Jt() { + let kt = ""; + for (; ; ) { + const cr = $(u); + if (cr === -1 || !Qge(cr)) + break; + kt += String.fromCharCode(cr), u++; + } + return kt; + } + function _r() { + const kt = Tt ? Cd(B(u)) : 1; + return u += kt, kt > 0 ? _.substring(u - kt, u) : ""; + } + function nr(kt) { + $(u) === kt ? u++ : W(p._0_expected, u, 0, String.fromCharCode(kt)); + } + yt( + /*isInGroup*/ + !1 + ), lr(qe, (kt) => { + if (!Ct?.has(kt.name) && (W(p.There_is_no_capturing_group_named_0_in_this_regular_expression, kt.pos, kt.end - kt.pos, kt.name), Ct)) { + const cr = Sb(kt.name, Ct, go); + cr && W(p.Did_you_mean_0, kt.pos, kt.end - kt.pos, cr); + } + }), lr(Lt, (kt) => { + kt.value > pt && (pt ? W(p.This_backreference_refers_to_a_group_that_does_not_exist_There_are_only_0_capturing_groups_in_this_regular_expression, kt.pos, kt.end - kt.pos, pt) : W(p.This_backreference_refers_to_a_group_that_does_not_exist_There_are_no_capturing_groups_in_this_regular_expression, kt.pos, kt.end - kt.pos)); + }); + } + function Bt(Y, Ae) { + const $e = BFe.get(Y); + $e && e < $e && W(p.This_regular_expression_flag_is_only_available_when_targeting_0_or_later, u, Ae, q5($e)); + } + function tr(Y, Ae, $e, Ke) { + const Tt = Nr(Ae.trimStart(), $e); + return Tt === void 0 ? Y : Er( + Y, + { + range: { pos: Ke, end: u }, + type: Tt + } + ); + } + function Nr(Y, Ae) { + const $e = Ae.exec(Y); + if ($e) + switch ($e[1]) { + case "ts-expect-error": + return 0; + case "ts-ignore": + return 1; + } + } + function st(Y) { + return u = h, S = q(!Y); + } + function Wt() { + return u = h, S = q( + /*shouldEmitInvalidEscapeError*/ + !0 + ); + } + function Jr(Y = !0) { + return u = h = m, S = Mn(Y); + } + function ui() { + return S === 48 ? (u = h + 1, S = 30) : S; + } + function Ji() { + return S === 81 ? (u = h + 1, S = 63) : S; + } + function Dt() { + return E.assert(S === 61, "'reScanQuestionToken' should only be called on a '??'"), u = h + 1, S = 58; + } + function Mn(Y = !0) { + if (m = h = u, u >= g) + return S = 1; + let Ae = U(u); + if (Ae === 60) + return U(u + 1) === 47 ? (u += 2, S = 31) : (u++, S = 30); + if (Ae === 123) + return u++, S = 19; + let $e = 0; + for (; u < g && (Ae = U(u), Ae !== 123); ) { + if (Ae === 60) { + if (gD(_, u)) + return u = $P(_, u, W), S = 7; + break; + } + if (Ae === 62 && W(p.Unexpected_token_Did_you_mean_or_gt, u, 1), Ae === 125 && W(p.Unexpected_token_Did_you_mean_or_rbrace, u, 1), Cu(Ae) && $e === 0) + $e = -1; + else { + if (!Y && Cu(Ae) && $e > 0) + break; + Cg(Ae) || ($e = u); + } + u++; + } + return T = _.substring(m, u), $e === -1 ? 13 : 12; + } + function ai() { + if (v_(S)) { + for (; u < g; ) { + if (U(u) === 45) { + T += "-", u++; + continue; + } + const Ae = u; + if (T += pe(), u === Ae) + break; + } + return Te(); + } + return S; + } + function fi() { + switch (m = u, U(u)) { + case 34: + case 39: + return T = he( + /*jsxAttributeString*/ + !0 + ), S = 11; + default: + return ne(); + } + } + function pn() { + return u = h = m, fi(); + } + function _i(Y) { + if (m = h = u, k = 0, u >= g) + return S = 1; + for (let Ae = U(u); u < g && !Cu(Ae) && Ae !== 96; Ae = R(++u)) + if (!Y) { + if (Ae === 123) + break; + if (Ae === 64 && u - 1 >= 0 && im(U(u - 1)) && !(u + 1 < g && Cg(U(u + 1)))) + break; + } + return u === h ? Je() : (T = _.substring(h, u), S = 82); + } + function Je() { + if (m = h = u, k = 0, u >= g) + return S = 1; + const Y = R(u); + switch (u += Cd(Y), Y) { + case 9: + case 11: + case 12: + case 32: + for (; u < g && im(U(u)); ) + u++; + return S = 5; + case 64: + return S = 60; + case 13: + U(u) === 10 && u++; + // falls through + case 10: + return k |= 1, S = 4; + case 42: + return S = 42; + case 123: + return S = 19; + case 125: + return S = 20; + case 91: + return S = 23; + case 93: + return S = 24; + case 40: + return S = 21; + case 41: + return S = 22; + case 60: + return S = 30; + case 62: + return S = 32; + case 61: + return S = 64; + case 44: + return S = 28; + case 46: + return S = 25; + case 96: + return S = 62; + case 35: + return S = 63; + case 92: + u--; + const Ae = Z(); + if (Ae >= 0 && Vm(Ae, e)) + return T = je( + /*shouldEmitInvalidEscapeError*/ + !0 + ) + pe(), S = Te(); + const $e = me(); + return $e >= 0 && Vm($e, e) ? (u += 6, k |= 1024, T = String.fromCharCode($e) + pe(), S = Te()) : (u++, S = 0); + } + if (Vm(Y, e)) { + let Ae = Y; + for (; u < g && hh(Ae = R(u), e) || Ae === 45; ) u += Cd(Ae); + return T = _.substring(h, u), Ae === 92 && (T += pe()), S = Te(); + } else + return S = 0; + } + function ft(Y, Ae) { + const $e = u, Ke = m, Tt = h, Le = S, mt = T, pt = k, Ct = Y(); + return (!Ct || Ae) && (u = $e, m = Ke, h = Tt, S = Le, T = mt, k = pt), Ct; + } + function er(Y, Ae, $e) { + const Ke = g, Tt = u, Le = m, mt = h, pt = S, Ct = T, qe = k, Lt = D; + Ds(_, Y, Ae); + const rn = $e(); + return g = Ke, u = Tt, m = Le, h = mt, S = pt, T = Ct, k = qe, D = Lt, rn; + } + function qr(Y) { + return ft( + Y, + /*isLookahead*/ + !0 + ); + } + function Jn(Y) { + return ft( + Y, + /*isLookahead*/ + !1 + ); + } + function Un() { + return _; + } + function ki() { + D = void 0; + } + function Ds(Y, Ae, $e) { + _ = Y || "", g = $e === void 0 ? _.length : Ae + $e, re(Ae || 0); + } + function Ks(Y) { + s = Y; + } + function yr(Y) { + e = Y; + } + function bs(Y) { + n = Y; + } + function Xe(Y) { + A = Y; + } + function Et(Y) { + O = Y; + } + function re(Y) { + E.assert(Y >= 0), u = Y, m = Y, h = Y, S = 0, T = void 0, k = 0; + } + function it(Y) { + P += Y ? 1 : -1; + } + } + function hD(e, t) { + return e.codePointAt(t); + } + function Cd(e) { + return e >= 65536 ? 2 : e === -1 ? 0 : 1; + } + function QFe(e) { + if (E.assert(0 <= e && e <= 1114111), e <= 65535) + return String.fromCharCode(e); + const t = Math.floor((e - 65536) / 1024) + 55296, n = (e - 65536) % 1024 + 56320; + return String.fromCharCode(t, n); + } + var YFe = String.fromCodePoint ? (e) => String.fromCodePoint(e) : QFe; + function yD(e) { + return YFe(e); + } + var ehe = new Map(Object.entries({ + General_Category: "General_Category", + gc: "General_Category", + Script: "Script", + sc: "Script", + Script_Extensions: "Script_Extensions", + scx: "Script_Extensions" + })), the = /* @__PURE__ */ new Set(["ASCII", "ASCII_Hex_Digit", "AHex", "Alphabetic", "Alpha", "Any", "Assigned", "Bidi_Control", "Bidi_C", "Bidi_Mirrored", "Bidi_M", "Case_Ignorable", "CI", "Cased", "Changes_When_Casefolded", "CWCF", "Changes_When_Casemapped", "CWCM", "Changes_When_Lowercased", "CWL", "Changes_When_NFKC_Casefolded", "CWKCF", "Changes_When_Titlecased", "CWT", "Changes_When_Uppercased", "CWU", "Dash", "Default_Ignorable_Code_Point", "DI", "Deprecated", "Dep", "Diacritic", "Dia", "Emoji", "Emoji_Component", "EComp", "Emoji_Modifier", "EMod", "Emoji_Modifier_Base", "EBase", "Emoji_Presentation", "EPres", "Extended_Pictographic", "ExtPict", "Extender", "Ext", "Grapheme_Base", "Gr_Base", "Grapheme_Extend", "Gr_Ext", "Hex_Digit", "Hex", "IDS_Binary_Operator", "IDSB", "IDS_Trinary_Operator", "IDST", "ID_Continue", "IDC", "ID_Start", "IDS", "Ideographic", "Ideo", "Join_Control", "Join_C", "Logical_Order_Exception", "LOE", "Lowercase", "Lower", "Math", "Noncharacter_Code_Point", "NChar", "Pattern_Syntax", "Pat_Syn", "Pattern_White_Space", "Pat_WS", "Quotation_Mark", "QMark", "Radical", "Regional_Indicator", "RI", "Sentence_Terminal", "STerm", "Soft_Dotted", "SD", "Terminal_Punctuation", "Term", "Unified_Ideograph", "UIdeo", "Uppercase", "Upper", "Variation_Selector", "VS", "White_Space", "space", "XID_Continue", "XIDC", "XID_Start", "XIDS"]), rhe = /* @__PURE__ */ new Set(["Basic_Emoji", "Emoji_Keycap_Sequence", "RGI_Emoji_Modifier_Sequence", "RGI_Emoji_Flag_Sequence", "RGI_Emoji_Tag_Sequence", "RGI_Emoji_ZWJ_Sequence", "RGI_Emoji"]), YP = { + General_Category: /* @__PURE__ */ new Set(["C", "Other", "Cc", "Control", "cntrl", "Cf", "Format", "Cn", "Unassigned", "Co", "Private_Use", "Cs", "Surrogate", "L", "Letter", "LC", "Cased_Letter", "Ll", "Lowercase_Letter", "Lm", "Modifier_Letter", "Lo", "Other_Letter", "Lt", "Titlecase_Letter", "Lu", "Uppercase_Letter", "M", "Mark", "Combining_Mark", "Mc", "Spacing_Mark", "Me", "Enclosing_Mark", "Mn", "Nonspacing_Mark", "N", "Number", "Nd", "Decimal_Number", "digit", "Nl", "Letter_Number", "No", "Other_Number", "P", "Punctuation", "punct", "Pc", "Connector_Punctuation", "Pd", "Dash_Punctuation", "Pe", "Close_Punctuation", "Pf", "Final_Punctuation", "Pi", "Initial_Punctuation", "Po", "Other_Punctuation", "Ps", "Open_Punctuation", "S", "Symbol", "Sc", "Currency_Symbol", "Sk", "Modifier_Symbol", "Sm", "Math_Symbol", "So", "Other_Symbol", "Z", "Separator", "Zl", "Line_Separator", "Zp", "Paragraph_Separator", "Zs", "Space_Separator"]), + Script: /* @__PURE__ */ new Set(["Adlm", "Adlam", "Aghb", "Caucasian_Albanian", "Ahom", "Arab", "Arabic", "Armi", "Imperial_Aramaic", "Armn", "Armenian", "Avst", "Avestan", "Bali", "Balinese", "Bamu", "Bamum", "Bass", "Bassa_Vah", "Batk", "Batak", "Beng", "Bengali", "Bhks", "Bhaiksuki", "Bopo", "Bopomofo", "Brah", "Brahmi", "Brai", "Braille", "Bugi", "Buginese", "Buhd", "Buhid", "Cakm", "Chakma", "Cans", "Canadian_Aboriginal", "Cari", "Carian", "Cham", "Cher", "Cherokee", "Chrs", "Chorasmian", "Copt", "Coptic", "Qaac", "Cpmn", "Cypro_Minoan", "Cprt", "Cypriot", "Cyrl", "Cyrillic", "Deva", "Devanagari", "Diak", "Dives_Akuru", "Dogr", "Dogra", "Dsrt", "Deseret", "Dupl", "Duployan", "Egyp", "Egyptian_Hieroglyphs", "Elba", "Elbasan", "Elym", "Elymaic", "Ethi", "Ethiopic", "Geor", "Georgian", "Glag", "Glagolitic", "Gong", "Gunjala_Gondi", "Gonm", "Masaram_Gondi", "Goth", "Gothic", "Gran", "Grantha", "Grek", "Greek", "Gujr", "Gujarati", "Guru", "Gurmukhi", "Hang", "Hangul", "Hani", "Han", "Hano", "Hanunoo", "Hatr", "Hatran", "Hebr", "Hebrew", "Hira", "Hiragana", "Hluw", "Anatolian_Hieroglyphs", "Hmng", "Pahawh_Hmong", "Hmnp", "Nyiakeng_Puachue_Hmong", "Hrkt", "Katakana_Or_Hiragana", "Hung", "Old_Hungarian", "Ital", "Old_Italic", "Java", "Javanese", "Kali", "Kayah_Li", "Kana", "Katakana", "Kawi", "Khar", "Kharoshthi", "Khmr", "Khmer", "Khoj", "Khojki", "Kits", "Khitan_Small_Script", "Knda", "Kannada", "Kthi", "Kaithi", "Lana", "Tai_Tham", "Laoo", "Lao", "Latn", "Latin", "Lepc", "Lepcha", "Limb", "Limbu", "Lina", "Linear_A", "Linb", "Linear_B", "Lisu", "Lyci", "Lycian", "Lydi", "Lydian", "Mahj", "Mahajani", "Maka", "Makasar", "Mand", "Mandaic", "Mani", "Manichaean", "Marc", "Marchen", "Medf", "Medefaidrin", "Mend", "Mende_Kikakui", "Merc", "Meroitic_Cursive", "Mero", "Meroitic_Hieroglyphs", "Mlym", "Malayalam", "Modi", "Mong", "Mongolian", "Mroo", "Mro", "Mtei", "Meetei_Mayek", "Mult", "Multani", "Mymr", "Myanmar", "Nagm", "Nag_Mundari", "Nand", "Nandinagari", "Narb", "Old_North_Arabian", "Nbat", "Nabataean", "Newa", "Nkoo", "Nko", "Nshu", "Nushu", "Ogam", "Ogham", "Olck", "Ol_Chiki", "Orkh", "Old_Turkic", "Orya", "Oriya", "Osge", "Osage", "Osma", "Osmanya", "Ougr", "Old_Uyghur", "Palm", "Palmyrene", "Pauc", "Pau_Cin_Hau", "Perm", "Old_Permic", "Phag", "Phags_Pa", "Phli", "Inscriptional_Pahlavi", "Phlp", "Psalter_Pahlavi", "Phnx", "Phoenician", "Plrd", "Miao", "Prti", "Inscriptional_Parthian", "Rjng", "Rejang", "Rohg", "Hanifi_Rohingya", "Runr", "Runic", "Samr", "Samaritan", "Sarb", "Old_South_Arabian", "Saur", "Saurashtra", "Sgnw", "SignWriting", "Shaw", "Shavian", "Shrd", "Sharada", "Sidd", "Siddham", "Sind", "Khudawadi", "Sinh", "Sinhala", "Sogd", "Sogdian", "Sogo", "Old_Sogdian", "Sora", "Sora_Sompeng", "Soyo", "Soyombo", "Sund", "Sundanese", "Sylo", "Syloti_Nagri", "Syrc", "Syriac", "Tagb", "Tagbanwa", "Takr", "Takri", "Tale", "Tai_Le", "Talu", "New_Tai_Lue", "Taml", "Tamil", "Tang", "Tangut", "Tavt", "Tai_Viet", "Telu", "Telugu", "Tfng", "Tifinagh", "Tglg", "Tagalog", "Thaa", "Thaana", "Thai", "Tibt", "Tibetan", "Tirh", "Tirhuta", "Tnsa", "Tangsa", "Toto", "Ugar", "Ugaritic", "Vaii", "Vai", "Vith", "Vithkuqi", "Wara", "Warang_Citi", "Wcho", "Wancho", "Xpeo", "Old_Persian", "Xsux", "Cuneiform", "Yezi", "Yezidi", "Yiii", "Yi", "Zanb", "Zanabazar_Square", "Zinh", "Inherited", "Qaai", "Zyyy", "Common", "Zzzz", "Unknown"]), + Script_Extensions: void 0 + }; + YP.Script_Extensions = YP.Script; + function Dl(e) { + return xf(e) || Z_(e); + } + function DC(e) { + return tD(e, c4, W5); + } + var qY = /* @__PURE__ */ new Map([ + [99, "lib.esnext.full.d.ts"], + [11, "lib.es2024.full.d.ts"], + [10, "lib.es2023.full.d.ts"], + [9, "lib.es2022.full.d.ts"], + [8, "lib.es2021.full.d.ts"], + [7, "lib.es2020.full.d.ts"], + [6, "lib.es2019.full.d.ts"], + [5, "lib.es2018.full.d.ts"], + [4, "lib.es2017.full.d.ts"], + [3, "lib.es2016.full.d.ts"], + [2, "lib.es6.d.ts"] + // We don't use lib.es2015.full.d.ts due to breaking change. + ]); + function ZP(e) { + const t = da(e); + switch (t) { + case 99: + case 11: + case 10: + case 9: + case 8: + case 7: + case 6: + case 5: + case 4: + case 3: + case 2: + return qY.get(t); + default: + return "lib.d.ts"; + } + } + function ec(e) { + return e.start + e.length; + } + function HY(e) { + return e.length === 0; + } + function Dj(e, t) { + return t >= e.start && t < ec(e); + } + function KP(e, t) { + return t >= e.pos && t <= e.end; + } + function GY(e, t) { + return t.start >= e.start && ec(t) <= ec(e); + } + function wj(e, t) { + return t.pos >= e.start && t.end <= ec(e); + } + function $Y(e, t) { + return t.start >= e.pos && ec(t) <= e.end; + } + function nhe(e, t) { + return XY(e, t) !== void 0; + } + function XY(e, t) { + const n = KY(e, t); + return n && n.length === 0 ? void 0 : n; + } + function QY(e, t) { + return t3(e.start, e.length, t.start, t.length); + } + function e3(e, t, n) { + return t3(e.start, e.length, t, n); + } + function t3(e, t, n, i) { + const s = e + t, o = n + i; + return n <= s && o >= e; + } + function YY(e, t) { + return t <= ec(e) && t >= e.start; + } + function ZY(e, t) { + return e3(t, e.pos, e.end - e.pos); + } + function KY(e, t) { + const n = Math.max(e.start, t.start), i = Math.min(ec(e), ec(t)); + return n <= i ? Nc(n, i) : void 0; + } + function Pj(e) { + e = e.filter((i) => i.length > 0).sort((i, s) => i.start !== s.start ? i.start - s.start : i.length - s.length); + const t = []; + let n = 0; + for (; n < e.length; ) { + let i = e[n], s = n + 1; + for (; s < e.length && QY(i, e[s]); ) { + const o = Math.min(i.start, e[s].start), c = Math.max(ec(i), ec(e[s])); + i = Nc(o, c), s++; + } + n = s, t.push(i); + } + return t; + } + function Kl(e, t) { + if (e < 0) + throw new Error("start < 0"); + if (t < 0) + throw new Error("length < 0"); + return { start: e, length: t }; + } + function Nc(e, t) { + return Kl(e, t - e); + } + function vD(e) { + return Kl(e.span.start, e.newLength); + } + function eZ(e) { + return HY(e.span) && e.newLength === 0; + } + function r3(e, t) { + if (t < 0) + throw new Error("newLength < 0"); + return { span: e, newLength: t }; + } + var g7 = r3(Kl(0, 0), 0); + function tZ(e) { + if (e.length === 0) + return g7; + if (e.length === 1) + return e[0]; + const t = e[0]; + let n = t.span.start, i = ec(t.span), s = n + t.newLength; + for (let o = 1; o < e.length; o++) { + const c = e[o], _ = n, u = i, g = s, m = c.span.start, h = ec(c.span), S = m + c.newLength; + n = Math.min(_, m), i = Math.max(u, u + (h - g)), s = Math.max(S, S + (g - h)); + } + return r3( + Nc(n, i), + /*newLength*/ + s - n + ); + } + function ihe(e) { + if (e && e.kind === 169) { + for (let t = e; t; t = t.parent) + if (Es(t) || $n(t) || t.kind === 265) + return t; + } + } + function K_(e, t) { + return Ii(e) && Gn( + e, + 31 + /* ParameterPropertyModifier */ + ) && t.kind === 177; + } + function rZ(e) { + return ws(e) ? Ni(e.elements, nZ) : !1; + } + function nZ(e) { + return vl(e) ? !0 : rZ(e.name); + } + function Y2(e) { + let t = e.parent; + for (; ya(t.parent); ) + t = t.parent.parent; + return t.parent; + } + function iZ(e, t) { + ya(e) && (e = Y2(e)); + let n = t(e); + return e.kind === 261 && (e = e.parent), e && e.kind === 262 && (n |= t(e), e = e.parent), e && e.kind === 244 && (n |= t(e)), n; + } + function J1(e) { + return iZ(e, pu); + } + function Nj(e) { + return iZ(e, ree); + } + function yh(e) { + return iZ(e, ZFe); + } + function ZFe(e) { + return e.flags; + } + var sZ = ["cs", "de", "es", "fr", "it", "ja", "ko", "pl", "pt-br", "ru", "tr", "zh-cn", "zh-tw"]; + function Aj(e, t, n) { + const i = e.toLowerCase(), s = /^([a-z]+)(?:[_-]([a-z]+))?$/.exec(i); + if (!s) { + n && n.push(Yo(p.Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1, "en", "ja-jp")); + return; + } + const o = s[1], c = s[2]; + ms(sZ, i) && !_(o, c, n) && _( + o, + /*territory*/ + void 0, + n + ), fQ(e); + function _(u, g, m) { + const h = Hs(t.getExecutingFilePath()), S = Hn(h); + let T = On(S, u); + if (g && (T = T + "-" + g), T = t.resolvePath(On(T, "diagnosticMessages.generated.json")), !t.fileExists(T)) + return !1; + let k = ""; + try { + k = t.readFile(T); + } catch { + return m && m.push(Yo(p.Unable_to_open_file_0, T)), !1; + } + try { + See(JSON.parse(k)); + } catch { + return m && m.push(Yo(p.Corrupted_locale_file_0, T)), !1; + } + return !0; + } + } + function Vo(e, t) { + if (e) + for (; e.original !== void 0; ) + e = e.original; + return !e || !t || t(e) ? e : void 0; + } + function dr(e, t) { + for (; e; ) { + const n = t(e); + if (n === "quit") + return; + if (n) + return e; + e = e.parent; + } + } + function bD(e) { + return (e.flags & 16) === 0; + } + function vs(e, t) { + if (e === void 0 || bD(e)) + return e; + for (e = e.original; e; ) { + if (bD(e)) + return !t || t(e) ? e : void 0; + e = e.original; + } + } + function tc(e) { + return e.length >= 2 && e.charCodeAt(0) === 95 && e.charCodeAt(1) === 95 ? "_" + e : e; + } + function Si(e) { + const t = e; + return t.length >= 3 && t.charCodeAt(0) === 95 && t.charCodeAt(1) === 95 && t.charCodeAt(2) === 95 ? t.substr(1) : t; + } + function An(e) { + return Si(e.escapedText); + } + function Z2(e) { + const t = Q2(e.escapedText); + return t ? Bn(t, k_) : void 0; + } + function cc(e) { + return e.valueDeclaration && Du(e.valueDeclaration) ? An(e.valueDeclaration.name) : Si(e.escapedName); + } + function she(e) { + const t = e.parent.parent; + if (t) { + if (Pl(t)) + return Ij(t); + switch (t.kind) { + case 244: + if (t.declarationList && t.declarationList.declarations[0]) + return Ij(t.declarationList.declarations[0]); + break; + case 245: + let n = t.expression; + switch (n.kind === 227 && n.operatorToken.kind === 64 && (n = n.left), n.kind) { + case 212: + return n.name; + case 213: + const i = n.argumentExpression; + if (Me(i)) + return i; + } + break; + case 218: + return Ij(t.expression); + case 257: { + if (Pl(t.statement) || ut(t.statement)) + return Ij(t.statement); + break; + } + } + } + } + function Ij(e) { + const t = _s(e); + return t && Me(t) ? t : void 0; + } + function n3(e, t) { + return !!(wl(e) && Me(e.name) && An(e.name) === An(t) || Ic(e) && ot(e.declarationList.declarations, (n) => n3(n, t))); + } + function aZ(e) { + return e.name || she(e); + } + function wl(e) { + return !!e.name; + } + function h7(e) { + switch (e.kind) { + case 80: + return e; + case 349: + case 342: { + const { name: n } = e; + if (n.kind === 167) + return n.right; + break; + } + case 214: + case 227: { + const n = e; + switch (Ac(n)) { + case 1: + case 4: + case 5: + case 3: + return p5(n.left); + case 7: + case 8: + case 9: + return n.arguments[1]; + default: + return; + } + } + case 347: + return aZ(e); + case 341: + return she(e); + case 278: { + const { expression: n } = e; + return Me(n) ? n : void 0; + } + case 213: + const t = e; + if (f5(t)) + return t.argumentExpression; + } + return e.name; + } + function _s(e) { + if (e !== void 0) + return h7(e) || (yo(e) || xo(e) || Rc(e) ? y7(e) : void 0); + } + function y7(e) { + if (e.parent) { + if (rl(e.parent) || ya(e.parent)) + return e.parent.name; + if (_n(e.parent) && e === e.parent.right) { + if (Me(e.parent.left)) + return e.parent.left; + if (To(e.parent.left)) + return p5(e.parent.left); + } else if (ei(e.parent) && Me(e.parent.name)) + return e.parent.name; + } else return; + } + function Ty(e) { + if (Ff(e)) + return kn(e.modifiers, ul); + } + function Tb(e) { + if (Gn( + e, + 98303 + /* Modifier */ + )) + return kn(e.modifiers, Zs); + } + function ahe(e, t) { + if (e.name) + if (Me(e.name)) { + const n = e.name.escapedText; + return b7(e.parent, t).filter((i) => Lf(i) && Me(i.name) && i.name.escapedText === n); + } else { + const n = e.parent.parameters.indexOf(e); + E.assert(n > -1, "Parameters should always be in their parents' parameter list"); + const i = b7(e.parent, t).filter(Lf); + if (n < i.length) + return [i[n]]; + } + return Ge; + } + function wC(e) { + return ahe( + e, + /*noCache*/ + !1 + ); + } + function oZ(e) { + return ahe( + e, + /*noCache*/ + !0 + ); + } + function ohe(e, t) { + const n = e.name.escapedText; + return b7(e.parent, t).filter((i) => Up(i) && i.typeParameters.some((s) => s.name.escapedText === n)); + } + function cZ(e) { + return ohe( + e, + /*noCache*/ + !1 + ); + } + function lZ(e) { + return ohe( + e, + /*noCache*/ + !0 + ); + } + function uZ(e) { + return !!Lp(e, Lf); + } + function _Z(e) { + return Lp(e, Yx); + } + function fZ(e) { + return S7(e, LF); + } + function Fj(e) { + return Lp(e, Yte); + } + function che(e) { + return Lp(e, Tz); + } + function pZ(e) { + return Lp( + e, + Tz, + /*noCache*/ + !0 + ); + } + function lhe(e) { + return Lp(e, xz); + } + function dZ(e) { + return Lp( + e, + xz, + /*noCache*/ + !0 + ); + } + function uhe(e) { + return Lp(e, kz); + } + function mZ(e) { + return Lp( + e, + kz, + /*noCache*/ + !0 + ); + } + function _he(e) { + return Lp(e, Cz); + } + function gZ(e) { + return Lp( + e, + Cz, + /*noCache*/ + !0 + ); + } + function hZ(e) { + return Lp( + e, + FF, + /*noCache*/ + !0 + ); + } + function Oj(e) { + return Lp(e, Ez); + } + function yZ(e) { + return Lp( + e, + Ez, + /*noCache*/ + !0 + ); + } + function Lj(e) { + return Lp(e, WN); + } + function v7(e) { + return Lp(e, Dz); + } + function vZ(e) { + return Lp(e, OF); + } + function fhe(e) { + return Lp(e, Up); + } + function Mj(e) { + return Lp(e, MF); + } + function z1(e) { + const t = Lp(e, R4); + if (t && t.typeExpression && t.typeExpression.type) + return t; + } + function f0(e) { + let t = Lp(e, R4); + return !t && Ii(e) && (t = Nn(wC(e), (n) => !!n.typeExpression)), t && t.typeExpression && t.typeExpression.type; + } + function i3(e) { + const t = vZ(e); + if (t && t.typeExpression) + return t.typeExpression.type; + const n = z1(e); + if (n && n.typeExpression) { + const i = n.typeExpression.type; + if (a_(i)) { + const s = Nn(i.members, Ux); + return s && s.type; + } + if (Zm(i) || b6(i)) + return i.type; + } + } + function b7(e, t) { + var n; + if (!H3(e)) return Ge; + let i = (n = e.jsDoc) == null ? void 0 : n.jsDocCache; + if (i === void 0 || t) { + const s = NB(e, t); + E.assert(s.length < 2 || s[0] !== s[1]), i = ka(s, (o) => Od(o) ? o.tags : o), t || (e.jsDoc ?? (e.jsDoc = []), e.jsDoc.jsDocCache = i); + } + return i; + } + function W1(e) { + return b7( + e, + /*noCache*/ + !1 + ); + } + function Lp(e, t, n) { + return Nn(b7(e, n), t); + } + function S7(e, t) { + return W1(e).filter(t); + } + function phe(e, t) { + return W1(e).filter((n) => n.kind === t); + } + function s3(e) { + return typeof e == "string" ? e : e?.map((t) => t.kind === 322 ? t.text : KFe(t)).join(""); + } + function KFe(e) { + const t = e.kind === 325 ? "link" : e.kind === 326 ? "linkcode" : "linkplain", n = e.name ? ef(e.name) : "", i = e.name && (e.text === "" || e.text.startsWith("://")) ? "" : " "; + return `{@${t} ${n}${i}${e.text}}`; + } + function xy(e) { + if (w0(e)) { + if (S6(e.parent)) { + const t = GC(e.parent); + if (t && wr(t.tags)) + return ka(t.tags, (n) => Up(n) ? n.typeParameters : void 0); + } + return Ge; + } + if (jp(e)) + return E.assert( + e.parent.kind === 321 + /* JSDoc */ + ), ka(e.parent.tags, (t) => Up(t) ? t.typeParameters : void 0); + if (e.typeParameters || lre(e) && e.typeParameters) + return e.typeParameters; + if (an(e)) { + const t = P5(e); + if (t.length) + return t; + const n = f0(e); + if (n && Zm(n) && n.typeParameters) + return n.typeParameters; + } + return Ge; + } + function PC(e) { + return e.constraint ? e.constraint : Up(e.parent) && e === e.parent.typeParameters[0] ? e.parent.constraint : void 0; + } + function wg(e) { + return e.kind === 80 || e.kind === 81; + } + function a3(e) { + return e.kind === 179 || e.kind === 178; + } + function T7(e) { + return wn(e) && !!(e.flags & 64); + } + function Rj(e) { + return uo(e) && !!(e.flags & 64); + } + function K2(e) { + return Ps(e) && !!(e.flags & 64); + } + function Eu(e) { + const t = e.kind; + return !!(e.flags & 64) && (t === 212 || t === 213 || t === 214 || t === 236); + } + function SD(e) { + return Eu(e) && !$x(e) && !!e.questionDotToken; + } + function x7(e) { + return SD(e.parent) && e.parent.expression === e; + } + function TD(e) { + return !Eu(e.parent) || SD(e.parent) || e !== e.parent.expression; + } + function jj(e) { + return e.kind === 227 && e.operatorToken.kind === 61; + } + function nd(e) { + return of(e) && Me(e.typeName) && e.typeName.escapedText === "const" && !e.typeArguments; + } + function id(e) { + return hc( + e, + 8 + /* PartiallyEmittedExpressions */ + ); + } + function k7(e) { + return $x(e) && !!(e.flags & 64); + } + function xD(e) { + return e.kind === 253 || e.kind === 252; + } + function Bj(e) { + return e.kind === 281 || e.kind === 280; + } + function kD(e) { + return e.kind === 349 || e.kind === 342; + } + function C7(e) { + return e >= 167; + } + function Jj(e) { + return e >= 0 && e <= 166; + } + function ix(e) { + return Jj(e.kind); + } + function xb(e) { + return eo(e, "pos") && eo(e, "end"); + } + function CD(e) { + return 9 <= e && e <= 15; + } + function eS(e) { + return CD(e.kind); + } + function zj(e) { + switch (e.kind) { + case 211: + case 210: + case 14: + case 219: + case 232: + return !0; + } + return !1; + } + function ky(e) { + return 15 <= e && e <= 18; + } + function bZ(e) { + return ky(e.kind); + } + function E7(e) { + const t = e.kind; + return t === 17 || t === 18; + } + function Cy(e) { + return Xu(e) || Nu(e); + } + function NC(e) { + switch (e.kind) { + case 277: + return e.isTypeOnly || e.parent.parent.phaseModifier === 156; + case 275: + return e.parent.phaseModifier === 156; + case 274: + return e.phaseModifier === 156; + case 272: + return e.isTypeOnly; + } + return !1; + } + function SZ(e) { + switch (e.kind) { + case 282: + return e.isTypeOnly || e.parent.parent.isTypeOnly; + case 279: + return e.isTypeOnly && !!e.moduleSpecifier && !e.exportClause; + case 281: + return e.parent.isTypeOnly; + } + return !1; + } + function p0(e) { + return NC(e) || SZ(e); + } + function TZ(e) { + return dr(e, p0) !== void 0; + } + function Wj(e) { + return e.kind === 11 || ky(e.kind); + } + function xZ(e) { + return ca(e) || Me(e); + } + function Bo(e) { + var t; + return Me(e) && ((t = e.emitNode) == null ? void 0 : t.autoGenerate) !== void 0; + } + function tS(e) { + var t; + return Ai(e) && ((t = e.emitNode) == null ? void 0 : t.autoGenerate) !== void 0; + } + function o3(e) { + const t = e.emitNode.autoGenerate.flags; + return !!(t & 32) && !!(t & 16) && !!(t & 8); + } + function Du(e) { + return (os(e) || ax(e)) && Ai(e.name); + } + function AC(e) { + return wn(e) && Ai(e.name); + } + function Ey(e) { + switch (e) { + case 128: + case 129: + case 134: + case 87: + case 138: + case 90: + case 95: + case 103: + case 125: + case 123: + case 124: + case 148: + case 126: + case 147: + case 164: + return !0; + } + return !1; + } + function ED(e) { + return !!(kx(e) & 31); + } + function Uj(e) { + return ED(e) || e === 126 || e === 164 || e === 129; + } + function Zs(e) { + return Ey(e.kind); + } + function r_(e) { + const t = e.kind; + return t === 167 || t === 80; + } + function qc(e) { + const t = e.kind; + return t === 80 || t === 81 || t === 11 || t === 9 || t === 168; + } + function rS(e) { + const t = e.kind; + return t === 80 || t === 207 || t === 208; + } + function Es(e) { + return !!e && sx(e.kind); + } + function IC(e) { + return !!e && (sx(e.kind) || kc(e)); + } + function io(e) { + return e && dhe(e.kind); + } + function DD(e) { + return e.kind === 112 || e.kind === 97; + } + function dhe(e) { + switch (e) { + case 263: + case 175: + case 177: + case 178: + case 179: + case 219: + case 220: + return !0; + default: + return !1; + } + } + function sx(e) { + switch (e) { + case 174: + case 180: + case 324: + case 181: + case 182: + case 185: + case 318: + case 186: + return !0; + default: + return dhe(e); + } + } + function Vj(e) { + return Di(e) || vm(e) || Ns(e) && Es(e.parent); + } + function Hc(e) { + const t = e.kind; + return t === 177 || t === 173 || t === 175 || t === 178 || t === 179 || t === 182 || t === 176 || t === 241; + } + function $n(e) { + return e && (e.kind === 264 || e.kind === 232); + } + function Dy(e) { + return e && (e.kind === 178 || e.kind === 179); + } + function b_(e) { + return os(e) && fm(e); + } + function kZ(e) { + return an(e) && Mx(e) ? (!Ib(e) || !jy(e.expression)) && !_S( + e, + /*excludeThisKeyword*/ + !0 + ) : e.parent && $n(e.parent) && os(e) && !fm(e); + } + function ax(e) { + switch (e.kind) { + case 175: + case 178: + case 179: + return !0; + default: + return !1; + } + } + function Jo(e) { + return Zs(e) || ul(e); + } + function kb(e) { + const t = e.kind; + return t === 181 || t === 180 || t === 172 || t === 174 || t === 182 || t === 178 || t === 179 || t === 355; + } + function D7(e) { + return kb(e) || Hc(e); + } + function vh(e) { + const t = e.kind; + return t === 304 || t === 305 || t === 306 || t === 175 || t === 178 || t === 179; + } + function li(e) { + return yJ(e.kind); + } + function CZ(e) { + switch (e.kind) { + case 185: + case 186: + return !0; + } + return !1; + } + function ws(e) { + if (e) { + const t = e.kind; + return t === 208 || t === 207; + } + return !1; + } + function wD(e) { + const t = e.kind; + return t === 210 || t === 211; + } + function w7(e) { + const t = e.kind; + return t === 209 || t === 233; + } + function c3(e) { + switch (e.kind) { + case 261: + case 170: + case 209: + return !0; + } + return !1; + } + function EZ(e) { + return ei(e) || Ii(e) || u3(e) || _3(e); + } + function l3(e) { + return qj(e) || Hj(e); + } + function qj(e) { + switch (e.kind) { + case 207: + case 211: + return !0; + } + return !1; + } + function u3(e) { + switch (e.kind) { + case 209: + case 304: + // AssignmentProperty + case 305: + // AssignmentProperty + case 306: + return !0; + } + return !1; + } + function Hj(e) { + switch (e.kind) { + case 208: + case 210: + return !0; + } + return !1; + } + function _3(e) { + switch (e.kind) { + case 209: + case 233: + // Elision + case 231: + // AssignmentRestElement + case 210: + // ArrayAssignmentPattern + case 211: + // ObjectAssignmentPattern + case 80: + // DestructuringAssignmentTarget + case 212: + // DestructuringAssignmentTarget + case 213: + return !0; + } + return Nl( + e, + /*excludeCompoundAssignment*/ + !0 + ); + } + function DZ(e) { + const t = e.kind; + return t === 212 || t === 167 || t === 206; + } + function f3(e) { + const t = e.kind; + return t === 212 || t === 167; + } + function Gj(e) { + return Cb(e) || zy(e); + } + function Cb(e) { + switch (e.kind) { + case 214: + case 215: + case 216: + case 171: + case 287: + case 286: + case 290: + return !0; + case 227: + return e.operatorToken.kind === 104; + default: + return !1; + } + } + function sm(e) { + return e.kind === 214 || e.kind === 215; + } + function ox(e) { + const t = e.kind; + return t === 229 || t === 15; + } + function S_(e) { + return mhe(id(e).kind); + } + function mhe(e) { + switch (e) { + case 212: + case 213: + case 215: + case 214: + case 285: + case 286: + case 289: + case 216: + case 210: + case 218: + case 211: + case 232: + case 219: + case 80: + case 81: + // technically this is only an Expression if it's in a `#field in expr` BinaryExpression + case 14: + case 9: + case 10: + case 11: + case 15: + case 229: + case 97: + case 106: + case 110: + case 112: + case 108: + case 236: + case 234: + case 237: + case 102: + // technically this is only an Expression if it's in a CallExpression + case 283: + return !0; + default: + return !1; + } + } + function $j(e) { + return ghe(id(e).kind); + } + function ghe(e) { + switch (e) { + case 225: + case 226: + case 221: + case 222: + case 223: + case 224: + case 217: + return !0; + default: + return mhe(e); + } + } + function wZ(e) { + switch (e.kind) { + case 226: + return !0; + case 225: + return e.operator === 46 || e.operator === 47; + default: + return !1; + } + } + function PZ(e) { + switch (e.kind) { + case 106: + case 112: + case 97: + case 225: + return !0; + default: + return eS(e); + } + } + function ut(e) { + return eOe(id(e).kind); + } + function eOe(e) { + switch (e) { + case 228: + case 230: + case 220: + case 227: + case 231: + case 235: + case 233: + case 357: + case 356: + case 239: + return !0; + default: + return ghe(e); + } + } + function Eb(e) { + const t = e.kind; + return t === 217 || t === 235; + } + function wy(e, t) { + switch (e.kind) { + case 249: + case 250: + case 251: + case 247: + case 248: + return !0; + case 257: + return t && wy(e.statement, t); + } + return !1; + } + function tOe(e) { + return Mo(e) || Bc(e); + } + function NZ(e) { + return ot(e, tOe); + } + function P7(e) { + return !T3(e) && !Mo(e) && !Gn( + e, + 32 + /* Export */ + ) && !Vu(e); + } + function p3(e) { + return T3(e) || Mo(e) || Gn( + e, + 32 + /* Export */ + ); + } + function nS(e) { + return e.kind === 250 || e.kind === 251; + } + function N7(e) { + return Ns(e) || ut(e); + } + function Xj(e) { + return Ns(e); + } + function ip(e) { + return Ul(e) || ut(e); + } + function AZ(e) { + const t = e.kind; + return t === 269 || t === 268 || t === 80; + } + function hhe(e) { + const t = e.kind; + return t === 269 || t === 268; + } + function yhe(e) { + const t = e.kind; + return t === 80 || t === 268; + } + function Qj(e) { + const t = e.kind; + return t === 276 || t === 275; + } + function d3(e) { + return e.kind === 268 || e.kind === 267; + } + function Ed(e) { + switch (e.kind) { + case 220: + case 227: + case 209: + case 214: + case 180: + case 264: + case 232: + case 176: + case 177: + case 186: + case 181: + case 213: + case 267: + case 307: + case 278: + case 279: + case 282: + case 263: + case 219: + case 185: + case 178: + case 80: + case 274: + case 272: + case 277: + case 182: + case 265: + case 339: + case 341: + case 318: + case 342: + case 349: + case 324: + case 347: + case 323: + case 292: + case 293: + case 294: + case 201: + case 175: + case 174: + case 268: + case 203: + case 281: + case 271: + case 275: + case 215: + case 15: + case 9: + case 211: + case 170: + case 212: + case 304: + case 173: + case 172: + case 179: + case 305: + case 308: + case 306: + case 11: + case 266: + case 188: + case 169: + case 261: + return !0; + default: + return !1; + } + } + function qm(e) { + switch (e.kind) { + case 220: + case 242: + case 180: + case 270: + case 300: + case 176: + case 195: + case 177: + case 186: + case 181: + case 249: + case 250: + case 251: + case 263: + case 219: + case 185: + case 178: + case 182: + case 339: + case 341: + case 318: + case 324: + case 347: + case 201: + case 175: + case 174: + case 268: + case 179: + case 308: + case 266: + return !0; + default: + return !1; + } + } + function rOe(e) { + return e === 220 || e === 209 || e === 264 || e === 232 || e === 176 || e === 177 || e === 267 || e === 307 || e === 282 || e === 263 || e === 219 || e === 178 || e === 274 || e === 272 || e === 277 || e === 265 || e === 292 || e === 175 || e === 174 || e === 268 || e === 271 || e === 275 || e === 281 || e === 170 || e === 304 || e === 173 || e === 172 || e === 179 || e === 305 || e === 266 || e === 169 || e === 261 || e === 347 || e === 339 || e === 349 || e === 203; + } + function IZ(e) { + return e === 263 || e === 283 || e === 264 || e === 265 || e === 266 || e === 267 || e === 268 || e === 273 || e === 272 || e === 279 || e === 278 || e === 271; + } + function FZ(e) { + return e === 253 || e === 252 || e === 260 || e === 247 || e === 245 || e === 243 || e === 250 || e === 251 || e === 249 || e === 246 || e === 257 || e === 254 || e === 256 || e === 258 || e === 259 || e === 244 || e === 248 || e === 255 || e === 354; + } + function Pl(e) { + return e.kind === 169 ? e.parent && e.parent.kind !== 346 || an(e) : rOe(e.kind); + } + function OZ(e) { + return IZ(e.kind); + } + function m3(e) { + return FZ(e.kind); + } + function Ti(e) { + const t = e.kind; + return FZ(t) || IZ(t) || nOe(e); + } + function nOe(e) { + return e.kind !== 242 || e.parent !== void 0 && (e.parent.kind === 259 || e.parent.kind === 300) ? !1 : !Nb(e); + } + function LZ(e) { + const t = e.kind; + return FZ(t) || IZ(t) || t === 242; + } + function MZ(e) { + const t = e.kind; + return t === 284 || t === 167 || t === 80; + } + function PD(e) { + const t = e.kind; + return t === 110 || t === 80 || t === 212 || t === 296; + } + function g3(e) { + const t = e.kind; + return t === 285 || t === 295 || t === 286 || t === 12 || t === 289; + } + function A7(e) { + const t = e.kind; + return t === 292 || t === 294; + } + function RZ(e) { + const t = e.kind; + return t === 11 || t === 295; + } + function wu(e) { + const t = e.kind; + return t === 287 || t === 286; + } + function jZ(e) { + const t = e.kind; + return t === 287 || t === 286 || t === 290; + } + function I7(e) { + const t = e.kind; + return t === 297 || t === 298; + } + function FC(e) { + return e.kind >= 310 && e.kind <= 352; + } + function F7(e) { + return e.kind === 321 || e.kind === 320 || e.kind === 322 || cx(e) || OC(e) || AS(e) || w0(e); + } + function OC(e) { + return e.kind >= 328 && e.kind <= 352; + } + function am(e) { + return e.kind === 179; + } + function Pg(e) { + return e.kind === 178; + } + function kf(e) { + if (!H3(e)) return !1; + const { jsDoc: t } = e; + return !!t && t.length > 0; + } + function O7(e) { + return !!e.type; + } + function d0(e) { + return !!e.initializer; + } + function iS(e) { + switch (e.kind) { + case 261: + case 170: + case 209: + case 173: + case 304: + case 307: + return !0; + default: + return !1; + } + } + function Yj(e) { + return e.kind === 292 || e.kind === 294 || vh(e); + } + function L7(e) { + return e.kind === 184 || e.kind === 234; + } + var vhe = 1073741823; + function BZ(e) { + let t = vhe; + for (const n of e) { + if (!n.length) + continue; + let i = 0; + for (; i < n.length && i < t && Cg(n.charCodeAt(i)); i++) + ; + if (i < t && (t = i), t === 0) + return 0; + } + return t === vhe ? void 0 : t; + } + function ja(e) { + return e.kind === 11 || e.kind === 15; + } + function cx(e) { + return e.kind === 325 || e.kind === 326 || e.kind === 327; + } + function Zj(e) { + const t = Do(e.parameters); + return !!t && Hm(t); + } + function Hm(e) { + const t = Lf(e) ? e.typeExpression && e.typeExpression.type : e.type; + return e.dotDotDotToken !== void 0 || !!t && t.kind === 319; + } + function bhe(e, t) { + return t.text.substring(e.pos, e.end).includes("@internal"); + } + function JZ(e, t) { + t ?? (t = xr(e)); + const n = vs(e); + if (n && n.kind === 170) { + const s = n.parent.parameters.indexOf(n), o = s > 0 ? n.parent.parameters[s - 1] : void 0, c = t.text, _ = o ? Bi( + // to handle + // ... parameters, /** @internal */ + // public param: string + Sy(c, oa( + c, + o.end + 1, + /*stopAfterLineBreak*/ + !1, + /*stopAtComments*/ + !0 + )), + Eg(c, e.pos) + ) : Sy(c, oa( + c, + e.pos, + /*stopAfterLineBreak*/ + !1, + /*stopAtComments*/ + !0 + )); + return ot(_) && bhe(pa(_), t); + } + const i = n && vB(n, t); + return !!lr(i, (s) => bhe(s, t)); + } + var Kj = [], Py = "tslib", ND = 160, eB = 1e6, zZ = 500; + function Oo(e, t) { + const n = e.declarations; + if (n) { + for (const i of n) + if (i.kind === t) + return i; + } + } + function WZ(e, t) { + return kn(e.declarations || Ge, (n) => n.kind === t); + } + function Bs(e) { + const t = /* @__PURE__ */ new Map(); + if (e) + for (const n of e) + t.set(n.escapedName, n); + return t; + } + function Ng(e) { + return (e.flags & 33554432) !== 0; + } + function lx(e) { + return !!(e.flags & 1536) && e.escapedName.charCodeAt(0) === 34; + } + var M7 = iOe(); + function iOe() { + var e = ""; + const t = (n) => e += n; + return { + getText: () => e, + write: t, + rawWrite: t, + writeKeyword: t, + writeOperator: t, + writePunctuation: t, + writeSpace: t, + writeStringLiteral: t, + writeLiteral: t, + writeParameter: t, + writeProperty: t, + writeSymbol: (n, i) => t(n), + writeTrailingSemicolon: t, + writeComment: t, + getTextPos: () => e.length, + getLine: () => 0, + getColumn: () => 0, + getIndent: () => 0, + isAtStartOfLine: () => !1, + hasTrailingComment: () => !1, + hasTrailingWhitespace: () => !!e.length && Cg(e.charCodeAt(e.length - 1)), + // Completely ignore indentation for string writers. And map newlines to + // a single space. + writeLine: () => e += " ", + increaseIndent: Ha, + decreaseIndent: Ha, + clear: () => e = "" + }; + } + function R7(e, t) { + return e.configFilePath !== t.configFilePath || sOe(e, t); + } + function sOe(e, t) { + return ux(e, t, Xz); + } + function UZ(e, t) { + return ux(e, t, Are); + } + function ux(e, t, n) { + return e !== t && n.some((i) => !iF(H5(e, i), H5(t, i))); + } + function VZ(e, t) { + for (; ; ) { + const n = t(e); + if (n === "quit") return; + if (n !== void 0) return n; + if (Di(e)) return; + e = e.parent; + } + } + function hl(e, t) { + const n = e.entries(); + for (const [i, s] of n) { + const o = t(s, i); + if (o) + return o; + } + } + function Ag(e, t) { + const n = e.keys(); + for (const i of n) { + const s = t(i); + if (s) + return s; + } + } + function j7(e, t) { + e.forEach((n, i) => { + t.set(i, n); + }); + } + function LC(e) { + const t = M7.getText(); + try { + return e(M7), M7.getText(); + } finally { + M7.clear(), M7.writeKeyword(t); + } + } + function h3(e) { + return e.end - e.pos; + } + function tB(e, t) { + return e.path === t.path && !e.prepend == !t.prepend && !e.circular == !t.circular; + } + function qZ(e, t) { + return e === t || e.resolvedModule === t.resolvedModule || !!e.resolvedModule && !!t.resolvedModule && e.resolvedModule.isExternalLibraryImport === t.resolvedModule.isExternalLibraryImport && e.resolvedModule.extension === t.resolvedModule.extension && e.resolvedModule.resolvedFileName === t.resolvedModule.resolvedFileName && e.resolvedModule.originalPath === t.resolvedModule.originalPath && aOe(e.resolvedModule.packageId, t.resolvedModule.packageId) && e.alternateResult === t.alternateResult; + } + function _x(e) { + return e.resolvedModule; + } + function B7(e) { + return e.resolvedTypeReferenceDirective; + } + function J7(e, t, n, i, s) { + var o; + const c = (o = t.getResolvedModule(e, n, i)) == null ? void 0 : o.alternateResult, _ = c && (Pu(t.getCompilerOptions()) === 2 ? [p.There_are_types_at_0_but_this_result_could_not_be_resolved_under_your_current_moduleResolution_setting_Consider_updating_to_node16_nodenext_or_bundler, [c]] : [ + p.There_are_types_at_0_but_this_result_could_not_be_resolved_when_respecting_package_json_exports_The_1_library_may_need_to_update_its_package_json_or_typings, + [c, c.includes(qg + "@types/") ? `@types/${F6(s)}` : s] + ]), u = _ ? Ts( + /*details*/ + void 0, + _[0], + ..._[1] + ) : t.typesPackageExists(s) ? Ts( + /*details*/ + void 0, + p.If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1, + s, + F6(s) + ) : t.packageBundlesTypes(s) ? Ts( + /*details*/ + void 0, + p.If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_declare_module_1, + s, + n + ) : Ts( + /*details*/ + void 0, + p.Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0, + n, + F6(s) + ); + return u && (u.repopulateInfo = () => ({ moduleReference: n, mode: i, packageName: s === n ? void 0 : s })), u; + } + function rB(e) { + const t = Jg(e.fileName), n = e.packageJsonScope, i = t === ".ts" ? ".mts" : t === ".js" ? ".mjs" : void 0, s = n && !n.contents.packageJsonContent.type ? i ? Ts( + /*details*/ + void 0, + p.To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Colon_module_to_1, + i, + On(n.packageDirectory, "package.json") + ) : Ts( + /*details*/ + void 0, + p.To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0, + On(n.packageDirectory, "package.json") + ) : i ? Ts( + /*details*/ + void 0, + p.To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_package_json_file_with_type_Colon_module, + i + ) : Ts( + /*details*/ + void 0, + p.To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module + ); + return s.repopulateInfo = () => !0, s; + } + function aOe(e, t) { + return e === t || !!e && !!t && e.name === t.name && e.subModuleName === t.subModuleName && e.version === t.version && e.peerDependencies === t.peerDependencies; + } + function z7({ name: e, subModuleName: t }) { + return t ? `${e}/${t}` : e; + } + function U1(e) { + return `${z7(e)}@${e.version}${e.peerDependencies ?? ""}`; + } + function HZ(e, t) { + return e === t || e.resolvedTypeReferenceDirective === t.resolvedTypeReferenceDirective || !!e.resolvedTypeReferenceDirective && !!t.resolvedTypeReferenceDirective && e.resolvedTypeReferenceDirective.resolvedFileName === t.resolvedTypeReferenceDirective.resolvedFileName && !!e.resolvedTypeReferenceDirective.primary == !!t.resolvedTypeReferenceDirective.primary && e.resolvedTypeReferenceDirective.originalPath === t.resolvedTypeReferenceDirective.originalPath; + } + function nB(e, t, n, i) { + E.assert(e.length === t.length); + for (let s = 0; s < e.length; s++) { + const o = t[s], c = e[s], _ = n(c); + if (_ ? !o || !i(_, o) : o) + return !0; + } + return !1; + } + function fx(e) { + return oOe(e), (e.flags & 1048576) !== 0; + } + function oOe(e) { + e.flags & 2097152 || (((e.flags & 262144) !== 0 || xs(e, fx)) && (e.flags |= 1048576), e.flags |= 2097152); + } + function xr(e) { + for (; e && e.kind !== 308; ) + e = e.parent; + return e; + } + function y3(e) { + return xr(e.valueDeclaration || fB(e)); + } + function AD(e, t) { + return !!e && (e.scriptKind === 1 || e.scriptKind === 2) && !e.checkJsDirective && t === void 0; + } + function GZ(e) { + switch (e.kind) { + case 242: + case 270: + case 249: + case 250: + case 251: + return !0; + } + return !1; + } + function Ny(e, t) { + return E.assert(e >= 0), kg(t)[e]; + } + function She(e) { + const t = xr(e), n = js(t, e.pos); + return `${t.fileName}(${n.line + 1},${n.character + 1})`; + } + function v3(e, t) { + E.assert(e >= 0); + const n = kg(t), i = e, s = t.text; + if (i + 1 === n.length) + return s.length - 1; + { + const o = n[i]; + let c = n[i + 1] - 1; + for (E.assert(Cu(s.charCodeAt(c))); o <= c && Cu(s.charCodeAt(c)); ) + c--; + return c; + } + } + function W7(e, t, n) { + return !(n && n(t)) && !e.identifiers.has(t); + } + function lc(e) { + return e === void 0 ? !0 : e.pos === e.end && e.pos >= 0 && e.kind !== 1; + } + function Mp(e) { + return !lc(e); + } + function $Z(e, t) { + return Lo(e) ? t === e.expression : kc(e) ? t === e.modifiers : $u(e) ? t === e.initializer : os(e) ? t === e.questionToken && b_(e) : rl(e) ? t === e.modifiers || t === e.questionToken || t === e.exclamationToken || b3(e.modifiers, t, Jo) : gu(e) ? t === e.equalsToken || t === e.modifiers || t === e.questionToken || t === e.exclamationToken || b3(e.modifiers, t, Jo) : rc(e) ? t === e.exclamationToken : nc(e) ? t === e.typeParameters || t === e.type || b3(e.typeParameters, t, Lo) : pp(e) ? t === e.typeParameters || b3(e.typeParameters, t, Lo) : z_(e) ? t === e.typeParameters || t === e.type || b3(e.typeParameters, t, Lo) : zN(e) ? t === e.modifiers || b3(e.modifiers, t, Jo) : !1; + } + function b3(e, t, n) { + return !e || as(t) || !n(t) ? !1 : ms(e, t); + } + function The(e, t, n) { + if (t === void 0 || t.length === 0) return e; + let i = 0; + for (; i < e.length && n(e[i]); ++i) + ; + return e.splice(i, 0, ...t), e; + } + function xhe(e, t, n) { + if (t === void 0) return e; + let i = 0; + for (; i < e.length && n(e[i]); ++i) + ; + return e.splice(i, 0, t), e; + } + function khe(e) { + return cm(e) || !!(Ea(e) & 2097152); + } + function Ig(e, t) { + return The(e, t, cm); + } + function iB(e, t) { + return The(e, t, khe); + } + function Che(e, t) { + return xhe(e, t, cm); + } + function sS(e, t) { + return xhe(e, t, khe); + } + function sB(e, t, n) { + if (e.charCodeAt(t + 1) === 47 && t + 2 < n && e.charCodeAt(t + 2) === 47) { + const i = e.substring(t, n); + return !!(gOe.test(i) || vOe.test(i) || bOe.test(i) || hOe.test(i) || yOe.test(i) || SOe.test(i)); + } + return !1; + } + function U7(e, t) { + return e.charCodeAt(t + 1) === 42 && e.charCodeAt(t + 2) === 33; + } + function XZ(e, t) { + const n = new Map( + t.map((c) => [ + `${js(e, c.range.end).line}`, + c + ]) + ), i = /* @__PURE__ */ new Map(); + return { getUnusedExpectations: s, markUsed: o }; + function s() { + return is(n.entries()).filter(([c, _]) => _.type === 0 && !i.get(c)).map(([c, _]) => _); + } + function o(c) { + return n.has(`${c}`) ? (i.set(`${c}`, !0), !0) : !1; + } + } + function Ay(e, t, n) { + if (lc(e)) + return e.pos; + if (FC(e) || e.kind === 12) + return oa( + (t ?? xr(e)).text, + e.pos, + /*stopAfterLineBreak*/ + !1, + /*stopAtComments*/ + !0 + ); + if (n && kf(e)) + return Ay(e.jsDoc[0], t); + if (e.kind === 353) { + t ?? (t = xr(e)); + const i = Yc(wz(e, t)); + if (i) + return Ay(i, t, n); + } + return oa( + (t ?? xr(e)).text, + e.pos, + /*stopAfterLineBreak*/ + !1, + /*stopAtComments*/ + !1, + BD(e) + ); + } + function aB(e, t) { + const n = !lc(e) && Vp(e) ? gb(e.modifiers, ul) : void 0; + return n ? oa((t || xr(e)).text, n.end) : Ay(e, t); + } + function QZ(e, t) { + const n = !lc(e) && Vp(e) && e.modifiers ? pa(e.modifiers) : void 0; + return n ? oa((t || xr(e)).text, n.end) : Ay(e, t); + } + function Db(e, t, n = !1) { + return ID(e.text, t, n); + } + function cOe(e) { + return !!dr(e, lv); + } + function V7(e) { + return !!(Bc(e) && e.exportClause && Km(e.exportClause) && Gm(e.exportClause.name)); + } + function Iy(e) { + return e.kind === 11 ? e.text : Si(e.escapedText); + } + function wb(e) { + return e.kind === 11 ? tc(e.text) : e.escapedText; + } + function Gm(e) { + return (e.kind === 11 ? e.text : e.escapedText) === "default"; + } + function ID(e, t, n = !1) { + if (lc(t)) + return ""; + let i = e.substring(n ? t.pos : oa(e, t.pos), t.end); + return cOe(t) && (i = i.split(/\r\n|\n|\r/).map((s) => s.replace(/^\s*\*/, "").trimStart()).join(` +`)), i; + } + function Qo(e, t = !1) { + return Db(xr(e), e, t); + } + function lOe(e) { + return e.pos; + } + function MC(e, t) { + return py(e, t, lOe, ho); + } + function Ea(e) { + const t = e.emitNode; + return t && t.flags || 0; + } + function sd(e) { + const t = e.emitNode; + return t && t.internalFlags || 0; + } + var oB = /* @__PURE__ */ Uu( + () => new Map(Object.entries({ + Array: new Map(Object.entries({ + es2015: [ + "find", + "findIndex", + "fill", + "copyWithin", + "entries", + "keys", + "values" + ], + es2016: [ + "includes" + ], + es2019: [ + "flat", + "flatMap" + ], + es2022: [ + "at" + ], + es2023: [ + "findLastIndex", + "findLast", + "toReversed", + "toSorted", + "toSpliced", + "with" + ] + })), + Iterator: new Map(Object.entries({ + es2015: Ge + })), + AsyncIterator: new Map(Object.entries({ + es2015: Ge + })), + ArrayBuffer: new Map(Object.entries({ + es2024: [ + "maxByteLength", + "resizable", + "resize", + "detached", + "transfer", + "transferToFixedLength" + ] + })), + Atomics: new Map(Object.entries({ + es2017: [ + "add", + "and", + "compareExchange", + "exchange", + "isLockFree", + "load", + "or", + "store", + "sub", + "wait", + "notify", + "xor" + ], + es2024: [ + "waitAsync" + ], + esnext: [ + "pause" + ] + })), + SharedArrayBuffer: new Map(Object.entries({ + es2017: [ + "byteLength", + "slice" + ], + es2024: [ + "growable", + "maxByteLength", + "grow" + ] + })), + AsyncIterable: new Map(Object.entries({ + es2018: Ge + })), + AsyncIterableIterator: new Map(Object.entries({ + es2018: Ge + })), + AsyncGenerator: new Map(Object.entries({ + es2018: Ge + })), + AsyncGeneratorFunction: new Map(Object.entries({ + es2018: Ge + })), + RegExp: new Map(Object.entries({ + es2015: [ + "flags", + "sticky", + "unicode" + ], + es2018: [ + "dotAll" + ], + es2024: [ + "unicodeSets" + ] + })), + Reflect: new Map(Object.entries({ + es2015: [ + "apply", + "construct", + "defineProperty", + "deleteProperty", + "get", + "getOwnPropertyDescriptor", + "getPrototypeOf", + "has", + "isExtensible", + "ownKeys", + "preventExtensions", + "set", + "setPrototypeOf" + ] + })), + ArrayConstructor: new Map(Object.entries({ + es2015: [ + "from", + "of" + ], + esnext: [ + "fromAsync" + ] + })), + ObjectConstructor: new Map(Object.entries({ + es2015: [ + "assign", + "getOwnPropertySymbols", + "keys", + "is", + "setPrototypeOf" + ], + es2017: [ + "values", + "entries", + "getOwnPropertyDescriptors" + ], + es2019: [ + "fromEntries" + ], + es2022: [ + "hasOwn" + ], + es2024: [ + "groupBy" + ] + })), + NumberConstructor: new Map(Object.entries({ + es2015: [ + "isFinite", + "isInteger", + "isNaN", + "isSafeInteger", + "parseFloat", + "parseInt" + ] + })), + Math: new Map(Object.entries({ + es2015: [ + "clz32", + "imul", + "sign", + "log10", + "log2", + "log1p", + "expm1", + "cosh", + "sinh", + "tanh", + "acosh", + "asinh", + "atanh", + "hypot", + "trunc", + "fround", + "cbrt" + ], + esnext: [ + "f16round" + ] + })), + Map: new Map(Object.entries({ + es2015: [ + "entries", + "keys", + "values" + ] + })), + MapConstructor: new Map(Object.entries({ + es2024: [ + "groupBy" + ] + })), + Set: new Map(Object.entries({ + es2015: [ + "entries", + "keys", + "values" + ], + esnext: [ + "union", + "intersection", + "difference", + "symmetricDifference", + "isSubsetOf", + "isSupersetOf", + "isDisjointFrom" + ] + })), + PromiseConstructor: new Map(Object.entries({ + es2015: [ + "all", + "race", + "reject", + "resolve" + ], + es2020: [ + "allSettled" + ], + es2021: [ + "any" + ], + es2024: [ + "withResolvers" + ] + })), + Symbol: new Map(Object.entries({ + es2015: [ + "for", + "keyFor" + ], + es2019: [ + "description" + ] + })), + WeakMap: new Map(Object.entries({ + es2015: [ + "entries", + "keys", + "values" + ] + })), + WeakSet: new Map(Object.entries({ + es2015: [ + "entries", + "keys", + "values" + ] + })), + String: new Map(Object.entries({ + es2015: [ + "codePointAt", + "includes", + "endsWith", + "normalize", + "repeat", + "startsWith", + "anchor", + "big", + "blink", + "bold", + "fixed", + "fontcolor", + "fontsize", + "italics", + "link", + "small", + "strike", + "sub", + "sup" + ], + es2017: [ + "padStart", + "padEnd" + ], + es2019: [ + "trimStart", + "trimEnd", + "trimLeft", + "trimRight" + ], + es2020: [ + "matchAll" + ], + es2021: [ + "replaceAll" + ], + es2022: [ + "at" + ], + es2024: [ + "isWellFormed", + "toWellFormed" + ] + })), + StringConstructor: new Map(Object.entries({ + es2015: [ + "fromCodePoint", + "raw" + ] + })), + DateTimeFormat: new Map(Object.entries({ + es2017: [ + "formatToParts" + ] + })), + Promise: new Map(Object.entries({ + es2015: Ge, + es2018: [ + "finally" + ] + })), + RegExpMatchArray: new Map(Object.entries({ + es2018: [ + "groups" + ] + })), + RegExpExecArray: new Map(Object.entries({ + es2018: [ + "groups" + ] + })), + Intl: new Map(Object.entries({ + es2018: [ + "PluralRules" + ] + })), + NumberFormat: new Map(Object.entries({ + es2018: [ + "formatToParts" + ] + })), + SymbolConstructor: new Map(Object.entries({ + es2020: [ + "matchAll" + ], + esnext: [ + "metadata", + "dispose", + "asyncDispose" + ] + })), + DataView: new Map(Object.entries({ + es2020: [ + "setBigInt64", + "setBigUint64", + "getBigInt64", + "getBigUint64" + ], + esnext: [ + "setFloat16", + "getFloat16" + ] + })), + BigInt: new Map(Object.entries({ + es2020: Ge + })), + RelativeTimeFormat: new Map(Object.entries({ + es2020: [ + "format", + "formatToParts", + "resolvedOptions" + ] + })), + Int8Array: new Map(Object.entries({ + es2022: [ + "at" + ], + es2023: [ + "findLastIndex", + "findLast", + "toReversed", + "toSorted", + "toSpliced", + "with" + ] + })), + Uint8Array: new Map(Object.entries({ + es2022: [ + "at" + ], + es2023: [ + "findLastIndex", + "findLast", + "toReversed", + "toSorted", + "toSpliced", + "with" + ] + })), + Uint8ClampedArray: new Map(Object.entries({ + es2022: [ + "at" + ], + es2023: [ + "findLastIndex", + "findLast", + "toReversed", + "toSorted", + "toSpliced", + "with" + ] + })), + Int16Array: new Map(Object.entries({ + es2022: [ + "at" + ], + es2023: [ + "findLastIndex", + "findLast", + "toReversed", + "toSorted", + "toSpliced", + "with" + ] + })), + Uint16Array: new Map(Object.entries({ + es2022: [ + "at" + ], + es2023: [ + "findLastIndex", + "findLast", + "toReversed", + "toSorted", + "toSpliced", + "with" + ] + })), + Int32Array: new Map(Object.entries({ + es2022: [ + "at" + ], + es2023: [ + "findLastIndex", + "findLast", + "toReversed", + "toSorted", + "toSpliced", + "with" + ] + })), + Uint32Array: new Map(Object.entries({ + es2022: [ + "at" + ], + es2023: [ + "findLastIndex", + "findLast", + "toReversed", + "toSorted", + "toSpliced", + "with" + ] + })), + Float16Array: new Map(Object.entries({ + esnext: Ge + })), + Float32Array: new Map(Object.entries({ + es2022: [ + "at" + ], + es2023: [ + "findLastIndex", + "findLast", + "toReversed", + "toSorted", + "toSpliced", + "with" + ] + })), + Float64Array: new Map(Object.entries({ + es2022: [ + "at" + ], + es2023: [ + "findLastIndex", + "findLast", + "toReversed", + "toSorted", + "toSpliced", + "with" + ] + })), + BigInt64Array: new Map(Object.entries({ + es2020: Ge, + es2022: [ + "at" + ], + es2023: [ + "findLastIndex", + "findLast", + "toReversed", + "toSorted", + "toSpliced", + "with" + ] + })), + BigUint64Array: new Map(Object.entries({ + es2020: Ge, + es2022: [ + "at" + ], + es2023: [ + "findLastIndex", + "findLast", + "toReversed", + "toSorted", + "toSpliced", + "with" + ] + })), + Error: new Map(Object.entries({ + es2022: [ + "cause" + ] + })) + })) + ), YZ = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.NeverAsciiEscape = 1] = "NeverAsciiEscape", e[e.JsxAttributeEscape = 2] = "JsxAttributeEscape", e[e.TerminateUnterminatedLiterals = 4] = "TerminateUnterminatedLiterals", e[e.AllowNumericSeparator = 8] = "AllowNumericSeparator", e))(YZ || {}); + function ZZ(e, t, n) { + if (t && uOe(e, n)) + return Db(t, e); + switch (e.kind) { + case 11: { + const i = n & 2 ? GB : n & 1 || Ea(e) & 16777216 ? Ym : S5; + return e.singleQuote ? "'" + i( + e.text, + 39 + /* singleQuote */ + ) + "'" : '"' + i( + e.text, + 34 + /* doubleQuote */ + ) + '"'; + } + case 15: + case 16: + case 17: + case 18: { + const i = n & 1 || Ea(e) & 16777216 ? Ym : S5, s = e.rawText ?? qB(i( + e.text, + 96 + /* backtick */ + )); + switch (e.kind) { + case 15: + return "`" + s + "`"; + case 16: + return "`" + s + "${"; + case 17: + return "}" + s + "${"; + case 18: + return "}" + s + "`"; + } + break; + } + case 9: + case 10: + return e.text; + case 14: + return n & 4 && e.isUnterminated ? e.text + (e.text.charCodeAt(e.text.length - 1) === 92 ? " /" : "/") : e.text; + } + return E.fail(`Literal kind '${e.kind}' not accounted for.`); + } + function uOe(e, t) { + if (lo(e) || !e.parent || t & 4 && e.isUnterminated) + return !1; + if (E_(e)) { + if (e.numericLiteralFlags & 26656) + return !1; + if (e.numericLiteralFlags & 512) + return !!(t & 8); + } + return !u6(e); + } + function KZ(e) { + return gs(e) ? `"${Ym(e)}"` : "" + e; + } + function eK(e) { + return Zc(e).replace(/^(\d)/, "_$1").replace(/\W/g, "_"); + } + function cB(e) { + return (yh(e) & 7) !== 0 || lB(e); + } + function lB(e) { + const t = _m(e); + return t.kind === 261 && t.parent.kind === 300; + } + function Vu(e) { + return jc(e) && (e.name.kind === 11 || $m(e)); + } + function q7(e) { + return jc(e) && e.name.kind === 11; + } + function uB(e) { + return jc(e) && ca(e.name); + } + function _Oe(e) { + return jc(e) || Me(e); + } + function S3(e) { + return fOe(e.valueDeclaration); + } + function fOe(e) { + return !!e && e.kind === 268 && !e.body; + } + function tK(e) { + return e.kind === 308 || e.kind === 268 || IC(e); + } + function $m(e) { + return !!(e.flags & 2048); + } + function Pb(e) { + return Vu(e) && _B(e); + } + function _B(e) { + switch (e.parent.kind) { + case 308: + return fl(e.parent); + case 269: + return Vu(e.parent.parent) && Di(e.parent.parent.parent) && !fl(e.parent.parent.parent); + } + return !1; + } + function fB(e) { + var t; + return (t = e.declarations) == null ? void 0 : t.find((n) => !Pb(n) && !(jc(n) && $m(n))); + } + function pOe(e) { + return e === 1 || 100 <= e && e <= 199; + } + function RC(e, t) { + return fl(e) || pOe(Hu(t)) && !!e.commonJsModuleIndicator; + } + function pB(e, t) { + switch (e.scriptKind) { + case 1: + case 3: + case 2: + case 4: + break; + default: + return !1; + } + return e.isDeclarationFile ? !1 : !!(du(t, "alwaysStrict") || are(e.statements) || fl(e) || zp(t)); + } + function dB(e) { + return !!(e.flags & 33554432) || Gn( + e, + 128 + /* Ambient */ + ); + } + function mB(e, t) { + switch (e.kind) { + case 308: + case 270: + case 300: + case 268: + case 249: + case 250: + case 251: + case 177: + case 175: + case 178: + case 179: + case 263: + case 219: + case 220: + case 173: + case 176: + return !0; + case 242: + return !IC(t); + } + return !1; + } + function gB(e) { + switch (E.type(e), e.kind) { + case 339: + case 347: + case 324: + return !0; + default: + return hB(e); + } + } + function hB(e) { + switch (E.type(e), e.kind) { + case 180: + case 181: + case 174: + case 182: + case 185: + case 186: + case 318: + case 264: + case 232: + case 265: + case 266: + case 346: + case 263: + case 175: + case 177: + case 178: + case 179: + case 219: + case 220: + return !0; + default: + return !1; + } + } + function px(e) { + switch (e.kind) { + case 273: + case 272: + return !0; + default: + return !1; + } + } + function rK(e) { + return px(e) || Ab(e); + } + function nK(e) { + return px(e) || M3(e); + } + function H7(e) { + switch (e.kind) { + case 273: + case 272: + case 244: + case 264: + case 263: + case 268: + case 266: + case 265: + case 267: + return !0; + default: + return !1; + } + } + function iK(e) { + return T3(e) || jc(e) || ym(e) || T_(e); + } + function T3(e) { + return px(e) || Bc(e); + } + function G7(e) { + return dr(e.parent, (t) => !!(xW(t) & 1)); + } + function Dd(e) { + return dr(e.parent, (t) => mB(t, t.parent)); + } + function sK(e, t) { + let n = Dd(e); + for (; n; ) + t(n), n = Dd(n); + } + function co(e) { + return !e || h3(e) === 0 ? "(Missing)" : Qo(e); + } + function aK(e) { + return e.declaration ? co(e.declaration.parameters[0].name) : void 0; + } + function x3(e) { + return e.kind === 168 && !If(e.expression); + } + function FD(e) { + var t; + switch (e.kind) { + case 80: + case 81: + return (t = e.emitNode) != null && t.autoGenerate ? void 0 : e.escapedText; + case 11: + case 9: + case 10: + case 15: + return tc(e.text); + case 168: + return If(e.expression) ? tc(e.expression.text) : void 0; + case 296: + return Lx(e); + default: + return E.assertNever(e); + } + } + function dx(e) { + return E.checkDefined(FD(e)); + } + function ef(e) { + switch (e.kind) { + case 110: + return "this"; + case 81: + case 80: + return h3(e) === 0 ? An(e) : Qo(e); + case 167: + return ef(e.left) + "." + ef(e.right); + case 212: + return Me(e.name) || Ai(e.name) ? ef(e.expression) + "." + ef(e.name) : E.assertNever(e.name); + case 312: + return ef(e.left) + "#" + ef(e.right); + case 296: + return ef(e.namespace) + ":" + ef(e.name); + default: + return E.assertNever(e); + } + } + function sn(e, t, ...n) { + const i = xr(e); + return sp(i, e, t, ...n); + } + function jC(e, t, n, ...i) { + const s = oa(e.text, t.pos); + return ll(e, s, t.end - s, n, ...i); + } + function sp(e, t, n, ...i) { + const s = aS(e, t); + return ll(e, s.start, s.length, n, ...i); + } + function Fg(e, t, n, i) { + const s = aS(e, t); + return $7(e, s.start, s.length, n, i); + } + function k3(e, t, n, i) { + const s = oa(e.text, t.pos); + return $7(e, s, t.end - s, n, i); + } + function oK(e, t, n) { + E.assertGreaterThanOrEqual(t, 0), E.assertGreaterThanOrEqual(n, 0), E.assertLessThanOrEqual(t, e.length), E.assertLessThanOrEqual(t + n, e.length); + } + function $7(e, t, n, i, s) { + return oK(e.text, t, n), { + file: e, + start: t, + length: n, + code: i.code, + category: i.category, + messageText: i.next ? i : i.messageText, + relatedInformation: s, + canonicalHead: i.canonicalHead + }; + } + function yB(e, t, n) { + return { + file: e, + start: 0, + length: 0, + code: t.code, + category: t.category, + messageText: t.next ? t : t.messageText, + relatedInformation: n + }; + } + function cK(e) { + return typeof e.messageText == "string" ? { + code: e.code, + category: e.category, + messageText: e.messageText, + next: e.next + } : e.messageText; + } + function lK(e, t, n) { + return { + file: e, + start: t.pos, + length: t.end - t.pos, + code: n.code, + category: n.category, + messageText: n.message + }; + } + function uK(e, ...t) { + return { + code: e.code, + messageText: Nx(e, ...t) + }; + } + function om(e, t) { + const n = Dg( + e.languageVersion, + /*skipTrivia*/ + !0, + e.languageVariant, + e.text, + /*onError*/ + void 0, + t + ); + n.scan(); + const i = n.getTokenStart(); + return Nc(i, n.getTokenEnd()); + } + function _K(e, t) { + const n = Dg( + e.languageVersion, + /*skipTrivia*/ + !0, + e.languageVariant, + e.text, + /*onError*/ + void 0, + t + ); + return n.scan(), n.getToken(); + } + function dOe(e, t) { + const n = oa(e.text, t.pos); + if (t.body && t.body.kind === 242) { + const { line: i } = js(e, t.body.pos), { line: s } = js(e, t.body.end); + if (i < s) + return Kl(n, v3(i, e) - n + 1); + } + return Nc(n, t.end); + } + function aS(e, t) { + let n = t; + switch (t.kind) { + case 308: { + const o = oa( + e.text, + 0, + /*stopAfterLineBreak*/ + !1 + ); + return o === e.text.length ? Kl(0, 0) : om(e, o); + } + // This list is a work in progress. Add missing node kinds to improve their error + // spans. + case 261: + case 209: + case 264: + case 232: + case 265: + case 268: + case 267: + case 307: + case 263: + case 219: + case 175: + case 178: + case 179: + case 266: + case 173: + case 172: + case 275: + n = t.name; + break; + case 220: + return dOe(e, t); + case 297: + case 298: { + const o = oa(e.text, t.pos), c = t.statements.length > 0 ? t.statements[0].pos : t.end; + return Nc(o, c); + } + case 254: + case 230: { + const o = oa(e.text, t.pos); + return om(e, o); + } + case 239: { + const o = oa(e.text, t.expression.end); + return om(e, o); + } + case 351: { + const o = oa(e.text, t.tagName.pos); + return om(e, o); + } + case 177: { + const o = t, c = oa(e.text, o.pos), _ = Dg( + e.languageVersion, + /*skipTrivia*/ + !0, + e.languageVariant, + e.text, + /*onError*/ + void 0, + c + ); + let u = _.scan(); + for (; u !== 137 && u !== 1; ) + u = _.scan(); + const g = _.getTokenEnd(); + return Nc(c, g); + } + } + if (n === void 0) + return om(e, t.pos); + E.assert(!Od(n)); + const i = lc(n), s = i || Bx(t) ? n.pos : oa(e.text, n.pos); + return i ? (E.assert(s === n.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809"), E.assert(s === n.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809")) : (E.assert(s >= n.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809"), E.assert(s <= n.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809")), Nc(s, n.end); + } + function m0(e) { + return e.kind === 308 && !tf(e); + } + function tf(e) { + return (e.externalModuleIndicator || e.commonJsModuleIndicator) !== void 0; + } + function ap(e) { + return e.scriptKind === 6; + } + function V1(e) { + return !!(J1(e) & 4096); + } + function C3(e) { + return !!(J1(e) & 8 && !K_(e, e.parent)); + } + function E3(e) { + return (yh(e) & 7) === 6; + } + function D3(e) { + return (yh(e) & 7) === 4; + } + function BC(e) { + return (yh(e) & 7) === 2; + } + function fK(e) { + const t = yh(e) & 7; + return t === 2 || t === 4 || t === 6; + } + function X7(e) { + return (yh(e) & 7) === 1; + } + function oS(e) { + return e.kind === 214 && e.expression.kind === 108; + } + function T_(e) { + if (e.kind !== 214) return !1; + const t = e.expression; + return t.kind === 102 || DS(t) && t.keywordToken === 102 && t.name.escapedText === "defer"; + } + function JC(e) { + return DS(e) && e.keywordToken === 102 && e.name.escapedText === "meta"; + } + function bh(e) { + return ym(e) && E0(e.argument) && ca(e.argument.literal); + } + function cm(e) { + return e.kind === 245 && e.expression.kind === 11; + } + function w3(e) { + return !!(Ea(e) & 2097152); + } + function Q7(e) { + return w3(e) && Cc(e); + } + function mOe(e) { + return Me(e.name) && !e.initializer; + } + function Y7(e) { + return w3(e) && Ic(e) && Ni(e.declarationList.declarations, mOe); + } + function vB(e, t) { + return e.kind !== 12 ? Eg(t.text, e.pos) : void 0; + } + function bB(e, t) { + const n = e.kind === 170 || e.kind === 169 || e.kind === 219 || e.kind === 220 || e.kind === 218 || e.kind === 261 || e.kind === 282 ? Bi(Sy(t, e.pos), Eg(t, e.pos)) : Eg(t, e.pos); + return kn( + n, + (i) => i.end <= e.end && // Due to parse errors sometime empty parameter may get comments assigned to it that end up not in parameter range + t.charCodeAt(i.pos + 1) === 42 && t.charCodeAt(i.pos + 2) === 42 && t.charCodeAt(i.pos + 3) !== 47 + /* slash */ + ); + } + var gOe = /^\/\/\/\s*/, hOe = /^\/\/\/\s*/, yOe = /^\/\/\/\s*/, vOe = /^\/\/\/\s*/, bOe = /^\/\/\/\s*/, SOe = /^\/\/\/\s*/; + function lm(e) { + if (183 <= e.kind && e.kind <= 206) + return !0; + switch (e.kind) { + case 133: + case 159: + case 150: + case 163: + case 154: + case 136: + case 155: + case 151: + case 157: + case 106: + case 146: + return !0; + case 116: + return e.parent.kind !== 223; + case 234: + return Ehe(e); + case 169: + return e.parent.kind === 201 || e.parent.kind === 196; + // Identifiers and qualified names may be type nodes, depending on their context. Climb + // above them to find the lowest container + case 80: + (e.parent.kind === 167 && e.parent.right === e || e.parent.kind === 212 && e.parent.name === e) && (e = e.parent), E.assert(e.kind === 80 || e.kind === 167 || e.kind === 212, "'node' was expected to be a qualified name, identifier or property access in 'isPartOfTypeNode'."); + // falls through + case 167: + case 212: + case 110: { + const { parent: t } = e; + if (t.kind === 187) + return !1; + if (t.kind === 206) + return !t.isTypeOf; + if (183 <= t.kind && t.kind <= 206) + return !0; + switch (t.kind) { + case 234: + return Ehe(t); + case 169: + return e === t.constraint; + case 346: + return e === t.constraint; + case 173: + case 172: + case 170: + case 261: + return e === t.type; + case 263: + case 219: + case 220: + case 177: + case 175: + case 174: + case 178: + case 179: + return e === t.type; + case 180: + case 181: + case 182: + return e === t.type; + case 217: + return e === t.type; + case 214: + case 215: + case 216: + return ms(t.typeArguments, e); + } + } + } + return !1; + } + function Ehe(e) { + return LF(e.parent) || Yx(e.parent) || cf(e.parent) && !I5(e); + } + function Fy(e, t) { + return n(e); + function n(i) { + switch (i.kind) { + case 254: + return t(i); + case 270: + case 242: + case 246: + case 247: + case 248: + case 249: + case 250: + case 251: + case 255: + case 256: + case 297: + case 298: + case 257: + case 259: + case 300: + return xs(i, n); + } + } + } + function pK(e, t) { + return n(e); + function n(i) { + switch (i.kind) { + case 230: + t(i); + const s = i.expression; + s && n(s); + return; + case 267: + case 265: + case 268: + case 266: + return; + default: + if (Es(i)) { + if (i.name && i.name.kind === 168) { + n(i.name.expression); + return; + } + } else lm(i) || xs(i, n); + } + } + } + function SB(e) { + return e && e.kind === 189 ? e.elementType : e && e.kind === 184 ? xg(e.typeArguments) : void 0; + } + function dK(e) { + switch (e.kind) { + case 265: + case 264: + case 232: + case 188: + return e.members; + case 211: + return e.properties; + } + } + function OD(e) { + if (e) + switch (e.kind) { + case 209: + case 307: + case 170: + case 304: + case 173: + case 172: + case 305: + case 261: + return !0; + } + return !1; + } + function LD(e) { + return e.parent.kind === 262 && e.parent.parent.kind === 244; + } + function mK(e) { + return an(e) ? _a(e.parent) && _n(e.parent.parent) && Ac(e.parent.parent) === 2 || Z7(e.parent) : !1; + } + function Z7(e) { + return an(e) ? _n(e) && Ac(e) === 1 : !1; + } + function gK(e) { + return (ei(e) ? BC(e) && Me(e.name) && LD(e) : os(e) ? gS(e) && cl(e) : $u(e) && gS(e)) || Z7(e); + } + function hK(e) { + switch (e.kind) { + case 175: + case 174: + case 177: + case 178: + case 179: + case 263: + case 219: + return !0; + } + return !1; + } + function TB(e, t) { + for (; ; ) { + if (t && t(e), e.statement.kind !== 257) + return e.statement; + e = e.statement; + } + } + function Nb(e) { + return e && e.kind === 242 && Es(e.parent); + } + function Rp(e) { + return e && e.kind === 175 && e.parent.kind === 211; + } + function K7(e) { + return (e.kind === 175 || e.kind === 178 || e.kind === 179) && (e.parent.kind === 211 || e.parent.kind === 232); + } + function yK(e) { + return e && e.kind === 1; + } + function vK(e) { + return e && e.kind === 0; + } + function zC(e, t, n, i) { + return lr(e?.properties, (s) => { + if (!rl(s)) return; + const o = FD(s.name); + return t === o || i && i === o ? n(s) : void 0; + }); + } + function MD(e) { + if (e && e.statements.length) { + const t = e.statements[0].expression; + return Bn(t, _a); + } + } + function e5(e, t, n) { + return P3(e, t, (i) => nu(i.initializer) ? Nn(i.initializer.elements, (s) => ca(s) && s.text === n) : void 0); + } + function P3(e, t, n) { + return zC(MD(e), t, n); + } + function Af(e) { + return dr(e.parent, Es); + } + function bK(e) { + return dr(e.parent, io); + } + function Wl(e) { + return dr(e.parent, $n); + } + function SK(e) { + return dr(e.parent, (t) => $n(t) || Es(t) ? "quit" : kc(t)); + } + function t5(e) { + return dr(e.parent, IC); + } + function r5(e) { + const t = dr(e.parent, (n) => $n(n) ? "quit" : ul(n)); + return t && $n(t.parent) ? Wl(t.parent) : Wl(t ?? e); + } + function qu(e, t, n) { + for (E.assert( + e.kind !== 308 + /* SourceFile */ + ); ; ) { + if (e = e.parent, !e) + return E.fail(); + switch (e.kind) { + case 168: + if (n && $n(e.parent.parent)) + return e; + e = e.parent.parent; + break; + case 171: + e.parent.kind === 170 && Hc(e.parent.parent) ? e = e.parent.parent : Hc(e.parent) && (e = e.parent); + break; + case 220: + if (!t) + continue; + // falls through + case 263: + case 219: + case 268: + case 176: + case 173: + case 172: + case 175: + case 174: + case 177: + case 178: + case 179: + case 180: + case 181: + case 182: + case 267: + case 308: + return e; + } + } + } + function TK(e) { + switch (e.kind) { + // Arrow functions use the same scope, but may do so in a "delayed" manner + // For example, `const getThis = () => this` may be before a super() call in a derived constructor + case 220: + case 263: + case 219: + case 173: + return !0; + case 242: + switch (e.parent.kind) { + case 177: + case 175: + case 178: + case 179: + return !0; + default: + return !1; + } + default: + return !1; + } + } + function n5(e) { + Me(e) && (tl(e.parent) || Cc(e.parent)) && e.parent.name === e && (e = e.parent); + const t = qu( + e, + /*includeArrowFunctions*/ + !0, + /*includeClassComputedPropertyName*/ + !1 + ); + return Di(t); + } + function xK(e) { + const t = qu( + e, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + if (t) + switch (t.kind) { + case 177: + case 263: + case 219: + return t; + } + } + function N3(e, t) { + for (; ; ) { + if (e = e.parent, !e) + return; + switch (e.kind) { + case 168: + e = e.parent; + break; + case 263: + case 219: + case 220: + if (!t) + continue; + // falls through + case 173: + case 172: + case 175: + case 174: + case 177: + case 178: + case 179: + case 176: + return e; + case 171: + e.parent.kind === 170 && Hc(e.parent.parent) ? e = e.parent.parent : Hc(e.parent) && (e = e.parent); + break; + } + } + } + function q1(e) { + if (e.kind === 219 || e.kind === 220) { + let t = e, n = e.parent; + for (; n.kind === 218; ) + t = n, n = n.parent; + if (n.kind === 214 && n.expression === t) + return n; + } + } + function j_(e) { + const t = e.kind; + return (t === 212 || t === 213) && e.expression.kind === 108; + } + function A3(e) { + const t = e.kind; + return (t === 212 || t === 213) && e.expression.kind === 110; + } + function i5(e) { + var t; + return !!e && ei(e) && ((t = e.initializer) == null ? void 0 : t.kind) === 110; + } + function kK(e) { + return !!e && (gu(e) || rl(e)) && _n(e.parent.parent) && e.parent.parent.operatorToken.kind === 64 && e.parent.parent.right.kind === 110; + } + function I3(e) { + switch (e.kind) { + case 184: + return e.typeName; + case 234: + return to(e.expression) ? e.expression : void 0; + // TODO(rbuckton): These aren't valid TypeNodes, but we treat them as such because of `isPartOfTypeNode`, which returns `true` for things that aren't `TypeNode`s. + case 80: + case 167: + return e; + } + } + function s5(e) { + switch (e.kind) { + case 216: + return e.tag; + case 287: + case 286: + return e.tagName; + case 227: + return e.right; + case 290: + return e; + default: + return e.expression; + } + } + function F3(e, t, n, i) { + if (e && wl(t) && Ai(t.name)) + return !1; + switch (t.kind) { + case 264: + return !0; + case 232: + return !e; + case 173: + return n !== void 0 && (e ? tl(n) : $n(n) && !Jb(t) && !nJ(t)); + case 178: + case 179: + case 175: + return t.body !== void 0 && n !== void 0 && (e ? tl(n) : $n(n)); + case 170: + return e ? n !== void 0 && n.body !== void 0 && (n.kind === 177 || n.kind === 175 || n.kind === 179) && Rb(n) !== t && i !== void 0 && i.kind === 264 : !1; + } + return !1; + } + function WC(e, t, n, i) { + return Ff(t) && F3(e, t, n, i); + } + function O3(e, t, n, i) { + return WC(e, t, n, i) || RD(e, t, n); + } + function RD(e, t, n) { + switch (t.kind) { + case 264: + return ot(t.members, (i) => O3(e, i, t, n)); + case 232: + return !e && ot(t.members, (i) => O3(e, i, t, n)); + case 175: + case 179: + case 177: + return ot(t.parameters, (i) => WC(e, i, t, n)); + default: + return !1; + } + } + function g0(e, t) { + if (WC(e, t)) return !0; + const n = Mg(t); + return !!n && RD(e, n, t); + } + function xB(e, t, n) { + let i; + if (Dy(t)) { + const { firstAccessor: s, secondAccessor: o, setAccessor: c } = Bb(n.members, t), _ = Ff(s) ? s : o && Ff(o) ? o : void 0; + if (!_ || t !== _) + return !1; + i = c?.parameters; + } else rc(t) && (i = t.parameters); + if (WC(e, t, n)) + return !0; + if (i) { + for (const s of i) + if (!My(s) && WC(e, s, t, n)) + return !0; + } + return !1; + } + function kB(e) { + if (e.textSourceNode) { + switch (e.textSourceNode.kind) { + case 11: + return kB(e.textSourceNode); + case 15: + return e.text === ""; + } + return !1; + } + return e.text === ""; + } + function UC(e) { + const { parent: t } = e; + return t.kind === 287 || t.kind === 286 || t.kind === 288 ? t.tagName === e : !1; + } + function Xm(e) { + switch (e.kind) { + case 108: + case 106: + case 112: + case 97: + case 14: + case 210: + case 211: + case 212: + case 213: + case 214: + case 215: + case 216: + case 235: + case 217: + case 239: + case 236: + case 218: + case 219: + case 232: + case 220: + case 223: + case 221: + case 222: + case 225: + case 226: + case 227: + case 228: + case 231: + case 229: + case 233: + case 285: + case 286: + case 289: + case 230: + case 224: + return !0; + case 237: + return !T_(e.parent) || e.parent.expression !== e; + case 234: + return !cf(e.parent) && !Yx(e.parent); + case 167: + for (; e.parent.kind === 167; ) + e = e.parent; + return e.parent.kind === 187 || cx(e.parent) || M4(e.parent) || uv(e.parent) || UC(e); + case 312: + for (; uv(e.parent); ) + e = e.parent; + return e.parent.kind === 187 || cx(e.parent) || M4(e.parent) || uv(e.parent) || UC(e); + case 81: + return _n(e.parent) && e.parent.left === e && e.parent.operatorToken.kind === 103; + case 80: + if (e.parent.kind === 187 || cx(e.parent) || M4(e.parent) || uv(e.parent) || UC(e)) + return !0; + // falls through + case 9: + case 10: + case 11: + case 15: + case 110: + return a5(e); + default: + return !1; + } + } + function a5(e) { + const { parent: t } = e; + switch (t.kind) { + case 261: + case 170: + case 173: + case 172: + case 307: + case 304: + case 209: + return t.initializer === e; + case 245: + case 246: + case 247: + case 248: + case 254: + case 255: + case 256: + case 297: + case 258: + return t.expression === e; + case 249: + const n = t; + return n.initializer === e && n.initializer.kind !== 262 || n.condition === e || n.incrementor === e; + case 250: + case 251: + const i = t; + return i.initializer === e && i.initializer.kind !== 262 || i.expression === e; + case 217: + case 235: + return e === t.expression; + case 240: + return e === t.expression; + case 168: + return e === t.expression; + case 171: + case 295: + case 294: + case 306: + return !0; + case 234: + return t.expression === e && !lm(t); + case 305: + return t.objectAssignmentInitializer === e; + case 239: + return e === t.expression; + default: + return Xm(t); + } + } + function o5(e) { + for (; e.kind === 167 || e.kind === 80; ) + e = e.parent; + return e.kind === 187; + } + function CK(e) { + return Km(e) && !!e.parent.moduleSpecifier; + } + function H1(e) { + return e.kind === 272 && e.moduleReference.kind === 284; + } + function jD(e) { + return E.assert(H1(e)), e.moduleReference.expression; + } + function CB(e) { + return Ab(e) && r6(e.initializer).arguments[0]; + } + function cS(e) { + return e.kind === 272 && e.moduleReference.kind !== 284; + } + function Og(e) { + return e?.kind === 308; + } + function n_(e) { + return an(e); + } + function an(e) { + return !!e && !!(e.flags & 524288); + } + function c5(e) { + return !!e && !!(e.flags & 134217728); + } + function l5(e) { + return !ap(e); + } + function BD(e) { + return !!e && !!(e.flags & 16777216); + } + function u5(e) { + return of(e) && Me(e.typeName) && e.typeName.escapedText === "Object" && e.typeArguments && e.typeArguments.length === 2 && (e.typeArguments[0].kind === 154 || e.typeArguments[0].kind === 150); + } + function x_(e, t) { + if (e.kind !== 214) + return !1; + const { expression: n, arguments: i } = e; + if (n.kind !== 80 || n.escapedText !== "require" || i.length !== 1) + return !1; + const s = i[0]; + return !t || ja(s); + } + function L3(e) { + return Dhe( + e, + /*allowAccessedRequire*/ + !1 + ); + } + function Ab(e) { + return Dhe( + e, + /*allowAccessedRequire*/ + !0 + ); + } + function EK(e) { + return ya(e) && Ab(e.parent.parent); + } + function Dhe(e, t) { + return ei(e) && !!e.initializer && x_( + t ? r6(e.initializer) : e.initializer, + /*requireStringLiteralLikeArgument*/ + !0 + ); + } + function M3(e) { + return Ic(e) && e.declarationList.declarations.length > 0 && Ni(e.declarationList.declarations, (t) => L3(t)); + } + function R3(e) { + return e === 39 || e === 34; + } + function _5(e, t) { + return Db(t, e).charCodeAt(0) === 34; + } + function JD(e) { + return _n(e) || To(e) || Me(e) || Ps(e); + } + function j3(e) { + return an(e) && e.initializer && _n(e.initializer) && (e.initializer.operatorToken.kind === 57 || e.initializer.operatorToken.kind === 61) && e.name && to(e.name) && VC(e.name, e.initializer.left) ? e.initializer.right : e.initializer; + } + function zD(e) { + const t = j3(e); + return t && G1(t, jy(e.name)); + } + function TOe(e, t) { + return lr(e.properties, (n) => rl(n) && Me(n.name) && n.name.escapedText === "value" && n.initializer && G1(n.initializer, t)); + } + function mx(e) { + if (e && e.parent && _n(e.parent) && e.parent.operatorToken.kind === 64) { + const t = jy(e.parent.left); + return G1(e.parent.right, t) || xOe(e.parent.left, e.parent.right, t); + } + if (e && Ps(e) && uS(e)) { + const t = TOe(e.arguments[2], e.arguments[1].text === "prototype"); + if (t) + return t; + } + } + function G1(e, t) { + if (Ps(e)) { + const n = Ba(e.expression); + return n.kind === 219 || n.kind === 220 ? e : void 0; + } + if (e.kind === 219 || e.kind === 232 || e.kind === 220 || _a(e) && (e.properties.length === 0 || t)) + return e; + } + function xOe(e, t, n) { + const i = _n(t) && (t.operatorToken.kind === 57 || t.operatorToken.kind === 61) && G1(t.right, n); + if (i && VC(e, t.left)) + return i; + } + function DK(e) { + const t = ei(e.parent) ? e.parent.name : _n(e.parent) && e.parent.operatorToken.kind === 64 ? e.parent.left : void 0; + return t && G1(e.right, jy(t)) && to(t) && VC(t, e.left); + } + function EB(e) { + if (_n(e.parent)) { + const t = (e.parent.operatorToken.kind === 57 || e.parent.operatorToken.kind === 61) && _n(e.parent.parent) ? e.parent.parent : e.parent; + if (t.operatorToken.kind === 64 && Me(t.left)) + return t.left; + } else if (ei(e.parent)) + return e.parent.name; + } + function VC(e, t) { + return um(e) && um(t) ? op(e) === op(t) : wg(e) && wK(t) && (t.expression.kind === 110 || Me(t.expression) && (t.expression.escapedText === "window" || t.expression.escapedText === "self" || t.expression.escapedText === "global")) ? VC(e, J3(t)) : wK(e) && wK(t) ? Sh(e) === Sh(t) && VC(e.expression, t.expression) : !1; + } + function B3(e) { + for (; Nl( + e, + /*excludeCompoundAssignment*/ + !0 + ); ) + e = e.right; + return e; + } + function lS(e) { + return Me(e) && e.escapedText === "exports"; + } + function DB(e) { + return Me(e) && e.escapedText === "module"; + } + function Lg(e) { + return (wn(e) || wB(e)) && DB(e.expression) && Sh(e) === "exports"; + } + function Ac(e) { + const t = kOe(e); + return t === 5 || an(e) ? t : 0; + } + function uS(e) { + return wr(e.arguments) === 3 && wn(e.expression) && Me(e.expression.expression) && An(e.expression.expression) === "Object" && An(e.expression.name) === "defineProperty" && If(e.arguments[1]) && _S( + e.arguments[0], + /*excludeThisKeyword*/ + !0 + ); + } + function wK(e) { + return wn(e) || wB(e); + } + function wB(e) { + return uo(e) && If(e.argumentExpression); + } + function Ib(e, t) { + return wn(e) && (!t && e.expression.kind === 110 || Me(e.name) && _S( + e.expression, + /*excludeThisKeyword*/ + !0 + )) || f5(e, t); + } + function f5(e, t) { + return wB(e) && (!t && e.expression.kind === 110 || to(e.expression) || Ib( + e.expression, + /*excludeThisKeyword*/ + !0 + )); + } + function _S(e, t) { + return to(e) || Ib(e, t); + } + function J3(e) { + return wn(e) ? e.name : e.argumentExpression; + } + function kOe(e) { + if (Ps(e)) { + if (!uS(e)) + return 0; + const t = e.arguments[0]; + return lS(t) || Lg(t) ? 8 : Ib(t) && Sh(t) === "prototype" ? 9 : 7; + } + return e.operatorToken.kind !== 64 || !To(e.left) || COe(B3(e)) ? 0 : _S( + e.left.expression, + /*excludeThisKeyword*/ + !0 + ) && Sh(e.left) === "prototype" && _a(PB(e)) ? 6 : z3(e.left); + } + function COe(e) { + return Gx(e) && E_(e.expression) && e.expression.text === "0"; + } + function p5(e) { + if (wn(e)) + return e.name; + const t = Ba(e.argumentExpression); + return E_(t) || ja(t) ? t : e; + } + function Sh(e) { + const t = p5(e); + if (t) { + if (Me(t)) + return t.escapedText; + if (ja(t) || E_(t)) + return tc(t.text); + } + } + function z3(e) { + if (e.expression.kind === 110) + return 4; + if (Lg(e)) + return 2; + if (_S( + e.expression, + /*excludeThisKeyword*/ + !0 + )) { + if (jy(e.expression)) + return 3; + let t = e; + for (; !Me(t.expression); ) + t = t.expression; + const n = t.expression; + if ((n.escapedText === "exports" || n.escapedText === "module" && Sh(t) === "exports") && // ExportsProperty does not support binding with computed names + Ib(e)) + return 1; + if (_S( + e, + /*excludeThisKeyword*/ + !0 + ) || uo(e) && v5(e)) + return 5; + } + return 0; + } + function PB(e) { + for (; _n(e.right); ) + e = e.right; + return e.right; + } + function W3(e) { + return _n(e) && Ac(e) === 3; + } + function PK(e) { + return an(e) && e.parent && e.parent.kind === 245 && (!uo(e) || wB(e)) && !!z1(e.parent); + } + function WD(e, t) { + const { valueDeclaration: n } = e; + (!n || !(t.flags & 33554432 && !an(t) && !(n.flags & 33554432)) && JD(n) && !JD(t) || n.kind !== t.kind && _Oe(n)) && (e.valueDeclaration = t); + } + function NK(e) { + if (!e || !e.valueDeclaration) + return !1; + const t = e.valueDeclaration; + return t.kind === 263 || ei(t) && t.initializer && Es(t.initializer); + } + function AK(e) { + switch (e?.kind) { + case 261: + case 209: + case 273: + case 279: + case 272: + case 274: + case 281: + case 275: + case 282: + case 277: + case 206: + return !0; + } + return !1; + } + function gx(e) { + var t, n; + switch (e.kind) { + case 261: + case 209: + return (t = dr(e.initializer, (i) => x_( + i, + /*requireStringLiteralLikeArgument*/ + !0 + ))) == null ? void 0 : t.arguments[0]; + case 273: + case 279: + case 352: + return Bn(e.moduleSpecifier, ja); + case 272: + return Bn((n = Bn(e.moduleReference, wh)) == null ? void 0 : n.expression, ja); + case 274: + case 281: + return Bn(e.parent.moduleSpecifier, ja); + case 275: + case 282: + return Bn(e.parent.parent.moduleSpecifier, ja); + case 277: + return Bn(e.parent.parent.parent.moduleSpecifier, ja); + case 206: + return bh(e) ? e.argument.literal : void 0; + default: + E.assertNever(e); + } + } + function UD(e) { + return U3(e) || E.failBadSyntaxKind(e.parent); + } + function U3(e) { + switch (e.parent.kind) { + case 273: + case 279: + case 352: + return e.parent; + case 284: + return e.parent.parent; + case 214: + return T_(e.parent) || x_( + e.parent, + /*requireStringLiteralLikeArgument*/ + !1 + ) ? e.parent : void 0; + case 202: + if (!ca(e)) + break; + return Bn(e.parent.parent, ym); + default: + return; + } + } + function V3(e, t) { + return !!t.rewriteRelativeImportExtensions && xf(e) && !Il(e) && yS(e); + } + function hx(e) { + switch (e.kind) { + case 273: + case 279: + case 352: + return e.moduleSpecifier; + case 272: + return e.moduleReference.kind === 284 ? e.moduleReference.expression : void 0; + case 206: + return bh(e) ? e.argument.literal : void 0; + case 214: + return e.arguments[0]; + case 268: + return e.name.kind === 11 ? e.name : void 0; + default: + return E.assertNever(e); + } + } + function qC(e) { + switch (e.kind) { + case 273: + return e.importClause && Bn(e.importClause.namedBindings, Ug); + case 272: + return e; + case 279: + return e.exportClause && Bn(e.exportClause, Km); + default: + return E.assertNever(e); + } + } + function fS(e) { + return (e.kind === 273 || e.kind === 352) && !!e.importClause && !!e.importClause.name; + } + function IK(e, t) { + if (e.name) { + const n = t(e); + if (n) return n; + } + if (e.namedBindings) { + const n = Ug(e.namedBindings) ? t(e.namedBindings) : lr(e.namedBindings.elements, t); + if (n) return n; + } + } + function yx(e) { + switch (e.kind) { + case 170: + case 175: + case 174: + case 305: + case 304: + case 173: + case 172: + return e.questionToken !== void 0; + } + return !1; + } + function vx(e) { + const t = b6(e) ? Yc(e.parameters) : void 0, n = Bn(t && t.name, Me); + return !!n && n.escapedText === "new"; + } + function jp(e) { + return e.kind === 347 || e.kind === 339 || e.kind === 341; + } + function q3(e) { + return jp(e) || Wp(e); + } + function EOe(e) { + return Al(e) && _n(e.expression) && e.expression.operatorToken.kind === 64 ? B3(e.expression) : void 0; + } + function whe(e) { + return Al(e) && _n(e.expression) && Ac(e.expression) !== 0 && _n(e.expression.right) && (e.expression.right.operatorToken.kind === 57 || e.expression.right.operatorToken.kind === 61) ? e.expression.right.right : void 0; + } + function Phe(e) { + switch (e.kind) { + case 244: + const t = bx(e); + return t && t.initializer; + case 173: + return e.initializer; + case 304: + return e.initializer; + } + } + function bx(e) { + return Ic(e) ? Yc(e.declarationList.declarations) : void 0; + } + function Nhe(e) { + return jc(e) && e.body && e.body.kind === 268 ? e.body : void 0; + } + function HC(e) { + if (e.kind >= 244 && e.kind <= 260) + return !0; + switch (e.kind) { + case 80: + case 110: + case 108: + case 167: + case 237: + case 213: + case 212: + case 209: + case 219: + case 220: + case 175: + case 178: + case 179: + return !0; + default: + return !1; + } + } + function H3(e) { + switch (e.kind) { + case 220: + case 227: + case 242: + case 253: + case 180: + case 297: + case 264: + case 232: + case 176: + case 177: + case 186: + case 181: + case 252: + case 260: + case 247: + case 213: + case 243: + case 1: + case 267: + case 307: + case 278: + case 279: + case 282: + case 245: + case 250: + case 251: + case 249: + case 263: + case 219: + case 185: + case 178: + case 80: + case 246: + case 273: + case 272: + case 182: + case 265: + case 318: + case 324: + case 257: + case 175: + case 174: + case 268: + case 203: + case 271: + case 211: + case 170: + case 218: + case 212: + case 304: + case 173: + case 172: + case 254: + case 241: + case 179: + case 305: + case 306: + case 256: + case 258: + case 259: + case 266: + case 169: + case 261: + case 244: + case 248: + case 255: + return !0; + default: + return !1; + } + } + function NB(e, t) { + let n; + OD(e) && d0(e) && kf(e.initializer) && (n = In(n, Ahe(e, e.initializer.jsDoc))); + let i = e; + for (; i && i.parent; ) { + if (kf(i) && (n = In(n, Ahe(e, i.jsDoc))), i.kind === 170) { + n = In(n, (t ? oZ : wC)(i)); + break; + } + if (i.kind === 169) { + n = In(n, (t ? lZ : cZ)(i)); + break; + } + i = AB(i); + } + return n || Ge; + } + function Ahe(e, t) { + const n = pa(t); + return ka(t, (i) => { + if (i === n) { + const s = kn(i.tags, (o) => DOe(e, o)); + return i.tags === s ? [i] : s; + } else + return kn(i.tags, S6); + }); + } + function DOe(e, t) { + return !(R4(t) || MF(t)) || !t.parent || !Od(t.parent) || !o_(t.parent.parent) || t.parent.parent === e; + } + function AB(e) { + const t = e.parent; + if (t.kind === 304 || t.kind === 278 || t.kind === 173 || t.kind === 245 && e.kind === 212 || t.kind === 254 || Nhe(t) || Nl(e)) + return t; + if (t.parent && (bx(t.parent) === e || Nl(t))) + return t.parent; + if (t.parent && t.parent.parent && (bx(t.parent.parent) || Phe(t.parent.parent) === e || whe(t.parent.parent))) + return t.parent.parent; + } + function G3(e) { + if (e.symbol) + return e.symbol; + if (!Me(e.name)) + return; + const t = e.name.escapedText, n = $1(e); + if (!n) + return; + const i = Nn(n.parameters, (s) => s.name.kind === 80 && s.name.escapedText === t); + return i && i.symbol; + } + function d5(e) { + if (Od(e.parent) && e.parent.tags) { + const t = Nn(e.parent.tags, jp); + if (t) + return t; + } + return $1(e); + } + function IB(e) { + return S7(e, S6); + } + function $1(e) { + const t = X1(e); + if (t) + return $u(t) && t.type && Es(t.type) ? t.type : Es(t) ? t : void 0; + } + function X1(e) { + const t = Fb(e); + if (t) + return whe(t) || EOe(t) || Phe(t) || bx(t) || Nhe(t) || t; + } + function Fb(e) { + const t = GC(e); + if (!t) + return; + const n = t.parent; + if (n && n.jsDoc && t === Do(n.jsDoc)) + return n; + } + function GC(e) { + return dr(e.parent, Od); + } + function FK(e) { + const t = e.name.escapedText, { typeParameters: n } = e.parent.parent.parent; + return n && Nn(n, (i) => i.name.escapedText === t); + } + function Ihe(e) { + return !!e.typeArguments; + } + var OK = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Definite = 1] = "Definite", e[e.Compound = 2] = "Compound", e))(OK || {}); + function LK(e) { + let t = e.parent; + for (; ; ) { + switch (t.kind) { + case 227: + const n = t, i = n.operatorToken.kind; + return kh(i) && n.left === e ? n : void 0; + case 225: + case 226: + const s = t, o = s.operator; + return o === 46 || o === 47 ? s : void 0; + case 250: + case 251: + const c = t; + return c.initializer === e ? c : void 0; + case 218: + case 210: + case 231: + case 236: + e = t; + break; + case 306: + e = t.parent; + break; + case 305: + if (t.name !== e) + return; + e = t.parent; + break; + case 304: + if (t.name === e) + return; + e = t.parent; + break; + default: + return; + } + t = e.parent; + } + } + function Oy(e) { + const t = LK(e); + if (!t) + return 0; + switch (t.kind) { + case 227: + const n = t.operatorToken.kind; + return n === 64 || t4(n) ? 1 : 2; + case 225: + case 226: + return 2; + case 250: + case 251: + return 1; + } + } + function Ly(e) { + return !!LK(e); + } + function wOe(e) { + const t = Ba(e.right); + return t.kind === 227 && Bz(t.operatorToken.kind); + } + function FB(e) { + const t = LK(e); + return !!t && Nl( + t, + /*excludeCompoundAssignment*/ + !0 + ) && wOe(t); + } + function MK(e) { + switch (e.kind) { + case 242: + case 244: + case 255: + case 246: + case 256: + case 270: + case 297: + case 298: + case 257: + case 249: + case 250: + case 251: + case 247: + case 248: + case 259: + case 300: + return !0; + } + return !1; + } + function pS(e) { + return yo(e) || xo(e) || ax(e) || Cc(e) || nc(e); + } + function Fhe(e, t) { + for (; e && e.kind === t; ) + e = e.parent; + return e; + } + function $3(e) { + return Fhe( + e, + 197 + /* ParenthesizedType */ + ); + } + function ad(e) { + return Fhe( + e, + 218 + /* ParenthesizedExpression */ + ); + } + function RK(e) { + let t; + for (; e && e.kind === 197; ) + t = e, e = e.parent; + return [t, e]; + } + function VD(e) { + for (; kS(e); ) e = e.type; + return e; + } + function Ba(e, t) { + return hc(e, t ? -2147483647 : 1); + } + function OB(e) { + return e.kind !== 212 && e.kind !== 213 ? !1 : (e = ad(e.parent), e && e.kind === 221); + } + function Ob(e, t) { + for (; e; ) { + if (e === t) return !0; + e = e.parent; + } + return !1; + } + function Qm(e) { + return !Di(e) && !ws(e) && Pl(e.parent) && e.parent.name === e; + } + function qD(e) { + const t = e.parent; + switch (e.kind) { + case 11: + case 15: + case 9: + if (Gs(t)) return t.parent; + // falls through + case 80: + if (Pl(t)) + return t.name === e ? t : void 0; + if (s_(t)) { + const n = t.parent; + return Lf(n) && n.name === t ? n : void 0; + } else { + const n = t.parent; + return _n(n) && Ac(n) !== 0 && (n.left.symbol || n.symbol) && _s(n) === e ? n : void 0; + } + case 81: + return Pl(t) && t.name === e ? t : void 0; + default: + return; + } + } + function X3(e) { + return If(e) && e.parent.kind === 168 && Pl(e.parent.parent); + } + function jK(e) { + const t = e.parent; + switch (t.kind) { + case 173: + case 172: + case 175: + case 174: + case 178: + case 179: + case 307: + case 304: + case 212: + return t.name === e; + case 167: + return t.right === e; + case 209: + case 277: + return t.propertyName === e; + case 282: + case 292: + case 286: + case 287: + case 288: + return !0; + } + return !1; + } + function LB(e) { + switch (e.parent.kind) { + case 274: + case 277: + case 275: + case 282: + case 278: + case 272: + case 281: + return e.parent; + case 167: + do + e = e.parent; + while (e.parent.kind === 167); + return LB(e); + } + } + function m5(e) { + return to(e) || Rc(e); + } + function Q3(e) { + const t = MB(e); + return m5(t); + } + function MB(e) { + return Mo(e) ? e.expression : e.right; + } + function BK(e) { + return e.kind === 305 ? e.name : e.kind === 304 ? e.initializer : e.parent.right; + } + function wd(e) { + const t = Lb(e); + if (t && an(e)) { + const n = _Z(e); + if (n) + return n.class; + } + return t; + } + function Lb(e) { + const t = Y3( + e.heritageClauses, + 96 + /* ExtendsKeyword */ + ); + return t && t.types.length > 0 ? t.types[0] : void 0; + } + function $C(e) { + if (an(e)) + return fZ(e).map((t) => t.class); + { + const t = Y3( + e.heritageClauses, + 119 + /* ImplementsKeyword */ + ); + return t?.types; + } + } + function HD(e) { + return Vl(e) ? GD(e) || Ge : $n(e) && Bi(ZT(wd(e)), $C(e)) || Ge; + } + function GD(e) { + const t = Y3( + e.heritageClauses, + 96 + /* ExtendsKeyword */ + ); + return t ? t.types : void 0; + } + function Y3(e, t) { + if (e) { + for (const n of e) + if (n.token === t) + return n; + } + } + function Q1(e, t) { + for (; e; ) { + if (e.kind === t) + return e; + e = e.parent; + } + } + function k_(e) { + return 83 <= e && e <= 166; + } + function RB(e) { + return 19 <= e && e <= 79; + } + function g5(e) { + return k_(e) || RB(e); + } + function h5(e) { + return 128 <= e && e <= 166; + } + function jB(e) { + return k_(e) && !h5(e); + } + function Sx(e) { + const t = Q2(e); + return t !== void 0 && jB(t); + } + function BB(e) { + const t = Z2(e); + return !!t && !h5(t); + } + function XC(e) { + return 2 <= e && e <= 7; + } + var JK = /* @__PURE__ */ ((e) => (e[e.Normal = 0] = "Normal", e[e.Generator = 1] = "Generator", e[e.Async = 2] = "Async", e[e.Invalid = 4] = "Invalid", e[e.AsyncGenerator = 3] = "AsyncGenerator", e))(JK || {}); + function Mc(e) { + if (!e) + return 4; + let t = 0; + switch (e.kind) { + case 263: + case 219: + case 175: + e.asteriskToken && (t |= 1); + // falls through + case 220: + Gn( + e, + 1024 + /* Async */ + ) && (t |= 2); + break; + } + return e.body || (t |= 4), t; + } + function $D(e) { + switch (e.kind) { + case 263: + case 219: + case 220: + case 175: + return e.body !== void 0 && e.asteriskToken === void 0 && Gn( + e, + 1024 + /* Async */ + ); + } + return !1; + } + function If(e) { + return ja(e) || E_(e); + } + function y5(e) { + return iv(e) && (e.operator === 40 || e.operator === 41) && E_(e.operand); + } + function Th(e) { + const t = _s(e); + return !!t && v5(t); + } + function v5(e) { + if (!(e.kind === 168 || e.kind === 213)) + return !1; + const t = uo(e) ? Ba(e.argumentExpression) : e.expression; + return !If(t) && !y5(t); + } + function dS(e) { + switch (e.kind) { + case 80: + case 81: + return e.escapedText; + case 11: + case 15: + case 9: + case 10: + return tc(e.text); + case 168: + const t = e.expression; + return If(t) ? tc(t.text) : y5(t) ? t.operator === 41 ? qs(t.operator) + t.operand.text : t.operand.text : void 0; + case 296: + return Lx(e); + default: + return E.assertNever(e); + } + } + function um(e) { + switch (e.kind) { + case 80: + case 11: + case 15: + case 9: + return !0; + default: + return !1; + } + } + function op(e) { + return wg(e) ? An(e) : Fd(e) ? T4(e) : e.text; + } + function XD(e) { + return wg(e) ? e.escapedText : Fd(e) ? Lx(e) : tc(e.text); + } + function Z3(e, t) { + return `__#${Xs(e)}@${t}`; + } + function QD(e) { + return Ui(e.escapedName, "__@"); + } + function zK(e) { + return Ui(e.escapedName, "__#"); + } + function POe(e) { + return Me(e) ? An(e) === "__proto__" : ca(e) && e.text === "__proto__"; + } + function b5(e, t) { + switch (e = hc(e), e.kind) { + case 232: + if (HW(e)) + return !1; + break; + case 219: + if (e.name) + return !1; + break; + case 220: + break; + default: + return !1; + } + return typeof t == "function" ? t(e) : !0; + } + function JB(e) { + switch (e.kind) { + case 304: + return !POe(e.name); + case 305: + return !!e.objectAssignmentInitializer; + case 261: + return Me(e.name) && !!e.initializer; + case 170: + return Me(e.name) && !!e.initializer && !e.dotDotDotToken; + case 209: + return Me(e.name) && !!e.initializer && !e.dotDotDotToken; + case 173: + return !!e.initializer; + case 227: + switch (e.operatorToken.kind) { + case 64: + case 77: + case 76: + case 78: + return Me(e.left); + } + break; + case 278: + return !0; + } + return !1; + } + function rf(e, t) { + if (!JB(e)) return !1; + switch (e.kind) { + case 304: + return b5(e.initializer, t); + case 305: + return b5(e.objectAssignmentInitializer, t); + case 261: + case 170: + case 209: + case 173: + return b5(e.initializer, t); + case 227: + return b5(e.right, t); + case 278: + return b5(e.expression, t); + } + } + function zB(e) { + return e.escapedText === "push" || e.escapedText === "unshift"; + } + function Y1(e) { + return _m(e).kind === 170; + } + function _m(e) { + for (; e.kind === 209; ) + e = e.parent.parent; + return e; + } + function WB(e) { + const t = e.kind; + return t === 177 || t === 219 || t === 263 || t === 220 || t === 175 || t === 178 || t === 179 || t === 268 || t === 308; + } + function lo(e) { + return Nd(e.pos) || Nd(e.end); + } + var WK = /* @__PURE__ */ ((e) => (e[e.Left = 0] = "Left", e[e.Right = 1] = "Right", e))(WK || {}); + function UB(e) { + const t = Ohe(e), n = e.kind === 215 && e.arguments !== void 0; + return VB(e.kind, t, n); + } + function VB(e, t, n) { + switch (e) { + case 215: + return n ? 0 : 1; + case 225: + case 222: + case 223: + case 221: + case 224: + case 228: + case 230: + return 1; + case 227: + switch (t) { + case 43: + case 64: + case 65: + case 66: + case 68: + case 67: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 79: + case 75: + case 76: + case 77: + case 78: + return 1; + } + } + return 0; + } + function YD(e) { + const t = Ohe(e), n = e.kind === 215 && e.arguments !== void 0; + return K3(e.kind, t, n); + } + function Ohe(e) { + return e.kind === 227 ? e.operatorToken.kind : e.kind === 225 || e.kind === 226 ? e.operator : e.kind; + } + var UK = /* @__PURE__ */ ((e) => (e[e.Comma = 0] = "Comma", e[e.Spread = 1] = "Spread", e[e.Yield = 2] = "Yield", e[e.Assignment = 3] = "Assignment", e[e.Conditional = 4] = "Conditional", e[e.LogicalOR = 5] = "LogicalOR", e[ + e.Coalesce = 5 + /* LogicalOR */ + ] = "Coalesce", e[e.LogicalAND = 6] = "LogicalAND", e[e.BitwiseOR = 7] = "BitwiseOR", e[e.BitwiseXOR = 8] = "BitwiseXOR", e[e.BitwiseAND = 9] = "BitwiseAND", e[e.Equality = 10] = "Equality", e[e.Relational = 11] = "Relational", e[e.Shift = 12] = "Shift", e[e.Additive = 13] = "Additive", e[e.Multiplicative = 14] = "Multiplicative", e[e.Exponentiation = 15] = "Exponentiation", e[e.Unary = 16] = "Unary", e[e.Update = 17] = "Update", e[e.LeftHandSide = 18] = "LeftHandSide", e[e.Member = 19] = "Member", e[e.Primary = 20] = "Primary", e[ + e.Highest = 20 + /* Primary */ + ] = "Highest", e[ + e.Lowest = 0 + /* Comma */ + ] = "Lowest", e[e.Invalid = -1] = "Invalid", e))(UK || {}); + function K3(e, t, n) { + switch (e) { + case 357: + return 0; + case 231: + return 1; + case 230: + return 2; + case 228: + return 4; + case 227: + switch (t) { + case 28: + return 0; + case 64: + case 65: + case 66: + case 68: + case 67: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 79: + case 75: + case 76: + case 77: + case 78: + return 3; + default: + return eN(t); + } + // TODO: Should prefix `++` and `--` be moved to the `Update` precedence? + case 217: + case 236: + case 225: + case 222: + case 223: + case 221: + case 224: + return 16; + case 226: + return 17; + case 214: + return 18; + case 215: + return n ? 19 : 18; + case 216: + case 212: + case 213: + case 237: + return 19; + case 235: + case 239: + return 11; + case 110: + case 108: + case 80: + case 81: + case 106: + case 112: + case 97: + case 9: + case 10: + case 11: + case 210: + case 211: + case 219: + case 220: + case 232: + case 14: + case 15: + case 229: + case 218: + case 233: + case 285: + case 286: + case 289: + return 20; + default: + return -1; + } + } + function eN(e) { + switch (e) { + case 61: + return 5; + case 57: + return 5; + case 56: + return 6; + case 52: + return 7; + case 53: + return 8; + case 51: + return 9; + case 35: + case 36: + case 37: + case 38: + return 10; + case 30: + case 32: + case 33: + case 34: + case 104: + case 103: + case 130: + case 152: + return 11; + case 48: + case 49: + case 50: + return 12; + case 40: + case 41: + return 13; + case 42: + case 44: + case 45: + return 14; + case 43: + return 15; + } + return -1; + } + function QC(e) { + return kn(e, (t) => { + switch (t.kind) { + case 295: + return !!t.expression; + case 12: + return !t.containsOnlyTriviaWhiteSpaces; + default: + return !0; + } + }); + } + function ZD() { + let e = []; + const t = [], n = /* @__PURE__ */ new Map(); + let i = !1; + return { + add: o, + lookup: s, + getGlobalDiagnostics: c, + getDiagnostics: _ + }; + function s(u) { + let g; + if (u.file ? g = n.get(u.file.fileName) : g = e, !g) + return; + const m = py(g, u, go, kee); + if (m >= 0) + return g[m]; + if (~m > 0 && W5(u, g[~m - 1])) + return g[~m - 1]; + } + function o(u) { + let g; + u.file ? (g = n.get(u.file.fileName), g || (g = [], n.set(u.file.fileName, g), _y(t, u.file.fileName, _u))) : (i && (i = !1, e = e.slice()), g = e), _y(g, u, kee, W5); + } + function c() { + return i = !0, e; + } + function _(u) { + if (u) + return n.get(u) || []; + const g = KE(t, (m) => n.get(m)); + return e.length && g.unshift(...e), g; + } + } + var NOe = /\$\{/g; + function qB(e) { + return e.replace(NOe, "\\${"); + } + function VK(e) { + return !!((e.templateFlags || 0) & 2048); + } + function HB(e) { + return e && !!(TS(e) ? VK(e) : VK(e.head) || ot(e.templateSpans, (t) => VK(t.literal))); + } + var AOe = /[\\"\u0000-\u001f\u2028\u2029\u0085]/g, IOe = /[\\'\u0000-\u001f\u2028\u2029\u0085]/g, FOe = /\r\n|[\\`\u0000-\u0009\u000b-\u001f\u2028\u2029\u0085]/g, OOe = new Map(Object.entries({ + " ": "\\t", + "\v": "\\v", + "\f": "\\f", + "\b": "\\b", + "\r": "\\r", + "\n": "\\n", + "\\": "\\\\", + '"': '\\"', + "'": "\\'", + "`": "\\`", + "\u2028": "\\u2028", + // lineSeparator + "\u2029": "\\u2029", + // paragraphSeparator + "…": "\\u0085", + // nextLine + "\r\n": "\\r\\n" + // special case for CRLFs in backticks + })); + function Lhe(e) { + return "\\u" + ("0000" + e.toString(16).toUpperCase()).slice(-4); + } + function LOe(e, t, n) { + if (e.charCodeAt(0) === 0) { + const i = n.charCodeAt(t + e.length); + return i >= 48 && i <= 57 ? "\\x00" : "\\0"; + } + return OOe.get(e) || Lhe(e.charCodeAt(0)); + } + function Ym(e, t) { + const n = t === 96 ? FOe : t === 39 ? IOe : AOe; + return e.replace(n, LOe); + } + var Mhe = /[^\u0000-\u007F]/g; + function S5(e, t) { + return e = Ym(e, t), Mhe.test(e) ? e.replace(Mhe, (n) => Lhe(n.charCodeAt(0))) : e; + } + var MOe = /["\u0000-\u001f\u2028\u2029\u0085]/g, ROe = /['\u0000-\u001f\u2028\u2029\u0085]/g, jOe = new Map(Object.entries({ + '"': """, + "'": "'" + })); + function BOe(e) { + return "&#x" + e.toString(16).toUpperCase() + ";"; + } + function JOe(e) { + return e.charCodeAt(0) === 0 ? "�" : jOe.get(e) || BOe(e.charCodeAt(0)); + } + function GB(e, t) { + const n = t === 39 ? ROe : MOe; + return e.replace(n, JOe); + } + function Bp(e) { + const t = e.length; + return t >= 2 && e.charCodeAt(0) === e.charCodeAt(t - 1) && zOe(e.charCodeAt(0)) ? e.substring(1, t - 1) : e; + } + function zOe(e) { + return e === 39 || e === 34 || e === 96; + } + function YC(e) { + const t = e.charCodeAt(0); + return t >= 97 && t <= 122 || e.includes("-"); + } + var tN = ["", " "]; + function T5(e) { + const t = tN[1]; + for (let n = tN.length; n <= e; n++) + tN.push(tN[n - 1] + t); + return tN[e]; + } + function rN() { + return tN[1].length; + } + function nN(e) { + var t, n, i, s, o, c = !1; + function _(D) { + const P = nx(D); + P.length > 1 ? (s = s + P.length - 1, o = t.length - D.length + pa(P), i = o - t.length === 0) : i = !1; + } + function u(D) { + D && D.length && (i && (D = T5(n) + D, i = !1), t += D, _(D)); + } + function g(D) { + D && (c = !1), u(D); + } + function m(D) { + D && (c = !0), u(D); + } + function h() { + t = "", n = 0, i = !0, s = 0, o = 0, c = !1; + } + function S(D) { + D !== void 0 && (t += D, _(D), c = !1); + } + function T(D) { + D && D.length && g(D); + } + function k(D) { + (!i || D) && (t += e, s++, o = t.length, i = !0, c = !1); + } + return h(), { + write: g, + rawWrite: S, + writeLiteral: T, + writeLine: k, + increaseIndent: () => { + n++; + }, + decreaseIndent: () => { + n--; + }, + getIndent: () => n, + getTextPos: () => t.length, + getLine: () => s, + getColumn: () => i ? n * rN() : t.length - o, + getText: () => t, + isAtStartOfLine: () => i, + hasTrailingComment: () => c, + hasTrailingWhitespace: () => !!t.length && Cg(t.charCodeAt(t.length - 1)), + clear: h, + writeKeyword: g, + writeOperator: g, + writeParameter: g, + writeProperty: g, + writePunctuation: g, + writeSpace: g, + writeStringLiteral: g, + writeSymbol: (D, P) => g(D), + writeTrailingSemicolon: g, + writeComment: m + }; + } + function $B(e) { + let t = !1; + function n() { + t && (e.writeTrailingSemicolon(";"), t = !1); + } + return { + ...e, + writeTrailingSemicolon() { + t = !0; + }, + writeLiteral(i) { + n(), e.writeLiteral(i); + }, + writeStringLiteral(i) { + n(), e.writeStringLiteral(i); + }, + writeSymbol(i, s) { + n(), e.writeSymbol(i, s); + }, + writePunctuation(i) { + n(), e.writePunctuation(i); + }, + writeKeyword(i) { + n(), e.writeKeyword(i); + }, + writeOperator(i) { + n(), e.writeOperator(i); + }, + writeParameter(i) { + n(), e.writeParameter(i); + }, + writeSpace(i) { + n(), e.writeSpace(i); + }, + writeProperty(i) { + n(), e.writeProperty(i); + }, + writeComment(i) { + n(), e.writeComment(i); + }, + writeLine() { + n(), e.writeLine(); + }, + increaseIndent() { + n(), e.increaseIndent(); + }, + decreaseIndent() { + n(), e.decreaseIndent(); + } + }; + } + function mS(e) { + return e.useCaseSensitiveFileNames ? e.useCaseSensitiveFileNames() : !1; + } + function xh(e) { + return Zl(mS(e)); + } + function XB(e, t, n) { + return t.moduleName || QB(e, t.fileName, n && n.fileName); + } + function Rhe(e, t) { + return e.getCanonicalFileName(Qi(t, e.getCurrentDirectory())); + } + function qK(e, t, n) { + const i = t.getExternalModuleFileFromDeclaration(n); + if (!i || i.isDeclarationFile) + return; + const s = hx(n); + if (!(s && ja(s) && !xf(s.text) && !Rhe(e, i.path).includes(Rhe(e, gl(e.getCommonSourceDirectory()))))) + return XB(e, i); + } + function QB(e, t, n) { + const i = (u) => e.getCanonicalFileName(u), s = oo(n ? Hn(n) : e.getCommonSourceDirectory(), e.getCurrentDirectory(), i), o = Qi(t, e.getCurrentDirectory()), c = rx( + s, + o, + s, + i, + /*isAbsolutePathAnUrl*/ + !1 + ), _ = Gu(c); + return n ? X2(_) : _; + } + function HK(e, t, n) { + const i = t.getCompilerOptions(); + let s; + return i.outDir ? s = Gu(D5(e, t, i.outDir)) : s = Gu(e), s + n; + } + function GK(e, t) { + return x5(e, t.getCompilerOptions(), t); + } + function x5(e, t, n) { + const i = t.declarationDir || t.outDir, s = i ? $K(e, i, n.getCurrentDirectory(), n.getCommonSourceDirectory(), (c) => n.getCanonicalFileName(c)) : e, o = k5(s); + return Gu(s) + o; + } + function k5(e) { + return xc(e, [ + ".mjs", + ".mts" + /* Mts */ + ]) ? ".d.mts" : xc(e, [ + ".cjs", + ".cts" + /* Cts */ + ]) ? ".d.cts" : xc(e, [ + ".json" + /* Json */ + ]) ? ".d.json.ts" : ( + // Drive-by redefinition of json declaration file output name so if it's ever enabled, it behaves well + ".d.ts" + ); + } + function YB(e) { + return xc(e, [ + ".d.mts", + ".mjs", + ".mts" + /* Mts */ + ]) ? [ + ".mts", + ".mjs" + /* Mjs */ + ] : xc(e, [ + ".d.cts", + ".cjs", + ".cts" + /* Cts */ + ]) ? [ + ".cts", + ".cjs" + /* Cjs */ + ] : xc(e, [".d.json.ts"]) ? [ + ".json" + /* Json */ + ] : [ + ".tsx", + ".ts", + ".jsx", + ".js" + /* Js */ + ]; + } + function ZB(e, t, n, i) { + return n ? by( + i(), + Nf(n, e, t) + ) : e; + } + function C5(e, t) { + var n; + if (e.paths) + return e.baseUrl ?? E.checkDefined(e.pathsBasePath || ((n = t.getCurrentDirectory) == null ? void 0 : n.call(t)), "Encountered 'paths' without a 'baseUrl', config file, or host 'getCurrentDirectory'."); + } + function E5(e, t, n) { + const i = e.getCompilerOptions(); + if (i.outFile) { + const s = Hu(i), o = i.emitDeclarationOnly || s === 2 || s === 4; + return kn( + e.getSourceFiles(), + (c) => (o || !fl(c)) && Mb(c, e, n) + ); + } else { + const s = t === void 0 ? e.getSourceFiles() : [t]; + return kn( + s, + (o) => Mb(o, e, n) + ); + } + } + function Mb(e, t, n) { + const i = t.getCompilerOptions(); + if (i.noEmitForJsFiles && n_(e) || e.isDeclarationFile || t.isSourceFileFromExternalLibrary(e)) return !1; + if (n) return !0; + if (t.isSourceOfProjectReferenceRedirect(e.fileName)) return !1; + if (!ap(e)) return !0; + if (t.getRedirectFromSourceFile(e.fileName)) return !1; + if (i.outFile) return !0; + if (!i.outDir) return !1; + if (i.rootDir || i.composite && i.configFilePath) { + const s = Qi(aw(i, () => [], t.getCurrentDirectory(), t.getCanonicalFileName), t.getCurrentDirectory()), o = $K(e.fileName, i.outDir, t.getCurrentDirectory(), s, t.getCanonicalFileName); + if (gh(e.fileName, o, t.getCurrentDirectory(), !t.useCaseSensitiveFileNames()) === 0) return !1; + } + return !0; + } + function D5(e, t, n) { + return $K(e, n, t.getCurrentDirectory(), t.getCommonSourceDirectory(), (i) => t.getCanonicalFileName(i)); + } + function $K(e, t, n, i, s) { + let o = Qi(e, n); + return o = s(o).indexOf(s(i)) === 0 ? o.substring(i.length) : o, On(t, o); + } + function w5(e, t, n, i, s, o, c) { + e.writeFile( + n, + i, + s, + (_) => { + t.add(Yo(p.Could_not_write_file_0_Colon_1, n, _)); + }, + o, + c + ); + } + function jhe(e, t, n) { + if (e.length > kd(e) && !n(e)) { + const i = Hn(e); + jhe(i, t, n), t(e); + } + } + function KB(e, t, n, i, s, o) { + try { + i(e, t, n); + } catch { + jhe(Hn(Hs(e)), s, o), i(e, t, n); + } + } + function KD(e, t) { + const n = kg(e); + return dD(n, t); + } + function ZC(e, t) { + return dD(e, t); + } + function Mg(e) { + return Nn(e.members, (t) => nc(t) && Mp(t.body)); + } + function e4(e) { + if (e && e.parameters.length > 0) { + const t = e.parameters.length === 2 && My(e.parameters[0]); + return e.parameters[t ? 1 : 0]; + } + } + function XK(e) { + const t = e4(e); + return t && t.type; + } + function Rb(e) { + if (e.parameters.length && !w0(e)) { + const t = e.parameters[0]; + if (My(t)) + return t; + } + } + function My(e) { + return Ry(e.name); + } + function Ry(e) { + return !!e && e.kind === 80 && eJ(e); + } + function Tx(e) { + return !!dr( + e, + (t) => t.kind === 187 ? !0 : t.kind === 80 || t.kind === 167 ? !1 : "quit" + ); + } + function jb(e) { + if (!Ry(e)) + return !1; + for (; s_(e.parent) && e.parent.left === e; ) + e = e.parent; + return e.parent.kind === 187; + } + function eJ(e) { + return e.escapedText === "this"; + } + function Bb(e, t) { + let n, i, s, o; + return Th(t) ? (n = t, t.kind === 178 ? s = t : t.kind === 179 ? o = t : E.fail("Accessor has wrong kind")) : lr(e, (c) => { + if (Dy(c) && Js(c) === Js(t)) { + const _ = dS(c.name), u = dS(t.name); + _ === u && (n ? i || (i = c) : n = c, c.kind === 178 && !s && (s = c), c.kind === 179 && !o && (o = c)); + } + }), { + firstAccessor: n, + secondAccessor: i, + getAccessor: s, + setAccessor: o + }; + } + function Kc(e) { + if (!an(e) && Cc(e) || Wp(e)) return; + const t = e.type; + return t || !an(e) ? t : kD(e) ? e.typeExpression && e.typeExpression.type : f0(e); + } + function QK(e) { + return e.type; + } + function nf(e) { + return w0(e) ? e.type && e.type.typeExpression && e.type.typeExpression.type : e.type || (an(e) ? i3(e) : void 0); + } + function P5(e) { + return ka(W1(e), (t) => WOe(t) ? t.typeParameters : void 0); + } + function WOe(e) { + return Up(e) && !(e.parent.kind === 321 && (e.parent.tags.some(jp) || e.parent.tags.some(S6))); + } + function tJ(e) { + const t = e4(e); + return t && Kc(t); + } + function UOe(e, t, n, i) { + VOe(e, t, n.pos, i); + } + function VOe(e, t, n, i) { + i && i.length && n !== i[0].pos && ZC(e, n) !== ZC(e, i[0].pos) && t.writeLine(); + } + function YK(e, t, n, i) { + n !== i && ZC(e, n) !== ZC(e, i) && t.writeLine(); + } + function qOe(e, t, n, i, s, o, c, _) { + if (i && i.length > 0) { + let u = !1; + for (const g of i) + u && (n.writeSpace(" "), u = !1), _(e, t, n, g.pos, g.end, c), g.hasTrailingNewLine ? n.writeLine() : u = !0; + u && o && n.writeSpace(" "); + } + } + function ZK(e, t, n, i, s, o, c) { + let _, u; + if (c ? s.pos === 0 && (_ = kn(Eg(e, s.pos), g)) : _ = Eg(e, s.pos), _) { + const m = []; + let h; + for (const S of _) { + if (h) { + const T = ZC(t, h.end); + if (ZC(t, S.pos) >= T + 2) + break; + } + m.push(S), h = S; + } + if (m.length) { + const S = ZC(t, pa(m).end); + ZC(t, oa(e, s.pos)) >= S + 2 && (UOe(t, n, s, _), qOe( + e, + t, + n, + m, + /*leadingSeparator*/ + !1, + /*trailingSeparator*/ + !0, + o, + i + ), u = { nodePos: s.pos, detachedCommentEndPos: pa(m).end }); + } + } + return u; + function g(m) { + return U7(e, m.pos); + } + } + function KC(e, t, n, i, s, o) { + if (e.charCodeAt(i + 1) === 42) { + const c = CC(t, i), _ = t.length; + let u; + for (let g = i, m = c.line; g < s; m++) { + const h = m + 1 === _ ? e.length + 1 : t[m + 1]; + if (g !== i) { + u === void 0 && (u = Bhe(e, t[c.line], i)); + const T = n.getIndent() * rN() - u + Bhe(e, g, h); + if (T > 0) { + let k = T % rN(); + const D = T5((T - k) / rN()); + for (n.rawWrite(D); k; ) + n.rawWrite(" "), k--; + } else + n.rawWrite(""); + } + HOe(e, s, n, o, g, h), g = h; + } + } else + n.writeComment(e.substring(i, s)); + } + function HOe(e, t, n, i, s, o) { + const c = Math.min(t, o - 1), _ = e.substring(s, c).trim(); + _ ? (n.writeComment(_), c !== t && n.writeLine()) : n.rawWrite(i); + } + function Bhe(e, t, n) { + let i = 0; + for (; t < n && im(e.charCodeAt(t)); t++) + e.charCodeAt(t) === 9 ? i += rN() - i % rN() : i++; + return i; + } + function rJ(e) { + return pu(e) !== 0; + } + function KK(e) { + return h0(e) !== 0; + } + function sf(e, t) { + return !!xx(e, t); + } + function Gn(e, t) { + return !!eee(e, t); + } + function Js(e) { + return Hc(e) && cl(e) || kc(e); + } + function cl(e) { + return Gn( + e, + 256 + /* Static */ + ); + } + function N5(e) { + return sf( + e, + 16 + /* Override */ + ); + } + function Jb(e) { + return Gn( + e, + 64 + /* Abstract */ + ); + } + function nJ(e) { + return Gn( + e, + 128 + /* Ambient */ + ); + } + function fm(e) { + return Gn( + e, + 512 + /* Accessor */ + ); + } + function gS(e) { + return sf( + e, + 8 + /* Readonly */ + ); + } + function Ff(e) { + return Gn( + e, + 32768 + /* Decorator */ + ); + } + function xx(e, t) { + return pu(e) & t; + } + function eee(e, t) { + return h0(e) & t; + } + function tee(e, t, n) { + return e.kind >= 0 && e.kind <= 166 ? 0 : (e.modifierFlagsCache & 536870912 || (e.modifierFlagsCache = iJ(e) | 536870912), n || t && an(e) ? (!(e.modifierFlagsCache & 268435456) && e.parent && (e.modifierFlagsCache |= Jhe(e) | 268435456), zhe(e.modifierFlagsCache)) : GOe(e.modifierFlagsCache)); + } + function pu(e) { + return tee( + e, + /*includeJSDoc*/ + !0 + ); + } + function ree(e) { + return tee( + e, + /*includeJSDoc*/ + !0, + /*alwaysIncludeJSDoc*/ + !0 + ); + } + function h0(e) { + return tee( + e, + /*includeJSDoc*/ + !1 + ); + } + function Jhe(e) { + let t = 0; + return e.parent && !Ii(e) && (an(e) && (pZ(e) && (t |= 8388608), dZ(e) && (t |= 16777216), mZ(e) && (t |= 33554432), gZ(e) && (t |= 67108864), hZ(e) && (t |= 134217728)), yZ(e) && (t |= 65536)), t; + } + function GOe(e) { + return e & 65535; + } + function zhe(e) { + return e & 131071 | (e & 260046848) >>> 23; + } + function $Oe(e) { + return zhe(Jhe(e)); + } + function nee(e) { + return iJ(e) | $Oe(e); + } + function iJ(e) { + let t = Vp(e) ? pm(e.modifiers) : 0; + return (e.flags & 8 || e.kind === 80 && e.flags & 4096) && (t |= 32), t; + } + function pm(e) { + let t = 0; + if (e) + for (const n of e) + t |= kx(n.kind); + return t; + } + function kx(e) { + switch (e) { + case 126: + return 256; + case 125: + return 1; + case 124: + return 4; + case 123: + return 2; + case 128: + return 64; + case 129: + return 512; + case 95: + return 32; + case 138: + return 128; + case 87: + return 4096; + case 90: + return 2048; + case 134: + return 1024; + case 148: + return 8; + case 164: + return 16; + case 103: + return 8192; + case 147: + return 16384; + case 171: + return 32768; + } + return 0; + } + function iN(e) { + return e === 57 || e === 56; + } + function iee(e) { + return iN(e) || e === 54; + } + function t4(e) { + return e === 76 || e === 77 || e === 78; + } + function sJ(e) { + return _n(e) && t4(e.operatorToken.kind); + } + function A5(e) { + return iN(e) || e === 61; + } + function sN(e) { + return _n(e) && A5(e.operatorToken.kind); + } + function kh(e) { + return e >= 64 && e <= 79; + } + function aJ(e) { + const t = oJ(e); + return t && !t.isImplements ? t.class : void 0; + } + function oJ(e) { + if (Dh(e)) { + if (cf(e.parent) && $n(e.parent.parent)) + return { + class: e.parent.parent, + isImplements: e.parent.token === 119 + /* ImplementsKeyword */ + }; + if (Yx(e.parent)) { + const t = X1(e.parent); + if (t && $n(t)) + return { class: t, isImplements: !1 }; + } + } + } + function Nl(e, t) { + return _n(e) && (t ? e.operatorToken.kind === 64 : kh(e.operatorToken.kind)) && S_(e.left); + } + function y0(e) { + if (Nl( + e, + /*excludeCompoundAssignment*/ + !0 + )) { + const t = e.left.kind; + return t === 211 || t === 210; + } + return !1; + } + function I5(e) { + return aJ(e) !== void 0; + } + function to(e) { + return e.kind === 80 || oN(e); + } + function i_(e) { + switch (e.kind) { + case 80: + return e; + case 167: + do + e = e.left; + while (e.kind !== 80); + return e; + case 212: + do + e = e.expression; + while (e.kind !== 80); + return e; + } + } + function aN(e) { + return e.kind === 80 || e.kind === 110 || e.kind === 108 || e.kind === 237 || e.kind === 212 && aN(e.expression) || e.kind === 218 && aN(e.expression); + } + function oN(e) { + return wn(e) && Me(e.name) && to(e.expression); + } + function cN(e) { + if (wn(e)) { + const t = cN(e.expression); + if (t !== void 0) + return t + "." + ef(e.name); + } else if (uo(e)) { + const t = cN(e.expression); + if (t !== void 0 && qc(e.argumentExpression)) + return t + "." + dS(e.argumentExpression); + } else { + if (Me(e)) + return Si(e.escapedText); + if (Fd(e)) + return T4(e); + } + } + function jy(e) { + return Ib(e) && Sh(e) === "prototype"; + } + function r4(e) { + return e.parent.kind === 167 && e.parent.right === e || e.parent.kind === 212 && e.parent.name === e || e.parent.kind === 237 && e.parent.name === e; + } + function cJ(e) { + return !!e.parent && (wn(e.parent) && e.parent.name === e || uo(e.parent) && e.parent.argumentExpression === e); + } + function see(e) { + return s_(e.parent) && e.parent.right === e || wn(e.parent) && e.parent.name === e || uv(e.parent) && e.parent.right === e; + } + function F5(e) { + return _n(e) && e.operatorToken.kind === 104; + } + function aee(e) { + return F5(e.parent) && e === e.parent.right; + } + function lJ(e) { + return e.kind === 211 && e.properties.length === 0; + } + function oee(e) { + return e.kind === 210 && e.elements.length === 0; + } + function n4(e) { + if (!(!XOe(e) || !e.declarations)) { + for (const t of e.declarations) + if (t.localSymbol) return t.localSymbol; + } + } + function XOe(e) { + return e && wr(e.declarations) > 0 && Gn( + e.declarations[0], + 2048 + /* Default */ + ); + } + function O5(e) { + return Nn(x9e, (t) => Xo(e, t)); + } + function QOe(e) { + const t = [], n = e.length; + for (let i = 0; i < n; i++) { + const s = e.charCodeAt(i); + s < 128 ? t.push(s) : s < 2048 ? (t.push(s >> 6 | 192), t.push(s & 63 | 128)) : s < 65536 ? (t.push(s >> 12 | 224), t.push(s >> 6 & 63 | 128), t.push(s & 63 | 128)) : s < 131072 ? (t.push(s >> 18 | 240), t.push(s >> 12 & 63 | 128), t.push(s >> 6 & 63 | 128), t.push(s & 63 | 128)) : E.assert(!1, "Unexpected code point"); + } + return t; + } + var Cx = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; + function cee(e) { + let t = ""; + const n = QOe(e); + let i = 0; + const s = n.length; + let o, c, _, u; + for (; i < s; ) + o = n[i] >> 2, c = (n[i] & 3) << 4 | n[i + 1] >> 4, _ = (n[i + 1] & 15) << 2 | n[i + 2] >> 6, u = n[i + 2] & 63, i + 1 >= s ? _ = u = 64 : i + 2 >= s && (u = 64), t += Cx.charAt(o) + Cx.charAt(c) + Cx.charAt(_) + Cx.charAt(u), i += 3; + return t; + } + function YOe(e) { + let t = "", n = 0; + const i = e.length; + for (; n < i; ) { + const s = e[n]; + if (s < 128) + t += String.fromCharCode(s), n++; + else if ((s & 192) === 192) { + let o = s & 63; + n++; + let c = e[n]; + for (; (c & 192) === 128; ) + o = o << 6 | c & 63, n++, c = e[n]; + t += String.fromCharCode(o); + } else + t += String.fromCharCode(s), n++; + } + return t; + } + function lee(e, t) { + return e && e.base64encode ? e.base64encode(t) : cee(t); + } + function uee(e, t) { + if (e && e.base64decode) + return e.base64decode(t); + const n = t.length, i = []; + let s = 0; + for (; s < n && t.charCodeAt(s) !== Cx.charCodeAt(64); ) { + const o = Cx.indexOf(t[s]), c = Cx.indexOf(t[s + 1]), _ = Cx.indexOf(t[s + 2]), u = Cx.indexOf(t[s + 3]), g = (o & 63) << 2 | c >> 4 & 3, m = (c & 15) << 4 | _ >> 2 & 15, h = (_ & 3) << 6 | u & 63; + m === 0 && _ !== 0 ? i.push(g) : h === 0 && u !== 0 ? i.push(g, m) : i.push(g, m, h), s += 4; + } + return YOe(i); + } + function uJ(e, t) { + const n = gs(t) ? t : t.readFile(e); + if (!n) return; + let i = lN(n); + if (i === void 0) { + const s = eW(e, n); + s.error || (i = s.config); + } + return i; + } + function e6(e, t) { + return uJ(e, t) || {}; + } + function lN(e) { + try { + return JSON.parse(e); + } catch { + return; + } + } + function Pd(e, t) { + return !t.directoryExists || t.directoryExists(e); + } + var ZOe = `\r +`, KOe = ` +`; + function v0(e) { + switch (e.newLine) { + case 0: + return ZOe; + case 1: + case void 0: + return KOe; + } + } + function cp(e, t = e) { + return E.assert(t >= e || t === -1), { pos: e, end: t }; + } + function L5(e, t) { + return cp(e.pos, t); + } + function Z1(e, t) { + return cp(t, e.end); + } + function Ch(e) { + const t = Vp(e) ? gb(e.modifiers, ul) : void 0; + return t && !Nd(t.end) ? Z1(e, t.end) : e; + } + function dm(e) { + if (os(e) || rc(e)) + return Z1(e, e.name.pos); + const t = Vp(e) ? Do(e.modifiers) : void 0; + return t && !Nd(t.end) ? Z1(e, t.end) : Ch(e); + } + function _J(e, t) { + return cp(e, e + qs(t).length); + } + function hS(e, t) { + return fee(e, e, t); + } + function M5(e, t, n) { + return lp( + i4( + e, + n, + /*includeComments*/ + !1 + ), + i4( + t, + n, + /*includeComments*/ + !1 + ), + n + ); + } + function _ee(e, t, n) { + return lp(e.end, t.end, n); + } + function fee(e, t, n) { + return lp(i4( + e, + n, + /*includeComments*/ + !1 + ), t.end, n); + } + function uN(e, t, n) { + return lp(e.end, i4( + t, + n, + /*includeComments*/ + !1 + ), n); + } + function fJ(e, t, n, i) { + const s = i4(t, n, i); + return mD(n, e.end, s); + } + function Whe(e, t, n) { + return mD(n, e.end, t.end); + } + function pee(e, t) { + return !lp(e.pos, e.end, t); + } + function lp(e, t, n) { + return mD(n, e, t) === 0; + } + function i4(e, t, n) { + return Nd(e.pos) ? -1 : oa( + t.text, + e.pos, + /*stopAfterLineBreak*/ + !1, + n + ); + } + function dee(e, t, n, i) { + const s = oa( + n.text, + e, + /*stopAfterLineBreak*/ + !1, + i + ), o = e9e(s, t, n); + return mD(n, o ?? t, s); + } + function mee(e, t, n, i) { + const s = oa( + n.text, + e, + /*stopAfterLineBreak*/ + !1, + i + ); + return mD(n, e, Math.min(t, s)); + } + function C_(e, t) { + return pJ(e.pos, e.end, t); + } + function pJ(e, t, n) { + return e <= n.pos && t >= n.end; + } + function e9e(e, t = 0, n) { + for (; e-- > t; ) + if (!Cg(n.text.charCodeAt(e))) + return e; + } + function dJ(e) { + const t = vs(e); + if (t) + switch (t.parent.kind) { + case 267: + case 268: + return t === t.parent.name; + } + return !1; + } + function s4(e) { + return kn(e.declarations, _N); + } + function _N(e) { + return ei(e) && e.initializer !== void 0; + } + function mJ(e) { + return e.watch && eo(e, "watch"); + } + function od(e) { + e.close(); + } + function uc(e) { + return e.flags & 33554432 ? e.links.checkFlags : 0; + } + function up(e, t = !1) { + if (e.valueDeclaration) { + const n = t && e.declarations && Nn(e.declarations, z_) || e.flags & 32768 && Nn(e.declarations, pp) || e.valueDeclaration, i = J1(n); + return e.parent && e.parent.flags & 32 ? i : i & -8; + } + if (uc(e) & 6) { + const n = e.links.checkFlags, i = n & 1024 ? 2 : n & 256 ? 1 : 4, s = n & 2048 ? 256 : 0; + return i | s; + } + return e.flags & 4194304 ? 257 : 0; + } + function eu(e, t) { + return e.flags & 2097152 ? t.getAliasedSymbol(e) : e; + } + function t6(e) { + return e.exportSymbol ? e.exportSymbol.flags | e.flags : e.flags; + } + function R5(e) { + return a4(e) === 1; + } + function Ex(e) { + return a4(e) !== 0; + } + function a4(e) { + const { parent: t } = e; + switch (t?.kind) { + case 218: + return a4(t); + case 226: + case 225: + const { operator: n } = t; + return n === 46 || n === 47 ? 2 : 0; + case 227: + const { left: i, operatorToken: s } = t; + return i === e && kh(s.kind) ? s.kind === 64 ? 1 : 2 : 0; + case 212: + return t.name !== e ? 0 : a4(t); + case 304: { + const o = a4(t.parent); + return e === t.name ? t9e(o) : o; + } + case 305: + return e === t.objectAssignmentInitializer ? 0 : a4(t.parent); + case 210: + return a4(t); + case 250: + case 251: + return e === t.initializer ? 1 : 0; + default: + return 0; + } + } + function t9e(e) { + switch (e) { + case 0: + return 1; + case 1: + return 0; + case 2: + return 2; + default: + return E.assertNever(e); + } + } + function gJ(e, t) { + if (!e || !t || Object.keys(e).length !== Object.keys(t).length) + return !1; + for (const n in e) + if (typeof e[n] == "object") { + if (!gJ(e[n], t[n])) + return !1; + } else if (typeof e[n] != "function" && e[n] !== t[n]) + return !1; + return !0; + } + function B_(e, t) { + e.forEach(t), e.clear(); + } + function Rg(e, t, n) { + const { onDeleteValue: i, onExistingValue: s } = n; + e.forEach((o, c) => { + var _; + t?.has(c) ? s && s(o, (_ = t.get) == null ? void 0 : _.call(t, c), c) : (e.delete(c), i(o, c)); + }); + } + function o4(e, t, n) { + Rg(e, t, n); + const { createNewValue: i } = n; + t?.forEach((s, o) => { + e.has(o) || e.set(o, i(o, s)); + }); + } + function gee(e) { + if (e.flags & 32) { + const t = Eh(e); + return !!t && Gn( + t, + 64 + /* Abstract */ + ); + } + return !1; + } + function Eh(e) { + var t; + return (t = e.declarations) == null ? void 0 : t.find($n); + } + function Dn(e) { + return e.flags & 3899393 ? e.objectFlags : 0; + } + function j5(e) { + return !!e && !!e.declarations && !!e.declarations[0] && zN(e.declarations[0]); + } + function hee({ moduleSpecifier: e }) { + return ca(e) ? e.text : Qo(e); + } + function hJ(e) { + let t; + return xs(e, (n) => { + Mp(n) && (t = n); + }, (n) => { + for (let i = n.length - 1; i >= 0; i--) + if (Mp(n[i])) { + t = n[i]; + break; + } + }), t; + } + function Jp(e, t) { + return e.has(t) ? !1 : (e.add(t), !0); + } + function Dx(e) { + return $n(e) || Vl(e) || a_(e); + } + function yJ(e) { + return e >= 183 && e <= 206 || e === 133 || e === 159 || e === 150 || e === 163 || e === 151 || e === 136 || e === 154 || e === 155 || e === 116 || e === 157 || e === 146 || e === 141 || e === 234 || e === 313 || e === 314 || e === 315 || e === 316 || e === 317 || e === 318 || e === 319; + } + function To(e) { + return e.kind === 212 || e.kind === 213; + } + function vJ(e) { + return e.kind === 212 ? e.name : (E.assert( + e.kind === 213 + /* ElementAccessExpression */ + ), e.argumentExpression); + } + function B5(e) { + return e.kind === 276 || e.kind === 280; + } + function r6(e) { + for (; To(e); ) + e = e.expression; + return e; + } + function yee(e, t) { + if (To(e.parent) && cJ(e)) + return n(e.parent); + function n(i) { + if (i.kind === 212) { + const s = t(i.name); + if (s !== void 0) + return s; + } else if (i.kind === 213) + if (Me(i.argumentExpression) || ja(i.argumentExpression)) { + const s = t(i.argumentExpression); + if (s !== void 0) + return s; + } else + return; + if (To(i.expression)) + return n(i.expression); + if (Me(i.expression)) + return t(i.expression); + } + } + function n6(e, t) { + for (; ; ) { + switch (e.kind) { + case 226: + e = e.operand; + continue; + case 227: + e = e.left; + continue; + case 228: + e = e.condition; + continue; + case 216: + e = e.tag; + continue; + case 214: + if (t) + return e; + // falls through + case 235: + case 213: + case 212: + case 236: + case 356: + case 239: + e = e.expression; + continue; + } + return e; + } + } + function r9e(e, t) { + this.flags = e, this.escapedName = t, this.declarations = void 0, this.valueDeclaration = void 0, this.id = 0, this.mergeId = 0, this.parent = void 0, this.members = void 0, this.exports = void 0, this.exportSymbol = void 0, this.constEnumOnlyModule = void 0, this.isReferenced = void 0, this.lastAssignmentPos = void 0, this.links = void 0; + } + function n9e(e, t) { + this.flags = t, (E.isDebugging || on) && (this.checker = e); + } + function i9e(e, t) { + this.flags = t, E.isDebugging && (this.checker = e); + } + function vee(e, t, n) { + this.pos = t, this.end = n, this.kind = e, this.id = 0, this.flags = 0, this.modifierFlagsCache = 0, this.transformFlags = 0, this.parent = void 0, this.original = void 0, this.emitNode = void 0; + } + function s9e(e, t, n) { + this.pos = t, this.end = n, this.kind = e, this.id = 0, this.flags = 0, this.transformFlags = 0, this.parent = void 0, this.emitNode = void 0; + } + function a9e(e, t, n) { + this.pos = t, this.end = n, this.kind = e, this.id = 0, this.flags = 0, this.transformFlags = 0, this.parent = void 0, this.original = void 0, this.emitNode = void 0; + } + function o9e(e, t, n) { + this.fileName = e, this.text = t, this.skipTrivia = n || ((i) => i); + } + var tu = { + getNodeConstructor: () => vee, + getTokenConstructor: () => s9e, + getIdentifierConstructor: () => a9e, + getPrivateIdentifierConstructor: () => vee, + getSourceFileConstructor: () => vee, + getSymbolConstructor: () => r9e, + getTypeConstructor: () => n9e, + getSignatureConstructor: () => i9e, + getSourceMapSourceConstructor: () => o9e + }, Uhe = []; + function Vhe(e) { + Uhe.push(e), e(tu); + } + function bee(e) { + Object.assign(tu, e), lr(Uhe, (t) => t(tu)); + } + function jg(e, t) { + return e.replace(/\{(\d+)\}/g, (n, i) => "" + E.checkDefined(t[+i])); + } + var J5; + function See(e) { + J5 = e; + } + function Tee(e) { + !J5 && e && (J5 = e()); + } + function Ss(e) { + return J5 && J5[e.key] || e.message; + } + function wx(e, t, n, i, s, ...o) { + n + i > t.length && (i = t.length - n), oK(t, n, i); + let c = Ss(s); + return ot(o) && (c = jg(c, o)), { + file: void 0, + start: n, + length: i, + messageText: c, + category: s.category, + code: s.code, + reportsUnnecessary: s.reportsUnnecessary, + fileName: e + }; + } + function c9e(e) { + return e.file === void 0 && e.start !== void 0 && e.length !== void 0 && typeof e.fileName == "string"; + } + function qhe(e, t) { + const n = t.fileName || "", i = t.text.length; + E.assertEqual(e.fileName, n), E.assertLessThanOrEqual(e.start, i), E.assertLessThanOrEqual(e.start + e.length, i); + const s = { + file: t, + start: e.start, + length: e.length, + messageText: e.messageText, + category: e.category, + code: e.code, + reportsUnnecessary: e.reportsUnnecessary + }; + if (e.relatedInformation) { + s.relatedInformation = []; + for (const o of e.relatedInformation) + c9e(o) && o.fileName === n ? (E.assertLessThanOrEqual(o.start, i), E.assertLessThanOrEqual(o.start + o.length, i), s.relatedInformation.push(qhe(o, t))) : s.relatedInformation.push(o); + } + return s; + } + function Px(e, t) { + const n = []; + for (const i of e) + n.push(qhe(i, t)); + return n; + } + function ll(e, t, n, i, ...s) { + oK(e.text, t, n); + let o = Ss(i); + return ot(s) && (o = jg(o, s)), { + file: e, + start: t, + length: n, + messageText: o, + category: i.category, + code: i.code, + reportsUnnecessary: i.reportsUnnecessary, + reportsDeprecated: i.reportsDeprecated + }; + } + function Nx(e, ...t) { + let n = Ss(e); + return ot(t) && (n = jg(n, t)), n; + } + function Yo(e, ...t) { + let n = Ss(e); + return ot(t) && (n = jg(n, t)), { + file: void 0, + start: void 0, + length: void 0, + messageText: n, + category: e.category, + code: e.code, + reportsUnnecessary: e.reportsUnnecessary, + reportsDeprecated: e.reportsDeprecated + }; + } + function z5(e, t) { + return { + file: void 0, + start: void 0, + length: void 0, + code: e.code, + category: e.category, + messageText: e.next ? e : e.messageText, + relatedInformation: t + }; + } + function Ts(e, t, ...n) { + let i = Ss(t); + return ot(n) && (i = jg(i, n)), { + messageText: i, + category: t.category, + code: t.code, + next: e === void 0 || Array.isArray(e) ? e : [e] + }; + } + function xee(e, t) { + let n = e; + for (; n.next; ) + n = n.next[0]; + n.next = [t]; + } + function bJ(e) { + return e.file ? e.file.path : void 0; + } + function c4(e, t) { + return kee(e, t) || l9e(e, t) || 0; + } + function kee(e, t) { + const n = SJ(e), i = SJ(t); + return _u(bJ(e), bJ(t)) || ho(e.start, t.start) || ho(e.length, t.length) || ho(n, i) || u9e(e, t) || 0; + } + function l9e(e, t) { + return !e.relatedInformation && !t.relatedInformation ? 0 : e.relatedInformation && t.relatedInformation ? ho(t.relatedInformation.length, e.relatedInformation.length) || lr(e.relatedInformation, (n, i) => { + const s = t.relatedInformation[i]; + return c4(n, s); + }) || 0 : e.relatedInformation ? -1 : 1; + } + function u9e(e, t) { + let n = TJ(e), i = TJ(t); + typeof n != "string" && (n = n.messageText), typeof i != "string" && (i = i.messageText); + const s = typeof e.messageText != "string" ? e.messageText.next : void 0, o = typeof t.messageText != "string" ? t.messageText.next : void 0; + let c = _u(n, i); + return c || (c = _9e(s, o), c) ? c : e.canonicalHead && !t.canonicalHead ? -1 : t.canonicalHead && !e.canonicalHead ? 1 : 0; + } + function _9e(e, t) { + return e === void 0 && t === void 0 ? 0 : e === void 0 ? 1 : t === void 0 ? -1 : Hhe(e, t) || Ghe(e, t); + } + function Hhe(e, t) { + if (e === void 0 && t === void 0) + return 0; + if (e === void 0) + return 1; + if (t === void 0) + return -1; + let n = ho(t.length, e.length); + if (n) + return n; + for (let i = 0; i < t.length; i++) + if (n = Hhe(e[i].next, t[i].next), n) + return n; + return 0; + } + function Ghe(e, t) { + let n; + for (let i = 0; i < t.length; i++) { + if (n = _u(e[i].messageText, t[i].messageText), n) + return n; + if (e[i].next !== void 0 && (n = Ghe(e[i].next, t[i].next), n)) + return n; + } + return 0; + } + function W5(e, t) { + const n = SJ(e), i = SJ(t), s = TJ(e), o = TJ(t); + return _u(bJ(e), bJ(t)) === 0 && ho(e.start, t.start) === 0 && ho(e.length, t.length) === 0 && ho(n, i) === 0 && f9e(s, o); + } + function SJ(e) { + var t; + return ((t = e.canonicalHead) == null ? void 0 : t.code) || e.code; + } + function TJ(e) { + var t; + return ((t = e.canonicalHead) == null ? void 0 : t.messageText) || e.messageText; + } + function f9e(e, t) { + const n = typeof e == "string" ? e : e.messageText, i = typeof t == "string" ? t : t.messageText; + return _u(n, i) === 0; + } + function fN(e) { + return e === 4 || e === 2 || e === 1 || e === 6 ? 1 : 0; + } + function $he(e) { + if (e.transformFlags & 2) + return wu(e) || cv(e) ? e : xs(e, $he); + } + function p9e(e) { + return e.isDeclarationFile ? void 0 : $he(e); + } + function d9e(e, t) { + return (zS(e, t) === 99 || xc(e.fileName, [ + ".cjs", + ".cts", + ".mjs", + ".mts" + /* Mts */ + ])) && !e.isDeclarationFile ? !0 : void 0; + } + function pN(e) { + switch (Eee(e)) { + case 3: + return (s) => { + s.externalModuleIndicator = ZN(s) || !s.isDeclarationFile || void 0; + }; + case 1: + return (s) => { + s.externalModuleIndicator = ZN(s); + }; + case 2: + const t = [ZN]; + (e.jsx === 4 || e.jsx === 5) && t.push(p9e), t.push(d9e); + const n = Q_(...t); + return (s) => void (s.externalModuleIndicator = n(s, e)); + } + } + function xJ(e) { + const t = Pu(e); + return 3 <= t && t <= 99 || dN(e) || mN(e); + } + function xpt(e) { + return e; + } + var ru = { + allowImportingTsExtensions: { + dependencies: ["rewriteRelativeImportExtensions"], + computeValue: (e) => !!(e.allowImportingTsExtensions || e.rewriteRelativeImportExtensions) + }, + target: { + dependencies: ["module"], + computeValue: (e) => (e.target === 0 ? void 0 : e.target) ?? (e.module === 100 && 9 || e.module === 101 && 9 || e.module === 102 && 10 || e.module === 199 && 99 || 1) + }, + module: { + dependencies: ["target"], + computeValue: (e) => typeof e.module == "number" ? e.module : ru.target.computeValue(e) >= 2 ? 5 : 1 + }, + moduleResolution: { + dependencies: ["module", "target"], + computeValue: (e) => { + let t = e.moduleResolution; + if (t === void 0) + switch (ru.module.computeValue(e)) { + case 1: + t = 2; + break; + case 100: + case 101: + case 102: + t = 3; + break; + case 199: + t = 99; + break; + case 200: + t = 100; + break; + default: + t = 1; + break; + } + return t; + } + }, + moduleDetection: { + dependencies: ["module", "target"], + computeValue: (e) => { + if (e.moduleDetection !== void 0) + return e.moduleDetection; + const t = ru.module.computeValue(e); + return 100 <= t && t <= 199 ? 3 : 2; + } + }, + isolatedModules: { + dependencies: ["verbatimModuleSyntax"], + computeValue: (e) => !!(e.isolatedModules || e.verbatimModuleSyntax) + }, + esModuleInterop: { + dependencies: ["module", "target"], + computeValue: (e) => { + if (e.esModuleInterop !== void 0) + return e.esModuleInterop; + switch (ru.module.computeValue(e)) { + case 100: + case 101: + case 102: + case 199: + case 200: + return !0; + } + return !1; + } + }, + allowSyntheticDefaultImports: { + dependencies: ["module", "target", "moduleResolution"], + computeValue: (e) => e.allowSyntheticDefaultImports !== void 0 ? e.allowSyntheticDefaultImports : ru.esModuleInterop.computeValue(e) || ru.module.computeValue(e) === 4 || ru.moduleResolution.computeValue(e) === 100 + }, + resolvePackageJsonExports: { + dependencies: ["moduleResolution"], + computeValue: (e) => { + const t = ru.moduleResolution.computeValue(e); + if (!i6(t)) + return !1; + if (e.resolvePackageJsonExports !== void 0) + return e.resolvePackageJsonExports; + switch (t) { + case 3: + case 99: + case 100: + return !0; + } + return !1; + } + }, + resolvePackageJsonImports: { + dependencies: ["moduleResolution", "resolvePackageJsonExports"], + computeValue: (e) => { + const t = ru.moduleResolution.computeValue(e); + if (!i6(t)) + return !1; + if (e.resolvePackageJsonImports !== void 0) + return e.resolvePackageJsonImports; + switch (t) { + case 3: + case 99: + case 100: + return !0; + } + return !1; + } + }, + resolveJsonModule: { + dependencies: ["moduleResolution", "module", "target"], + computeValue: (e) => { + if (e.resolveJsonModule !== void 0) + return e.resolveJsonModule; + switch (ru.module.computeValue(e)) { + // TODO in 6.0: uncomment + // case ModuleKind.Node16: + // case ModuleKind.Node18: + case 102: + case 199: + return !0; + } + return ru.moduleResolution.computeValue(e) === 100; + } + }, + declaration: { + dependencies: ["composite"], + computeValue: (e) => !!(e.declaration || e.composite) + }, + preserveConstEnums: { + dependencies: ["isolatedModules", "verbatimModuleSyntax"], + computeValue: (e) => !!(e.preserveConstEnums || ru.isolatedModules.computeValue(e)) + }, + incremental: { + dependencies: ["composite"], + computeValue: (e) => !!(e.incremental || e.composite) + }, + declarationMap: { + dependencies: ["declaration", "composite"], + computeValue: (e) => !!(e.declarationMap && ru.declaration.computeValue(e)) + }, + allowJs: { + dependencies: ["checkJs"], + computeValue: (e) => e.allowJs === void 0 ? !!e.checkJs : e.allowJs + }, + useDefineForClassFields: { + dependencies: ["target", "module"], + computeValue: (e) => e.useDefineForClassFields === void 0 ? ru.target.computeValue(e) >= 9 : e.useDefineForClassFields + }, + noImplicitAny: { + dependencies: ["strict"], + computeValue: (e) => du(e, "noImplicitAny") + }, + noImplicitThis: { + dependencies: ["strict"], + computeValue: (e) => du(e, "noImplicitThis") + }, + strictNullChecks: { + dependencies: ["strict"], + computeValue: (e) => du(e, "strictNullChecks") + }, + strictFunctionTypes: { + dependencies: ["strict"], + computeValue: (e) => du(e, "strictFunctionTypes") + }, + strictBindCallApply: { + dependencies: ["strict"], + computeValue: (e) => du(e, "strictBindCallApply") + }, + strictPropertyInitialization: { + dependencies: ["strict"], + computeValue: (e) => du(e, "strictPropertyInitialization") + }, + strictBuiltinIteratorReturn: { + dependencies: ["strict"], + computeValue: (e) => du(e, "strictBuiltinIteratorReturn") + }, + alwaysStrict: { + dependencies: ["strict"], + computeValue: (e) => du(e, "alwaysStrict") + }, + useUnknownInCatchVariables: { + dependencies: ["strict"], + computeValue: (e) => du(e, "useUnknownInCatchVariables") + } + }, l4 = ru, Cee = ru.allowImportingTsExtensions.computeValue, da = ru.target.computeValue, Hu = ru.module.computeValue, Pu = ru.moduleResolution.computeValue, Eee = ru.moduleDetection.computeValue, zp = ru.isolatedModules.computeValue, mm = ru.esModuleInterop.computeValue, Ax = ru.allowSyntheticDefaultImports.computeValue, dN = ru.resolvePackageJsonExports.computeValue, mN = ru.resolvePackageJsonImports.computeValue, zb = ru.resolveJsonModule.computeValue, J_ = ru.declaration.computeValue, By = ru.preserveConstEnums.computeValue, Wb = ru.incremental.computeValue, U5 = ru.declarationMap.computeValue, Jy = ru.allowJs.computeValue, gN = ru.useDefineForClassFields.computeValue; + function hN(e) { + return e >= 5 && e <= 99; + } + function V5(e) { + switch (Hu(e)) { + case 0: + case 4: + case 3: + return !1; + } + return !0; + } + function Dee(e) { + return e.allowUnreachableCode === !1; + } + function wee(e) { + return e.allowUnusedLabels === !1; + } + function i6(e) { + return e >= 3 && e <= 99 || e === 100; + } + function Pee(e) { + return 101 <= e && e <= 199 || e === 200 || e === 99; + } + function du(e, t) { + return e[t] === void 0 ? !!e.strict : !!e[t]; + } + function q5(e) { + return hl($z.type, (t, n) => t === e ? n : void 0); + } + function kJ(e) { + return e.useDefineForClassFields !== !1 && da(e) >= 9; + } + function Nee(e, t) { + return ux(t, e, wre); + } + function Aee(e, t) { + return ux(t, e, Pre); + } + function Iee(e, t) { + return ux(t, e, Nre); + } + function H5(e, t) { + return t.strictFlag ? du(e, t.name) : t.allowJsFlag ? Jy(e) : e[t.name]; + } + function G5(e) { + const t = e.jsx; + return t === 2 || t === 4 || t === 5; + } + function yN(e, t) { + const n = t?.pragmas.get("jsximportsource"), i = as(n) ? n[n.length - 1] : n, s = t?.pragmas.get("jsxruntime"), o = as(s) ? s[s.length - 1] : s; + if (o?.arguments.factory !== "classic") + return e.jsx === 4 || e.jsx === 5 || e.jsxImportSource || i || o?.arguments.factory === "automatic" ? i?.arguments.factory || e.jsxImportSource || "react" : void 0; + } + function $5(e, t) { + return e ? `${e}/${t.jsx === 5 ? "jsx-dev-runtime" : "jsx-runtime"}` : void 0; + } + function CJ(e) { + let t = !1; + for (let n = 0; n < e.length; n++) + if (e.charCodeAt(n) === 42) + if (!t) + t = !0; + else + return !1; + return !0; + } + function EJ(e, t) { + let n, i, s, o = !1; + return { + getSymlinkedFiles: () => s, + getSymlinkedDirectories: () => n, + getSymlinkedDirectoriesByRealpath: () => i, + setSymlinkedFile: (u, g) => (s || (s = /* @__PURE__ */ new Map())).set(u, g), + setSymlinkedDirectory: (u, g) => { + let m = oo(u, e, t); + y4(m) || (m = gl(m), g !== !1 && !n?.has(m) && (i || (i = Fp())).add(g.realPath, u), (n || (n = /* @__PURE__ */ new Map())).set(m, g)); + }, + setSymlinksFromResolutions(u, g, m) { + E.assert(!o), o = !0, u((h) => _(this, h.resolvedModule)), g((h) => _(this, h.resolvedTypeReferenceDirective)), m.forEach((h) => _(this, h.resolvedTypeReferenceDirective)); + }, + hasProcessedResolutions: () => o, + setSymlinksFromResolution(u) { + _(this, u); + }, + hasAnySymlinks: c + }; + function c() { + return !!s?.size || !!n && !!hl(n, (u) => !!u); + } + function _(u, g) { + if (!g || !g.originalPath || !g.resolvedFileName) return; + const { resolvedFileName: m, originalPath: h } = g; + u.setSymlinkedFile(oo(h, e, t), m); + const [S, T] = m9e(m, h, e, t) || Ge; + S && T && u.setSymlinkedDirectory( + T, + { + real: gl(S), + realPath: gl(oo(S, e, t)) + } + ); + } + } + function m9e(e, t, n, i) { + const s = fu(Qi(e, n)), o = fu(Qi(t, n)); + let c = !1; + for (; s.length >= 2 && o.length >= 2 && !Xhe(s[s.length - 2], i) && !Xhe(o[o.length - 2], i) && i(s[s.length - 1]) === i(o[o.length - 1]); ) + s.pop(), o.pop(), c = !0; + return c ? [B1(s), B1(o)] : void 0; + } + function Xhe(e, t) { + return e !== void 0 && (t(e) === "node_modules" || Ui(e, "@")); + } + function g9e(e) { + return hj(e.charCodeAt(0)) ? e.slice(1) : void 0; + } + function DJ(e, t, n) { + const i = qR(e, t, n); + return i === void 0 ? void 0 : g9e(i); + } + var Fee = /[^\w\s/]/g; + function Qhe(e) { + return e.replace(Fee, h9e); + } + function h9e(e) { + return "\\" + e; + } + var y9e = [ + 42, + 63 + /* question */ + ], v9e = ["node_modules", "bower_components", "jspm_packages"], Oee = `(?!(?:${v9e.join("|")})(?:/|$))`, Yhe = { + /** + * Matches any single directory segment unless it is the last segment and a .min.js file + * Breakdown: + * [^./] # matches everything up to the first . character (excluding directory separators) + * (\\.(?!min\\.js$))? # matches . characters but not if they are part of the .min.js file extension + */ + singleAsteriskRegexFragment: "(?:[^./]|(?:\\.(?!min\\.js$))?)*", + /** + * Regex for the ** wildcard. Matches any number of subdirectories. When used for including + * files or directories, does not match subdirectories that start with a . character + */ + doubleAsteriskRegexFragment: `(?:/${Oee}[^/.][^/]*)*?`, + replaceWildcardCharacter: (e) => Mee(e, Yhe.singleAsteriskRegexFragment) + }, Zhe = { + singleAsteriskRegexFragment: "[^/]*", + /** + * Regex for the ** wildcard. Matches any number of subdirectories. When used for including + * files or directories, does not match subdirectories that start with a . character + */ + doubleAsteriskRegexFragment: `(?:/${Oee}[^/.][^/]*)*?`, + replaceWildcardCharacter: (e) => Mee(e, Zhe.singleAsteriskRegexFragment) + }, Khe = { + singleAsteriskRegexFragment: "[^/]*", + doubleAsteriskRegexFragment: "(?:/.+?)?", + replaceWildcardCharacter: (e) => Mee(e, Khe.singleAsteriskRegexFragment) + }, Lee = { + files: Yhe, + directories: Zhe, + exclude: Khe + }; + function u4(e, t, n) { + const i = X5(e, t, n); + return !i || !i.length ? void 0 : `^(?:${i.map((c) => `(?:${c})`).join("|")})${n === "exclude" ? "(?:$|/)" : "$"}`; + } + function X5(e, t, n) { + if (!(e === void 0 || e.length === 0)) + return ka(e, (i) => i && Q5(i, t, n, Lee[n])); + } + function wJ(e) { + return !/[.*?]/.test(e); + } + function PJ(e, t, n) { + const i = e && Q5(e, t, n, Lee[n]); + return i && `^(?:${i})${n === "exclude" ? "(?:$|/)" : "$"}`; + } + function Q5(e, t, n, { singleAsteriskRegexFragment: i, doubleAsteriskRegexFragment: s, replaceWildcardCharacter: o } = Lee[n]) { + let c = "", _ = !1; + const u = l7(e, t), g = pa(u); + if (n !== "exclude" && g === "**") + return; + u[0] = _0(u[0]), wJ(g) && u.push("**", "*"); + let m = 0; + for (let h of u) { + if (h === "**") + c += s; + else if (n === "directories" && (c += "(?:", m++), _ && (c += So), n !== "exclude") { + let S = ""; + h.charCodeAt(0) === 42 ? (S += "(?:[^./]" + i + ")?", h = h.substr(1)) : h.charCodeAt(0) === 63 && (S += "[^./]", h = h.substr(1)), S += h.replace(Fee, o), S !== h && (c += Oee), c += S; + } else + c += h.replace(Fee, o); + _ = !0; + } + for (; m > 0; ) + c += ")?", m--; + return c; + } + function Mee(e, t) { + return e === "*" ? t : e === "?" ? "[^/]" : "\\" + e; + } + function Y5(e, t, n, i, s) { + e = Hs(e), s = Hs(s); + const o = On(s, e); + return { + includeFilePatterns: hr(X5(n, o, "files"), (c) => `^${c}$`), + includeFilePattern: u4(n, o, "files"), + includeDirectoryPattern: u4(n, o, "directories"), + excludePattern: u4(t, o, "exclude"), + basePaths: b9e(e, n, i) + }; + } + function b0(e, t) { + return new RegExp(e, t ? "" : "i"); + } + function NJ(e, t, n, i, s, o, c, _, u) { + e = Hs(e), o = Hs(o); + const g = Y5(e, n, i, s, o), m = g.includeFilePatterns && g.includeFilePatterns.map((A) => b0(A, s)), h = g.includeDirectoryPattern && b0(g.includeDirectoryPattern, s), S = g.excludePattern && b0(g.excludePattern, s), T = m ? m.map(() => []) : [[]], k = /* @__PURE__ */ new Map(), D = Zl(s); + for (const A of g.basePaths) + P(A, On(o, A), c); + return Ip(T); + function P(A, O, F) { + const R = D(u(O)); + if (k.has(R)) return; + k.set(R, !0); + const { files: B, directories: U } = _(A); + for (const $ of X_(B, _u)) { + const W = On(A, $), _e = On(O, $); + if (!(t && !xc(W, t)) && !(S && S.test(_e))) + if (!m) + T[0].push(W); + else { + const K = oc(m, (V) => V.test(_e)); + K !== -1 && T[K].push(W); + } + } + if (!(F !== void 0 && (F--, F === 0))) + for (const $ of X_(U, _u)) { + const W = On(A, $), _e = On(O, $); + (!h || h.test(_e)) && (!S || !S.test(_e)) && P(W, _e, F); + } + } + } + function b9e(e, t, n) { + const i = [e]; + if (t) { + const s = []; + for (const o of t) { + const c = Z_(o) ? o : Hs(On(e, o)); + s.push(S9e(c)); + } + s.sort(vC(!n)); + for (const o of s) + Ni(i, (c) => !np(c, o, e, !n)) && i.push(o); + } + return i; + } + function S9e(e) { + const t = KX(e, y9e); + return t < 0 ? xC(e) ? _0(Hn(e)) : e : e.substring(0, e.lastIndexOf(So, t)); + } + function Z5(e, t) { + return t || K5(e) || 3; + } + function K5(e) { + switch (e.substr(e.lastIndexOf(".")).toLowerCase()) { + case ".js": + case ".cjs": + case ".mjs": + return 1; + case ".jsx": + return 2; + case ".ts": + case ".cts": + case ".mts": + return 3; + case ".tsx": + return 4; + case ".json": + return 6; + default: + return 0; + } + } + var eF = [[ + ".ts", + ".tsx", + ".d.ts" + /* Dts */ + ], [ + ".cts", + ".d.cts" + /* Dcts */ + ], [ + ".mts", + ".d.mts" + /* Dmts */ + ]], AJ = Ip(eF), T9e = [...eF, [ + ".json" + /* Json */ + ]], x9e = [ + ".d.ts", + ".d.cts", + ".d.mts", + ".cts", + ".mts", + ".ts", + ".tsx" + /* Tsx */ + ], k9e = [[ + ".js", + ".jsx" + /* Jsx */ + ], [ + ".mjs" + /* Mjs */ + ], [ + ".cjs" + /* Cjs */ + ]], s6 = Ip(k9e), IJ = [[ + ".ts", + ".tsx", + ".d.ts", + ".js", + ".jsx" + /* Jsx */ + ], [ + ".cts", + ".d.cts", + ".cjs" + /* Cjs */ + ], [ + ".mts", + ".d.mts", + ".mjs" + /* Mjs */ + ]], C9e = [...IJ, [ + ".json" + /* Json */ + ]], tF = [ + ".d.ts", + ".d.cts", + ".d.mts" + /* Dmts */ + ], vN = [ + ".ts", + ".cts", + ".mts", + ".tsx" + /* Tsx */ + ], rF = [ + ".mts", + ".d.mts", + ".mjs", + ".cts", + ".d.cts", + ".cjs" + /* Cjs */ + ]; + function _4(e, t) { + const n = e && Jy(e); + if (!t || t.length === 0) + return n ? IJ : eF; + const i = n ? IJ : eF, s = Ip(i); + return [ + ...i, + ...Fi(t, (c) => c.scriptKind === 7 || n && E9e(c.scriptKind) && !s.includes(c.extension) ? [c.extension] : void 0) + ]; + } + function bN(e, t) { + return !e || !zb(e) ? t : t === IJ ? C9e : t === eF ? T9e : [...t, [ + ".json" + /* Json */ + ]]; + } + function E9e(e) { + return e === 1 || e === 2; + } + function Bg(e) { + return ot(s6, (t) => Xo(e, t)); + } + function yS(e) { + return ot(AJ, (t) => Xo(e, t)); + } + function Ree(e) { + return ot(vN, (t) => Xo(e, t)) && !Il(e); + } + var jee = /* @__PURE__ */ ((e) => (e[e.Minimal = 0] = "Minimal", e[e.Index = 1] = "Index", e[e.JsExtension = 2] = "JsExtension", e[e.TsExtension = 3] = "TsExtension", e))(jee || {}); + function D9e({ imports: e }, t = Q_(Bg, yS)) { + return Lc(e, ({ text: n }) => xf(n) && !xc(n, rF) ? t(n) : void 0) || !1; + } + function Bee(e, t, n, i) { + const s = Pu(n), o = 3 <= s && s <= 99; + if (e === "js" || t === 99 && o) + return O6(n) && c() !== 2 ? 3 : 2; + if (e === "minimal") + return 0; + if (e === "index") + return 1; + if (!O6(n)) + return i && D9e(i) ? 2 : 0; + return c(); + function c() { + let _ = !1; + const u = i?.imports.length ? i.imports : i && n_(i) ? w9e(i).map((g) => g.arguments[0]) : Ge; + for (const g of u) + if (xf(g.text)) { + if (o && t === 1 && gU(i, g, n) === 99 || xc(g.text, rF)) + continue; + if (yS(g.text)) + return 3; + Bg(g.text) && (_ = !0); + } + return _ ? 2 : 0; + } + } + function w9e(e) { + let t = 0, n; + for (const i of e.statements) { + if (t > 3) + break; + M3(i) ? n = Bi(n, i.declarationList.declarations.map((s) => s.initializer)) : Al(i) && x_( + i.expression, + /*requireStringLiteralLikeArgument*/ + !0 + ) ? n = Er(n, i.expression) : t++; + } + return n || Ge; + } + function FJ(e, t, n) { + if (!e) return !1; + const i = _4(t, n); + for (const s of Ip(bN(t, i))) + if (Xo(e, s)) + return !0; + return !1; + } + function e0e(e) { + const t = e.match(/\//g); + return t ? t.length : 0; + } + function SN(e, t) { + return ho( + e0e(e), + e0e(t) + ); + } + var Jee = [ + ".d.ts", + ".d.mts", + ".d.cts", + ".mjs", + ".mts", + ".cjs", + ".cts", + ".ts", + ".js", + ".tsx", + ".jsx", + ".json" + /* Json */ + ]; + function Gu(e) { + for (const t of Jee) { + const n = zee(e, t); + if (n !== void 0) + return n; + } + return e; + } + function zee(e, t) { + return Xo(e, t) ? TN(e, t) : void 0; + } + function TN(e, t) { + return e.substring(0, e.length - t.length); + } + function S0(e, t) { + return HP( + e, + t, + Jee, + /*ignoreCase*/ + !1 + ); + } + function Ix(e) { + const t = e.indexOf("*"); + return t === -1 ? e : e.indexOf("*", t + 1) !== -1 ? void 0 : { + prefix: e.substr(0, t), + suffix: e.substr(t + 1) + }; + } + var t0e = /* @__PURE__ */ new WeakMap(); + function xN(e) { + let t = t0e.get(e); + if (t !== void 0) + return t; + let n, i; + const s = rm(e); + for (const o of s) { + const c = Ix(o); + c !== void 0 && (typeof c == "string" ? (n ?? (n = /* @__PURE__ */ new Set())).add(c) : (i ?? (i = [])).push(c)); + } + return t0e.set( + e, + t = { + matchableStringSet: n, + patterns: i + } + ), t; + } + function Nd(e) { + return !(e >= 0); + } + function nF(e) { + return e === ".ts" || e === ".tsx" || e === ".d.ts" || e === ".cts" || e === ".mts" || e === ".d.mts" || e === ".d.cts" || Ui(e, ".d.") && wo(e, ".ts"); + } + function f4(e) { + return nF(e) || e === ".json"; + } + function p4(e) { + const t = Jg(e); + return t !== void 0 ? t : E.fail(`File ${e} has unknown extension.`); + } + function r0e(e) { + return Jg(e) !== void 0; + } + function Jg(e) { + return Nn(Jee, (t) => Xo(e, t)); + } + function d4(e, t) { + return e.checkJsDirective ? e.checkJsDirective.enabled : t.checkJs; + } + var OJ = { + files: Ge, + directories: Ge + }; + function LJ(e, t) { + const { matchableStringSet: n, patterns: i } = e; + if (n?.has(t)) + return t; + if (!(i === void 0 || i.length === 0)) + return VR(i, (s) => s, t); + } + function MJ(e, t) { + const n = e.indexOf(t); + return E.assert(n !== -1), e.slice(n); + } + function zs(e, ...t) { + return t.length && (e.relatedInformation || (e.relatedInformation = []), E.assert(e.relatedInformation !== Ge, "Diagnostic had empty array singleton for related info, but is still being constructed!"), e.relatedInformation.push(...t)), e; + } + function Wee(e, t) { + E.assert(e.length !== 0); + let n = t(e[0]), i = n; + for (let s = 1; s < e.length; s++) { + const o = t(e[s]); + o < n ? n = o : o > i && (i = o); + } + return { min: n, max: i }; + } + function RJ(e) { + return { pos: Ay(e), end: e.end }; + } + function jJ(e, t) { + const n = t.pos - 1, i = Math.min(e.text.length, oa(e.text, t.end) + 1); + return { pos: n, end: i }; + } + function a6(e, t, n) { + return n0e( + e, + t, + n, + /*ignoreNoCheck*/ + !1 + ); + } + function Uee(e, t, n) { + return n0e( + e, + t, + n, + /*ignoreNoCheck*/ + !0 + ); + } + function n0e(e, t, n, i) { + return t.skipLibCheck && e.isDeclarationFile || t.skipDefaultLibCheck && e.hasNoDefaultLib || !i && t.noCheck || n.isSourceOfProjectReferenceRedirect(e.fileName) || !m4(e, t); + } + function m4(e, t) { + if (e.checkJsDirective && e.checkJsDirective.enabled === !1) return !1; + if (e.scriptKind === 3 || e.scriptKind === 4 || e.scriptKind === 5) return !0; + const i = (e.scriptKind === 1 || e.scriptKind === 2) && d4(e, t); + return AD(e, t.checkJs) || i || e.scriptKind === 7; + } + function iF(e, t) { + return e === t || typeof e == "object" && e !== null && typeof t == "object" && t !== null && aQ(e, t, iF); + } + function g4(e) { + let t; + switch (e.charCodeAt(1)) { + // "x" in "0x123" + case 98: + case 66: + t = 1; + break; + case 111: + case 79: + t = 3; + break; + case 120: + case 88: + t = 4; + break; + default: + const g = e.length - 1; + let m = 0; + for (; e.charCodeAt(m) === 48; ) + m++; + return e.slice(m, g) || "0"; + } + const n = 2, i = e.length - 1, s = (i - n) * t, o = new Uint16Array((s >>> 4) + (s & 15 ? 1 : 0)); + for (let g = i - 1, m = 0; g >= n; g--, m += t) { + const h = m >>> 4, S = e.charCodeAt(g), k = (S <= 57 ? S - 48 : 10 + S - (S <= 70 ? 65 : 97)) << (m & 15); + o[h] |= k; + const D = k >>> 16; + D && (o[h + 1] |= D); + } + let c = "", _ = o.length - 1, u = !0; + for (; u; ) { + let g = 0; + u = !1; + for (let m = _; m >= 0; m--) { + const h = g << 16 | o[m], S = h / 10 | 0; + o[m] = S, g = h - S * 10, S && !u && (_ = m, u = !0); + } + c = g + c; + } + return c; + } + function Ub({ negative: e, base10Value: t }) { + return (e && t !== "0" ? "-" : "") + t; + } + function Vee(e) { + if (sF( + e, + /*roundTripOnly*/ + !1 + )) + return BJ(e); + } + function BJ(e) { + const t = e.startsWith("-"), n = g4(`${t ? e.slice(1) : e}n`); + return { negative: t, base10Value: n }; + } + function sF(e, t) { + if (e === "") return !1; + const n = Dg( + 99, + /*skipTrivia*/ + !1 + ); + let i = !0; + n.setOnError(() => i = !1), n.setText(e + "n"); + let s = n.scan(); + const o = s === 41; + o && (s = n.scan()); + const c = n.getTokenFlags(); + return i && s === 10 && n.getTokenEnd() === e.length + 1 && !(c & 512) && (!t || e === Ub({ negative: o, base10Value: g4(n.getTokenValue()) })); + } + function K1(e) { + return !!(e.flags & 33554432) || BD(e) || o5(e) || A9e(e) || N9e(e) || !(Xm(e) || P9e(e)); + } + function P9e(e) { + return Me(e) && gu(e.parent) && e.parent.name === e; + } + function N9e(e) { + for (; e.kind === 80 || e.kind === 212; ) + e = e.parent; + if (e.kind !== 168) + return !1; + if (Gn( + e.parent, + 64 + /* Abstract */ + )) + return !0; + const t = e.parent.parent.kind; + return t === 265 || t === 188; + } + function A9e(e) { + if (e.kind !== 80) return !1; + const t = dr(e.parent, (n) => { + switch (n.kind) { + case 299: + return !0; + case 212: + case 234: + return !1; + default: + return "quit"; + } + }); + return t?.token === 119 || t?.parent.kind === 265; + } + function qee(e) { + return of(e) && Me(e.typeName); + } + function Hee(e, t = gy) { + if (e.length < 2) return !0; + const n = e[0]; + for (let i = 1, s = e.length; i < s; i++) { + const o = e[i]; + if (!t(n, o)) return !1; + } + return !0; + } + function h4(e, t) { + return e.pos = t, e; + } + function o6(e, t) { + return e.end = t, e; + } + function Ad(e, t, n) { + return o6(h4(e, t), n); + } + function JJ(e, t, n) { + return Ad(e, t, t + n); + } + function Gee(e, t) { + return e && (e.flags = t), e; + } + function za(e, t) { + return e && t && (e.parent = t), e; + } + function ev(e, t) { + if (!e) return e; + return Kx(e, FC(e) ? n : s), e; + function n(o, c) { + if (t && o.parent === c) + return "skip"; + za(o, c); + } + function i(o) { + if (kf(o)) + for (const c of o.jsDoc) + n(c, o), Kx(c, n); + } + function s(o, c) { + return n(o, c) || i(o); + } + } + function I9e(e) { + return !vl(e); + } + function zJ(e) { + return nu(e) && Ni(e.elements, I9e); + } + function $ee(e) { + for (E.assertIsDefined(e.parent); ; ) { + const t = e.parent; + if (o_(t)) { + e = t; + continue; + } + if (Al(t) || Gx(t) || av(t) && (t.initializer === e || t.incrementor === e)) + return !0; + if (I4(t)) { + if (e !== pa(t.elements)) return !0; + e = t; + continue; + } + if (_n(t) && t.operatorToken.kind === 28) { + if (e === t.left) return !0; + e = t; + continue; + } + return !1; + } + } + function y4(e) { + return ot(a7, (t) => e.includes(t)); + } + function Xee(e) { + if (!e.parent) return; + switch (e.kind) { + case 169: + const { parent: n } = e; + return n.kind === 196 ? void 0 : n.typeParameters; + case 170: + return e.parent.parameters; + case 205: + return e.parent.templateSpans; + case 240: + return e.parent.templateSpans; + case 171: { + const { parent: i } = e; + return e2(i) ? i.modifiers : void 0; + } + case 299: + return e.parent.heritageClauses; + } + const { parent: t } = e; + if (OC(e)) + return AS(e.parent) ? void 0 : e.parent.tags; + switch (t.kind) { + case 188: + case 265: + return kb(e) ? t.members : void 0; + case 193: + case 194: + return t.types; + case 190: + case 210: + case 357: + case 276: + case 280: + return t.elements; + case 211: + case 293: + return t.properties; + case 214: + case 215: + return li(e) ? t.typeArguments : t.expression === e ? void 0 : t.arguments; + case 285: + case 289: + return g3(e) ? t.children : void 0; + case 287: + case 286: + return li(e) ? t.typeArguments : void 0; + case 242: + case 297: + case 298: + case 269: + return t.statements; + case 270: + return t.clauses; + case 264: + case 232: + return Hc(e) ? t.members : void 0; + case 267: + return Ph(e) ? t.members : void 0; + case 308: + return t.statements; + } + } + function aF(e) { + if (!e.typeParameters) { + if (ot(e.parameters, (t) => !Kc(t))) + return !0; + if (e.kind !== 220) { + const t = Yc(e.parameters); + if (!(t && My(t))) + return !0; + } + } + return !1; + } + function v4(e) { + return e === "Infinity" || e === "-Infinity" || e === "NaN"; + } + function Qee(e) { + return e.kind === 261 && e.parent.kind === 300; + } + function zy(e) { + return e.kind === 219 || e.kind === 220; + } + function Vb(e) { + return e.replace(/\$/g, () => "\\$"); + } + function zg(e) { + return (+e).toString() === e; + } + function kN(e, t, n, i, s) { + const o = s && e === "new"; + return !o && R_(e, t) ? N.createIdentifier(e) : !i && !o && zg(e) && +e >= 0 ? N.createNumericLiteral(+e) : N.createStringLiteral(e, !!n); + } + function b4(e) { + return !!(e.flags & 262144 && e.isThisType); + } + function oF(e) { + let t = 0, n = 0, i = 0, s = 0, o; + ((g) => { + g[g.BeforeNodeModules = 0] = "BeforeNodeModules", g[g.NodeModules = 1] = "NodeModules", g[g.Scope = 2] = "Scope", g[g.PackageContent = 3] = "PackageContent"; + })(o || (o = {})); + let c = 0, _ = 0, u = 0; + for (; _ >= 0; ) + switch (c = _, _ = e.indexOf("/", c + 1), u) { + case 0: + e.indexOf(qg, c) === c && (t = c, n = _, u = 1); + break; + case 1: + case 2: + u === 1 && e.charAt(c + 1) === "@" ? u = 2 : (i = _, u = 3); + break; + case 3: + e.indexOf(qg, c) === c ? u = 1 : u = 3; + break; + } + return s = c, u > 1 ? { topLevelNodeModulesIndex: t, topLevelPackageNameIndex: n, packageRootIndex: i, fileNameIndex: s } : void 0; + } + function Fx(e) { + switch (e.kind) { + case 169: + case 264: + case 265: + case 266: + case 267: + case 347: + case 339: + case 341: + return !0; + case 274: + return e.phaseModifier === 156; + case 277: + return e.parent.parent.phaseModifier === 156; + case 282: + return e.parent.parent.isTypeOnly; + default: + return !1; + } + } + function CN(e) { + return ov(e) || Ic(e) || Cc(e) || tl(e) || Vl(e) || Fx(e) || jc(e) && !Pb(e) && !$m(e); + } + function EN(e) { + if (!kD(e)) + return !1; + const { isBracketed: t, typeExpression: n } = e; + return t || !!n && n.type.kind === 317; + } + function WJ(e, t) { + if (e.length === 0) + return !1; + const n = e.charCodeAt(0); + return n === 35 ? e.length > 1 && Vm(e.charCodeAt(1), t) : Vm(n, t); + } + function Yee(e) { + var t; + return ((t = az(e)) == null ? void 0 : t.kind) === 0; + } + function cF(e) { + return an(e) && // node.type should only be a JSDocOptionalType when node is a parameter of a JSDocFunctionType + (e.type && e.type.kind === 317 || wC(e).some(EN)); + } + function Ox(e) { + switch (e.kind) { + case 173: + case 172: + return !!e.questionToken; + case 170: + return !!e.questionToken || cF(e); + case 349: + case 342: + return EN(e); + default: + return !1; + } + } + function Zee(e) { + const t = e.kind; + return (t === 212 || t === 213) && $x(e.expression); + } + function UJ(e) { + return an(e) && o_(e) && kf(e) && !!Mj(e); + } + function VJ(e) { + return E.checkDefined(lF(e)); + } + function lF(e) { + const t = Mj(e); + return t && t.typeExpression && t.typeExpression.type; + } + function S4(e) { + return Me(e) ? e.escapedText : Lx(e); + } + function DN(e) { + return Me(e) ? An(e) : T4(e); + } + function Kee(e) { + const t = e.kind; + return t === 80 || t === 296; + } + function Lx(e) { + return `${e.namespace.escapedText}:${An(e.name)}`; + } + function T4(e) { + return `${An(e.namespace)}:${An(e.name)}`; + } + function qJ(e) { + return Me(e) ? An(e) : T4(e); + } + function _p(e) { + return !!(e.flags & 8576); + } + function fp(e) { + return e.flags & 8192 ? e.escapedName : e.flags & 384 ? tc("" + e.value) : E.fail(); + } + function Mx(e) { + return !!e && (wn(e) || uo(e) || _n(e)); + } + function ete(e) { + return e === void 0 ? !1 : !!R6(e.attributes); + } + var F9e = String.prototype.replace; + function vS(e, t) { + return F9e.call(e, "*", t); + } + function uF(e) { + return Me(e.name) ? e.name.escapedText : tc(e.name.text); + } + function tte(e) { + switch (e.kind) { + case 169: + case 170: + case 173: + case 172: + case 186: + case 185: + case 180: + case 181: + case 182: + case 175: + case 174: + case 176: + case 177: + case 178: + case 179: + case 184: + case 183: + case 187: + case 188: + case 189: + case 190: + case 193: + case 194: + case 197: + case 191: + case 192: + case 198: + case 199: + case 195: + case 196: + case 204: + case 206: + case 203: + case 329: + case 330: + case 347: + case 339: + case 341: + case 346: + case 345: + case 325: + case 326: + case 327: + case 342: + case 349: + case 318: + case 316: + case 315: + case 313: + case 314: + case 323: + case 319: + case 310: + case 334: + case 336: + case 335: + case 351: + case 344: + case 200: + case 201: + case 263: + case 242: + case 269: + case 244: + case 245: + case 246: + case 247: + case 248: + case 249: + case 250: + case 251: + case 252: + case 253: + case 254: + case 255: + case 256: + case 257: + case 258: + case 259: + case 261: + case 209: + case 264: + case 265: + case 266: + case 267: + case 268: + case 273: + case 272: + case 279: + case 278: + case 243: + case 260: + case 283: + return !0; + } + return !1; + } + function yl(e, t = !1, n = !1, i = !1) { + return { value: e, isSyntacticallyString: t, resolvedOtherFiles: n, hasExternalReferences: i }; + } + function rte({ evaluateElementAccessExpression: e, evaluateEntityNameExpression: t }) { + function n(s, o) { + let c = !1, _ = !1, u = !1; + switch (s = Ba(s), s.kind) { + case 225: + const g = n(s.operand, o); + if (_ = g.resolvedOtherFiles, u = g.hasExternalReferences, typeof g.value == "number") + switch (s.operator) { + case 40: + return yl(g.value, c, _, u); + case 41: + return yl(-g.value, c, _, u); + case 55: + return yl(~g.value, c, _, u); + } + break; + case 227: { + const m = n(s.left, o), h = n(s.right, o); + if (c = (m.isSyntacticallyString || h.isSyntacticallyString) && s.operatorToken.kind === 40, _ = m.resolvedOtherFiles || h.resolvedOtherFiles, u = m.hasExternalReferences || h.hasExternalReferences, typeof m.value == "number" && typeof h.value == "number") + switch (s.operatorToken.kind) { + case 52: + return yl(m.value | h.value, c, _, u); + case 51: + return yl(m.value & h.value, c, _, u); + case 49: + return yl(m.value >> h.value, c, _, u); + case 50: + return yl(m.value >>> h.value, c, _, u); + case 48: + return yl(m.value << h.value, c, _, u); + case 53: + return yl(m.value ^ h.value, c, _, u); + case 42: + return yl(m.value * h.value, c, _, u); + case 44: + return yl(m.value / h.value, c, _, u); + case 40: + return yl(m.value + h.value, c, _, u); + case 41: + return yl(m.value - h.value, c, _, u); + case 45: + return yl(m.value % h.value, c, _, u); + case 43: + return yl(m.value ** h.value, c, _, u); + } + else if ((typeof m.value == "string" || typeof m.value == "number") && (typeof h.value == "string" || typeof h.value == "number") && s.operatorToken.kind === 40) + return yl( + "" + m.value + h.value, + c, + _, + u + ); + break; + } + case 11: + case 15: + return yl( + s.text, + /*isSyntacticallyString*/ + !0 + ); + case 229: + return i(s, o); + case 9: + return yl(+s.text); + case 80: + return t(s, o); + case 212: + if (to(s)) + return t(s, o); + break; + case 213: + return e(s, o); + } + return yl( + /*value*/ + void 0, + c, + _, + u + ); + } + function i(s, o) { + let c = s.head.text, _ = !1, u = !1; + for (const g of s.templateSpans) { + const m = n(g.expression, o); + if (m.value === void 0) + return yl( + /*value*/ + void 0, + /*isSyntacticallyString*/ + !0 + ); + c += m.value, c += g.literal.text, _ || (_ = m.resolvedOtherFiles), u || (u = m.hasExternalReferences); + } + return yl( + c, + /*isSyntacticallyString*/ + !0, + _, + u + ); + } + return n; + } + function HJ(e) { + return Eb(e) && nd(e.type) || R4(e) && nd(e.typeExpression); + } + function wN(e) { + const t = e.members; + for (const n of t) + if (n.kind === 177 && Mp(n.body)) + return n; + } + function GJ({ + compilerOptions: e, + requireSymbol: t, + argumentsSymbol: n, + error: i, + getSymbolOfDeclaration: s, + globals: o, + lookup: c, + setRequiresScopeChangeCache: _ = vb, + getRequiresScopeChangeCache: u = vb, + onPropertyWithInvalidInitializer: g = mh, + onFailedToResolveSymbol: m = vb, + onSuccessfullyResolvedSymbol: h = vb + }) { + var S = e.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules", T = kJ(e), k = Bs(); + return D; + function D(R, B, U, $, W, _e) { + var K, V, ae; + const se = R; + let ce, fe, he, q, be, je = !1, me; + const Z = gs(B) ? B : B.escapedText; + e: + for (; R; ) { + if (Z === "const" && HJ(R)) + return; + if (d3(R) && fe && R.name === fe && (fe = R, R = R.parent), qm(R) && R.locals && !m0(R) && (ce = c(R.locals, Z, U))) { + let pe = !0; + if (Es(R) && fe && fe !== R.body ? (U & ce.flags & 788968 && fe.kind !== 321 && (pe = ce.flags & 262144 ? !!(fe.flags & 16) || // Synthetic fake scopes are added for signatures so type parameters are accessible from them + fe === R.type || fe.kind === 170 || fe.kind === 342 || fe.kind === 343 || fe.kind === 169 : !1), U & ce.flags & 3 && (P(ce, R, fe) ? pe = !1 : ce.flags & 1 && (pe = fe.kind === 170 || !!(fe.flags & 16) || // Synthetic fake scopes are added for signatures so parameters are accessible from them + fe === R.type && !!dr(ce.valueDeclaration, Ii)))) : R.kind === 195 && (pe = fe === R.trueType), pe) + break e; + ce = void 0; + } + switch (je = je || A(R, fe), R.kind) { + case 308: + if (!tf(R)) break; + // falls through + case 268: + const pe = ((K = s(R)) == null ? void 0 : K.exports) || k; + if (R.kind === 308 || jc(R) && R.flags & 33554432 && !$m(R)) { + if (ce = pe.get( + "default" + /* Default */ + )) { + const Ye = n4(ce); + if (Ye && ce.flags & U && Ye.escapedName === Z) + break e; + ce = void 0; + } + const Fe = pe.get(Z); + if (Fe && Fe.flags === 2097152 && (Oo( + Fe, + 282 + /* ExportSpecifier */ + ) || Oo( + Fe, + 281 + /* NamespaceExport */ + ))) + break; + } + if (Z !== "default" && (ce = c( + pe, + Z, + U & 2623475 + /* ModuleMember */ + ))) + if (Di(R) && R.commonJsModuleIndicator && !((V = ce.declarations) != null && V.some(jp))) + ce = void 0; + else + break e; + break; + case 267: + if (ce = c( + ((ae = s(R)) == null ? void 0 : ae.exports) || k, + Z, + U & 8 + /* EnumMember */ + )) { + $ && zp(e) && !(R.flags & 33554432) && xr(R) !== xr(ce.valueDeclaration) && i( + se, + p.Cannot_access_0_from_another_file_without_qualification_when_1_is_enabled_Use_2_instead, + Si(Z), + S, + `${Si(s(R).escapedName)}.${Si(Z)}` + ); + break e; + } + break; + case 173: + if (!Js(R)) { + const Fe = wN(R.parent); + Fe && Fe.locals && c( + Fe.locals, + Z, + U & 111551 + /* Value */ + ) && (E.assertNode(R, os), q = R); + } + break; + case 264: + case 232: + case 265: + if (ce = c( + s(R).members || k, + Z, + U & 788968 + /* Type */ + )) { + if (!F(ce, R)) { + ce = void 0; + break; + } + if (fe && Js(fe)) { + $ && i(se, p.Static_members_cannot_reference_class_type_parameters); + return; + } + break e; + } + if (Rc(R) && U & 32) { + const Fe = R.name; + if (Fe && Z === Fe.escapedText) { + ce = R.symbol; + break e; + } + } + break; + case 234: + if (fe === R.expression && R.parent.token === 96) { + const Fe = R.parent.parent; + if ($n(Fe) && (ce = c( + s(Fe).members, + Z, + U & 788968 + /* Type */ + ))) { + $ && i(se, p.Base_class_expressions_cannot_reference_class_type_parameters); + return; + } + } + break; + // It is not legal to reference a class's own type parameters from a computed property name that + // belongs to the class. For example: + // + // function foo() { return '' } + // class C { // <-- Class's own type parameter T + // [foo()]() { } // <-- Reference to T from class's own computed property + // } + // + case 168: + if (me = R.parent.parent, ($n(me) || me.kind === 265) && (ce = c( + s(me).members, + Z, + U & 788968 + /* Type */ + ))) { + $ && i(se, p.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type); + return; + } + break; + case 220: + if (da(e) >= 2) + break; + // falls through + case 175: + case 177: + case 178: + case 179: + case 263: + if (U & 3 && Z === "arguments") { + ce = n; + break e; + } + break; + case 219: + if (U & 3 && Z === "arguments") { + ce = n; + break e; + } + if (U & 16) { + const Fe = R.name; + if (Fe && Z === Fe.escapedText) { + ce = R.symbol; + break e; + } + } + break; + case 171: + R.parent && R.parent.kind === 170 && (R = R.parent), R.parent && (Hc(R.parent) || R.parent.kind === 264) && (R = R.parent); + break; + case 347: + case 339: + case 341: + case 352: + const Te = GC(R); + Te && (R = Te.parent); + break; + case 170: + fe && (fe === R.initializer || fe === R.name && ws(fe)) && (be || (be = R)); + break; + case 209: + fe && (fe === R.initializer || fe === R.name && ws(fe)) && Y1(R) && !be && (be = R); + break; + case 196: + if (U & 262144) { + const Fe = R.typeParameter.name; + if (Fe && Z === Fe.escapedText) { + ce = R.typeParameter.symbol; + break e; + } + } + break; + case 282: + fe && fe === R.propertyName && R.parent.parent.moduleSpecifier && (R = R.parent.parent.parent); + break; + } + O(R, fe) && (he = R), fe = R, R = Up(R) ? d5(R) || R.parent : (Lf(R) || OF(R)) && $1(R) || R.parent; + } + if (W && ce && (!he || ce !== he.symbol) && (ce.isReferenced |= U), !ce) { + if (fe && (E.assertNode(fe, Di), fe.commonJsModuleIndicator && Z === "exports" && U & fe.symbol.flags)) + return fe.symbol; + _e || (ce = c(o, Z, U)); + } + if (!ce && se && an(se) && se.parent && x_( + se.parent, + /*requireStringLiteralLikeArgument*/ + !1 + )) + return t; + if ($) { + if (q && g(se, Z, q, ce)) + return; + ce ? h(se, ce, U, fe, be, je) : m(se, B, U, $); + } + return ce; + } + function P(R, B, U) { + const $ = da(e), W = B; + if (Ii(U) && W.body && R.valueDeclaration && R.valueDeclaration.pos >= W.body.pos && R.valueDeclaration.end <= W.body.end && $ >= 2) { + let V = u(W); + return V === void 0 && (V = lr(W.parameters, _e) || !1, _(W, V)), !V; + } + return !1; + function _e(V) { + return K(V.name) || !!V.initializer && K(V.initializer); + } + function K(V) { + switch (V.kind) { + case 220: + case 219: + case 263: + case 177: + return !1; + case 175: + case 178: + case 179: + case 304: + return K(V.name); + case 173: + return cl(V) ? !T : K(V.name); + default: + return jj(V) || Eu(V) ? $ < 7 : ya(V) && V.dotDotDotToken && Of(V.parent) ? $ < 4 : li(V) ? !1 : xs(V, K) || !1; + } + } + } + function A(R, B) { + return R.kind !== 220 && R.kind !== 219 ? Hb(R) || (io(R) || R.kind === 173 && !Js(R)) && (!B || B !== R.name) : B && B === R.name ? !1 : R.asteriskToken || Gn( + R, + 1024 + /* Async */ + ) ? !0 : !q1(R); + } + function O(R, B) { + switch (R.kind) { + case 170: + return !!B && B === R.name; + case 263: + case 264: + case 265: + case 267: + case 266: + case 268: + return !0; + default: + return !1; + } + } + function F(R, B) { + if (R.declarations) { + for (const U of R.declarations) + if (U.kind === 169 && (Up(U.parent) ? Fb(U.parent) : U.parent) === B) + return !(Up(U.parent) && Nn(U.parent.parent.tags, jp)); + } + return !1; + } + } + function _F(e, t = !0) { + switch (E.type(e), e.kind) { + case 112: + case 97: + case 9: + case 11: + case 15: + return !0; + case 10: + return t; + case 225: + return e.operator === 41 ? E_(e.operand) || t && u6(e.operand) : e.operator === 40 ? E_(e.operand) : !1; + default: + return !1; + } + } + function nte(e) { + for (; e.kind === 218; ) + e = e.expression; + return e; + } + function fF(e) { + switch (E.type(e), e.kind) { + case 170: + case 172: + case 173: + case 209: + case 212: + case 213: + case 227: + case 261: + case 278: + case 304: + case 305: + case 342: + case 349: + return !0; + default: + return !1; + } + } + function $J(e) { + const t = dr(e, qo); + return !!t && !t.importClause; + } + var ite = [ + "assert", + "assert/strict", + "async_hooks", + "buffer", + "child_process", + "cluster", + "console", + "constants", + "crypto", + "dgram", + "diagnostics_channel", + "dns", + "dns/promises", + "domain", + "events", + "fs", + "fs/promises", + "http", + "http2", + "https", + "inspector", + "inspector/promises", + "module", + "net", + "os", + "path", + "path/posix", + "path/win32", + "perf_hooks", + "process", + "punycode", + "querystring", + "readline", + "readline/promises", + "repl", + "stream", + "stream/consumers", + "stream/promises", + "stream/web", + "string_decoder", + "sys", + "test/mock_loader", + "timers", + "timers/promises", + "tls", + "trace_events", + "tty", + "url", + "util", + "util/types", + "v8", + "vm", + "wasi", + "worker_threads", + "zlib" + ], ste = new Set(ite), pF = /* @__PURE__ */ new Set([ + "node:sea", + "node:sqlite", + "node:test", + "node:test/reporters" + ]), c6 = /* @__PURE__ */ new Set([ + ...ite, + ...ite.map((e) => `node:${e}`), + ...pF + ]); + function dF(e, t, n, i) { + const s = an(e), o = /import|require/g; + for (; o.exec(e.text) !== null; ) { + const c = O9e( + e, + o.lastIndex, + /*includeJSDoc*/ + t + ); + if (s && x_(c, n)) + i(c, c.arguments[0]); + else if (T_(c) && c.arguments.length >= 1 && (!n || ja(c.arguments[0]))) + i(c, c.arguments[0]); + else if (t && bh(c)) + i(c, c.argument.literal); + else if (t && xm(c)) { + const _ = hx(c); + _ && ca(_) && _.text && i(c, _); + } + } + } + function O9e(e, t, n) { + const i = an(e); + let s = e; + const o = (c) => { + if (c.pos <= t && (t < c.end || t === c.end && c.kind === 1)) + return c; + }; + for (; ; ) { + const c = i && n && kf(s) && lr(s.jsDoc, o) || xs(s, o); + if (!c || DS(c)) + return s; + s = c; + } + } + function ate(e) { + return Es(e) || w0(e) || CS(e); + } + function XJ(e) { + return my(e.fileName); + } + function QJ(e) { + const t = XJ(e); + return Gz.get(t); + } + function YJ(e, t) { + return x4( + /*projectReferences*/ + void 0, + e, + (n) => n && t(n) + ); + } + function x4(e, t, n, i) { + let s; + return o( + e, + t, + /*parent*/ + void 0 + ); + function o(c, _, u) { + if (i) { + const m = i(c, u); + if (m) return m; + } + let g; + return lr( + _, + (m, h) => { + if (m && s?.has(m.sourceFile.path)) { + (g ?? (g = /* @__PURE__ */ new Set())).add(m); + return; + } + const S = n(m, u, h); + if (S || !m) return S; + (s || (s = /* @__PURE__ */ new Set())).add(m.sourceFile.path); + } + ) || lr( + _, + (m) => m && !g?.has(m) ? o(m.commandLine.projectReferences, m.references, m) : void 0 + ); + } + } + function ZJ(e, t, n) { + return e && L9e(e, t, n); + } + function L9e(e, t, n) { + return zC(e, t, (i) => nu(i.initializer) ? Nn(i.initializer.elements, (s) => ca(s) && s.text === n) : void 0); + } + function ote(e, t, n) { + return KJ(e, t, (i) => ca(i.initializer) && i.initializer.text === n ? i.initializer : void 0); + } + function KJ(e, t, n) { + return zC(e, t, n); + } + function qa(e, t = !0) { + const n = e && i0e(e); + return n && !t && af(n), ev( + n, + /*incremental*/ + !1 + ); + } + function PN(e, t, n) { + let i = n(e); + return i ? Cn(i, e) : i = i0e(e, n), i && !t && af(i), i; + } + function i0e(e, t) { + const n = t ? (o) => PN( + o, + /*includeTrivia*/ + !0, + t + ) : qa, s = br( + e, + n, + /*context*/ + void 0, + t ? (o) => o && ez( + o, + /*includeTrivia*/ + !0, + t + ) : (o) => o && qb(o), + n + ); + if (s === e) { + const o = ca(e) ? Cn(N.createStringLiteralFromNode(e), e) : E_(e) ? Cn(N.createNumericLiteral(e.text, e.numericLiteralFlags), e) : N.cloneNode(e); + return ct(o, e); + } + return s.parent = void 0, s; + } + function qb(e, t = !0) { + if (e) { + const n = N.createNodeArray(e.map((i) => qa(i, t)), e.hasTrailingComma); + return ct(n, e), n; + } + return e; + } + function ez(e, t, n) { + return N.createNodeArray(e.map((i) => PN(i, t, n)), e.hasTrailingComma); + } + function af(e) { + tz(e), cte(e); + } + function tz(e) { + lte(e, 1024, M9e); + } + function cte(e) { + lte(e, 2048, hJ); + } + function lte(e, t, n) { + gm(e, t); + const i = n(e); + i && lte(i, t, n); + } + function M9e(e) { + return xs(e, (t) => t); + } + function ute() { + let e, t, n, i, s; + return { + createBaseSourceFileNode: o, + createBaseIdentifierNode: c, + createBasePrivateIdentifierNode: _, + createBaseTokenNode: u, + createBaseNode: g + }; + function o(m) { + return new (s || (s = tu.getSourceFileConstructor()))( + m, + /*pos*/ + -1, + /*end*/ + -1 + ); + } + function c(m) { + return new (n || (n = tu.getIdentifierConstructor()))( + m, + /*pos*/ + -1, + /*end*/ + -1 + ); + } + function _(m) { + return new (i || (i = tu.getPrivateIdentifierConstructor()))( + m, + /*pos*/ + -1, + /*end*/ + -1 + ); + } + function u(m) { + return new (t || (t = tu.getTokenConstructor()))( + m, + /*pos*/ + -1, + /*end*/ + -1 + ); + } + function g(m) { + return new (e || (e = tu.getNodeConstructor()))( + m, + /*pos*/ + -1, + /*end*/ + -1 + ); + } + } + function _te(e) { + let t, n; + return { + getParenthesizeLeftSideOfBinaryForOperator: i, + getParenthesizeRightSideOfBinaryForOperator: s, + parenthesizeLeftSideOfBinary: m, + parenthesizeRightSideOfBinary: h, + parenthesizeExpressionOfComputedPropertyName: S, + parenthesizeConditionOfConditionalExpression: T, + parenthesizeBranchOfConditionalExpression: k, + parenthesizeExpressionOfExportDefault: D, + parenthesizeExpressionOfNew: P, + parenthesizeLeftSideOfAccess: A, + parenthesizeOperandOfPostfixUnary: O, + parenthesizeOperandOfPrefixUnary: F, + parenthesizeExpressionsOfCommaDelimitedList: R, + parenthesizeExpressionForDisallowedComma: B, + parenthesizeExpressionOfExpressionStatement: U, + parenthesizeConciseBodyOfArrowFunction: $, + parenthesizeCheckTypeOfConditionalType: W, + parenthesizeExtendsTypeOfConditionalType: _e, + parenthesizeConstituentTypesOfUnionType: V, + parenthesizeConstituentTypeOfUnionType: K, + parenthesizeConstituentTypesOfIntersectionType: se, + parenthesizeConstituentTypeOfIntersectionType: ae, + parenthesizeOperandOfTypeOperator: ce, + parenthesizeOperandOfReadonlyTypeOperator: fe, + parenthesizeNonArrayTypeOfPostfixType: he, + parenthesizeElementTypesOfTupleType: q, + parenthesizeElementTypeOfTupleType: be, + parenthesizeTypeOfOptionalType: me, + parenthesizeTypeArguments: Te, + parenthesizeLeadingTypeArgument: Z + }; + function i(Fe) { + t || (t = /* @__PURE__ */ new Map()); + let Ye = t.get(Fe); + return Ye || (Ye = (ne) => m(Fe, ne), t.set(Fe, Ye)), Ye; + } + function s(Fe) { + n || (n = /* @__PURE__ */ new Map()); + let Ye = n.get(Fe); + return Ye || (Ye = (ne) => h( + Fe, + /*leftSide*/ + void 0, + ne + ), n.set(Fe, Ye)), Ye; + } + function o(Fe, Ye) { + return Fe === 61 ? Ye === 56 || Ye === 57 : Ye === 61 ? Fe === 56 || Fe === 57 : !1; + } + function c(Fe, Ye, ne, Se) { + const ie = id(Ye); + if (_n(ie) && o(Fe, ie.operatorToken.kind)) + return !0; + const Ne = K3(227, Fe), Ee = VB(227, Fe); + if (!ne && Ye.kind === 220 && Ne > 3) + return !0; + const Ce = YD(ie); + switch (ho(Ce, Ne)) { + case -1: + return !(!ne && Ee === 1 && Ye.kind === 230); + case 1: + return !1; + case 0: + if (ne) + return Ee === 1; + if (_n(ie) && ie.operatorToken.kind === Fe) { + if (_(Fe)) + return !1; + if (Fe === 40) { + const St = Se ? u(Se) : 0; + if (CD(St) && St === u(ie)) + return !1; + } + } + return UB(ie) === 0; + } + } + function _(Fe) { + return Fe === 42 || Fe === 52 || Fe === 51 || Fe === 53 || Fe === 28; + } + function u(Fe) { + if (Fe = id(Fe), CD(Fe.kind)) + return Fe.kind; + if (Fe.kind === 227 && Fe.operatorToken.kind === 40) { + if (Fe.cachedLiteralKind !== void 0) + return Fe.cachedLiteralKind; + const Ye = u(Fe.left), ne = CD(Ye) && Ye === u(Fe.right) ? Ye : 0; + return Fe.cachedLiteralKind = ne, ne; + } + return 0; + } + function g(Fe, Ye, ne, Se) { + return id(Ye).kind === 218 ? Ye : c(Fe, Ye, ne, Se) ? e.createParenthesizedExpression(Ye) : Ye; + } + function m(Fe, Ye) { + return g( + Fe, + Ye, + /*isLeftSideOfBinary*/ + !0 + ); + } + function h(Fe, Ye, ne) { + return g( + Fe, + ne, + /*isLeftSideOfBinary*/ + !1, + Ye + ); + } + function S(Fe) { + return B4(Fe) ? e.createParenthesizedExpression(Fe) : Fe; + } + function T(Fe) { + const Ye = K3( + 228, + 58 + /* QuestionToken */ + ), ne = id(Fe), Se = YD(ne); + return ho(Se, Ye) !== 1 ? e.createParenthesizedExpression(Fe) : Fe; + } + function k(Fe) { + const Ye = id(Fe); + return B4(Ye) ? e.createParenthesizedExpression(Fe) : Fe; + } + function D(Fe) { + const Ye = id(Fe); + let ne = B4(Ye); + if (!ne) + switch (n6( + Ye, + /*stopAtCallExpressions*/ + !1 + ).kind) { + case 232: + case 219: + ne = !0; + } + return ne ? e.createParenthesizedExpression(Fe) : Fe; + } + function P(Fe) { + const Ye = n6( + Fe, + /*stopAtCallExpressions*/ + !0 + ); + switch (Ye.kind) { + case 214: + return e.createParenthesizedExpression(Fe); + case 215: + return Ye.arguments ? Fe : e.createParenthesizedExpression(Fe); + } + return A(Fe); + } + function A(Fe, Ye) { + const ne = id(Fe); + return S_(ne) && (ne.kind !== 215 || ne.arguments) && (Ye || !Eu(ne)) ? Fe : ct(e.createParenthesizedExpression(Fe), Fe); + } + function O(Fe) { + return S_(Fe) ? Fe : ct(e.createParenthesizedExpression(Fe), Fe); + } + function F(Fe) { + return $j(Fe) ? Fe : ct(e.createParenthesizedExpression(Fe), Fe); + } + function R(Fe) { + const Ye = Qc(Fe, B); + return ct(e.createNodeArray(Ye, Fe.hasTrailingComma), Fe); + } + function B(Fe) { + const Ye = id(Fe), ne = YD(Ye), Se = K3( + 227, + 28 + /* CommaToken */ + ); + return ne > Se ? Fe : ct(e.createParenthesizedExpression(Fe), Fe); + } + function U(Fe) { + const Ye = id(Fe); + if (Ps(Ye)) { + const Se = Ye.expression, ie = id(Se).kind; + if (ie === 219 || ie === 220) { + const Ne = e.updateCallExpression( + Ye, + ct(e.createParenthesizedExpression(Se), Se), + Ye.typeArguments, + Ye.arguments + ); + return e.restoreOuterExpressions( + Fe, + Ne, + 8 + /* PartiallyEmittedExpressions */ + ); + } + } + const ne = n6( + Ye, + /*stopAtCallExpressions*/ + !1 + ).kind; + return ne === 211 || ne === 219 ? ct(e.createParenthesizedExpression(Fe), Fe) : Fe; + } + function $(Fe) { + return !Ns(Fe) && (B4(Fe) || n6( + Fe, + /*stopAtCallExpressions*/ + !1 + ).kind === 211) ? ct(e.createParenthesizedExpression(Fe), Fe) : Fe; + } + function W(Fe) { + switch (Fe.kind) { + case 185: + case 186: + case 195: + return e.createParenthesizedType(Fe); + } + return Fe; + } + function _e(Fe) { + switch (Fe.kind) { + case 195: + return e.createParenthesizedType(Fe); + } + return Fe; + } + function K(Fe) { + switch (Fe.kind) { + case 193: + // Not strictly necessary, but a union containing a union should have been flattened + case 194: + return e.createParenthesizedType(Fe); + } + return W(Fe); + } + function V(Fe) { + return e.createNodeArray(Qc(Fe, K)); + } + function ae(Fe) { + switch (Fe.kind) { + case 193: + case 194: + return e.createParenthesizedType(Fe); + } + return K(Fe); + } + function se(Fe) { + return e.createNodeArray(Qc(Fe, ae)); + } + function ce(Fe) { + switch (Fe.kind) { + case 194: + return e.createParenthesizedType(Fe); + } + return ae(Fe); + } + function fe(Fe) { + switch (Fe.kind) { + case 199: + return e.createParenthesizedType(Fe); + } + return ce(Fe); + } + function he(Fe) { + switch (Fe.kind) { + case 196: + case 199: + case 187: + return e.createParenthesizedType(Fe); + } + return ce(Fe); + } + function q(Fe) { + return e.createNodeArray(Qc(Fe, be)); + } + function be(Fe) { + return je(Fe) ? e.createParenthesizedType(Fe) : Fe; + } + function je(Fe) { + return v6(Fe) ? Fe.postfix : f6(Fe) || Zm(Fe) || _6(Fe) || rv(Fe) ? je(Fe.type) : Gb(Fe) ? je(Fe.falseType) : C0(Fe) || Hx(Fe) ? je(pa(Fe.types)) : xS(Fe) ? !!Fe.typeParameter.constraint && je(Fe.typeParameter.constraint) : !1; + } + function me(Fe) { + return je(Fe) ? e.createParenthesizedType(Fe) : he(Fe); + } + function Z(Fe) { + return CZ(Fe) && Fe.typeParameters ? e.createParenthesizedType(Fe) : Fe; + } + function pe(Fe, Ye) { + return Ye === 0 ? Z(Fe) : Fe; + } + function Te(Fe) { + if (ot(Fe)) + return e.createNodeArray(Qc(Fe, pe)); + } + } + var fte = { + getParenthesizeLeftSideOfBinaryForOperator: (e) => go, + getParenthesizeRightSideOfBinaryForOperator: (e) => go, + parenthesizeLeftSideOfBinary: (e, t) => t, + parenthesizeRightSideOfBinary: (e, t, n) => n, + parenthesizeExpressionOfComputedPropertyName: go, + parenthesizeConditionOfConditionalExpression: go, + parenthesizeBranchOfConditionalExpression: go, + parenthesizeExpressionOfExportDefault: go, + parenthesizeExpressionOfNew: (e) => Us(e, S_), + parenthesizeLeftSideOfAccess: (e) => Us(e, S_), + parenthesizeOperandOfPostfixUnary: (e) => Us(e, S_), + parenthesizeOperandOfPrefixUnary: (e) => Us(e, $j), + parenthesizeExpressionsOfCommaDelimitedList: (e) => Us(e, xb), + parenthesizeExpressionForDisallowedComma: go, + parenthesizeExpressionOfExpressionStatement: go, + parenthesizeConciseBodyOfArrowFunction: go, + parenthesizeCheckTypeOfConditionalType: go, + parenthesizeExtendsTypeOfConditionalType: go, + parenthesizeConstituentTypesOfUnionType: (e) => Us(e, xb), + parenthesizeConstituentTypeOfUnionType: go, + parenthesizeConstituentTypesOfIntersectionType: (e) => Us(e, xb), + parenthesizeConstituentTypeOfIntersectionType: go, + parenthesizeOperandOfTypeOperator: go, + parenthesizeOperandOfReadonlyTypeOperator: go, + parenthesizeNonArrayTypeOfPostfixType: go, + parenthesizeElementTypesOfTupleType: (e) => Us(e, xb), + parenthesizeElementTypeOfTupleType: go, + parenthesizeTypeOfOptionalType: go, + parenthesizeTypeArguments: (e) => e && Us(e, xb), + parenthesizeLeadingTypeArgument: go + }; + function pte(e) { + return { + convertToFunctionBlock: t, + convertToFunctionExpression: n, + convertToClassExpression: i, + convertToArrayAssignmentElement: s, + convertToObjectAssignmentElement: o, + convertToAssignmentPattern: c, + convertToObjectAssignmentPattern: _, + convertToArrayAssignmentPattern: u, + convertToAssignmentElementTarget: g + }; + function t(m, h) { + if (Ns(m)) return m; + const S = e.createReturnStatement(m); + ct(S, m); + const T = e.createBlock([S], h); + return ct(T, m), T; + } + function n(m) { + var h; + if (!m.body) return E.fail("Cannot convert a FunctionDeclaration without a body"); + const S = e.createFunctionExpression( + (h = Tb(m)) == null ? void 0 : h.filter((T) => !zx(T) && !kF(T)), + m.asteriskToken, + m.name, + m.typeParameters, + m.parameters, + m.type, + m.body + ); + return Cn(S, m), ct(S, m), k4(m) && hF( + S, + /*newLine*/ + !0 + ), S; + } + function i(m) { + var h; + const S = e.createClassExpression( + (h = m.modifiers) == null ? void 0 : h.filter((T) => !zx(T) && !kF(T)), + m.name, + m.typeParameters, + m.heritageClauses, + m.members + ); + return Cn(S, m), ct(S, m), k4(m) && hF( + S, + /*newLine*/ + !0 + ), S; + } + function s(m) { + if (ya(m)) { + if (m.dotDotDotToken) + return E.assertNode(m.name, Me), Cn(ct(e.createSpreadElement(m.name), m), m); + const h = g(m.name); + return m.initializer ? Cn( + ct( + e.createAssignment(h, m.initializer), + m + ), + m + ) : h; + } + return Us(m, ut); + } + function o(m) { + if (ya(m)) { + if (m.dotDotDotToken) + return E.assertNode(m.name, Me), Cn(ct(e.createSpreadAssignment(m.name), m), m); + if (m.propertyName) { + const h = g(m.name); + return Cn(ct(e.createPropertyAssignment(m.propertyName, m.initializer ? e.createAssignment(h, m.initializer) : h), m), m); + } + return E.assertNode(m.name, Me), Cn(ct(e.createShorthandPropertyAssignment(m.name, m.initializer), m), m); + } + return Us(m, vh); + } + function c(m) { + switch (m.kind) { + case 208: + case 210: + return u(m); + case 207: + case 211: + return _(m); + } + } + function _(m) { + return Of(m) ? Cn( + ct( + e.createObjectLiteralExpression(hr(m.elements, o)), + m + ), + m + ) : Us(m, _a); + } + function u(m) { + return D0(m) ? Cn( + ct( + e.createArrayLiteralExpression(hr(m.elements, s)), + m + ), + m + ) : Us(m, nu); + } + function g(m) { + return ws(m) ? c(m) : Us(m, ut); + } + } + var dte = { + convertToFunctionBlock: Vs, + convertToFunctionExpression: Vs, + convertToClassExpression: Vs, + convertToArrayAssignmentElement: Vs, + convertToObjectAssignmentElement: Vs, + convertToAssignmentPattern: Vs, + convertToObjectAssignmentPattern: Vs, + convertToArrayAssignmentPattern: Vs, + convertToAssignmentElementTarget: Vs + }, rz = 0, mte = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.NoParenthesizerRules = 1] = "NoParenthesizerRules", e[e.NoNodeConverters = 2] = "NoNodeConverters", e[e.NoIndentationOnFreshPropertyAccess = 4] = "NoIndentationOnFreshPropertyAccess", e[e.NoOriginalNode = 8] = "NoOriginalNode", e))(mte || {}), s0e = []; + function a0e(e) { + s0e.push(e); + } + function NN(e, t) { + const n = e & 8 ? go : Cn, i = Uu(() => e & 1 ? fte : _te(A)), s = Uu(() => e & 2 ? dte : pte(A)), o = nm((v) => (w, j) => zr(w, v, j)), c = nm((v) => (w) => et(v, w)), _ = nm((v) => (w) => Gt(w, v)), u = nm((v) => () => fs(v)), g = nm((v) => (w) => aT(v, w)), m = nm((v) => (w, j) => fn(v, w, j)), h = nm((v) => (w, j) => U_(v, w, j)), S = nm((v) => (w, j) => u1(v, w, j)), T = nm((v) => (w, j) => Vv(v, w, j)), k = nm((v) => (w, j, oe) => $h(v, w, j, oe)), D = nm((v) => (w, j, oe) => SE(v, w, j, oe)), P = nm((v) => (w, j, oe, Ue) => qv(v, w, j, oe, Ue)), A = { + get parenthesizer() { + return i(); + }, + get converters() { + return s(); + }, + baseFactory: t, + flags: e, + createNodeArray: O, + createNumericLiteral: U, + createBigIntLiteral: $, + createStringLiteral: _e, + createStringLiteralFromNode: K, + createRegularExpressionLiteral: V, + createLiteralLikeNode: ae, + createIdentifier: fe, + createTempVariable: he, + createLoopVariable: q, + createUniqueName: be, + getGeneratedNameForNode: je, + createPrivateIdentifier: Z, + createUniquePrivateName: Te, + getGeneratedPrivateNameForNode: Fe, + createToken: ne, + createSuper: Se, + createThis: ie, + createNull: Ne, + createTrue: Ee, + createFalse: Ce, + createModifier: Ve, + createModifiersFromModifierFlags: St, + createQualifiedName: Bt, + updateQualifiedName: tr, + createComputedPropertyName: Nr, + updateComputedPropertyName: st, + createTypeParameterDeclaration: Wt, + updateTypeParameterDeclaration: Jr, + createParameterDeclaration: ui, + updateParameterDeclaration: Ji, + createDecorator: Dt, + updateDecorator: Mn, + createPropertySignature: ai, + updatePropertySignature: fi, + createPropertyDeclaration: _i, + updatePropertyDeclaration: Je, + createMethodSignature: ft, + updateMethodSignature: er, + createMethodDeclaration: qr, + updateMethodDeclaration: Jn, + createConstructorDeclaration: yr, + updateConstructorDeclaration: bs, + createGetAccessorDeclaration: Et, + updateGetAccessorDeclaration: re, + createSetAccessorDeclaration: Y, + updateSetAccessorDeclaration: Ae, + createCallSignature: Ke, + updateCallSignature: Tt, + createConstructSignature: Le, + updateConstructSignature: mt, + createIndexSignature: pt, + updateIndexSignature: Ct, + createClassStaticBlockDeclaration: ki, + updateClassStaticBlockDeclaration: Ds, + createTemplateLiteralTypeSpan: qe, + updateTemplateLiteralTypeSpan: Lt, + createKeywordTypeNode: rn, + createTypePredicateNode: Pe, + updateTypePredicateNode: yt, + createTypeReferenceNode: ue, + updateTypeReferenceNode: M, + createFunctionTypeNode: ye, + updateFunctionTypeNode: Q, + createConstructorTypeNode: Mt, + updateConstructorTypeNode: wt, + createTypeQueryNode: Pr, + updateTypeQueryNode: rt, + createTypeLiteralNode: vt, + updateTypeLiteralNode: Nt, + createArrayTypeNode: Jt, + updateArrayTypeNode: _r, + createTupleTypeNode: nr, + updateTupleTypeNode: kt, + createNamedTupleMember: cr, + updateNamedTupleMember: fr, + createOptionalTypeNode: vr, + updateOptionalTypeNode: Xt, + createRestTypeNode: oi, + updateRestTypeNode: Fs, + createUnionTypeNode: pc, + updateUnionTypeNode: Zo, + createIntersectionTypeNode: so, + updateIntersectionTypeNode: zi, + createConditionalTypeNode: hs, + updateConditionalTypeNode: Gc, + createInferTypeNode: Co, + updateInferTypeNode: ta, + createImportTypeNode: cs, + updateImportTypeNode: Ws, + createParenthesizedType: Fa, + updateParenthesizedType: va, + createThisTypeNode: zt, + createTypeOperatorNode: Za, + updateTypeOperatorNode: yc, + createIndexedAccessTypeNode: Fc, + updateIndexedAccessTypeNode: Hl, + createMappedTypeNode: _o, + updateMappedTypeNode: ge, + createLiteralTypeNode: H, + updateLiteralTypeNode: tt, + createTemplateLiteralType: Ec, + updateTemplateLiteralType: zf, + createObjectBindingPattern: Ft, + updateObjectBindingPattern: Kt, + createArrayBindingPattern: Hr, + updateArrayBindingPattern: Vn, + createBindingElement: ln, + updateBindingElement: kr, + createArrayLiteralExpression: Li, + updateArrayLiteralExpression: Yi, + createObjectLiteralExpression: no, + updateObjectLiteralExpression: ra, + createPropertyAccessExpression: e & 4 ? (v, w) => un( + $c(v, w), + 262144 + /* NoIndentation */ + ) : $c, + updatePropertyAccessExpression: Jc, + createPropertyAccessChain: e & 4 ? (v, w, j) => un( + vo(v, w, j), + 262144 + /* NoIndentation */ + ) : vo, + updatePropertyAccessChain: ic, + createElementAccessExpression: au, + updateElementAccessExpression: Ef, + createElementAccessChain: P_, + updateElementAccessChain: Ie, + createCallExpression: Mr, + updateCallExpression: Gi, + createCallChain: Da, + updateCallChain: wa, + createNewExpression: ma, + updateNewExpression: il, + createTaggedTemplateExpression: Po, + updateTaggedTemplateExpression: sc, + createTypeAssertion: vc, + updateTypeAssertion: Df, + createParenthesizedExpression: Gl, + updateParenthesizedExpression: Ol, + createFunctionExpression: pf, + updateFunctionExpression: Qu, + createArrowFunction: hp, + updateArrowFunction: ig, + createDeleteExpression: Gg, + updateDeleteExpression: $g, + createTypeOfExpression: N_, + updateTypeOfExpression: Sl, + createVoidExpression: Jd, + updateVoidExpression: Wf, + createAwaitExpression: Nm, + updateAwaitExpression: ee, + createPrefixUnaryExpression: et, + updatePrefixUnaryExpression: Ut, + createPostfixUnaryExpression: Gt, + updatePostfixUnaryExpression: Sr, + createBinaryExpression: zr, + updateBinaryExpression: ni, + createConditionalExpression: wi, + updateConditionalExpression: L, + createTemplateExpression: Oe, + updateTemplateExpression: xt, + createTemplateHead: zo, + createTemplateMiddle: na, + createTemplateTail: Ll, + createNoSubstitutionTemplateLiteral: df, + createTemplateLiteralLikeNode: ys, + createYieldExpression: Uf, + updateYieldExpression: yp, + createSpreadElement: jh, + updateSpreadElement: M0, + createClassExpression: __, + updateClassExpression: sg, + createOmittedExpression: zd, + createExpressionWithTypeArguments: $p, + updateExpressionWithTypeArguments: s1, + createAsExpression: Be, + updateAsExpression: nt, + createNonNullExpression: Rt, + updateNonNullExpression: pr, + createSatisfiesExpression: Or, + updateSatisfiesExpression: dn, + createNonNullChain: Ir, + updateNonNullChain: Vr, + createMetaProperty: hi, + updateMetaProperty: rs, + createTemplateSpan: Zn, + updateTemplateSpan: ns, + createSemicolonClassElement: Pi, + createBlock: Wo, + updateBlock: A_, + createVariableStatement: Xp, + updateVariableStatement: $l, + createEmptyStatement: Qp, + createExpressionStatement: mf, + updateExpressionStatement: wv, + createIfStatement: Am, + updateIfStatement: ag, + createDoStatement: Pv, + updateDoStatement: og, + createWhileStatement: pE, + updateWhileStatement: Vw, + createForStatement: dE, + updateForStatement: Xg, + createForInStatement: Nv, + updateForInStatement: YS, + createForOfStatement: R0, + updateForOfStatement: ZS, + createContinueStatement: Dk, + updateContinueStatement: qw, + createBreakStatement: KS, + updateBreakStatement: wk, + createReturnStatement: Av, + updateReturnStatement: mE, + createWithStatement: eT, + updateWithStatement: Pk, + createSwitchStatement: g2, + updateSwitchStatement: a1, + createLabeledStatement: Nk, + updateLabeledStatement: Ak, + createThrowStatement: h2, + updateThrowStatement: o1, + createTryStatement: j0, + updateTryStatement: Bh, + createDebuggerStatement: Jh, + createVariableDeclaration: zh, + updateVariableDeclaration: c1, + createVariableDeclarationList: Iv, + updateVariableDeclarationList: tT, + createFunctionDeclaration: Fv, + updateFunctionDeclaration: Aa, + createClassDeclaration: gE, + updateClassDeclaration: Wh, + createInterfaceDeclaration: Uh, + updateInterfaceDeclaration: cg, + createTypeAliasDeclaration: Ro, + updateTypeAliasDeclaration: yu, + createEnumDeclaration: I_, + updateEnumDeclaration: vu, + createModuleDeclaration: Ov, + updateModuleDeclaration: Yu, + createModuleBlock: lg, + updateModuleBlock: f_, + createCaseBlock: Yp, + updateCaseBlock: pd, + createNamespaceExportDeclaration: Lv, + updateNamespaceExportDeclaration: Mv, + createImportEqualsDeclaration: hE, + updateImportEqualsDeclaration: B0, + createImportDeclaration: y2, + updateImportDeclaration: ze, + createImportClause: nT, + updateImportClause: Qg, + createAssertClause: dd, + updateAssertClause: J0, + createAssertEntry: l1, + updateAssertEntry: Zu, + createImportTypeAssertionContainer: Wd, + updateImportTypeAssertionContainer: Zp, + createImportAttributes: Rv, + updateImportAttributes: ga, + createImportAttribute: Vf, + updateImportAttribute: z0, + createNamespaceImport: iT, + updateNamespaceImport: Vh, + createNamespaceExport: v2, + updateNamespaceExport: vp, + createNamedImports: Yg, + updateNamedImports: jv, + createImportSpecifier: W0, + updateImportSpecifier: Im, + createExportAssignment: b2, + updateExportAssignment: Bv, + createExportDeclaration: Pn, + updateExportDeclaration: xn, + createNamedExports: sT, + updateNamedExports: qh, + createExportSpecifier: S2, + updateExportSpecifier: yE, + createMissingDeclaration: Gw, + createExternalModuleReference: bn, + updateExternalModuleReference: Ku, + // lazily load factory members for JSDoc types with similar structure + get createJSDocAllType() { + return u( + 313 + /* JSDocAllType */ + ); + }, + get createJSDocUnknownType() { + return u( + 314 + /* JSDocUnknownType */ + ); + }, + get createJSDocNonNullableType() { + return h( + 316 + /* JSDocNonNullableType */ + ); + }, + get updateJSDocNonNullableType() { + return S( + 316 + /* JSDocNonNullableType */ + ); + }, + get createJSDocNullableType() { + return h( + 315 + /* JSDocNullableType */ + ); + }, + get updateJSDocNullableType() { + return S( + 315 + /* JSDocNullableType */ + ); + }, + get createJSDocOptionalType() { + return g( + 317 + /* JSDocOptionalType */ + ); + }, + get updateJSDocOptionalType() { + return m( + 317 + /* JSDocOptionalType */ + ); + }, + get createJSDocVariadicType() { + return g( + 319 + /* JSDocVariadicType */ + ); + }, + get updateJSDocVariadicType() { + return m( + 319 + /* JSDocVariadicType */ + ); + }, + get createJSDocNamepathType() { + return g( + 320 + /* JSDocNamepathType */ + ); + }, + get updateJSDocNamepathType() { + return m( + 320 + /* JSDocNamepathType */ + ); + }, + createJSDocFunctionType: vE, + updateJSDocFunctionType: Ik, + createJSDocTypeLiteral: Lu, + updateJSDocTypeLiteral: ug, + createJSDocTypeExpression: Ud, + updateJSDocTypeExpression: _1, + createJSDocSignature: oT, + updateJSDocSignature: f1, + createJSDocTemplateTag: F_, + updateJSDocTemplateTag: U0, + createJSDocTypedefTag: Jv, + updateJSDocTypedefTag: Fk, + createJSDocParameterTag: zv, + updateJSDocParameterTag: p1, + createJSDocPropertyTag: Ok, + updateJSDocPropertyTag: Hh, + createJSDocCallbackTag: Fm, + updateJSDocCallbackTag: d1, + createJSDocOverloadTag: Wv, + updateJSDocOverloadTag: V0, + createJSDocAugmentsTag: m1, + updateJSDocAugmentsTag: gd, + createJSDocImplementsTag: Gh, + updateJSDocImplementsTag: Rk, + createJSDocSeeTag: Zg, + updateJSDocSeeTag: g1, + createJSDocImportTag: O_, + updateJSDocImportTag: Sp, + createJSDocNameReference: Ml, + updateJSDocNameReference: T2, + createJSDocMemberName: Kg, + updateJSDocMemberName: Uv, + createJSDocLink: cT, + updateJSDocLink: eh, + createJSDocLinkCode: bE, + updateJSDocLinkCode: Lk, + createJSDocLinkPlain: Mk, + updateJSDocLinkPlain: $w, + // lazily load factory members for JSDoc tags with similar structure + get createJSDocTypeTag() { + return D( + 345 + /* JSDocTypeTag */ + ); + }, + get updateJSDocTypeTag() { + return P( + 345 + /* JSDocTypeTag */ + ); + }, + get createJSDocReturnTag() { + return D( + 343 + /* JSDocReturnTag */ + ); + }, + get updateJSDocReturnTag() { + return P( + 343 + /* JSDocReturnTag */ + ); + }, + get createJSDocThisTag() { + return D( + 344 + /* JSDocThisTag */ + ); + }, + get updateJSDocThisTag() { + return P( + 344 + /* JSDocThisTag */ + ); + }, + get createJSDocAuthorTag() { + return T( + 331 + /* JSDocAuthorTag */ + ); + }, + get updateJSDocAuthorTag() { + return k( + 331 + /* JSDocAuthorTag */ + ); + }, + get createJSDocClassTag() { + return T( + 333 + /* JSDocClassTag */ + ); + }, + get updateJSDocClassTag() { + return k( + 333 + /* JSDocClassTag */ + ); + }, + get createJSDocPublicTag() { + return T( + 334 + /* JSDocPublicTag */ + ); + }, + get updateJSDocPublicTag() { + return k( + 334 + /* JSDocPublicTag */ + ); + }, + get createJSDocPrivateTag() { + return T( + 335 + /* JSDocPrivateTag */ + ); + }, + get updateJSDocPrivateTag() { + return k( + 335 + /* JSDocPrivateTag */ + ); + }, + get createJSDocProtectedTag() { + return T( + 336 + /* JSDocProtectedTag */ + ); + }, + get updateJSDocProtectedTag() { + return k( + 336 + /* JSDocProtectedTag */ + ); + }, + get createJSDocReadonlyTag() { + return T( + 337 + /* JSDocReadonlyTag */ + ); + }, + get updateJSDocReadonlyTag() { + return k( + 337 + /* JSDocReadonlyTag */ + ); + }, + get createJSDocOverrideTag() { + return T( + 338 + /* JSDocOverrideTag */ + ); + }, + get updateJSDocOverrideTag() { + return k( + 338 + /* JSDocOverrideTag */ + ); + }, + get createJSDocDeprecatedTag() { + return T( + 332 + /* JSDocDeprecatedTag */ + ); + }, + get updateJSDocDeprecatedTag() { + return k( + 332 + /* JSDocDeprecatedTag */ + ); + }, + get createJSDocThrowsTag() { + return D( + 350 + /* JSDocThrowsTag */ + ); + }, + get updateJSDocThrowsTag() { + return P( + 350 + /* JSDocThrowsTag */ + ); + }, + get createJSDocSatisfiesTag() { + return D( + 351 + /* JSDocSatisfiesTag */ + ); + }, + get updateJSDocSatisfiesTag() { + return P( + 351 + /* JSDocSatisfiesTag */ + ); + }, + createJSDocEnumTag: Rl, + updateJSDocEnumTag: jk, + createJSDocUnknownTag: lT, + updateJSDocUnknownTag: zc, + createJSDocText: x2, + updateJSDocText: Vd, + createJSDocComment: h1, + updateJSDocComment: q0, + createJsxElement: Bk, + updateJsxElement: Xw, + createJsxSelfClosingElement: dc, + updateJsxSelfClosingElement: TE, + createJsxOpeningElement: uT, + updateJsxOpeningElement: k2, + createJsxClosingElement: Jk, + updateJsxClosingElement: Mu, + createJsxFragment: V_, + createJsxText: Hv, + updateJsxText: q_, + createJsxOpeningFragment: fT, + createJsxJsxClosingFragment: th, + updateJsxFragment: _T, + createJsxAttribute: zk, + updateJsxAttribute: pT, + createJsxAttributes: hd, + updateJsxAttributes: Wk, + createJsxSpreadAttribute: xE, + updateJsxSpreadAttribute: Uk, + createJsxExpression: dT, + updateJsxExpression: Vk, + createJsxNamespacedName: H0, + updateJsxNamespacedName: gf, + createCaseClause: Om, + updateCaseClause: mT, + createDefaultClause: gT, + updateDefaultClause: Oa, + createHeritageClause: yn, + updateHeritageClause: Hf, + createCatchClause: Tl, + updateCatchClause: Gv, + createPropertyAssignment: hT, + updatePropertyAssignment: C2, + createShorthandPropertyAssignment: yT, + updateShorthandPropertyAssignment: C, + createSpreadAssignment: _t, + updateSpreadAssignment: ur, + createEnumMember: ti, + updateEnumMember: gi, + createSourceFile: Ki, + updateSourceFile: Xv, + createRedirectedSourceFile: mi, + createBundle: d_, + updateBundle: y1, + createSyntheticExpression: qk, + createSyntaxList: Kp, + createNotEmittedStatement: Ho, + createNotEmittedTypeElement: yd, + createPartiallyEmittedExpression: vT, + updatePartiallyEmittedExpression: G0, + createCommaListExpression: E2, + updateCommaListExpression: qL, + createSyntheticReferenceExpression: Qw, + updateSyntheticReferenceExpression: Hk, + cloneNode: bT, + // Lazily load factory methods for common operator factories and utilities + get createComma() { + return o( + 28 + /* CommaToken */ + ); + }, + get createAssignment() { + return o( + 64 + /* EqualsToken */ + ); + }, + get createLogicalOr() { + return o( + 57 + /* BarBarToken */ + ); + }, + get createLogicalAnd() { + return o( + 56 + /* AmpersandAmpersandToken */ + ); + }, + get createBitwiseOr() { + return o( + 52 + /* BarToken */ + ); + }, + get createBitwiseXor() { + return o( + 53 + /* CaretToken */ + ); + }, + get createBitwiseAnd() { + return o( + 51 + /* AmpersandToken */ + ); + }, + get createStrictEquality() { + return o( + 37 + /* EqualsEqualsEqualsToken */ + ); + }, + get createStrictInequality() { + return o( + 38 + /* ExclamationEqualsEqualsToken */ + ); + }, + get createEquality() { + return o( + 35 + /* EqualsEqualsToken */ + ); + }, + get createInequality() { + return o( + 36 + /* ExclamationEqualsToken */ + ); + }, + get createLessThan() { + return o( + 30 + /* LessThanToken */ + ); + }, + get createLessThanEquals() { + return o( + 33 + /* LessThanEqualsToken */ + ); + }, + get createGreaterThan() { + return o( + 32 + /* GreaterThanToken */ + ); + }, + get createGreaterThanEquals() { + return o( + 34 + /* GreaterThanEqualsToken */ + ); + }, + get createLeftShift() { + return o( + 48 + /* LessThanLessThanToken */ + ); + }, + get createRightShift() { + return o( + 49 + /* GreaterThanGreaterThanToken */ + ); + }, + get createUnsignedRightShift() { + return o( + 50 + /* GreaterThanGreaterThanGreaterThanToken */ + ); + }, + get createAdd() { + return o( + 40 + /* PlusToken */ + ); + }, + get createSubtract() { + return o( + 41 + /* MinusToken */ + ); + }, + get createMultiply() { + return o( + 42 + /* AsteriskToken */ + ); + }, + get createDivide() { + return o( + 44 + /* SlashToken */ + ); + }, + get createModulo() { + return o( + 45 + /* PercentToken */ + ); + }, + get createExponent() { + return o( + 43 + /* AsteriskAsteriskToken */ + ); + }, + get createPrefixPlus() { + return c( + 40 + /* PlusToken */ + ); + }, + get createPrefixMinus() { + return c( + 41 + /* MinusToken */ + ); + }, + get createPrefixIncrement() { + return c( + 46 + /* PlusPlusToken */ + ); + }, + get createPrefixDecrement() { + return c( + 47 + /* MinusMinusToken */ + ); + }, + get createBitwiseNot() { + return c( + 55 + /* TildeToken */ + ); + }, + get createLogicalNot() { + return c( + 54 + /* ExclamationToken */ + ); + }, + get createPostfixIncrement() { + return _( + 46 + /* PlusPlusToken */ + ); + }, + get createPostfixDecrement() { + return _( + 47 + /* MinusMinusToken */ + ); + }, + // Compound nodes + createImmediatelyInvokedFunctionExpression: HL, + createImmediatelyInvokedArrowFunction: D2, + createVoidZero: ST, + createExportDefault: Zw, + createExternalModuleExport: $k, + createTypeCheck: Wi, + createIsNotTypeCheck: b1, + createMethodCall: Wr, + createGlobalMethodCall: w2, + createFunctionBindCall: Kw, + createFunctionCallCall: kE, + createFunctionApplyCall: CE, + createArraySliceCall: V8, + createArrayConcatCall: TT, + createObjectDefinePropertyCall: GL, + createObjectGetOwnPropertyDescriptorCall: EE, + createReflectGetCall: _g, + createReflectSetCall: q8, + createPropertyDescriptor: $L, + createCallBinding: DE, + createAssignmentTargetWrapper: Lm, + // Utilities + inlineExpressions: X, + getInternalName: He, + getLocalName: bt, + getExportName: Vt, + getDeclarationName: rr, + getNamespaceMemberName: Rn, + getExternalModuleOrNamespaceExportName: gn, + restoreOuterExpressions: tP, + restoreEnclosingLabel: Yv, + createUseStrictPrologue: ji, + copyPrologue: Gr, + copyStandardPrologue: fo, + copyCustomPrologue: Ka, + ensureUseStrict: La, + liftToBlock: Tp, + mergeLexicalEnvironment: X0, + replaceModifiers: Q0, + replaceDecoratorsAndModifiers: rh, + replacePropertyName: S1 + }; + return lr(s0e, (v) => v(A)), A; + function O(v, w) { + if (v === void 0 || v === Ge) + v = []; + else if (xb(v)) { + if (w === void 0 || v.hasTrailingComma === w) + return v.transformFlags === void 0 && c0e(v), E.attachNodeArrayDebugInfo(v), v; + const Ue = v.slice(); + return Ue.pos = v.pos, Ue.end = v.end, Ue.hasTrailingComma = w, Ue.transformFlags = v.transformFlags, E.attachNodeArrayDebugInfo(Ue), Ue; + } + const j = v.length, oe = j >= 1 && j <= 4 ? v.slice() : v; + return oe.pos = -1, oe.end = -1, oe.hasTrailingComma = !!w, oe.transformFlags = 0, c0e(oe), E.attachNodeArrayDebugInfo(oe), oe; + } + function F(v) { + return t.createBaseNode(v); + } + function R(v) { + const w = F(v); + return w.symbol = void 0, w.localSymbol = void 0, w; + } + function B(v, w) { + return v !== w && (v.typeArguments = w.typeArguments), tn(v, w); + } + function U(v, w = 0) { + const j = typeof v == "number" ? v + "" : v; + E.assert(j.charCodeAt(0) !== 45, "Negative numbers should be created in combination with createPrefixUnaryExpression"); + const oe = R( + 9 + /* NumericLiteral */ + ); + return oe.text = j, oe.numericLiteralFlags = w, w & 384 && (oe.transformFlags |= 1024), oe; + } + function $(v) { + const w = Ye( + 10 + /* BigIntLiteral */ + ); + return w.text = typeof v == "string" ? v : Ub(v) + "n", w.transformFlags |= 32, w; + } + function W(v, w) { + const j = R( + 11 + /* StringLiteral */ + ); + return j.text = v, j.singleQuote = w, j; + } + function _e(v, w, j) { + const oe = W(v, w); + return oe.hasExtendedUnicodeEscape = j, j && (oe.transformFlags |= 1024), oe; + } + function K(v) { + const w = W( + op(v), + /*isSingleQuote*/ + void 0 + ); + return w.textSourceNode = v, w; + } + function V(v) { + const w = Ye( + 14 + /* RegularExpressionLiteral */ + ); + return w.text = v, w; + } + function ae(v, w) { + switch (v) { + case 9: + return U( + w, + /*numericLiteralFlags*/ + 0 + ); + case 10: + return $(w); + case 11: + return _e( + w, + /*isSingleQuote*/ + void 0 + ); + case 12: + return Hv( + w, + /*containsOnlyTriviaWhiteSpaces*/ + !1 + ); + case 13: + return Hv( + w, + /*containsOnlyTriviaWhiteSpaces*/ + !0 + ); + case 14: + return V(w); + case 15: + return ys( + v, + w, + /*rawText*/ + void 0, + /*templateFlags*/ + 0 + ); + } + } + function se(v) { + const w = t.createBaseIdentifierNode( + 80 + /* Identifier */ + ); + return w.escapedText = v, w.jsDoc = void 0, w.flowNode = void 0, w.symbol = void 0, w; + } + function ce(v, w, j, oe) { + const Ue = se(tc(v)); + return LN(Ue, { + flags: w, + id: rz, + prefix: j, + suffix: oe + }), rz++, Ue; + } + function fe(v, w, j) { + w === void 0 && v && (w = Q2(v)), w === 80 && (w = void 0); + const oe = se(tc(v)); + return j && (oe.flags |= 256), oe.escapedText === "await" && (oe.transformFlags |= 67108864), oe.flags & 256 && (oe.transformFlags |= 1024), oe; + } + function he(v, w, j, oe) { + let Ue = 1; + w && (Ue |= 8); + const qt = ce("", Ue, j, oe); + return v && v(qt), qt; + } + function q(v) { + let w = 2; + return v && (w |= 8), ce( + "", + w, + /*prefix*/ + void 0, + /*suffix*/ + void 0 + ); + } + function be(v, w = 0, j, oe) { + return E.assert(!(w & 7), "Argument out of range: flags"), E.assert((w & 48) !== 32, "GeneratedIdentifierFlags.FileLevel cannot be set without also setting GeneratedIdentifierFlags.Optimistic"), ce(v, 3 | w, j, oe); + } + function je(v, w = 0, j, oe) { + E.assert(!(w & 7), "Argument out of range: flags"); + const Ue = v ? wg(v) ? _v( + /*privateName*/ + !1, + j, + v, + oe, + An + ) : `generated@${Ma(v)}` : ""; + (j || oe) && (w |= 16); + const qt = ce(Ue, 4 | w, j, oe); + return qt.original = v, qt; + } + function me(v) { + const w = t.createBasePrivateIdentifierNode( + 81 + /* PrivateIdentifier */ + ); + return w.escapedText = v, w.transformFlags |= 16777216, w; + } + function Z(v) { + return Ui(v, "#") || E.fail("First character of private identifier must be #: " + v), me(tc(v)); + } + function pe(v, w, j, oe) { + const Ue = me(tc(v)); + return LN(Ue, { + flags: w, + id: rz, + prefix: j, + suffix: oe + }), rz++, Ue; + } + function Te(v, w, j) { + v && !Ui(v, "#") && E.fail("First character of private identifier must be #: " + v); + const oe = 8 | (v ? 3 : 1); + return pe(v ?? "", oe, w, j); + } + function Fe(v, w, j) { + const oe = wg(v) ? _v( + /*privateName*/ + !0, + w, + v, + j, + An + ) : `#generated@${Ma(v)}`, qt = pe(oe, 4 | (w || j ? 16 : 0), w, j); + return qt.original = v, qt; + } + function Ye(v) { + return t.createBaseTokenNode(v); + } + function ne(v) { + E.assert(v >= 0 && v <= 166, "Invalid token"), E.assert(v <= 15 || v >= 18, "Invalid token. Use 'createTemplateLiteralLikeNode' to create template literals."), E.assert(v <= 9 || v >= 15, "Invalid token. Use 'createLiteralLikeNode' to create literals."), E.assert(v !== 80, "Invalid token. Use 'createIdentifier' to create identifiers"); + const w = Ye(v); + let j = 0; + switch (v) { + case 134: + j = 384; + break; + case 160: + j = 4; + break; + case 125: + case 123: + case 124: + case 148: + case 128: + case 138: + case 87: + case 133: + case 150: + case 163: + case 146: + case 151: + case 103: + case 147: + case 164: + case 154: + case 136: + case 155: + case 116: + case 159: + case 157: + j = 1; + break; + case 108: + j = 134218752, w.flowNode = void 0; + break; + case 126: + j = 1024; + break; + case 129: + j = 16777216; + break; + case 110: + j = 16384, w.flowNode = void 0; + break; + } + return j && (w.transformFlags |= j), w; + } + function Se() { + return ne( + 108 + /* SuperKeyword */ + ); + } + function ie() { + return ne( + 110 + /* ThisKeyword */ + ); + } + function Ne() { + return ne( + 106 + /* NullKeyword */ + ); + } + function Ee() { + return ne( + 112 + /* TrueKeyword */ + ); + } + function Ce() { + return ne( + 97 + /* FalseKeyword */ + ); + } + function Ve(v) { + return ne(v); + } + function St(v) { + const w = []; + return v & 32 && w.push(Ve( + 95 + /* ExportKeyword */ + )), v & 128 && w.push(Ve( + 138 + /* DeclareKeyword */ + )), v & 2048 && w.push(Ve( + 90 + /* DefaultKeyword */ + )), v & 4096 && w.push(Ve( + 87 + /* ConstKeyword */ + )), v & 1 && w.push(Ve( + 125 + /* PublicKeyword */ + )), v & 2 && w.push(Ve( + 123 + /* PrivateKeyword */ + )), v & 4 && w.push(Ve( + 124 + /* ProtectedKeyword */ + )), v & 64 && w.push(Ve( + 128 + /* AbstractKeyword */ + )), v & 256 && w.push(Ve( + 126 + /* StaticKeyword */ + )), v & 16 && w.push(Ve( + 164 + /* OverrideKeyword */ + )), v & 8 && w.push(Ve( + 148 + /* ReadonlyKeyword */ + )), v & 512 && w.push(Ve( + 129 + /* AccessorKeyword */ + )), v & 1024 && w.push(Ve( + 134 + /* AsyncKeyword */ + )), v & 8192 && w.push(Ve( + 103 + /* InKeyword */ + )), v & 16384 && w.push(Ve( + 147 + /* OutKeyword */ + )), w.length ? w : void 0; + } + function Bt(v, w) { + const j = F( + 167 + /* QualifiedName */ + ); + return j.left = v, j.right = dl(w), j.transformFlags |= vn(j.left) | AN(j.right), j.flowNode = void 0, j; + } + function tr(v, w, j) { + return v.left !== w || v.right !== j ? tn(Bt(w, j), v) : v; + } + function Nr(v) { + const w = F( + 168 + /* ComputedPropertyName */ + ); + return w.expression = i().parenthesizeExpressionOfComputedPropertyName(v), w.transformFlags |= vn(w.expression) | 1024 | 131072, w; + } + function st(v, w) { + return v.expression !== w ? tn(Nr(w), v) : v; + } + function Wt(v, w, j, oe) { + const Ue = R( + 169 + /* TypeParameter */ + ); + return Ue.modifiers = Ra(v), Ue.name = dl(w), Ue.constraint = j, Ue.default = oe, Ue.transformFlags = 1, Ue.expression = void 0, Ue.jsDoc = void 0, Ue; + } + function Jr(v, w, j, oe, Ue) { + return v.modifiers !== w || v.name !== j || v.constraint !== oe || v.default !== Ue ? tn(Wt(w, j, oe, Ue), v) : v; + } + function ui(v, w, j, oe, Ue, qt) { + const hn = R( + 170 + /* Parameter */ + ); + return hn.modifiers = Ra(v), hn.dotDotDotToken = w, hn.name = dl(j), hn.questionToken = oe, hn.type = Ue, hn.initializer = Ru(qt), Ry(hn.name) ? hn.transformFlags = 1 : hn.transformFlags = Ia(hn.modifiers) | vn(hn.dotDotDotToken) | Wy(hn.name) | vn(hn.questionToken) | vn(hn.initializer) | (hn.questionToken ?? hn.type ? 1 : 0) | (hn.dotDotDotToken ?? hn.initializer ? 1024 : 0) | (pm(hn.modifiers) & 31 ? 8192 : 0), hn.jsDoc = void 0, hn; + } + function Ji(v, w, j, oe, Ue, qt, hn) { + return v.modifiers !== w || v.dotDotDotToken !== j || v.name !== oe || v.questionToken !== Ue || v.type !== qt || v.initializer !== hn ? tn(ui(w, j, oe, Ue, qt, hn), v) : v; + } + function Dt(v) { + const w = F( + 171 + /* Decorator */ + ); + return w.expression = i().parenthesizeLeftSideOfAccess( + v, + /*optionalChain*/ + !1 + ), w.transformFlags |= vn(w.expression) | 1 | 8192 | 33554432, w; + } + function Mn(v, w) { + return v.expression !== w ? tn(Dt(w), v) : v; + } + function ai(v, w, j, oe) { + const Ue = R( + 172 + /* PropertySignature */ + ); + return Ue.modifiers = Ra(v), Ue.name = dl(w), Ue.type = oe, Ue.questionToken = j, Ue.transformFlags = 1, Ue.initializer = void 0, Ue.jsDoc = void 0, Ue; + } + function fi(v, w, j, oe, Ue) { + return v.modifiers !== w || v.name !== j || v.questionToken !== oe || v.type !== Ue ? pn(ai(w, j, oe, Ue), v) : v; + } + function pn(v, w) { + return v !== w && (v.initializer = w.initializer), tn(v, w); + } + function _i(v, w, j, oe, Ue) { + const qt = R( + 173 + /* PropertyDeclaration */ + ); + qt.modifiers = Ra(v), qt.name = dl(w), qt.questionToken = j && Vy(j) ? j : void 0, qt.exclamationToken = j && RN(j) ? j : void 0, qt.type = oe, qt.initializer = Ru(Ue); + const hn = qt.flags & 33554432 || pm(qt.modifiers) & 128; + return qt.transformFlags = Ia(qt.modifiers) | Wy(qt.name) | vn(qt.initializer) | (hn || qt.questionToken || qt.exclamationToken || qt.type ? 1 : 0) | (Gs(qt.name) || pm(qt.modifiers) & 256 && qt.initializer ? 8192 : 0) | 16777216, qt.jsDoc = void 0, qt; + } + function Je(v, w, j, oe, Ue, qt) { + return v.modifiers !== w || v.name !== j || v.questionToken !== (oe !== void 0 && Vy(oe) ? oe : void 0) || v.exclamationToken !== (oe !== void 0 && RN(oe) ? oe : void 0) || v.type !== Ue || v.initializer !== qt ? tn(_i(w, j, oe, Ue, qt), v) : v; + } + function ft(v, w, j, oe, Ue, qt) { + const hn = R( + 174 + /* MethodSignature */ + ); + return hn.modifiers = Ra(v), hn.name = dl(w), hn.questionToken = j, hn.typeParameters = Ra(oe), hn.parameters = Ra(Ue), hn.type = qt, hn.transformFlags = 1, hn.jsDoc = void 0, hn.locals = void 0, hn.nextContainer = void 0, hn.typeArguments = void 0, hn; + } + function er(v, w, j, oe, Ue, qt, hn) { + return v.modifiers !== w || v.name !== j || v.questionToken !== oe || v.typeParameters !== Ue || v.parameters !== qt || v.type !== hn ? B(ft(w, j, oe, Ue, qt, hn), v) : v; + } + function qr(v, w, j, oe, Ue, qt, hn, ls) { + const No = R( + 175 + /* MethodDeclaration */ + ); + if (No.modifiers = Ra(v), No.asteriskToken = w, No.name = dl(j), No.questionToken = oe, No.exclamationToken = void 0, No.typeParameters = Ra(Ue), No.parameters = O(qt), No.type = hn, No.body = ls, !No.body) + No.transformFlags = 1; + else { + const wf = pm(No.modifiers) & 1024, T1 = !!No.asteriskToken, qd = wf && T1; + No.transformFlags = Ia(No.modifiers) | vn(No.asteriskToken) | Wy(No.name) | vn(No.questionToken) | Ia(No.typeParameters) | Ia(No.parameters) | vn(No.type) | vn(No.body) & -67108865 | (qd ? 128 : wf ? 256 : T1 ? 2048 : 0) | (No.questionToken || No.typeParameters || No.type ? 1 : 0) | 1024; + } + return No.typeArguments = void 0, No.jsDoc = void 0, No.locals = void 0, No.nextContainer = void 0, No.flowNode = void 0, No.endFlowNode = void 0, No.returnFlowNode = void 0, No; + } + function Jn(v, w, j, oe, Ue, qt, hn, ls, No) { + return v.modifiers !== w || v.asteriskToken !== j || v.name !== oe || v.questionToken !== Ue || v.typeParameters !== qt || v.parameters !== hn || v.type !== ls || v.body !== No ? Un(qr(w, j, oe, Ue, qt, hn, ls, No), v) : v; + } + function Un(v, w) { + return v !== w && (v.exclamationToken = w.exclamationToken), tn(v, w); + } + function ki(v) { + const w = R( + 176 + /* ClassStaticBlockDeclaration */ + ); + return w.body = v, w.transformFlags = vn(v) | 16777216, w.modifiers = void 0, w.jsDoc = void 0, w.locals = void 0, w.nextContainer = void 0, w.endFlowNode = void 0, w.returnFlowNode = void 0, w; + } + function Ds(v, w) { + return v.body !== w ? Ks(ki(w), v) : v; + } + function Ks(v, w) { + return v !== w && (v.modifiers = w.modifiers), tn(v, w); + } + function yr(v, w, j) { + const oe = R( + 177 + /* Constructor */ + ); + return oe.modifiers = Ra(v), oe.parameters = O(w), oe.body = j, oe.body ? oe.transformFlags = Ia(oe.modifiers) | Ia(oe.parameters) | vn(oe.body) & -67108865 | 1024 : oe.transformFlags = 1, oe.typeParameters = void 0, oe.type = void 0, oe.typeArguments = void 0, oe.jsDoc = void 0, oe.locals = void 0, oe.nextContainer = void 0, oe.endFlowNode = void 0, oe.returnFlowNode = void 0, oe; + } + function bs(v, w, j, oe) { + return v.modifiers !== w || v.parameters !== j || v.body !== oe ? Xe(yr(w, j, oe), v) : v; + } + function Xe(v, w) { + return v !== w && (v.typeParameters = w.typeParameters, v.type = w.type), B(v, w); + } + function Et(v, w, j, oe, Ue) { + const qt = R( + 178 + /* GetAccessor */ + ); + return qt.modifiers = Ra(v), qt.name = dl(w), qt.parameters = O(j), qt.type = oe, qt.body = Ue, qt.body ? qt.transformFlags = Ia(qt.modifiers) | Wy(qt.name) | Ia(qt.parameters) | vn(qt.type) | vn(qt.body) & -67108865 | (qt.type ? 1 : 0) : qt.transformFlags = 1, qt.typeArguments = void 0, qt.typeParameters = void 0, qt.jsDoc = void 0, qt.locals = void 0, qt.nextContainer = void 0, qt.flowNode = void 0, qt.endFlowNode = void 0, qt.returnFlowNode = void 0, qt; + } + function re(v, w, j, oe, Ue, qt) { + return v.modifiers !== w || v.name !== j || v.parameters !== oe || v.type !== Ue || v.body !== qt ? it(Et(w, j, oe, Ue, qt), v) : v; + } + function it(v, w) { + return v !== w && (v.typeParameters = w.typeParameters), B(v, w); + } + function Y(v, w, j, oe) { + const Ue = R( + 179 + /* SetAccessor */ + ); + return Ue.modifiers = Ra(v), Ue.name = dl(w), Ue.parameters = O(j), Ue.body = oe, Ue.body ? Ue.transformFlags = Ia(Ue.modifiers) | Wy(Ue.name) | Ia(Ue.parameters) | vn(Ue.body) & -67108865 | (Ue.type ? 1 : 0) : Ue.transformFlags = 1, Ue.typeArguments = void 0, Ue.typeParameters = void 0, Ue.type = void 0, Ue.jsDoc = void 0, Ue.locals = void 0, Ue.nextContainer = void 0, Ue.flowNode = void 0, Ue.endFlowNode = void 0, Ue.returnFlowNode = void 0, Ue; + } + function Ae(v, w, j, oe, Ue) { + return v.modifiers !== w || v.name !== j || v.parameters !== oe || v.body !== Ue ? $e(Y(w, j, oe, Ue), v) : v; + } + function $e(v, w) { + return v !== w && (v.typeParameters = w.typeParameters, v.type = w.type), B(v, w); + } + function Ke(v, w, j) { + const oe = R( + 180 + /* CallSignature */ + ); + return oe.typeParameters = Ra(v), oe.parameters = Ra(w), oe.type = j, oe.transformFlags = 1, oe.jsDoc = void 0, oe.locals = void 0, oe.nextContainer = void 0, oe.typeArguments = void 0, oe; + } + function Tt(v, w, j, oe) { + return v.typeParameters !== w || v.parameters !== j || v.type !== oe ? B(Ke(w, j, oe), v) : v; + } + function Le(v, w, j) { + const oe = R( + 181 + /* ConstructSignature */ + ); + return oe.typeParameters = Ra(v), oe.parameters = Ra(w), oe.type = j, oe.transformFlags = 1, oe.jsDoc = void 0, oe.locals = void 0, oe.nextContainer = void 0, oe.typeArguments = void 0, oe; + } + function mt(v, w, j, oe) { + return v.typeParameters !== w || v.parameters !== j || v.type !== oe ? B(Le(w, j, oe), v) : v; + } + function pt(v, w, j) { + const oe = R( + 182 + /* IndexSignature */ + ); + return oe.modifiers = Ra(v), oe.parameters = Ra(w), oe.type = j, oe.transformFlags = 1, oe.jsDoc = void 0, oe.locals = void 0, oe.nextContainer = void 0, oe.typeArguments = void 0, oe; + } + function Ct(v, w, j, oe) { + return v.parameters !== j || v.type !== oe || v.modifiers !== w ? B(pt(w, j, oe), v) : v; + } + function qe(v, w) { + const j = F( + 205 + /* TemplateLiteralTypeSpan */ + ); + return j.type = v, j.literal = w, j.transformFlags = 1, j; + } + function Lt(v, w, j) { + return v.type !== w || v.literal !== j ? tn(qe(w, j), v) : v; + } + function rn(v) { + return ne(v); + } + function Pe(v, w, j) { + const oe = F( + 183 + /* TypePredicate */ + ); + return oe.assertsModifier = v, oe.parameterName = dl(w), oe.type = j, oe.transformFlags = 1, oe; + } + function yt(v, w, j, oe) { + return v.assertsModifier !== w || v.parameterName !== j || v.type !== oe ? tn(Pe(w, j, oe), v) : v; + } + function ue(v, w) { + const j = F( + 184 + /* TypeReference */ + ); + return j.typeName = dl(v), j.typeArguments = w && i().parenthesizeTypeArguments(O(w)), j.transformFlags = 1, j; + } + function M(v, w, j) { + return v.typeName !== w || v.typeArguments !== j ? tn(ue(w, j), v) : v; + } + function ye(v, w, j) { + const oe = R( + 185 + /* FunctionType */ + ); + return oe.typeParameters = Ra(v), oe.parameters = Ra(w), oe.type = j, oe.transformFlags = 1, oe.modifiers = void 0, oe.jsDoc = void 0, oe.locals = void 0, oe.nextContainer = void 0, oe.typeArguments = void 0, oe; + } + function Q(v, w, j, oe) { + return v.typeParameters !== w || v.parameters !== j || v.type !== oe ? dt(ye(w, j, oe), v) : v; + } + function dt(v, w) { + return v !== w && (v.modifiers = w.modifiers), B(v, w); + } + function Mt(...v) { + return v.length === 4 ? ke(...v) : v.length === 3 ? at(...v) : E.fail("Incorrect number of arguments specified."); + } + function ke(v, w, j, oe) { + const Ue = R( + 186 + /* ConstructorType */ + ); + return Ue.modifiers = Ra(v), Ue.typeParameters = Ra(w), Ue.parameters = Ra(j), Ue.type = oe, Ue.transformFlags = 1, Ue.jsDoc = void 0, Ue.locals = void 0, Ue.nextContainer = void 0, Ue.typeArguments = void 0, Ue; + } + function at(v, w, j) { + return ke( + /*modifiers*/ + void 0, + v, + w, + j + ); + } + function wt(...v) { + return v.length === 5 ? Zr(...v) : v.length === 4 ? Rr(...v) : E.fail("Incorrect number of arguments specified."); + } + function Zr(v, w, j, oe, Ue) { + return v.modifiers !== w || v.typeParameters !== j || v.parameters !== oe || v.type !== Ue ? B(Mt(w, j, oe, Ue), v) : v; + } + function Rr(v, w, j, oe) { + return Zr(v, v.modifiers, w, j, oe); + } + function Pr(v, w) { + const j = F( + 187 + /* TypeQuery */ + ); + return j.exprName = v, j.typeArguments = w && i().parenthesizeTypeArguments(w), j.transformFlags = 1, j; + } + function rt(v, w, j) { + return v.exprName !== w || v.typeArguments !== j ? tn(Pr(w, j), v) : v; + } + function vt(v) { + const w = R( + 188 + /* TypeLiteral */ + ); + return w.members = O(v), w.transformFlags = 1, w; + } + function Nt(v, w) { + return v.members !== w ? tn(vt(w), v) : v; + } + function Jt(v) { + const w = F( + 189 + /* ArrayType */ + ); + return w.elementType = i().parenthesizeNonArrayTypeOfPostfixType(v), w.transformFlags = 1, w; + } + function _r(v, w) { + return v.elementType !== w ? tn(Jt(w), v) : v; + } + function nr(v) { + const w = F( + 190 + /* TupleType */ + ); + return w.elements = O(i().parenthesizeElementTypesOfTupleType(v)), w.transformFlags = 1, w; + } + function kt(v, w) { + return v.elements !== w ? tn(nr(w), v) : v; + } + function cr(v, w, j, oe) { + const Ue = R( + 203 + /* NamedTupleMember */ + ); + return Ue.dotDotDotToken = v, Ue.name = w, Ue.questionToken = j, Ue.type = oe, Ue.transformFlags = 1, Ue.jsDoc = void 0, Ue; + } + function fr(v, w, j, oe, Ue) { + return v.dotDotDotToken !== w || v.name !== j || v.questionToken !== oe || v.type !== Ue ? tn(cr(w, j, oe, Ue), v) : v; + } + function vr(v) { + const w = F( + 191 + /* OptionalType */ + ); + return w.type = i().parenthesizeTypeOfOptionalType(v), w.transformFlags = 1, w; + } + function Xt(v, w) { + return v.type !== w ? tn(vr(w), v) : v; + } + function oi(v) { + const w = F( + 192 + /* RestType */ + ); + return w.type = v, w.transformFlags = 1, w; + } + function Fs(v, w) { + return v.type !== w ? tn(oi(w), v) : v; + } + function Rs(v, w, j) { + const oe = F(v); + return oe.types = A.createNodeArray(j(w)), oe.transformFlags = 1, oe; + } + function ds(v, w, j) { + return v.types !== w ? tn(Rs(v.kind, w, j), v) : v; + } + function pc(v) { + return Rs(193, v, i().parenthesizeConstituentTypesOfUnionType); + } + function Zo(v, w) { + return ds(v, w, i().parenthesizeConstituentTypesOfUnionType); + } + function so(v) { + return Rs(194, v, i().parenthesizeConstituentTypesOfIntersectionType); + } + function zi(v, w) { + return ds(v, w, i().parenthesizeConstituentTypesOfIntersectionType); + } + function hs(v, w, j, oe) { + const Ue = F( + 195 + /* ConditionalType */ + ); + return Ue.checkType = i().parenthesizeCheckTypeOfConditionalType(v), Ue.extendsType = i().parenthesizeExtendsTypeOfConditionalType(w), Ue.trueType = j, Ue.falseType = oe, Ue.transformFlags = 1, Ue.locals = void 0, Ue.nextContainer = void 0, Ue; + } + function Gc(v, w, j, oe, Ue) { + return v.checkType !== w || v.extendsType !== j || v.trueType !== oe || v.falseType !== Ue ? tn(hs(w, j, oe, Ue), v) : v; + } + function Co(v) { + const w = F( + 196 + /* InferType */ + ); + return w.typeParameter = v, w.transformFlags = 1, w; + } + function ta(v, w) { + return v.typeParameter !== w ? tn(Co(w), v) : v; + } + function Ec(v, w) { + const j = F( + 204 + /* TemplateLiteralType */ + ); + return j.head = v, j.templateSpans = O(w), j.transformFlags = 1, j; + } + function zf(v, w, j) { + return v.head !== w || v.templateSpans !== j ? tn(Ec(w, j), v) : v; + } + function cs(v, w, j, oe, Ue = !1) { + const qt = F( + 206 + /* ImportType */ + ); + return qt.argument = v, qt.attributes = w, qt.assertions && qt.assertions.assertClause && qt.attributes && (qt.assertions.assertClause = qt.attributes), qt.qualifier = j, qt.typeArguments = oe && i().parenthesizeTypeArguments(oe), qt.isTypeOf = Ue, qt.transformFlags = 1, qt; + } + function Ws(v, w, j, oe, Ue, qt = v.isTypeOf) { + return v.argument !== w || v.attributes !== j || v.qualifier !== oe || v.typeArguments !== Ue || v.isTypeOf !== qt ? tn(cs(w, j, oe, Ue, qt), v) : v; + } + function Fa(v) { + const w = F( + 197 + /* ParenthesizedType */ + ); + return w.type = v, w.transformFlags = 1, w; + } + function va(v, w) { + return v.type !== w ? tn(Fa(w), v) : v; + } + function zt() { + const v = F( + 198 + /* ThisType */ + ); + return v.transformFlags = 1, v; + } + function Za(v, w) { + const j = F( + 199 + /* TypeOperator */ + ); + return j.operator = v, j.type = v === 148 ? i().parenthesizeOperandOfReadonlyTypeOperator(w) : i().parenthesizeOperandOfTypeOperator(w), j.transformFlags = 1, j; + } + function yc(v, w) { + return v.type !== w ? tn(Za(v.operator, w), v) : v; + } + function Fc(v, w) { + const j = F( + 200 + /* IndexedAccessType */ + ); + return j.objectType = i().parenthesizeNonArrayTypeOfPostfixType(v), j.indexType = w, j.transformFlags = 1, j; + } + function Hl(v, w, j) { + return v.objectType !== w || v.indexType !== j ? tn(Fc(w, j), v) : v; + } + function _o(v, w, j, oe, Ue, qt) { + const hn = R( + 201 + /* MappedType */ + ); + return hn.readonlyToken = v, hn.typeParameter = w, hn.nameType = j, hn.questionToken = oe, hn.type = Ue, hn.members = qt && O(qt), hn.transformFlags = 1, hn.locals = void 0, hn.nextContainer = void 0, hn; + } + function ge(v, w, j, oe, Ue, qt, hn) { + return v.readonlyToken !== w || v.typeParameter !== j || v.nameType !== oe || v.questionToken !== Ue || v.type !== qt || v.members !== hn ? tn(_o(w, j, oe, Ue, qt, hn), v) : v; + } + function H(v) { + const w = F( + 202 + /* LiteralType */ + ); + return w.literal = v, w.transformFlags = 1, w; + } + function tt(v, w) { + return v.literal !== w ? tn(H(w), v) : v; + } + function Ft(v) { + const w = F( + 207 + /* ObjectBindingPattern */ + ); + return w.elements = O(v), w.transformFlags |= Ia(w.elements) | 1024 | 524288, w.transformFlags & 32768 && (w.transformFlags |= 65664), w; + } + function Kt(v, w) { + return v.elements !== w ? tn(Ft(w), v) : v; + } + function Hr(v) { + const w = F( + 208 + /* ArrayBindingPattern */ + ); + return w.elements = O(v), w.transformFlags |= Ia(w.elements) | 1024 | 524288, w; + } + function Vn(v, w) { + return v.elements !== w ? tn(Hr(w), v) : v; + } + function ln(v, w, j, oe) { + const Ue = R( + 209 + /* BindingElement */ + ); + return Ue.dotDotDotToken = v, Ue.propertyName = dl(w), Ue.name = dl(j), Ue.initializer = Ru(oe), Ue.transformFlags |= vn(Ue.dotDotDotToken) | Wy(Ue.propertyName) | Wy(Ue.name) | vn(Ue.initializer) | (Ue.dotDotDotToken ? 32768 : 0) | 1024, Ue.flowNode = void 0, Ue; + } + function kr(v, w, j, oe, Ue) { + return v.propertyName !== j || v.dotDotDotToken !== w || v.name !== oe || v.initializer !== Ue ? tn(ln(w, j, oe, Ue), v) : v; + } + function Li(v, w) { + const j = F( + 210 + /* ArrayLiteralExpression */ + ), oe = v && Do(v), Ue = O(v, oe && vl(oe) ? !0 : void 0); + return j.elements = i().parenthesizeExpressionsOfCommaDelimitedList(Ue), j.multiLine = w, j.transformFlags |= Ia(j.elements), j; + } + function Yi(v, w) { + return v.elements !== w ? tn(Li(w, v.multiLine), v) : v; + } + function no(v, w) { + const j = R( + 211 + /* ObjectLiteralExpression */ + ); + return j.properties = O(v), j.multiLine = w, j.transformFlags |= Ia(j.properties), j.jsDoc = void 0, j; + } + function ra(v, w) { + return v.properties !== w ? tn(no(w, v.multiLine), v) : v; + } + function Eo(v, w, j) { + const oe = R( + 212 + /* PropertyAccessExpression */ + ); + return oe.expression = v, oe.questionDotToken = w, oe.name = j, oe.transformFlags = vn(oe.expression) | vn(oe.questionDotToken) | (Me(oe.name) ? AN(oe.name) : vn(oe.name) | 536870912), oe.jsDoc = void 0, oe.flowNode = void 0, oe; + } + function $c(v, w) { + const j = Eo( + i().parenthesizeLeftSideOfAccess( + v, + /*optionalChain*/ + !1 + ), + /*questionDotToken*/ + void 0, + dl(w) + ); + return w4(v) && (j.transformFlags |= 384), j; + } + function Jc(v, w, j) { + return T7(v) ? ic(v, w, v.questionDotToken, Us(j, Me)) : v.expression !== w || v.name !== j ? tn($c(w, j), v) : v; + } + function vo(v, w, j) { + const oe = Eo( + i().parenthesizeLeftSideOfAccess( + v, + /*optionalChain*/ + !0 + ), + w, + dl(j) + ); + return oe.flags |= 64, oe.transformFlags |= 32, oe; + } + function ic(v, w, j, oe) { + return E.assert(!!(v.flags & 64), "Cannot update a PropertyAccessExpression using updatePropertyAccessChain. Use updatePropertyAccess instead."), v.expression !== w || v.questionDotToken !== j || v.name !== oe ? tn(vo(w, j, oe), v) : v; + } + function Bd(v, w, j) { + const oe = R( + 213 + /* ElementAccessExpression */ + ); + return oe.expression = v, oe.questionDotToken = w, oe.argumentExpression = j, oe.transformFlags |= vn(oe.expression) | vn(oe.questionDotToken) | vn(oe.argumentExpression), oe.jsDoc = void 0, oe.flowNode = void 0, oe; + } + function au(v, w) { + const j = Bd( + i().parenthesizeLeftSideOfAccess( + v, + /*optionalChain*/ + !1 + ), + /*questionDotToken*/ + void 0, + Y0(w) + ); + return w4(v) && (j.transformFlags |= 384), j; + } + function Ef(v, w, j) { + return Rj(v) ? Ie(v, w, v.questionDotToken, j) : v.expression !== w || v.argumentExpression !== j ? tn(au(w, j), v) : v; + } + function P_(v, w, j) { + const oe = Bd( + i().parenthesizeLeftSideOfAccess( + v, + /*optionalChain*/ + !0 + ), + w, + Y0(j) + ); + return oe.flags |= 64, oe.transformFlags |= 32, oe; + } + function Ie(v, w, j, oe) { + return E.assert(!!(v.flags & 64), "Cannot update a ElementAccessExpression using updateElementAccessChain. Use updateElementAccess instead."), v.expression !== w || v.questionDotToken !== j || v.argumentExpression !== oe ? tn(P_(w, j, oe), v) : v; + } + function Ot(v, w, j, oe) { + const Ue = R( + 214 + /* CallExpression */ + ); + return Ue.expression = v, Ue.questionDotToken = w, Ue.typeArguments = j, Ue.arguments = oe, Ue.transformFlags |= vn(Ue.expression) | vn(Ue.questionDotToken) | Ia(Ue.typeArguments) | Ia(Ue.arguments), Ue.typeArguments && (Ue.transformFlags |= 1), j_(Ue.expression) && (Ue.transformFlags |= 16384), Ue; + } + function Mr(v, w, j) { + const oe = Ot( + i().parenthesizeLeftSideOfAccess( + v, + /*optionalChain*/ + !1 + ), + /*questionDotToken*/ + void 0, + Ra(w), + i().parenthesizeExpressionsOfCommaDelimitedList(O(j)) + ); + return P4(oe.expression) && (oe.transformFlags |= 8388608), oe; + } + function Gi(v, w, j, oe) { + return K2(v) ? wa(v, w, v.questionDotToken, j, oe) : v.expression !== w || v.typeArguments !== j || v.arguments !== oe ? tn(Mr(w, j, oe), v) : v; + } + function Da(v, w, j, oe) { + const Ue = Ot( + i().parenthesizeLeftSideOfAccess( + v, + /*optionalChain*/ + !0 + ), + w, + Ra(j), + i().parenthesizeExpressionsOfCommaDelimitedList(O(oe)) + ); + return Ue.flags |= 64, Ue.transformFlags |= 32, Ue; + } + function wa(v, w, j, oe, Ue) { + return E.assert(!!(v.flags & 64), "Cannot update a CallExpression using updateCallChain. Use updateCall instead."), v.expression !== w || v.questionDotToken !== j || v.typeArguments !== oe || v.arguments !== Ue ? tn(Da(w, j, oe, Ue), v) : v; + } + function ma(v, w, j) { + const oe = R( + 215 + /* NewExpression */ + ); + return oe.expression = i().parenthesizeExpressionOfNew(v), oe.typeArguments = Ra(w), oe.arguments = j ? i().parenthesizeExpressionsOfCommaDelimitedList(j) : void 0, oe.transformFlags |= vn(oe.expression) | Ia(oe.typeArguments) | Ia(oe.arguments) | 32, oe.typeArguments && (oe.transformFlags |= 1), oe; + } + function il(v, w, j, oe) { + return v.expression !== w || v.typeArguments !== j || v.arguments !== oe ? tn(ma(w, j, oe), v) : v; + } + function Po(v, w, j) { + const oe = F( + 216 + /* TaggedTemplateExpression */ + ); + return oe.tag = i().parenthesizeLeftSideOfAccess( + v, + /*optionalChain*/ + !1 + ), oe.typeArguments = Ra(w), oe.template = j, oe.transformFlags |= vn(oe.tag) | Ia(oe.typeArguments) | vn(oe.template) | 1024, oe.typeArguments && (oe.transformFlags |= 1), HB(oe.template) && (oe.transformFlags |= 128), oe; + } + function sc(v, w, j, oe) { + return v.tag !== w || v.typeArguments !== j || v.template !== oe ? tn(Po(w, j, oe), v) : v; + } + function vc(v, w) { + const j = F( + 217 + /* TypeAssertionExpression */ + ); + return j.expression = i().parenthesizeOperandOfPrefixUnary(w), j.type = v, j.transformFlags |= vn(j.expression) | vn(j.type) | 1, j; + } + function Df(v, w, j) { + return v.type !== w || v.expression !== j ? tn(vc(w, j), v) : v; + } + function Gl(v) { + const w = F( + 218 + /* ParenthesizedExpression */ + ); + return w.expression = v, w.transformFlags = vn(w.expression), w.jsDoc = void 0, w; + } + function Ol(v, w) { + return v.expression !== w ? tn(Gl(w), v) : v; + } + function pf(v, w, j, oe, Ue, qt, hn) { + const ls = R( + 219 + /* FunctionExpression */ + ); + ls.modifiers = Ra(v), ls.asteriskToken = w, ls.name = dl(j), ls.typeParameters = Ra(oe), ls.parameters = O(Ue), ls.type = qt, ls.body = hn; + const No = pm(ls.modifiers) & 1024, wf = !!ls.asteriskToken, T1 = No && wf; + return ls.transformFlags = Ia(ls.modifiers) | vn(ls.asteriskToken) | Wy(ls.name) | Ia(ls.typeParameters) | Ia(ls.parameters) | vn(ls.type) | vn(ls.body) & -67108865 | (T1 ? 128 : No ? 256 : wf ? 2048 : 0) | (ls.typeParameters || ls.type ? 1 : 0) | 4194304, ls.typeArguments = void 0, ls.jsDoc = void 0, ls.locals = void 0, ls.nextContainer = void 0, ls.flowNode = void 0, ls.endFlowNode = void 0, ls.returnFlowNode = void 0, ls; + } + function Qu(v, w, j, oe, Ue, qt, hn, ls) { + return v.name !== oe || v.modifiers !== w || v.asteriskToken !== j || v.typeParameters !== Ue || v.parameters !== qt || v.type !== hn || v.body !== ls ? B(pf(w, j, oe, Ue, qt, hn, ls), v) : v; + } + function hp(v, w, j, oe, Ue, qt) { + const hn = R( + 220 + /* ArrowFunction */ + ); + hn.modifiers = Ra(v), hn.typeParameters = Ra(w), hn.parameters = O(j), hn.type = oe, hn.equalsGreaterThanToken = Ue ?? ne( + 39 + /* EqualsGreaterThanToken */ + ), hn.body = i().parenthesizeConciseBodyOfArrowFunction(qt); + const ls = pm(hn.modifiers) & 1024; + return hn.transformFlags = Ia(hn.modifiers) | Ia(hn.typeParameters) | Ia(hn.parameters) | vn(hn.type) | vn(hn.equalsGreaterThanToken) | vn(hn.body) & -67108865 | (hn.typeParameters || hn.type ? 1 : 0) | (ls ? 16640 : 0) | 1024, hn.typeArguments = void 0, hn.jsDoc = void 0, hn.locals = void 0, hn.nextContainer = void 0, hn.flowNode = void 0, hn.endFlowNode = void 0, hn.returnFlowNode = void 0, hn; + } + function ig(v, w, j, oe, Ue, qt, hn) { + return v.modifiers !== w || v.typeParameters !== j || v.parameters !== oe || v.type !== Ue || v.equalsGreaterThanToken !== qt || v.body !== hn ? B(hp(w, j, oe, Ue, qt, hn), v) : v; + } + function Gg(v) { + const w = F( + 221 + /* DeleteExpression */ + ); + return w.expression = i().parenthesizeOperandOfPrefixUnary(v), w.transformFlags |= vn(w.expression), w; + } + function $g(v, w) { + return v.expression !== w ? tn(Gg(w), v) : v; + } + function N_(v) { + const w = F( + 222 + /* TypeOfExpression */ + ); + return w.expression = i().parenthesizeOperandOfPrefixUnary(v), w.transformFlags |= vn(w.expression), w; + } + function Sl(v, w) { + return v.expression !== w ? tn(N_(w), v) : v; + } + function Jd(v) { + const w = F( + 223 + /* VoidExpression */ + ); + return w.expression = i().parenthesizeOperandOfPrefixUnary(v), w.transformFlags |= vn(w.expression), w; + } + function Wf(v, w) { + return v.expression !== w ? tn(Jd(w), v) : v; + } + function Nm(v) { + const w = F( + 224 + /* AwaitExpression */ + ); + return w.expression = i().parenthesizeOperandOfPrefixUnary(v), w.transformFlags |= vn(w.expression) | 256 | 128 | 2097152, w; + } + function ee(v, w) { + return v.expression !== w ? tn(Nm(w), v) : v; + } + function et(v, w) { + const j = F( + 225 + /* PrefixUnaryExpression */ + ); + return j.operator = v, j.operand = i().parenthesizeOperandOfPrefixUnary(w), j.transformFlags |= vn(j.operand), (v === 46 || v === 47) && Me(j.operand) && !Bo(j.operand) && !Nh(j.operand) && (j.transformFlags |= 268435456), j; + } + function Ut(v, w) { + return v.operand !== w ? tn(et(v.operator, w), v) : v; + } + function Gt(v, w) { + const j = F( + 226 + /* PostfixUnaryExpression */ + ); + return j.operator = w, j.operand = i().parenthesizeOperandOfPostfixUnary(v), j.transformFlags |= vn(j.operand), Me(j.operand) && !Bo(j.operand) && !Nh(j.operand) && (j.transformFlags |= 268435456), j; + } + function Sr(v, w) { + return v.operand !== w ? tn(Gt(w, v.operator), v) : v; + } + function zr(v, w, j) { + const oe = R( + 227 + /* BinaryExpression */ + ), Ue = Xk(w), qt = Ue.kind; + return oe.left = i().parenthesizeLeftSideOfBinary(qt, v), oe.operatorToken = Ue, oe.right = i().parenthesizeRightSideOfBinary(qt, oe.left, j), oe.transformFlags |= vn(oe.left) | vn(oe.operatorToken) | vn(oe.right), qt === 61 ? oe.transformFlags |= 32 : qt === 64 ? _a(oe.left) ? oe.transformFlags |= 5248 | jn(oe.left) : nu(oe.left) && (oe.transformFlags |= 5120 | jn(oe.left)) : qt === 43 || qt === 68 ? oe.transformFlags |= 512 : t4(qt) && (oe.transformFlags |= 16), qt === 103 && Ai(oe.left) && (oe.transformFlags |= 536870912), oe.jsDoc = void 0, oe; + } + function jn(v) { + return YN(v) ? 65536 : 0; + } + function ni(v, w, j, oe) { + return v.left !== w || v.operatorToken !== j || v.right !== oe ? tn(zr(w, j, oe), v) : v; + } + function wi(v, w, j, oe, Ue) { + const qt = F( + 228 + /* ConditionalExpression */ + ); + return qt.condition = i().parenthesizeConditionOfConditionalExpression(v), qt.questionToken = w ?? ne( + 58 + /* QuestionToken */ + ), qt.whenTrue = i().parenthesizeBranchOfConditionalExpression(j), qt.colonToken = oe ?? ne( + 59 + /* ColonToken */ + ), qt.whenFalse = i().parenthesizeBranchOfConditionalExpression(Ue), qt.transformFlags |= vn(qt.condition) | vn(qt.questionToken) | vn(qt.whenTrue) | vn(qt.colonToken) | vn(qt.whenFalse), qt.flowNodeWhenFalse = void 0, qt.flowNodeWhenTrue = void 0, qt; + } + function L(v, w, j, oe, Ue, qt) { + return v.condition !== w || v.questionToken !== j || v.whenTrue !== oe || v.colonToken !== Ue || v.whenFalse !== qt ? tn(wi(w, j, oe, Ue, qt), v) : v; + } + function Oe(v, w) { + const j = F( + 229 + /* TemplateExpression */ + ); + return j.head = v, j.templateSpans = O(w), j.transformFlags |= vn(j.head) | Ia(j.templateSpans) | 1024, j; + } + function xt(v, w, j) { + return v.head !== w || v.templateSpans !== j ? tn(Oe(w, j), v) : v; + } + function Tr(v, w, j, oe = 0) { + E.assert(!(oe & -7177), "Unsupported template flags."); + let Ue; + if (j !== void 0 && j !== w && (Ue = R9e(v, j), typeof Ue == "object")) + return E.fail("Invalid raw text"); + if (w === void 0) { + if (Ue === void 0) + return E.fail("Arguments 'text' and 'rawText' may not both be undefined."); + w = Ue; + } else Ue !== void 0 && E.assert(w === Ue, "Expected argument 'text' to be the normalized (i.e. 'cooked') version of argument 'rawText'."); + return w; + } + function $i(v) { + let w = 1024; + return v && (w |= 128), w; + } + function As(v, w, j, oe) { + const Ue = Ye(v); + return Ue.text = w, Ue.rawText = j, Ue.templateFlags = oe & 7176, Ue.transformFlags = $i(Ue.templateFlags), Ue; + } + function Zi(v, w, j, oe) { + const Ue = R(v); + return Ue.text = w, Ue.rawText = j, Ue.templateFlags = oe & 7176, Ue.transformFlags = $i(Ue.templateFlags), Ue; + } + function ys(v, w, j, oe) { + return v === 15 ? Zi(v, w, j, oe) : As(v, w, j, oe); + } + function zo(v, w, j) { + return v = Tr(16, v, w, j), ys(16, v, w, j); + } + function na(v, w, j) { + return v = Tr(16, v, w, j), ys(17, v, w, j); + } + function Ll(v, w, j) { + return v = Tr(16, v, w, j), ys(18, v, w, j); + } + function df(v, w, j) { + return v = Tr(16, v, w, j), Zi(15, v, w, j); + } + function Uf(v, w) { + E.assert(!v || !!w, "A `YieldExpression` with an asteriskToken must have an expression."); + const j = F( + 230 + /* YieldExpression */ + ); + return j.expression = w && i().parenthesizeExpressionForDisallowedComma(w), j.asteriskToken = v, j.transformFlags |= vn(j.expression) | vn(j.asteriskToken) | 1024 | 128 | 1048576, j; + } + function yp(v, w, j) { + return v.expression !== j || v.asteriskToken !== w ? tn(Uf(w, j), v) : v; + } + function jh(v) { + const w = F( + 231 + /* SpreadElement */ + ); + return w.expression = i().parenthesizeExpressionForDisallowedComma(v), w.transformFlags |= vn(w.expression) | 1024 | 32768, w; + } + function M0(v, w) { + return v.expression !== w ? tn(jh(w), v) : v; + } + function __(v, w, j, oe, Ue) { + const qt = R( + 232 + /* ClassExpression */ + ); + return qt.modifiers = Ra(v), qt.name = dl(w), qt.typeParameters = Ra(j), qt.heritageClauses = Ra(oe), qt.members = O(Ue), qt.transformFlags |= Ia(qt.modifiers) | Wy(qt.name) | Ia(qt.typeParameters) | Ia(qt.heritageClauses) | Ia(qt.members) | (qt.typeParameters ? 1 : 0) | 1024, qt.jsDoc = void 0, qt; + } + function sg(v, w, j, oe, Ue, qt) { + return v.modifiers !== w || v.name !== j || v.typeParameters !== oe || v.heritageClauses !== Ue || v.members !== qt ? tn(__(w, j, oe, Ue, qt), v) : v; + } + function zd() { + return F( + 233 + /* OmittedExpression */ + ); + } + function $p(v, w) { + const j = F( + 234 + /* ExpressionWithTypeArguments */ + ); + return j.expression = i().parenthesizeLeftSideOfAccess( + v, + /*optionalChain*/ + !1 + ), j.typeArguments = w && i().parenthesizeTypeArguments(w), j.transformFlags |= vn(j.expression) | Ia(j.typeArguments) | 1024, j; + } + function s1(v, w, j) { + return v.expression !== w || v.typeArguments !== j ? tn($p(w, j), v) : v; + } + function Be(v, w) { + const j = F( + 235 + /* AsExpression */ + ); + return j.expression = v, j.type = w, j.transformFlags |= vn(j.expression) | vn(j.type) | 1, j; + } + function nt(v, w, j) { + return v.expression !== w || v.type !== j ? tn(Be(w, j), v) : v; + } + function Rt(v) { + const w = F( + 236 + /* NonNullExpression */ + ); + return w.expression = i().parenthesizeLeftSideOfAccess( + v, + /*optionalChain*/ + !1 + ), w.transformFlags |= vn(w.expression) | 1, w; + } + function pr(v, w) { + return k7(v) ? Vr(v, w) : v.expression !== w ? tn(Rt(w), v) : v; + } + function Or(v, w) { + const j = F( + 239 + /* SatisfiesExpression */ + ); + return j.expression = v, j.type = w, j.transformFlags |= vn(j.expression) | vn(j.type) | 1, j; + } + function dn(v, w, j) { + return v.expression !== w || v.type !== j ? tn(Or(w, j), v) : v; + } + function Ir(v) { + const w = F( + 236 + /* NonNullExpression */ + ); + return w.flags |= 64, w.expression = i().parenthesizeLeftSideOfAccess( + v, + /*optionalChain*/ + !0 + ), w.transformFlags |= vn(w.expression) | 1, w; + } + function Vr(v, w) { + return E.assert(!!(v.flags & 64), "Cannot update a NonNullExpression using updateNonNullChain. Use updateNonNullExpression instead."), v.expression !== w ? tn(Ir(w), v) : v; + } + function hi(v, w) { + const j = F( + 237 + /* MetaProperty */ + ); + switch (j.keywordToken = v, j.name = w, j.transformFlags |= vn(j.name), v) { + case 105: + j.transformFlags |= 1024; + break; + case 102: + j.transformFlags |= 32; + break; + default: + return E.assertNever(v); + } + return j.flowNode = void 0, j; + } + function rs(v, w) { + return v.name !== w ? tn(hi(v.keywordToken, w), v) : v; + } + function Zn(v, w) { + const j = F( + 240 + /* TemplateSpan */ + ); + return j.expression = v, j.literal = w, j.transformFlags |= vn(j.expression) | vn(j.literal) | 1024, j; + } + function ns(v, w, j) { + return v.expression !== w || v.literal !== j ? tn(Zn(w, j), v) : v; + } + function Pi() { + const v = F( + 241 + /* SemicolonClassElement */ + ); + return v.transformFlags |= 1024, v; + } + function Wo(v, w) { + const j = F( + 242 + /* Block */ + ); + return j.statements = O(v), j.multiLine = w, j.transformFlags |= Ia(j.statements), j.jsDoc = void 0, j.locals = void 0, j.nextContainer = void 0, j; + } + function A_(v, w) { + return v.statements !== w ? tn(Wo(w, v.multiLine), v) : v; + } + function Xp(v, w) { + const j = F( + 244 + /* VariableStatement */ + ); + return j.modifiers = Ra(v), j.declarationList = as(w) ? Iv(w) : w, j.transformFlags |= Ia(j.modifiers) | vn(j.declarationList), pm(j.modifiers) & 128 && (j.transformFlags = 1), j.jsDoc = void 0, j.flowNode = void 0, j; + } + function $l(v, w, j) { + return v.modifiers !== w || v.declarationList !== j ? tn(Xp(w, j), v) : v; + } + function Qp() { + const v = F( + 243 + /* EmptyStatement */ + ); + return v.jsDoc = void 0, v; + } + function mf(v) { + const w = F( + 245 + /* ExpressionStatement */ + ); + return w.expression = i().parenthesizeExpressionOfExpressionStatement(v), w.transformFlags |= vn(w.expression), w.jsDoc = void 0, w.flowNode = void 0, w; + } + function wv(v, w) { + return v.expression !== w ? tn(mf(w), v) : v; + } + function Am(v, w, j) { + const oe = F( + 246 + /* IfStatement */ + ); + return oe.expression = v, oe.thenStatement = nh(w), oe.elseStatement = nh(j), oe.transformFlags |= vn(oe.expression) | vn(oe.thenStatement) | vn(oe.elseStatement), oe.jsDoc = void 0, oe.flowNode = void 0, oe; + } + function ag(v, w, j, oe) { + return v.expression !== w || v.thenStatement !== j || v.elseStatement !== oe ? tn(Am(w, j, oe), v) : v; + } + function Pv(v, w) { + const j = F( + 247 + /* DoStatement */ + ); + return j.statement = nh(v), j.expression = w, j.transformFlags |= vn(j.statement) | vn(j.expression), j.jsDoc = void 0, j.flowNode = void 0, j; + } + function og(v, w, j) { + return v.statement !== w || v.expression !== j ? tn(Pv(w, j), v) : v; + } + function pE(v, w) { + const j = F( + 248 + /* WhileStatement */ + ); + return j.expression = v, j.statement = nh(w), j.transformFlags |= vn(j.expression) | vn(j.statement), j.jsDoc = void 0, j.flowNode = void 0, j; + } + function Vw(v, w, j) { + return v.expression !== w || v.statement !== j ? tn(pE(w, j), v) : v; + } + function dE(v, w, j, oe) { + const Ue = F( + 249 + /* ForStatement */ + ); + return Ue.initializer = v, Ue.condition = w, Ue.incrementor = j, Ue.statement = nh(oe), Ue.transformFlags |= vn(Ue.initializer) | vn(Ue.condition) | vn(Ue.incrementor) | vn(Ue.statement), Ue.jsDoc = void 0, Ue.locals = void 0, Ue.nextContainer = void 0, Ue.flowNode = void 0, Ue; + } + function Xg(v, w, j, oe, Ue) { + return v.initializer !== w || v.condition !== j || v.incrementor !== oe || v.statement !== Ue ? tn(dE(w, j, oe, Ue), v) : v; + } + function Nv(v, w, j) { + const oe = F( + 250 + /* ForInStatement */ + ); + return oe.initializer = v, oe.expression = w, oe.statement = nh(j), oe.transformFlags |= vn(oe.initializer) | vn(oe.expression) | vn(oe.statement), oe.jsDoc = void 0, oe.locals = void 0, oe.nextContainer = void 0, oe.flowNode = void 0, oe; + } + function YS(v, w, j, oe) { + return v.initializer !== w || v.expression !== j || v.statement !== oe ? tn(Nv(w, j, oe), v) : v; + } + function R0(v, w, j, oe) { + const Ue = F( + 251 + /* ForOfStatement */ + ); + return Ue.awaitModifier = v, Ue.initializer = w, Ue.expression = i().parenthesizeExpressionForDisallowedComma(j), Ue.statement = nh(oe), Ue.transformFlags |= vn(Ue.awaitModifier) | vn(Ue.initializer) | vn(Ue.expression) | vn(Ue.statement) | 1024, v && (Ue.transformFlags |= 128), Ue.jsDoc = void 0, Ue.locals = void 0, Ue.nextContainer = void 0, Ue.flowNode = void 0, Ue; + } + function ZS(v, w, j, oe, Ue) { + return v.awaitModifier !== w || v.initializer !== j || v.expression !== oe || v.statement !== Ue ? tn(R0(w, j, oe, Ue), v) : v; + } + function Dk(v) { + const w = F( + 252 + /* ContinueStatement */ + ); + return w.label = dl(v), w.transformFlags |= vn(w.label) | 4194304, w.jsDoc = void 0, w.flowNode = void 0, w; + } + function qw(v, w) { + return v.label !== w ? tn(Dk(w), v) : v; + } + function KS(v) { + const w = F( + 253 + /* BreakStatement */ + ); + return w.label = dl(v), w.transformFlags |= vn(w.label) | 4194304, w.jsDoc = void 0, w.flowNode = void 0, w; + } + function wk(v, w) { + return v.label !== w ? tn(KS(w), v) : v; + } + function Av(v) { + const w = F( + 254 + /* ReturnStatement */ + ); + return w.expression = v, w.transformFlags |= vn(w.expression) | 128 | 4194304, w.jsDoc = void 0, w.flowNode = void 0, w; + } + function mE(v, w) { + return v.expression !== w ? tn(Av(w), v) : v; + } + function eT(v, w) { + const j = F( + 255 + /* WithStatement */ + ); + return j.expression = v, j.statement = nh(w), j.transformFlags |= vn(j.expression) | vn(j.statement), j.jsDoc = void 0, j.flowNode = void 0, j; + } + function Pk(v, w, j) { + return v.expression !== w || v.statement !== j ? tn(eT(w, j), v) : v; + } + function g2(v, w) { + const j = F( + 256 + /* SwitchStatement */ + ); + return j.expression = i().parenthesizeExpressionForDisallowedComma(v), j.caseBlock = w, j.transformFlags |= vn(j.expression) | vn(j.caseBlock), j.jsDoc = void 0, j.flowNode = void 0, j.possiblyExhaustive = !1, j; + } + function a1(v, w, j) { + return v.expression !== w || v.caseBlock !== j ? tn(g2(w, j), v) : v; + } + function Nk(v, w) { + const j = F( + 257 + /* LabeledStatement */ + ); + return j.label = dl(v), j.statement = nh(w), j.transformFlags |= vn(j.label) | vn(j.statement), j.jsDoc = void 0, j.flowNode = void 0, j; + } + function Ak(v, w, j) { + return v.label !== w || v.statement !== j ? tn(Nk(w, j), v) : v; + } + function h2(v) { + const w = F( + 258 + /* ThrowStatement */ + ); + return w.expression = v, w.transformFlags |= vn(w.expression), w.jsDoc = void 0, w.flowNode = void 0, w; + } + function o1(v, w) { + return v.expression !== w ? tn(h2(w), v) : v; + } + function j0(v, w, j) { + const oe = F( + 259 + /* TryStatement */ + ); + return oe.tryBlock = v, oe.catchClause = w, oe.finallyBlock = j, oe.transformFlags |= vn(oe.tryBlock) | vn(oe.catchClause) | vn(oe.finallyBlock), oe.jsDoc = void 0, oe.flowNode = void 0, oe; + } + function Bh(v, w, j, oe) { + return v.tryBlock !== w || v.catchClause !== j || v.finallyBlock !== oe ? tn(j0(w, j, oe), v) : v; + } + function Jh() { + const v = F( + 260 + /* DebuggerStatement */ + ); + return v.jsDoc = void 0, v.flowNode = void 0, v; + } + function zh(v, w, j, oe) { + const Ue = R( + 261 + /* VariableDeclaration */ + ); + return Ue.name = dl(v), Ue.exclamationToken = w, Ue.type = j, Ue.initializer = Ru(oe), Ue.transformFlags |= Wy(Ue.name) | vn(Ue.initializer) | (Ue.exclamationToken ?? Ue.type ? 1 : 0), Ue.jsDoc = void 0, Ue; + } + function c1(v, w, j, oe, Ue) { + return v.name !== w || v.type !== oe || v.exclamationToken !== j || v.initializer !== Ue ? tn(zh(w, j, oe, Ue), v) : v; + } + function Iv(v, w = 0) { + const j = F( + 262 + /* VariableDeclarationList */ + ); + return j.flags |= w & 7, j.declarations = O(v), j.transformFlags |= Ia(j.declarations) | 4194304, w & 7 && (j.transformFlags |= 263168), w & 4 && (j.transformFlags |= 4), j; + } + function tT(v, w) { + return v.declarations !== w ? tn(Iv(w, v.flags), v) : v; + } + function Fv(v, w, j, oe, Ue, qt, hn) { + const ls = R( + 263 + /* FunctionDeclaration */ + ); + if (ls.modifiers = Ra(v), ls.asteriskToken = w, ls.name = dl(j), ls.typeParameters = Ra(oe), ls.parameters = O(Ue), ls.type = qt, ls.body = hn, !ls.body || pm(ls.modifiers) & 128) + ls.transformFlags = 1; + else { + const No = pm(ls.modifiers) & 1024, wf = !!ls.asteriskToken, T1 = No && wf; + ls.transformFlags = Ia(ls.modifiers) | vn(ls.asteriskToken) | Wy(ls.name) | Ia(ls.typeParameters) | Ia(ls.parameters) | vn(ls.type) | vn(ls.body) & -67108865 | (T1 ? 128 : No ? 256 : wf ? 2048 : 0) | (ls.typeParameters || ls.type ? 1 : 0) | 4194304; + } + return ls.typeArguments = void 0, ls.jsDoc = void 0, ls.locals = void 0, ls.nextContainer = void 0, ls.endFlowNode = void 0, ls.returnFlowNode = void 0, ls; + } + function Aa(v, w, j, oe, Ue, qt, hn, ls) { + return v.modifiers !== w || v.asteriskToken !== j || v.name !== oe || v.typeParameters !== Ue || v.parameters !== qt || v.type !== hn || v.body !== ls ? rT(Fv(w, j, oe, Ue, qt, hn, ls), v) : v; + } + function rT(v, w) { + return v !== w && v.modifiers === w.modifiers && (v.modifiers = w.modifiers), B(v, w); + } + function gE(v, w, j, oe, Ue) { + const qt = R( + 264 + /* ClassDeclaration */ + ); + return qt.modifiers = Ra(v), qt.name = dl(w), qt.typeParameters = Ra(j), qt.heritageClauses = Ra(oe), qt.members = O(Ue), pm(qt.modifiers) & 128 ? qt.transformFlags = 1 : (qt.transformFlags |= Ia(qt.modifiers) | Wy(qt.name) | Ia(qt.typeParameters) | Ia(qt.heritageClauses) | Ia(qt.members) | (qt.typeParameters ? 1 : 0) | 1024, qt.transformFlags & 8192 && (qt.transformFlags |= 1)), qt.jsDoc = void 0, qt; + } + function Wh(v, w, j, oe, Ue, qt) { + return v.modifiers !== w || v.name !== j || v.typeParameters !== oe || v.heritageClauses !== Ue || v.members !== qt ? tn(gE(w, j, oe, Ue, qt), v) : v; + } + function Uh(v, w, j, oe, Ue) { + const qt = R( + 265 + /* InterfaceDeclaration */ + ); + return qt.modifiers = Ra(v), qt.name = dl(w), qt.typeParameters = Ra(j), qt.heritageClauses = Ra(oe), qt.members = O(Ue), qt.transformFlags = 1, qt.jsDoc = void 0, qt; + } + function cg(v, w, j, oe, Ue, qt) { + return v.modifiers !== w || v.name !== j || v.typeParameters !== oe || v.heritageClauses !== Ue || v.members !== qt ? tn(Uh(w, j, oe, Ue, qt), v) : v; + } + function Ro(v, w, j, oe) { + const Ue = R( + 266 + /* TypeAliasDeclaration */ + ); + return Ue.modifiers = Ra(v), Ue.name = dl(w), Ue.typeParameters = Ra(j), Ue.type = oe, Ue.transformFlags = 1, Ue.jsDoc = void 0, Ue.locals = void 0, Ue.nextContainer = void 0, Ue; + } + function yu(v, w, j, oe, Ue) { + return v.modifiers !== w || v.name !== j || v.typeParameters !== oe || v.type !== Ue ? tn(Ro(w, j, oe, Ue), v) : v; + } + function I_(v, w, j) { + const oe = R( + 267 + /* EnumDeclaration */ + ); + return oe.modifiers = Ra(v), oe.name = dl(w), oe.members = O(j), oe.transformFlags |= Ia(oe.modifiers) | vn(oe.name) | Ia(oe.members) | 1, oe.transformFlags &= -67108865, oe.jsDoc = void 0, oe; + } + function vu(v, w, j, oe) { + return v.modifiers !== w || v.name !== j || v.members !== oe ? tn(I_(w, j, oe), v) : v; + } + function Ov(v, w, j, oe = 0) { + const Ue = R( + 268 + /* ModuleDeclaration */ + ); + return Ue.modifiers = Ra(v), Ue.flags |= oe & 2088, Ue.name = w, Ue.body = j, pm(Ue.modifiers) & 128 ? Ue.transformFlags = 1 : Ue.transformFlags |= Ia(Ue.modifiers) | vn(Ue.name) | vn(Ue.body) | 1, Ue.transformFlags &= -67108865, Ue.jsDoc = void 0, Ue.locals = void 0, Ue.nextContainer = void 0, Ue; + } + function Yu(v, w, j, oe) { + return v.modifiers !== w || v.name !== j || v.body !== oe ? tn(Ov(w, j, oe, v.flags), v) : v; + } + function lg(v) { + const w = F( + 269 + /* ModuleBlock */ + ); + return w.statements = O(v), w.transformFlags |= Ia(w.statements), w.jsDoc = void 0, w; + } + function f_(v, w) { + return v.statements !== w ? tn(lg(w), v) : v; + } + function Yp(v) { + const w = F( + 270 + /* CaseBlock */ + ); + return w.clauses = O(v), w.transformFlags |= Ia(w.clauses), w.locals = void 0, w.nextContainer = void 0, w; + } + function pd(v, w) { + return v.clauses !== w ? tn(Yp(w), v) : v; + } + function Lv(v) { + const w = R( + 271 + /* NamespaceExportDeclaration */ + ); + return w.name = dl(v), w.transformFlags |= AN(w.name) | 1, w.modifiers = void 0, w.jsDoc = void 0, w; + } + function Mv(v, w) { + return v.name !== w ? Hw(Lv(w), v) : v; + } + function Hw(v, w) { + return v !== w && (v.modifiers = w.modifiers), tn(v, w); + } + function hE(v, w, j, oe) { + const Ue = R( + 272 + /* ImportEqualsDeclaration */ + ); + return Ue.modifiers = Ra(v), Ue.name = dl(j), Ue.isTypeOnly = w, Ue.moduleReference = oe, Ue.transformFlags |= Ia(Ue.modifiers) | AN(Ue.name) | vn(Ue.moduleReference), wh(Ue.moduleReference) || (Ue.transformFlags |= 1), Ue.transformFlags &= -67108865, Ue.jsDoc = void 0, Ue; + } + function B0(v, w, j, oe, Ue) { + return v.modifiers !== w || v.isTypeOnly !== j || v.name !== oe || v.moduleReference !== Ue ? tn(hE(w, j, oe, Ue), v) : v; + } + function y2(v, w, j, oe) { + const Ue = F( + 273 + /* ImportDeclaration */ + ); + return Ue.modifiers = Ra(v), Ue.importClause = w, Ue.moduleSpecifier = j, Ue.attributes = Ue.assertClause = oe, Ue.transformFlags |= vn(Ue.importClause) | vn(Ue.moduleSpecifier), Ue.transformFlags &= -67108865, Ue.jsDoc = void 0, Ue; + } + function ze(v, w, j, oe, Ue) { + return v.modifiers !== w || v.importClause !== j || v.moduleSpecifier !== oe || v.attributes !== Ue ? tn(y2(w, j, oe, Ue), v) : v; + } + function nT(v, w, j) { + const oe = R( + 274 + /* ImportClause */ + ); + return typeof v == "boolean" && (v = v ? 156 : void 0), oe.isTypeOnly = v === 156, oe.phaseModifier = v, oe.name = w, oe.namedBindings = j, oe.transformFlags |= vn(oe.name) | vn(oe.namedBindings), v === 156 && (oe.transformFlags |= 1), oe.transformFlags &= -67108865, oe; + } + function Qg(v, w, j, oe) { + return typeof w == "boolean" && (w = w ? 156 : void 0), v.phaseModifier !== w || v.name !== j || v.namedBindings !== oe ? tn(nT(w, j, oe), v) : v; + } + function dd(v, w) { + const j = F( + 301 + /* AssertClause */ + ); + return j.elements = O(v), j.multiLine = w, j.token = 132, j.transformFlags |= 4, j; + } + function J0(v, w, j) { + return v.elements !== w || v.multiLine !== j ? tn(dd(w, j), v) : v; + } + function l1(v, w) { + const j = F( + 302 + /* AssertEntry */ + ); + return j.name = v, j.value = w, j.transformFlags |= 4, j; + } + function Zu(v, w, j) { + return v.name !== w || v.value !== j ? tn(l1(w, j), v) : v; + } + function Wd(v, w) { + const j = F( + 303 + /* ImportTypeAssertionContainer */ + ); + return j.assertClause = v, j.multiLine = w, j; + } + function Zp(v, w, j) { + return v.assertClause !== w || v.multiLine !== j ? tn(Wd(w, j), v) : v; + } + function Rv(v, w, j) { + const oe = F( + 301 + /* ImportAttributes */ + ); + return oe.token = j ?? 118, oe.elements = O(v), oe.multiLine = w, oe.transformFlags |= 4, oe; + } + function ga(v, w, j) { + return v.elements !== w || v.multiLine !== j ? tn(Rv(w, j, v.token), v) : v; + } + function Vf(v, w) { + const j = F( + 302 + /* ImportAttribute */ + ); + return j.name = v, j.value = w, j.transformFlags |= 4, j; + } + function z0(v, w, j) { + return v.name !== w || v.value !== j ? tn(Vf(w, j), v) : v; + } + function iT(v) { + const w = R( + 275 + /* NamespaceImport */ + ); + return w.name = v, w.transformFlags |= vn(w.name), w.transformFlags &= -67108865, w; + } + function Vh(v, w) { + return v.name !== w ? tn(iT(w), v) : v; + } + function v2(v) { + const w = R( + 281 + /* NamespaceExport */ + ); + return w.name = v, w.transformFlags |= vn(w.name) | 32, w.transformFlags &= -67108865, w; + } + function vp(v, w) { + return v.name !== w ? tn(v2(w), v) : v; + } + function Yg(v) { + const w = F( + 276 + /* NamedImports */ + ); + return w.elements = O(v), w.transformFlags |= Ia(w.elements), w.transformFlags &= -67108865, w; + } + function jv(v, w) { + return v.elements !== w ? tn(Yg(w), v) : v; + } + function W0(v, w, j) { + const oe = R( + 277 + /* ImportSpecifier */ + ); + return oe.isTypeOnly = v, oe.propertyName = w, oe.name = j, oe.transformFlags |= vn(oe.propertyName) | vn(oe.name), oe.transformFlags &= -67108865, oe; + } + function Im(v, w, j, oe) { + return v.isTypeOnly !== w || v.propertyName !== j || v.name !== oe ? tn(W0(w, j, oe), v) : v; + } + function b2(v, w, j) { + const oe = R( + 278 + /* ExportAssignment */ + ); + return oe.modifiers = Ra(v), oe.isExportEquals = w, oe.expression = w ? i().parenthesizeRightSideOfBinary( + 64, + /*leftSide*/ + void 0, + j + ) : i().parenthesizeExpressionOfExportDefault(j), oe.transformFlags |= Ia(oe.modifiers) | vn(oe.expression), oe.transformFlags &= -67108865, oe.jsDoc = void 0, oe; + } + function Bv(v, w, j) { + return v.modifiers !== w || v.expression !== j ? tn(b2(w, v.isExportEquals, j), v) : v; + } + function Pn(v, w, j, oe, Ue) { + const qt = R( + 279 + /* ExportDeclaration */ + ); + return qt.modifiers = Ra(v), qt.isTypeOnly = w, qt.exportClause = j, qt.moduleSpecifier = oe, qt.attributes = qt.assertClause = Ue, qt.transformFlags |= Ia(qt.modifiers) | vn(qt.exportClause) | vn(qt.moduleSpecifier), qt.transformFlags &= -67108865, qt.jsDoc = void 0, qt; + } + function xn(v, w, j, oe, Ue, qt) { + return v.modifiers !== w || v.isTypeOnly !== j || v.exportClause !== oe || v.moduleSpecifier !== Ue || v.attributes !== qt ? Xl(Pn(w, j, oe, Ue, qt), v) : v; + } + function Xl(v, w) { + return v !== w && v.modifiers === w.modifiers && (v.modifiers = w.modifiers), tn(v, w); + } + function sT(v) { + const w = F( + 280 + /* NamedExports */ + ); + return w.elements = O(v), w.transformFlags |= Ia(w.elements), w.transformFlags &= -67108865, w; + } + function qh(v, w) { + return v.elements !== w ? tn(sT(w), v) : v; + } + function S2(v, w, j) { + const oe = F( + 282 + /* ExportSpecifier */ + ); + return oe.isTypeOnly = v, oe.propertyName = dl(w), oe.name = dl(j), oe.transformFlags |= vn(oe.propertyName) | vn(oe.name), oe.transformFlags &= -67108865, oe.jsDoc = void 0, oe; + } + function yE(v, w, j, oe) { + return v.isTypeOnly !== w || v.propertyName !== j || v.name !== oe ? tn(S2(w, j, oe), v) : v; + } + function Gw() { + const v = R( + 283 + /* MissingDeclaration */ + ); + return v.jsDoc = void 0, v; + } + function bn(v) { + const w = F( + 284 + /* ExternalModuleReference */ + ); + return w.expression = v, w.transformFlags |= vn(w.expression), w.transformFlags &= -67108865, w; + } + function Ku(v, w) { + return v.expression !== w ? tn(bn(w), v) : v; + } + function fs(v) { + return F(v); + } + function U_(v, w, j = !1) { + const oe = aT( + v, + j ? w && i().parenthesizeNonArrayTypeOfPostfixType(w) : w + ); + return oe.postfix = j, oe; + } + function aT(v, w) { + const j = F(v); + return j.type = w, j; + } + function u1(v, w, j) { + return w.type !== j ? tn(U_(v, j, w.postfix), w) : w; + } + function fn(v, w, j) { + return w.type !== j ? tn(aT(v, j), w) : w; + } + function vE(v, w) { + const j = R( + 318 + /* JSDocFunctionType */ + ); + return j.parameters = Ra(v), j.type = w, j.transformFlags = Ia(j.parameters) | (j.type ? 1 : 0), j.jsDoc = void 0, j.locals = void 0, j.nextContainer = void 0, j.typeArguments = void 0, j; + } + function Ik(v, w, j) { + return v.parameters !== w || v.type !== j ? tn(vE(w, j), v) : v; + } + function Lu(v, w = !1) { + const j = R( + 323 + /* JSDocTypeLiteral */ + ); + return j.jsDocPropertyTags = Ra(v), j.isArrayType = w, j; + } + function ug(v, w, j) { + return v.jsDocPropertyTags !== w || v.isArrayType !== j ? tn(Lu(w, j), v) : v; + } + function Ud(v) { + const w = F( + 310 + /* JSDocTypeExpression */ + ); + return w.type = v, w; + } + function _1(v, w) { + return v.type !== w ? tn(Ud(w), v) : v; + } + function oT(v, w, j) { + const oe = R( + 324 + /* JSDocSignature */ + ); + return oe.typeParameters = Ra(v), oe.parameters = O(w), oe.type = j, oe.jsDoc = void 0, oe.locals = void 0, oe.nextContainer = void 0, oe; + } + function f1(v, w, j, oe) { + return v.typeParameters !== w || v.parameters !== j || v.type !== oe ? tn(oT(w, j, oe), v) : v; + } + function qf(v) { + const w = nz(v.kind); + return v.tagName.escapedText === tc(w) ? v.tagName : fe(w); + } + function md(v, w, j) { + const oe = F(v); + return oe.tagName = w, oe.comment = j, oe; + } + function bp(v, w, j) { + const oe = R(v); + return oe.tagName = w, oe.comment = j, oe; + } + function F_(v, w, j, oe) { + const Ue = md(346, v ?? fe("template"), oe); + return Ue.constraint = w, Ue.typeParameters = O(j), Ue; + } + function U0(v, w = qf(v), j, oe, Ue) { + return v.tagName !== w || v.constraint !== j || v.typeParameters !== oe || v.comment !== Ue ? tn(F_(w, j, oe, Ue), v) : v; + } + function Jv(v, w, j, oe) { + const Ue = bp(347, v ?? fe("typedef"), oe); + return Ue.typeExpression = w, Ue.fullName = j, Ue.name = Rz(j), Ue.locals = void 0, Ue.nextContainer = void 0, Ue; + } + function Fk(v, w = qf(v), j, oe, Ue) { + return v.tagName !== w || v.typeExpression !== j || v.fullName !== oe || v.comment !== Ue ? tn(Jv(w, j, oe, Ue), v) : v; + } + function zv(v, w, j, oe, Ue, qt) { + const hn = bp(342, v ?? fe("param"), qt); + return hn.typeExpression = oe, hn.name = w, hn.isNameFirst = !!Ue, hn.isBracketed = j, hn; + } + function p1(v, w = qf(v), j, oe, Ue, qt, hn) { + return v.tagName !== w || v.name !== j || v.isBracketed !== oe || v.typeExpression !== Ue || v.isNameFirst !== qt || v.comment !== hn ? tn(zv(w, j, oe, Ue, qt, hn), v) : v; + } + function Ok(v, w, j, oe, Ue, qt) { + const hn = bp(349, v ?? fe("prop"), qt); + return hn.typeExpression = oe, hn.name = w, hn.isNameFirst = !!Ue, hn.isBracketed = j, hn; + } + function Hh(v, w = qf(v), j, oe, Ue, qt, hn) { + return v.tagName !== w || v.name !== j || v.isBracketed !== oe || v.typeExpression !== Ue || v.isNameFirst !== qt || v.comment !== hn ? tn(Ok(w, j, oe, Ue, qt, hn), v) : v; + } + function Fm(v, w, j, oe) { + const Ue = bp(339, v ?? fe("callback"), oe); + return Ue.typeExpression = w, Ue.fullName = j, Ue.name = Rz(j), Ue.locals = void 0, Ue.nextContainer = void 0, Ue; + } + function d1(v, w = qf(v), j, oe, Ue) { + return v.tagName !== w || v.typeExpression !== j || v.fullName !== oe || v.comment !== Ue ? tn(Fm(w, j, oe, Ue), v) : v; + } + function Wv(v, w, j) { + const oe = md(340, v ?? fe("overload"), j); + return oe.typeExpression = w, oe; + } + function V0(v, w = qf(v), j, oe) { + return v.tagName !== w || v.typeExpression !== j || v.comment !== oe ? tn(Wv(w, j, oe), v) : v; + } + function m1(v, w, j) { + const oe = md(329, v ?? fe("augments"), j); + return oe.class = w, oe; + } + function gd(v, w = qf(v), j, oe) { + return v.tagName !== w || v.class !== j || v.comment !== oe ? tn(m1(w, j, oe), v) : v; + } + function Gh(v, w, j) { + const oe = md(330, v ?? fe("implements"), j); + return oe.class = w, oe; + } + function Zg(v, w, j) { + const oe = md(348, v ?? fe("see"), j); + return oe.name = w, oe; + } + function g1(v, w, j, oe) { + return v.tagName !== w || v.name !== j || v.comment !== oe ? tn(Zg(w, j, oe), v) : v; + } + function Ml(v) { + const w = F( + 311 + /* JSDocNameReference */ + ); + return w.name = v, w; + } + function T2(v, w) { + return v.name !== w ? tn(Ml(w), v) : v; + } + function Kg(v, w) { + const j = F( + 312 + /* JSDocMemberName */ + ); + return j.left = v, j.right = w, j.transformFlags |= vn(j.left) | vn(j.right), j; + } + function Uv(v, w, j) { + return v.left !== w || v.right !== j ? tn(Kg(w, j), v) : v; + } + function cT(v, w) { + const j = F( + 325 + /* JSDocLink */ + ); + return j.name = v, j.text = w, j; + } + function eh(v, w, j) { + return v.name !== w ? tn(cT(w, j), v) : v; + } + function bE(v, w) { + const j = F( + 326 + /* JSDocLinkCode */ + ); + return j.name = v, j.text = w, j; + } + function Lk(v, w, j) { + return v.name !== w ? tn(bE(w, j), v) : v; + } + function Mk(v, w) { + const j = F( + 327 + /* JSDocLinkPlain */ + ); + return j.name = v, j.text = w, j; + } + function $w(v, w, j) { + return v.name !== w ? tn(Mk(w, j), v) : v; + } + function Rk(v, w = qf(v), j, oe) { + return v.tagName !== w || v.class !== j || v.comment !== oe ? tn(Gh(w, j, oe), v) : v; + } + function Vv(v, w, j) { + return md(v, w ?? fe(nz(v)), j); + } + function $h(v, w, j = qf(w), oe) { + return w.tagName !== j || w.comment !== oe ? tn(Vv(v, j, oe), w) : w; + } + function SE(v, w, j, oe) { + const Ue = md(v, w ?? fe(nz(v)), oe); + return Ue.typeExpression = j, Ue; + } + function qv(v, w, j = qf(w), oe, Ue) { + return w.tagName !== j || w.typeExpression !== oe || w.comment !== Ue ? tn(SE(v, j, oe, Ue), w) : w; + } + function lT(v, w) { + return md(328, v, w); + } + function zc(v, w, j) { + return v.tagName !== w || v.comment !== j ? tn(lT(w, j), v) : v; + } + function Rl(v, w, j) { + const oe = bp(341, v ?? fe(nz( + 341 + /* JSDocEnumTag */ + )), j); + return oe.typeExpression = w, oe.locals = void 0, oe.nextContainer = void 0, oe; + } + function jk(v, w = qf(v), j, oe) { + return v.tagName !== w || v.typeExpression !== j || v.comment !== oe ? tn(Rl(w, j, oe), v) : v; + } + function O_(v, w, j, oe, Ue) { + const qt = md(352, v ?? fe("import"), Ue); + return qt.importClause = w, qt.moduleSpecifier = j, qt.attributes = oe, qt.comment = Ue, qt; + } + function Sp(v, w, j, oe, Ue, qt) { + return v.tagName !== w || v.comment !== qt || v.importClause !== j || v.moduleSpecifier !== oe || v.attributes !== Ue ? tn(O_(w, j, oe, Ue, qt), v) : v; + } + function x2(v) { + const w = F( + 322 + /* JSDocText */ + ); + return w.text = v, w; + } + function Vd(v, w) { + return v.text !== w ? tn(x2(w), v) : v; + } + function h1(v, w) { + const j = F( + 321 + /* JSDoc */ + ); + return j.comment = v, j.tags = Ra(w), j; + } + function q0(v, w, j) { + return v.comment !== w || v.tags !== j ? tn(h1(w, j), v) : v; + } + function Bk(v, w, j) { + const oe = F( + 285 + /* JsxElement */ + ); + return oe.openingElement = v, oe.children = O(w), oe.closingElement = j, oe.transformFlags |= vn(oe.openingElement) | Ia(oe.children) | vn(oe.closingElement) | 2, oe; + } + function Xw(v, w, j, oe) { + return v.openingElement !== w || v.children !== j || v.closingElement !== oe ? tn(Bk(w, j, oe), v) : v; + } + function dc(v, w, j) { + const oe = F( + 286 + /* JsxSelfClosingElement */ + ); + return oe.tagName = v, oe.typeArguments = Ra(w), oe.attributes = j, oe.transformFlags |= vn(oe.tagName) | Ia(oe.typeArguments) | vn(oe.attributes) | 2, oe.typeArguments && (oe.transformFlags |= 1), oe; + } + function TE(v, w, j, oe) { + return v.tagName !== w || v.typeArguments !== j || v.attributes !== oe ? tn(dc(w, j, oe), v) : v; + } + function uT(v, w, j) { + const oe = F( + 287 + /* JsxOpeningElement */ + ); + return oe.tagName = v, oe.typeArguments = Ra(w), oe.attributes = j, oe.transformFlags |= vn(oe.tagName) | Ia(oe.typeArguments) | vn(oe.attributes) | 2, w && (oe.transformFlags |= 1), oe; + } + function k2(v, w, j, oe) { + return v.tagName !== w || v.typeArguments !== j || v.attributes !== oe ? tn(uT(w, j, oe), v) : v; + } + function Jk(v) { + const w = F( + 288 + /* JsxClosingElement */ + ); + return w.tagName = v, w.transformFlags |= vn(w.tagName) | 2, w; + } + function Mu(v, w) { + return v.tagName !== w ? tn(Jk(w), v) : v; + } + function V_(v, w, j) { + const oe = F( + 289 + /* JsxFragment */ + ); + return oe.openingFragment = v, oe.children = O(w), oe.closingFragment = j, oe.transformFlags |= vn(oe.openingFragment) | Ia(oe.children) | vn(oe.closingFragment) | 2, oe; + } + function _T(v, w, j, oe) { + return v.openingFragment !== w || v.children !== j || v.closingFragment !== oe ? tn(V_(w, j, oe), v) : v; + } + function Hv(v, w) { + const j = F( + 12 + /* JsxText */ + ); + return j.text = v, j.containsOnlyTriviaWhiteSpaces = !!w, j.transformFlags |= 2, j; + } + function q_(v, w, j) { + return v.text !== w || v.containsOnlyTriviaWhiteSpaces !== j ? tn(Hv(w, j), v) : v; + } + function fT() { + const v = F( + 290 + /* JsxOpeningFragment */ + ); + return v.transformFlags |= 2, v; + } + function th() { + const v = F( + 291 + /* JsxClosingFragment */ + ); + return v.transformFlags |= 2, v; + } + function zk(v, w) { + const j = R( + 292 + /* JsxAttribute */ + ); + return j.name = v, j.initializer = w, j.transformFlags |= vn(j.name) | vn(j.initializer) | 2, j; + } + function pT(v, w, j) { + return v.name !== w || v.initializer !== j ? tn(zk(w, j), v) : v; + } + function hd(v) { + const w = R( + 293 + /* JsxAttributes */ + ); + return w.properties = O(v), w.transformFlags |= Ia(w.properties) | 2, w; + } + function Wk(v, w) { + return v.properties !== w ? tn(hd(w), v) : v; + } + function xE(v) { + const w = F( + 294 + /* JsxSpreadAttribute */ + ); + return w.expression = v, w.transformFlags |= vn(w.expression) | 2, w; + } + function Uk(v, w) { + return v.expression !== w ? tn(xE(w), v) : v; + } + function dT(v, w) { + const j = F( + 295 + /* JsxExpression */ + ); + return j.dotDotDotToken = v, j.expression = w, j.transformFlags |= vn(j.dotDotDotToken) | vn(j.expression) | 2, j; + } + function Vk(v, w) { + return v.expression !== w ? tn(dT(v.dotDotDotToken, w), v) : v; + } + function H0(v, w) { + const j = F( + 296 + /* JsxNamespacedName */ + ); + return j.namespace = v, j.name = w, j.transformFlags |= vn(j.namespace) | vn(j.name) | 2, j; + } + function gf(v, w, j) { + return v.namespace !== w || v.name !== j ? tn(H0(w, j), v) : v; + } + function Om(v, w) { + const j = F( + 297 + /* CaseClause */ + ); + return j.expression = i().parenthesizeExpressionForDisallowedComma(v), j.statements = O(w), j.transformFlags |= vn(j.expression) | Ia(j.statements), j.jsDoc = void 0, j; + } + function mT(v, w, j) { + return v.expression !== w || v.statements !== j ? tn(Om(w, j), v) : v; + } + function gT(v) { + const w = F( + 298 + /* DefaultClause */ + ); + return w.statements = O(v), w.transformFlags = Ia(w.statements), w; + } + function Oa(v, w) { + return v.statements !== w ? tn(gT(w), v) : v; + } + function yn(v, w) { + const j = F( + 299 + /* HeritageClause */ + ); + switch (j.token = v, j.types = O(w), j.transformFlags |= Ia(j.types), v) { + case 96: + j.transformFlags |= 1024; + break; + case 119: + j.transformFlags |= 1; + break; + default: + return E.assertNever(v); + } + return j; + } + function Hf(v, w) { + return v.types !== w ? tn(yn(v.token, w), v) : v; + } + function Tl(v, w) { + const j = F( + 300 + /* CatchClause */ + ); + return j.variableDeclaration = pg(v), j.block = w, j.transformFlags |= vn(j.variableDeclaration) | vn(j.block) | (v ? 0 : 64), j.locals = void 0, j.nextContainer = void 0, j; + } + function Gv(v, w, j) { + return v.variableDeclaration !== w || v.block !== j ? tn(Tl(w, j), v) : v; + } + function hT(v, w) { + const j = R( + 304 + /* PropertyAssignment */ + ); + return j.name = dl(v), j.initializer = i().parenthesizeExpressionForDisallowedComma(w), j.transformFlags |= Wy(j.name) | vn(j.initializer), j.modifiers = void 0, j.questionToken = void 0, j.exclamationToken = void 0, j.jsDoc = void 0, j; + } + function C2(v, w, j) { + return v.name !== w || v.initializer !== j ? $v(hT(w, j), v) : v; + } + function $v(v, w) { + return v !== w && (v.modifiers = w.modifiers, v.questionToken = w.questionToken, v.exclamationToken = w.exclamationToken), tn(v, w); + } + function yT(v, w) { + const j = R( + 305 + /* ShorthandPropertyAssignment */ + ); + return j.name = dl(v), j.objectAssignmentInitializer = w && i().parenthesizeExpressionForDisallowedComma(w), j.transformFlags |= AN(j.name) | vn(j.objectAssignmentInitializer) | 1024, j.equalsToken = void 0, j.modifiers = void 0, j.questionToken = void 0, j.exclamationToken = void 0, j.jsDoc = void 0, j; + } + function C(v, w, j) { + return v.name !== w || v.objectAssignmentInitializer !== j ? le(yT(w, j), v) : v; + } + function le(v, w) { + return v !== w && (v.modifiers = w.modifiers, v.questionToken = w.questionToken, v.exclamationToken = w.exclamationToken, v.equalsToken = w.equalsToken), tn(v, w); + } + function _t(v) { + const w = R( + 306 + /* SpreadAssignment */ + ); + return w.expression = i().parenthesizeExpressionForDisallowedComma(v), w.transformFlags |= vn(w.expression) | 128 | 65536, w.jsDoc = void 0, w; + } + function ur(v, w) { + return v.expression !== w ? tn(_t(w), v) : v; + } + function ti(v, w) { + const j = R( + 307 + /* EnumMember */ + ); + return j.name = dl(v), j.initializer = w && i().parenthesizeExpressionForDisallowedComma(w), j.transformFlags |= vn(j.name) | vn(j.initializer) | 1, j.jsDoc = void 0, j; + } + function gi(v, w, j) { + return v.name !== w || v.initializer !== j ? tn(ti(w, j), v) : v; + } + function Ki(v, w, j) { + const oe = t.createBaseSourceFileNode( + 308 + /* SourceFile */ + ); + return oe.statements = O(v), oe.endOfFileToken = w, oe.flags |= j, oe.text = "", oe.fileName = "", oe.path = "", oe.resolvedPath = "", oe.originalFileName = "", oe.languageVersion = 1, oe.languageVariant = 0, oe.scriptKind = 0, oe.isDeclarationFile = !1, oe.hasNoDefaultLib = !1, oe.transformFlags |= Ia(oe.statements) | vn(oe.endOfFileToken), oe.locals = void 0, oe.nextContainer = void 0, oe.endFlowNode = void 0, oe.nodeCount = 0, oe.identifierCount = 0, oe.symbolCount = 0, oe.parseDiagnostics = void 0, oe.bindDiagnostics = void 0, oe.bindSuggestionDiagnostics = void 0, oe.lineMap = void 0, oe.externalModuleIndicator = void 0, oe.setExternalModuleIndicator = void 0, oe.pragmas = void 0, oe.checkJsDirective = void 0, oe.referencedFiles = void 0, oe.typeReferenceDirectives = void 0, oe.libReferenceDirectives = void 0, oe.amdDependencies = void 0, oe.commentDirectives = void 0, oe.identifiers = void 0, oe.packageJsonLocations = void 0, oe.packageJsonScope = void 0, oe.imports = void 0, oe.moduleAugmentations = void 0, oe.ambientModuleNames = void 0, oe.classifiableNames = void 0, oe.impliedNodeFormat = void 0, oe; + } + function mi(v) { + const w = Object.create(v.redirectTarget); + return Object.defineProperties(w, { + id: { + get() { + return this.redirectInfo.redirectTarget.id; + }, + set(j) { + this.redirectInfo.redirectTarget.id = j; + } + }, + symbol: { + get() { + return this.redirectInfo.redirectTarget.symbol; + }, + set(j) { + this.redirectInfo.redirectTarget.symbol = j; + } + } + }), w.redirectInfo = v, w; + } + function ba(v) { + const w = mi(v.redirectInfo); + return w.flags |= v.flags & -17, w.fileName = v.fileName, w.path = v.path, w.resolvedPath = v.resolvedPath, w.originalFileName = v.originalFileName, w.packageJsonLocations = v.packageJsonLocations, w.packageJsonScope = v.packageJsonScope, w.emitNode = void 0, w; + } + function Wc(v) { + const w = t.createBaseSourceFileNode( + 308 + /* SourceFile */ + ); + w.flags |= v.flags & -17; + for (const j in v) + if (!(eo(w, j) || !eo(v, j))) { + if (j === "emitNode") { + w.emitNode = void 0; + continue; + } + w[j] = v[j]; + } + return w; + } + function bu(v) { + const w = v.redirectInfo ? ba(v) : Wc(v); + return n(w, v), w; + } + function p_(v, w, j, oe, Ue, qt, hn) { + const ls = bu(v); + return ls.statements = O(w), ls.isDeclarationFile = j, ls.referencedFiles = oe, ls.typeReferenceDirectives = Ue, ls.hasNoDefaultLib = qt, ls.libReferenceDirectives = hn, ls.transformFlags = Ia(ls.statements) | vn(ls.endOfFileToken), ls; + } + function Xv(v, w, j = v.isDeclarationFile, oe = v.referencedFiles, Ue = v.typeReferenceDirectives, qt = v.hasNoDefaultLib, hn = v.libReferenceDirectives) { + return v.statements !== w || v.isDeclarationFile !== j || v.referencedFiles !== oe || v.typeReferenceDirectives !== Ue || v.hasNoDefaultLib !== qt || v.libReferenceDirectives !== hn ? tn(p_(v, w, j, oe, Ue, qt, hn), v) : v; + } + function d_(v) { + const w = F( + 309 + /* Bundle */ + ); + return w.sourceFiles = v, w.syntheticFileReferences = void 0, w.syntheticTypeReferences = void 0, w.syntheticLibReferences = void 0, w.hasNoDefaultLib = void 0, w; + } + function y1(v, w) { + return v.sourceFiles !== w ? tn(d_(w), v) : v; + } + function qk(v, w = !1, j) { + const oe = F( + 238 + /* SyntheticExpression */ + ); + return oe.type = v, oe.isSpread = w, oe.tupleNameSource = j, oe; + } + function Kp(v) { + const w = F( + 353 + /* SyntaxList */ + ); + return w._children = v, w; + } + function Ho(v) { + const w = F( + 354 + /* NotEmittedStatement */ + ); + return w.original = v, ct(w, v), w; + } + function vT(v, w) { + const j = F( + 356 + /* PartiallyEmittedExpression */ + ); + return j.expression = v, j.original = w, j.transformFlags |= vn(j.expression) | 1, ct(j, w), j; + } + function G0(v, w) { + return v.expression !== w ? tn(vT(w, v.original), v) : v; + } + function yd() { + return F( + 355 + /* NotEmittedTypeElement */ + ); + } + function $0(v) { + if (lo(v) && !bD(v) && !v.original && !v.emitNode && !v.id) { + if (I4(v)) + return v.elements; + if (_n(v) && Pte(v.operatorToken)) + return [v.left, v.right]; + } + return v; + } + function E2(v) { + const w = F( + 357 + /* CommaListExpression */ + ); + return w.elements = O(eQ(v, $0)), w.transformFlags |= Ia(w.elements), w; + } + function qL(v, w) { + return v.elements !== w ? tn(E2(w), v) : v; + } + function Qw(v, w) { + const j = F( + 358 + /* SyntheticReferenceExpression */ + ); + return j.expression = v, j.thisArg = w, j.transformFlags |= vn(j.expression) | vn(j.thisArg), j; + } + function Hk(v, w, j) { + return v.expression !== w || v.thisArg !== j ? tn(Qw(w, j), v) : v; + } + function Yw(v) { + const w = se(v.escapedText); + return w.flags |= v.flags & -17, w.transformFlags = v.transformFlags, n(w, v), LN(w, { ...v.emitNode.autoGenerate }), w; + } + function U8(v) { + const w = se(v.escapedText); + w.flags |= v.flags & -17, w.jsDoc = v.jsDoc, w.flowNode = v.flowNode, w.symbol = v.symbol, w.transformFlags = v.transformFlags, n(w, v); + const j = SS(v); + return j && k0(w, j), w; + } + function v1(v) { + const w = me(v.escapedText); + return w.flags |= v.flags & -17, w.transformFlags = v.transformFlags, n(w, v), LN(w, { ...v.emitNode.autoGenerate }), w; + } + function Gk(v) { + const w = me(v.escapedText); + return w.flags |= v.flags & -17, w.transformFlags = v.transformFlags, n(w, v), w; + } + function bT(v) { + if (v === void 0) + return v; + if (Di(v)) + return bu(v); + if (Bo(v)) + return Yw(v); + if (Me(v)) + return U8(v); + if (tS(v)) + return v1(v); + if (Ai(v)) + return Gk(v); + const w = C7(v.kind) ? t.createBaseNode(v.kind) : t.createBaseTokenNode(v.kind); + w.flags |= v.flags & -17, w.transformFlags = v.transformFlags, n(w, v); + for (const j in v) + eo(w, j) || !eo(v, j) || (w[j] = v[j]); + return w; + } + function HL(v, w, j) { + return Mr( + pf( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + /*parameters*/ + w ? [w] : [], + /*type*/ + void 0, + Wo( + v, + /*multiLine*/ + !0 + ) + ), + /*typeArguments*/ + void 0, + /*argumentsArray*/ + j ? [j] : [] + ); + } + function D2(v, w, j) { + return Mr( + hp( + /*modifiers*/ + void 0, + /*typeParameters*/ + void 0, + /*parameters*/ + w ? [w] : [], + /*type*/ + void 0, + /*equalsGreaterThanToken*/ + void 0, + Wo( + v, + /*multiLine*/ + !0 + ) + ), + /*typeArguments*/ + void 0, + /*argumentsArray*/ + j ? [j] : [] + ); + } + function ST() { + return Jd(U("0")); + } + function Zw(v) { + return b2( + /*modifiers*/ + void 0, + /*isExportEquals*/ + !1, + v + ); + } + function $k(v) { + return Pn( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + sT([ + S2( + /*isTypeOnly*/ + !1, + /*propertyName*/ + void 0, + v + ) + ]) + ); + } + function Wi(v, w) { + return w === "null" ? A.createStrictEquality(v, Ne()) : w === "undefined" ? A.createStrictEquality(v, ST()) : A.createStrictEquality(N_(v), _e(w)); + } + function b1(v, w) { + return w === "null" ? A.createStrictInequality(v, Ne()) : w === "undefined" ? A.createStrictInequality(v, ST()) : A.createStrictInequality(N_(v), _e(w)); + } + function Wr(v, w, j) { + return K2(v) ? Da( + vo( + v, + /*questionDotToken*/ + void 0, + w + ), + /*questionDotToken*/ + void 0, + /*typeArguments*/ + void 0, + j + ) : Mr( + $c(v, w), + /*typeArguments*/ + void 0, + j + ); + } + function Kw(v, w, j) { + return Wr(v, "bind", [w, ...j]); + } + function kE(v, w, j) { + return Wr(v, "call", [w, ...j]); + } + function CE(v, w, j) { + return Wr(v, "apply", [w, j]); + } + function w2(v, w, j) { + return Wr(fe(v), w, j); + } + function V8(v, w) { + return Wr(v, "slice", w === void 0 ? [] : [Y0(w)]); + } + function TT(v, w) { + return Wr(v, "concat", w); + } + function GL(v, w, j) { + return w2("Object", "defineProperty", [v, Y0(w), j]); + } + function EE(v, w) { + return w2("Object", "getOwnPropertyDescriptor", [v, Y0(w)]); + } + function _g(v, w, j) { + return w2("Reflect", "get", j ? [v, w, j] : [v, w]); + } + function q8(v, w, j, oe) { + return w2("Reflect", "set", oe ? [v, w, j, oe] : [v, w, j]); + } + function Qv(v, w, j) { + return j ? (v.push(hT(w, j)), !0) : !1; + } + function $L(v, w) { + const j = []; + Qv(j, "enumerable", Y0(v.enumerable)), Qv(j, "configurable", Y0(v.configurable)); + let oe = Qv(j, "writable", Y0(v.writable)); + oe = Qv(j, "value", v.value) || oe; + let Ue = Qv(j, "get", v.get); + return Ue = Qv(j, "set", v.set) || Ue, E.assert(!(oe && Ue), "A PropertyDescriptor may not be both an accessor descriptor and a data descriptor."), no(j, !w); + } + function eP(v, w) { + switch (v.kind) { + case 218: + return Ol(v, w); + case 217: + return Df(v, v.type, w); + case 235: + return nt(v, w, v.type); + case 239: + return dn(v, w, v.type); + case 236: + return pr(v, w); + case 234: + return s1(v, w, v.typeArguments); + case 356: + return G0(v, w); + } + } + function H8(v) { + return o_(v) && lo(v) && lo(x0(v)) && lo(hm(v)) && !ot(l6(v)) && !ot(ON(v)); + } + function tP(v, w, j = 63) { + return v && BF(v, j) && !H8(v) ? eP( + v, + tP(v.expression, w) + ) : w; + } + function Yv(v, w, j) { + if (!w) + return v; + const oe = Ak( + w, + w.label, + Gy(w.statement) ? Yv(v, w.statement) : v + ); + return j && j(w), oe; + } + function fg(v, w) { + const j = Ba(v); + switch (j.kind) { + case 80: + return w; + case 110: + case 9: + case 10: + case 11: + return !1; + case 210: + return j.elements.length !== 0; + case 211: + return j.properties.length > 0; + default: + return !0; + } + } + function DE(v, w, j, oe = !1) { + const Ue = hc( + v, + 63 + /* All */ + ); + let qt, hn; + return j_(Ue) ? (qt = ie(), hn = Ue) : w4(Ue) ? (qt = ie(), hn = j !== void 0 && j < 2 ? ct(fe("_super"), Ue) : Ue) : Ea(Ue) & 8192 ? (qt = ST(), hn = i().parenthesizeLeftSideOfAccess( + Ue, + /*optionalChain*/ + !1 + )) : wn(Ue) ? fg(Ue.expression, oe) ? (qt = he(w), hn = $c( + ct( + A.createAssignment( + qt, + Ue.expression + ), + Ue.expression + ), + Ue.name + ), ct(hn, Ue)) : (qt = Ue.expression, hn = Ue) : uo(Ue) ? fg(Ue.expression, oe) ? (qt = he(w), hn = au( + ct( + A.createAssignment( + qt, + Ue.expression + ), + Ue.expression + ), + Ue.argumentExpression + ), ct(hn, Ue)) : (qt = Ue.expression, hn = Ue) : (qt = ST(), hn = i().parenthesizeLeftSideOfAccess( + v, + /*optionalChain*/ + !1 + )), { target: hn, thisArg: qt }; + } + function Lm(v, w) { + return $c( + // Explicit parens required because of v8 regression (https://bugs.chromium.org/p/v8/issues/detail?id=9560) + Gl( + no([ + Y( + /*modifiers*/ + void 0, + "value", + [ui( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + v, + /*questionToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + )], + Wo([ + mf(w) + ]) + ) + ]) + ), + "value" + ); + } + function X(v) { + return v.length > 10 ? E2(v) : Wu(v, A.createComma); + } + function De(v, w, j, oe = 0, Ue) { + const qt = Ue ? v && h7(v) : _s(v); + if (qt && Me(qt) && !Bo(qt)) { + const hn = za(ct(bT(qt), qt), qt.parent); + return oe |= Ea(qt), j || (oe |= 96), w || (oe |= 3072), oe && un(hn, oe), hn; + } + return je(v); + } + function He(v, w, j) { + return De( + v, + w, + j, + 98304 + /* InternalName */ + ); + } + function bt(v, w, j, oe) { + return De(v, w, j, 32768, oe); + } + function Vt(v, w, j) { + return De( + v, + w, + j, + 16384 + /* ExportName */ + ); + } + function rr(v, w, j) { + return De(v, w, j); + } + function Rn(v, w, j, oe) { + const Ue = $c(v, lo(w) ? w : bT(w)); + ct(Ue, w); + let qt = 0; + return oe || (qt |= 96), j || (qt |= 3072), qt && un(Ue, qt), Ue; + } + function gn(v, w, j, oe) { + return v && Gn( + w, + 32 + /* Export */ + ) ? Rn(v, De(w), j, oe) : Vt(w, j, oe); + } + function Gr(v, w, j, oe) { + const Ue = fo(v, w, 0, j); + return Ka(v, w, Ue, oe); + } + function ii(v) { + return ca(v.expression) && v.expression.text === "use strict"; + } + function ji() { + return Au(mf(_e("use strict"))); + } + function fo(v, w, j = 0, oe) { + E.assert(w.length === 0, "Prologue directives should be at the first statement in the target statements array"); + let Ue = !1; + const qt = v.length; + for (; j < qt; ) { + const hn = v[j]; + if (cm(hn)) + ii(hn) && (Ue = !0), w.push(hn); + else + break; + j++; + } + return oe && !Ue && w.push(ji()), j; + } + function Ka(v, w, j, oe, Ue = yb) { + const qt = v.length; + for (; j !== void 0 && j < qt; ) { + const hn = v[j]; + if (Ea(hn) & 2097152 && Ue(hn)) + Er(w, oe ? Qe(hn, oe, Ti) : hn); + else + break; + j++; + } + return j; + } + function La(v) { + return Oz(v) ? v : ct(O([ji(), ...v]), v); + } + function Tp(v) { + return E.assert(Ni(v, LZ), "Cannot lift nodes to a Block."), xg(v) || Wo(v); + } + function Gf(v, w, j) { + let oe = j; + for (; oe < v.length && w(v[oe]); ) + oe++; + return oe; + } + function X0(v, w) { + if (!ot(w)) + return v; + const j = Gf(v, cm, 0), oe = Gf(v, Q7, j), Ue = Gf(v, Y7, oe), qt = Gf(w, cm, 0), hn = Gf(w, Q7, qt), ls = Gf(w, Y7, hn), No = Gf(w, w3, ls); + E.assert(No === w.length, "Expected declarations to be valid standard or custom prologues"); + const wf = xb(v) ? v.slice() : v; + if (No > ls && wf.splice(Ue, 0, ...w.slice(ls, No)), ls > hn && wf.splice(oe, 0, ...w.slice(hn, ls)), hn > qt && wf.splice(j, 0, ...w.slice(qt, hn)), qt > 0) + if (j === 0) + wf.splice(0, 0, ...w.slice(0, qt)); + else { + const T1 = /* @__PURE__ */ new Map(); + for (let qd = 0; qd < j; qd++) { + const Qk = v[qd]; + T1.set(Qk.expression.text, !0); + } + for (let qd = qt - 1; qd >= 0; qd--) { + const Qk = w[qd]; + T1.has(Qk.expression.text) || wf.unshift(Qk); + } + } + return xb(v) ? ct(O(wf, v.hasTrailingComma), v) : v; + } + function Q0(v, w) { + let j; + return typeof w == "number" ? j = St(w) : j = w, Lo(v) ? Jr(v, j, v.name, v.constraint, v.default) : Ii(v) ? Ji(v, j, v.dotDotDotToken, v.name, v.questionToken, v.type, v.initializer) : _6(v) ? Zr(v, j, v.typeParameters, v.parameters, v.type) : $u(v) ? fi(v, j, v.name, v.questionToken, v.type) : os(v) ? Je(v, j, v.name, v.questionToken ?? v.exclamationToken, v.type, v.initializer) : cd(v) ? er(v, j, v.name, v.questionToken, v.typeParameters, v.parameters, v.type) : rc(v) ? Jn(v, j, v.asteriskToken, v.name, v.questionToken, v.typeParameters, v.parameters, v.type, v.body) : nc(v) ? bs(v, j, v.parameters, v.body) : pp(v) ? re(v, j, v.name, v.parameters, v.type, v.body) : z_(v) ? Ae(v, j, v.name, v.parameters, v.body) : qy(v) ? Ct(v, j, v.parameters, v.type) : yo(v) ? Qu(v, j, v.asteriskToken, v.name, v.typeParameters, v.parameters, v.type, v.body) : xo(v) ? ig(v, j, v.typeParameters, v.parameters, v.type, v.equalsGreaterThanToken, v.body) : Rc(v) ? sg(v, j, v.name, v.typeParameters, v.heritageClauses, v.members) : Ic(v) ? $l(v, j, v.declarationList) : Cc(v) ? Aa(v, j, v.asteriskToken, v.name, v.typeParameters, v.parameters, v.type, v.body) : tl(v) ? Wh(v, j, v.name, v.typeParameters, v.heritageClauses, v.members) : Vl(v) ? cg(v, j, v.name, v.typeParameters, v.heritageClauses, v.members) : Wp(v) ? yu(v, j, v.name, v.typeParameters, v.type) : ov(v) ? vu(v, j, v.name, v.members) : jc(v) ? Yu(v, j, v.name, v.body) : _l(v) ? B0(v, j, v.isTypeOnly, v.name, v.moduleReference) : qo(v) ? ze(v, j, v.importClause, v.moduleSpecifier, v.attributes) : Mo(v) ? Bv(v, j, v.expression) : Bc(v) ? xn(v, j, v.isTypeOnly, v.exportClause, v.moduleSpecifier, v.attributes) : E.assertNever(v); + } + function rh(v, w) { + return Ii(v) ? Ji(v, w, v.dotDotDotToken, v.name, v.questionToken, v.type, v.initializer) : os(v) ? Je(v, w, v.name, v.questionToken ?? v.exclamationToken, v.type, v.initializer) : rc(v) ? Jn(v, w, v.asteriskToken, v.name, v.questionToken, v.typeParameters, v.parameters, v.type, v.body) : pp(v) ? re(v, w, v.name, v.parameters, v.type, v.body) : z_(v) ? Ae(v, w, v.name, v.parameters, v.body) : Rc(v) ? sg(v, w, v.name, v.typeParameters, v.heritageClauses, v.members) : tl(v) ? Wh(v, w, v.name, v.typeParameters, v.heritageClauses, v.members) : E.assertNever(v); + } + function S1(v, w) { + switch (v.kind) { + case 178: + return re(v, v.modifiers, w, v.parameters, v.type, v.body); + case 179: + return Ae(v, v.modifiers, w, v.parameters, v.body); + case 175: + return Jn(v, v.modifiers, v.asteriskToken, w, v.questionToken, v.typeParameters, v.parameters, v.type, v.body); + case 174: + return er(v, v.modifiers, w, v.questionToken, v.typeParameters, v.parameters, v.type); + case 173: + return Je(v, v.modifiers, w, v.questionToken ?? v.exclamationToken, v.type, v.initializer); + case 172: + return fi(v, v.modifiers, w, v.questionToken, v.type); + case 304: + return C2(v, w, v.initializer); + } + } + function Ra(v) { + return v ? O(v) : void 0; + } + function dl(v) { + return typeof v == "string" ? fe(v) : v; + } + function Y0(v) { + return typeof v == "string" ? _e(v) : typeof v == "number" ? U(v) : typeof v == "boolean" ? v ? Ee() : Ce() : v; + } + function Ru(v) { + return v && i().parenthesizeExpressionForDisallowedComma(v); + } + function Xk(v) { + return typeof v == "number" ? ne(v) : v; + } + function nh(v) { + return v && Vte(v) ? ct(n(Qp(), v), v) : v; + } + function pg(v) { + return typeof v == "string" || v && !ei(v) ? zh( + v, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + ) : v; + } + function tn(v, w) { + return v !== w && (n(v, w), ct(v, w)), v; + } + } + function nz(e) { + switch (e) { + case 345: + return "type"; + case 343: + return "returns"; + case 344: + return "this"; + case 341: + return "enum"; + case 331: + return "author"; + case 333: + return "class"; + case 334: + return "public"; + case 335: + return "private"; + case 336: + return "protected"; + case 337: + return "readonly"; + case 338: + return "override"; + case 346: + return "template"; + case 347: + return "typedef"; + case 342: + return "param"; + case 349: + return "prop"; + case 339: + return "callback"; + case 340: + return "overload"; + case 329: + return "augments"; + case 330: + return "implements"; + case 352: + return "import"; + default: + return E.fail(`Unsupported kind: ${E.formatSyntaxKind(e)}`); + } + } + var T0, o0e = {}; + function R9e(e, t) { + switch (T0 || (T0 = Dg( + 99, + /*skipTrivia*/ + !1, + 0 + /* Standard */ + )), e) { + case 15: + T0.setText("`" + t + "`"); + break; + case 16: + T0.setText("`" + t + "${"); + break; + case 17: + T0.setText("}" + t + "${"); + break; + case 18: + T0.setText("}" + t + "`"); + break; + } + let n = T0.scan(); + if (n === 20 && (n = T0.reScanTemplateToken( + /*isTaggedTemplate*/ + !1 + )), T0.isUnterminated()) + return T0.setText(void 0), o0e; + let i; + switch (n) { + case 15: + case 16: + case 17: + case 18: + i = T0.getTokenValue(); + break; + } + return i === void 0 || T0.scan() !== 1 ? (T0.setText(void 0), o0e) : (T0.setText(void 0), i); + } + function Wy(e) { + return e && Me(e) ? AN(e) : vn(e); + } + function AN(e) { + return vn(e) & -67108865; + } + function j9e(e, t) { + return t | e.transformFlags & 134234112; + } + function vn(e) { + if (!e) return 0; + const t = e.transformFlags & ~B9e(e.kind); + return wl(e) && qc(e.name) ? j9e(e.name, t) : t; + } + function Ia(e) { + return e ? e.transformFlags : 0; + } + function c0e(e) { + let t = 0; + for (const n of e) + t |= vn(n); + e.transformFlags = t; + } + function B9e(e) { + if (e >= 183 && e <= 206) + return -2; + switch (e) { + case 214: + case 215: + case 210: + return -2147450880; + case 268: + return -1941676032; + case 170: + return -2147483648; + case 220: + return -2072174592; + case 219: + case 263: + return -1937940480; + case 262: + return -2146893824; + case 264: + case 232: + return -2147344384; + case 177: + return -1937948672; + case 173: + return -2013249536; + case 175: + case 178: + case 179: + return -2005057536; + case 133: + case 150: + case 163: + case 146: + case 154: + case 151: + case 136: + case 155: + case 116: + case 169: + case 172: + case 174: + case 180: + case 181: + case 182: + case 265: + case 266: + return -2; + case 211: + return -2147278848; + case 300: + return -2147418112; + case 207: + case 208: + return -2147450880; + case 217: + case 239: + case 235: + case 356: + case 218: + case 108: + return -2147483648; + case 212: + case 213: + return -2147483648; + default: + return -2147483648; + } + } + var mF = ute(); + function gF(e) { + return e.flags |= 16, e; + } + var J9e = { + createBaseSourceFileNode: (e) => gF(mF.createBaseSourceFileNode(e)), + createBaseIdentifierNode: (e) => gF(mF.createBaseIdentifierNode(e)), + createBasePrivateIdentifierNode: (e) => gF(mF.createBasePrivateIdentifierNode(e)), + createBaseTokenNode: (e) => gF(mF.createBaseTokenNode(e)), + createBaseNode: (e) => gF(mF.createBaseNode(e)) + }, N = NN(4, J9e), l0e; + function u0e(e, t, n) { + return new (l0e || (l0e = tu.getSourceMapSourceConstructor()))(e, t, n); + } + function Cn(e, t) { + if (e.original !== t && (e.original = t, t)) { + const n = t.emitNode; + n && (e.emitNode = z9e(n, e.emitNode)); + } + return e; + } + function z9e(e, t) { + const { + flags: n, + internalFlags: i, + leadingComments: s, + trailingComments: o, + commentRange: c, + sourceMapRange: _, + tokenSourceMapRanges: u, + constantValue: g, + helpers: m, + startsOnNewLine: h, + snippetElement: S, + classThis: T, + assignedName: k + } = e; + if (t || (t = {}), n && (t.flags = n), i && (t.internalFlags = i & -9), s && (t.leadingComments = In(s.slice(), t.leadingComments)), o && (t.trailingComments = In(o.slice(), t.trailingComments)), c && (t.commentRange = c), _ && (t.sourceMapRange = _), u && (t.tokenSourceMapRanges = W9e(u, t.tokenSourceMapRanges)), g !== void 0 && (t.constantValue = g), m) + for (const D of m) + t.helpers = dh(t.helpers, D); + return h !== void 0 && (t.startsOnNewLine = h), S !== void 0 && (t.snippetElement = S), T && (t.classThis = T), k && (t.assignedName = k), t; + } + function W9e(e, t) { + t || (t = []); + for (const n in e) + t[n] = e[n]; + return t; + } + function mu(e) { + if (e.emitNode) + E.assert(!(e.emitNode.internalFlags & 8), "Invalid attempt to mutate an immutable node."); + else { + if (bD(e)) { + if (e.kind === 308) + return e.emitNode = { annotatedNodes: [e] }; + const t = xr(vs(xr(e))) ?? E.fail("Could not determine parsed source file."); + mu(t).annotatedNodes.push(e); + } + e.emitNode = {}; + } + return e.emitNode; + } + function iz(e) { + var t, n; + const i = (n = (t = xr(vs(e))) == null ? void 0 : t.emitNode) == null ? void 0 : n.annotatedNodes; + if (i) + for (const s of i) + s.emitNode = void 0; + } + function IN(e) { + const t = mu(e); + return t.flags |= 3072, t.leadingComments = void 0, t.trailingComments = void 0, e; + } + function un(e, t) { + return mu(e).flags = t, e; + } + function gm(e, t) { + const n = mu(e); + return n.flags = n.flags | t, e; + } + function FN(e, t) { + return mu(e).internalFlags = t, e; + } + function bS(e, t) { + const n = mu(e); + return n.internalFlags = n.internalFlags | t, e; + } + function x0(e) { + var t; + return ((t = e.emitNode) == null ? void 0 : t.sourceMapRange) ?? e; + } + function ha(e, t) { + return mu(e).sourceMapRange = t, e; + } + function _0e(e, t) { + var n, i; + return (i = (n = e.emitNode) == null ? void 0 : n.tokenSourceMapRanges) == null ? void 0 : i[t]; + } + function gte(e, t, n) { + const i = mu(e), s = i.tokenSourceMapRanges ?? (i.tokenSourceMapRanges = []); + return s[t] = n, e; + } + function k4(e) { + var t; + return (t = e.emitNode) == null ? void 0 : t.startsOnNewLine; + } + function hF(e, t) { + return mu(e).startsOnNewLine = t, e; + } + function hm(e) { + var t; + return ((t = e.emitNode) == null ? void 0 : t.commentRange) ?? e; + } + function el(e, t) { + return mu(e).commentRange = t, e; + } + function l6(e) { + var t; + return (t = e.emitNode) == null ? void 0 : t.leadingComments; + } + function tv(e, t) { + return mu(e).leadingComments = t, e; + } + function Uy(e, t, n, i) { + return tv(e, Er(l6(e), { kind: t, pos: -1, end: -1, hasTrailingNewLine: i, text: n })); + } + function ON(e) { + var t; + return (t = e.emitNode) == null ? void 0 : t.trailingComments; + } + function Rx(e, t) { + return mu(e).trailingComments = t, e; + } + function C4(e, t, n, i) { + return Rx(e, Er(ON(e), { kind: t, pos: -1, end: -1, hasTrailingNewLine: i, text: n })); + } + function hte(e, t) { + tv(e, l6(t)), Rx(e, ON(t)); + const n = mu(t); + return n.leadingComments = void 0, n.trailingComments = void 0, e; + } + function yte(e) { + var t; + return (t = e.emitNode) == null ? void 0 : t.constantValue; + } + function vte(e, t) { + const n = mu(e); + return n.constantValue = t, e; + } + function jx(e, t) { + const n = mu(e); + return n.helpers = Er(n.helpers, t), e; + } + function Wg(e, t) { + if (ot(t)) { + const n = mu(e); + for (const i of t) + n.helpers = dh(n.helpers, i); + } + return e; + } + function f0e(e, t) { + var n; + const i = (n = e.emitNode) == null ? void 0 : n.helpers; + return i ? rD(i, t) : !1; + } + function sz(e) { + var t; + return (t = e.emitNode) == null ? void 0 : t.helpers; + } + function bte(e, t, n) { + const i = e.emitNode, s = i && i.helpers; + if (!ot(s)) return; + const o = mu(t); + let c = 0; + for (let _ = 0; _ < s.length; _++) { + const u = s[_]; + n(u) ? (c++, o.helpers = dh(o.helpers, u)) : c > 0 && (s[_ - c] = u); + } + c > 0 && (s.length -= c); + } + function az(e) { + var t; + return (t = e.emitNode) == null ? void 0 : t.snippetElement; + } + function oz(e, t) { + const n = mu(e); + return n.snippetElement = t, e; + } + function cz(e) { + return mu(e).internalFlags |= 4, e; + } + function Ste(e, t) { + const n = mu(e); + return n.typeNode = t, e; + } + function Tte(e) { + var t; + return (t = e.emitNode) == null ? void 0 : t.typeNode; + } + function k0(e, t) { + return mu(e).identifierTypeArguments = t, e; + } + function SS(e) { + var t; + return (t = e.emitNode) == null ? void 0 : t.identifierTypeArguments; + } + function LN(e, t) { + return mu(e).autoGenerate = t, e; + } + function p0e(e) { + var t; + return (t = e.emitNode) == null ? void 0 : t.autoGenerate; + } + function xte(e, t) { + return mu(e).generatedImportReference = t, e; + } + function kte(e) { + var t; + return (t = e.emitNode) == null ? void 0 : t.generatedImportReference; + } + var Cte = /* @__PURE__ */ ((e) => (e.Field = "f", e.Method = "m", e.Accessor = "a", e))(Cte || {}); + function Ete(e) { + const t = e.factory, n = Uu(() => FN( + t.createTrue(), + 8 + /* Immutable */ + )), i = Uu(() => FN( + t.createFalse(), + 8 + /* Immutable */ + )); + return { + getUnscopedHelperName: s, + // TypeScript Helpers + createDecorateHelper: o, + createMetadataHelper: c, + createParamHelper: _, + // ES Decorators Helpers + createESDecorateHelper: D, + createRunInitializersHelper: P, + // ES2018 Helpers + createAssignHelper: A, + createAwaitHelper: O, + createAsyncGeneratorHelper: F, + createAsyncDelegatorHelper: R, + createAsyncValuesHelper: B, + // ES2018 Destructuring Helpers + createRestHelper: U, + // ES2017 Helpers + createAwaiterHelper: $, + // ES2015 Helpers + createExtendsHelper: W, + createTemplateObjectHelper: _e, + createSpreadArrayHelper: K, + createPropKeyHelper: V, + createSetFunctionNameHelper: ae, + // ES2015 Destructuring Helpers + createValuesHelper: se, + createReadHelper: ce, + // ES2015 Generator Helpers + createGeneratorHelper: fe, + // ES Module Helpers + createImportStarHelper: he, + createImportStarCallbackHelper: q, + createImportDefaultHelper: be, + createExportStarHelper: je, + // Class Fields Helpers + createClassPrivateFieldGetHelper: me, + createClassPrivateFieldSetHelper: Z, + createClassPrivateFieldInHelper: pe, + // 'using' helpers + createAddDisposableResourceHelper: Te, + createDisposeResourcesHelper: Fe, + // --rewriteRelativeImportExtensions helpers + createRewriteRelativeImportExtensionsHelper: Ye + }; + function s(ne) { + return un( + t.createIdentifier(ne), + 8196 + /* AdviseOnEmitNode */ + ); + } + function o(ne, Se, ie, Ne) { + e.requestEmitHelper(U9e); + const Ee = []; + return Ee.push(t.createArrayLiteralExpression( + ne, + /*multiLine*/ + !0 + )), Ee.push(Se), ie && (Ee.push(ie), Ne && Ee.push(Ne)), t.createCallExpression( + s("__decorate"), + /*typeArguments*/ + void 0, + Ee + ); + } + function c(ne, Se) { + return e.requestEmitHelper(V9e), t.createCallExpression( + s("__metadata"), + /*typeArguments*/ + void 0, + [ + t.createStringLiteral(ne), + Se + ] + ); + } + function _(ne, Se, ie) { + return e.requestEmitHelper(q9e), ct( + t.createCallExpression( + s("__param"), + /*typeArguments*/ + void 0, + [ + t.createNumericLiteral(Se + ""), + ne + ] + ), + ie + ); + } + function u(ne) { + const Se = [ + t.createPropertyAssignment(t.createIdentifier("kind"), t.createStringLiteral("class")), + t.createPropertyAssignment(t.createIdentifier("name"), ne.name), + t.createPropertyAssignment(t.createIdentifier("metadata"), ne.metadata) + ]; + return t.createObjectLiteralExpression(Se); + } + function g(ne) { + const Se = ne.computed ? t.createElementAccessExpression(t.createIdentifier("obj"), ne.name) : t.createPropertyAccessExpression(t.createIdentifier("obj"), ne.name); + return t.createPropertyAssignment( + "get", + t.createArrowFunction( + /*modifiers*/ + void 0, + /*typeParameters*/ + void 0, + [t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + t.createIdentifier("obj") + )], + /*type*/ + void 0, + /*equalsGreaterThanToken*/ + void 0, + Se + ) + ); + } + function m(ne) { + const Se = ne.computed ? t.createElementAccessExpression(t.createIdentifier("obj"), ne.name) : t.createPropertyAccessExpression(t.createIdentifier("obj"), ne.name); + return t.createPropertyAssignment( + "set", + t.createArrowFunction( + /*modifiers*/ + void 0, + /*typeParameters*/ + void 0, + [ + t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + t.createIdentifier("obj") + ), + t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + t.createIdentifier("value") + ) + ], + /*type*/ + void 0, + /*equalsGreaterThanToken*/ + void 0, + t.createBlock([ + t.createExpressionStatement( + t.createAssignment( + Se, + t.createIdentifier("value") + ) + ) + ]) + ) + ); + } + function h(ne) { + const Se = ne.computed ? ne.name : Me(ne.name) ? t.createStringLiteralFromNode(ne.name) : ne.name; + return t.createPropertyAssignment( + "has", + t.createArrowFunction( + /*modifiers*/ + void 0, + /*typeParameters*/ + void 0, + [t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + t.createIdentifier("obj") + )], + /*type*/ + void 0, + /*equalsGreaterThanToken*/ + void 0, + t.createBinaryExpression( + Se, + 103, + t.createIdentifier("obj") + ) + ) + ); + } + function S(ne, Se) { + const ie = []; + return ie.push(h(ne)), Se.get && ie.push(g(ne)), Se.set && ie.push(m(ne)), t.createObjectLiteralExpression(ie); + } + function T(ne) { + const Se = [ + t.createPropertyAssignment(t.createIdentifier("kind"), t.createStringLiteral(ne.kind)), + t.createPropertyAssignment(t.createIdentifier("name"), ne.name.computed ? ne.name.name : t.createStringLiteralFromNode(ne.name.name)), + t.createPropertyAssignment(t.createIdentifier("static"), ne.static ? t.createTrue() : t.createFalse()), + t.createPropertyAssignment(t.createIdentifier("private"), ne.private ? t.createTrue() : t.createFalse()), + t.createPropertyAssignment(t.createIdentifier("access"), S(ne.name, ne.access)), + t.createPropertyAssignment(t.createIdentifier("metadata"), ne.metadata) + ]; + return t.createObjectLiteralExpression(Se); + } + function k(ne) { + return ne.kind === "class" ? u(ne) : T(ne); + } + function D(ne, Se, ie, Ne, Ee, Ce) { + return e.requestEmitHelper(H9e), t.createCallExpression( + s("__esDecorate"), + /*typeArguments*/ + void 0, + [ + ne ?? t.createNull(), + Se ?? t.createNull(), + ie, + k(Ne), + Ee, + Ce + ] + ); + } + function P(ne, Se, ie) { + return e.requestEmitHelper(G9e), t.createCallExpression( + s("__runInitializers"), + /*typeArguments*/ + void 0, + ie ? [ne, Se, ie] : [ne, Se] + ); + } + function A(ne) { + return da(e.getCompilerOptions()) >= 2 ? t.createCallExpression( + t.createPropertyAccessExpression(t.createIdentifier("Object"), "assign"), + /*typeArguments*/ + void 0, + ne + ) : (e.requestEmitHelper($9e), t.createCallExpression( + s("__assign"), + /*typeArguments*/ + void 0, + ne + )); + } + function O(ne) { + return e.requestEmitHelper(yF), t.createCallExpression( + s("__await"), + /*typeArguments*/ + void 0, + [ne] + ); + } + function F(ne, Se) { + return e.requestEmitHelper(yF), e.requestEmitHelper(X9e), (ne.emitNode || (ne.emitNode = {})).flags |= 1572864, t.createCallExpression( + s("__asyncGenerator"), + /*typeArguments*/ + void 0, + [ + Se ? t.createThis() : t.createVoidZero(), + t.createIdentifier("arguments"), + ne + ] + ); + } + function R(ne) { + return e.requestEmitHelper(yF), e.requestEmitHelper(Q9e), t.createCallExpression( + s("__asyncDelegator"), + /*typeArguments*/ + void 0, + [ne] + ); + } + function B(ne) { + return e.requestEmitHelper(Y9e), t.createCallExpression( + s("__asyncValues"), + /*typeArguments*/ + void 0, + [ne] + ); + } + function U(ne, Se, ie, Ne) { + e.requestEmitHelper(Z9e); + const Ee = []; + let Ce = 0; + for (let Ve = 0; Ve < Se.length - 1; Ve++) { + const St = Mz(Se[Ve]); + if (St) + if (Gs(St)) { + E.assertIsDefined(ie, "Encountered computed property name but 'computedTempVariables' argument was not provided."); + const Bt = ie[Ce]; + Ce++, Ee.push( + t.createConditionalExpression( + t.createTypeCheck(Bt, "symbol"), + /*questionToken*/ + void 0, + Bt, + /*colonToken*/ + void 0, + t.createAdd(Bt, t.createStringLiteral("")) + ) + ); + } else + Ee.push(t.createStringLiteralFromNode(St)); + } + return t.createCallExpression( + s("__rest"), + /*typeArguments*/ + void 0, + [ + ne, + ct( + t.createArrayLiteralExpression(Ee), + Ne + ) + ] + ); + } + function $(ne, Se, ie, Ne, Ee) { + e.requestEmitHelper(K9e); + const Ce = t.createFunctionExpression( + /*modifiers*/ + void 0, + t.createToken( + 42 + /* AsteriskToken */ + ), + /*name*/ + void 0, + /*typeParameters*/ + void 0, + Ne ?? [], + /*type*/ + void 0, + Ee + ); + return (Ce.emitNode || (Ce.emitNode = {})).flags |= 1572864, t.createCallExpression( + s("__awaiter"), + /*typeArguments*/ + void 0, + [ + ne ? t.createThis() : t.createVoidZero(), + Se ?? t.createVoidZero(), + ie ? VN(t, ie) : t.createVoidZero(), + Ce + ] + ); + } + function W(ne) { + return e.requestEmitHelper(eLe), t.createCallExpression( + s("__extends"), + /*typeArguments*/ + void 0, + [ne, t.createUniqueName( + "_super", + 48 + /* FileLevel */ + )] + ); + } + function _e(ne, Se) { + return e.requestEmitHelper(tLe), t.createCallExpression( + s("__makeTemplateObject"), + /*typeArguments*/ + void 0, + [ne, Se] + ); + } + function K(ne, Se, ie) { + return e.requestEmitHelper(nLe), t.createCallExpression( + s("__spreadArray"), + /*typeArguments*/ + void 0, + [ne, Se, ie ? n() : i()] + ); + } + function V(ne) { + return e.requestEmitHelper(iLe), t.createCallExpression( + s("__propKey"), + /*typeArguments*/ + void 0, + [ne] + ); + } + function ae(ne, Se, ie) { + return e.requestEmitHelper(sLe), e.factory.createCallExpression( + s("__setFunctionName"), + /*typeArguments*/ + void 0, + ie ? [ne, Se, e.factory.createStringLiteral(ie)] : [ne, Se] + ); + } + function se(ne) { + return e.requestEmitHelper(aLe), t.createCallExpression( + s("__values"), + /*typeArguments*/ + void 0, + [ne] + ); + } + function ce(ne, Se) { + return e.requestEmitHelper(rLe), t.createCallExpression( + s("__read"), + /*typeArguments*/ + void 0, + Se !== void 0 ? [ne, t.createNumericLiteral(Se + "")] : [ne] + ); + } + function fe(ne) { + return e.requestEmitHelper(oLe), t.createCallExpression( + s("__generator"), + /*typeArguments*/ + void 0, + [t.createThis(), ne] + ); + } + function he(ne) { + return e.requestEmitHelper(m0e), t.createCallExpression( + s("__importStar"), + /*typeArguments*/ + void 0, + [ne] + ); + } + function q() { + return e.requestEmitHelper(m0e), s("__importStar"); + } + function be(ne) { + return e.requestEmitHelper(lLe), t.createCallExpression( + s("__importDefault"), + /*typeArguments*/ + void 0, + [ne] + ); + } + function je(ne, Se = t.createIdentifier("exports")) { + return e.requestEmitHelper(uLe), e.requestEmitHelper(wte), t.createCallExpression( + s("__exportStar"), + /*typeArguments*/ + void 0, + [ne, Se] + ); + } + function me(ne, Se, ie, Ne) { + e.requestEmitHelper(_Le); + let Ee; + return Ne ? Ee = [ne, Se, t.createStringLiteral(ie), Ne] : Ee = [ne, Se, t.createStringLiteral(ie)], t.createCallExpression( + s("__classPrivateFieldGet"), + /*typeArguments*/ + void 0, + Ee + ); + } + function Z(ne, Se, ie, Ne, Ee) { + e.requestEmitHelper(fLe); + let Ce; + return Ee ? Ce = [ne, Se, ie, t.createStringLiteral(Ne), Ee] : Ce = [ne, Se, ie, t.createStringLiteral(Ne)], t.createCallExpression( + s("__classPrivateFieldSet"), + /*typeArguments*/ + void 0, + Ce + ); + } + function pe(ne, Se) { + return e.requestEmitHelper(pLe), t.createCallExpression( + s("__classPrivateFieldIn"), + /*typeArguments*/ + void 0, + [ne, Se] + ); + } + function Te(ne, Se, ie) { + return e.requestEmitHelper(dLe), t.createCallExpression( + s("__addDisposableResource"), + /*typeArguments*/ + void 0, + [ne, Se, ie ? t.createTrue() : t.createFalse()] + ); + } + function Fe(ne) { + return e.requestEmitHelper(mLe), t.createCallExpression( + s("__disposeResources"), + /*typeArguments*/ + void 0, + [ne] + ); + } + function Ye(ne) { + return e.requestEmitHelper(gLe), t.createCallExpression( + s("__rewriteRelativeImportExtension"), + /*typeArguments*/ + void 0, + e.getCompilerOptions().jsx === 1 ? [ne, t.createTrue()] : [ne] + ); + } + } + function Dte(e, t) { + return e === t || e.priority === t.priority ? 0 : e.priority === void 0 ? 1 : t.priority === void 0 ? -1 : ho(e.priority, t.priority); + } + function d0e(e, ...t) { + return (n) => { + let i = ""; + for (let s = 0; s < t.length; s++) + i += e[s], i += n(t[s]); + return i += e[e.length - 1], i; + }; + } + var U9e = { + name: "typescript:decorate", + importName: "__decorate", + scoped: !1, + priority: 2, + text: ` + var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; + };` + }, V9e = { + name: "typescript:metadata", + importName: "__metadata", + scoped: !1, + priority: 3, + text: ` + var __metadata = (this && this.__metadata) || function (k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); + };` + }, q9e = { + name: "typescript:param", + importName: "__param", + scoped: !1, + priority: 4, + text: ` + var __param = (this && this.__param) || function (paramIndex, decorator) { + return function (target, key) { decorator(target, key, paramIndex); } + };` + }, H9e = { + name: "typescript:esDecorate", + importName: "__esDecorate", + scoped: !1, + priority: 2, + text: ` + var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) { + function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; } + var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value"; + var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null; + var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {}); + var _, done = false; + for (var i = decorators.length - 1; i >= 0; i--) { + var context = {}; + for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p]; + for (var p in contextIn.access) context.access[p] = contextIn.access[p]; + context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); }; + var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context); + if (kind === "accessor") { + if (result === void 0) continue; + if (result === null || typeof result !== "object") throw new TypeError("Object expected"); + if (_ = accept(result.get)) descriptor.get = _; + if (_ = accept(result.set)) descriptor.set = _; + if (_ = accept(result.init)) initializers.unshift(_); + } + else if (_ = accept(result)) { + if (kind === "field") initializers.unshift(_); + else descriptor[key] = _; + } + } + if (target) Object.defineProperty(target, contextIn.name, descriptor); + done = true; + };` + }, G9e = { + name: "typescript:runInitializers", + importName: "__runInitializers", + scoped: !1, + priority: 2, + text: ` + var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) { + var useValue = arguments.length > 2; + for (var i = 0; i < initializers.length; i++) { + value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg); + } + return useValue ? value : void 0; + };` + }, $9e = { + name: "typescript:assign", + importName: "__assign", + scoped: !1, + priority: 1, + text: ` + var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); + };` + }, yF = { + name: "typescript:await", + importName: "__await", + scoped: !1, + text: ` + var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }` + }, X9e = { + name: "typescript:asyncGenerator", + importName: "__asyncGenerator", + scoped: !1, + dependencies: [yF], + text: ` + var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i; + function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; } + function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } + function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } + };` + }, Q9e = { + name: "typescript:asyncDelegator", + importName: "__asyncDelegator", + scoped: !1, + dependencies: [yF], + text: ` + var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i, p; + return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; } + };` + }, Y9e = { + name: "typescript:asyncValues", + importName: "__asyncValues", + scoped: !1, + text: ` + var __asyncValues = (this && this.__asyncValues) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } + };` + }, Z9e = { + name: "typescript:rest", + importName: "__rest", + scoped: !1, + text: ` + var __rest = (this && this.__rest) || function (s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; + };` + }, K9e = { + name: "typescript:awaiter", + importName: "__awaiter", + scoped: !1, + priority: 5, + text: ` + var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + };` + }, eLe = { + name: "typescript:extends", + importName: "__extends", + scoped: !1, + priority: 0, + text: ` + var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + })();` + }, tLe = { + name: "typescript:makeTemplateObject", + importName: "__makeTemplateObject", + scoped: !1, + priority: 0, + text: ` + var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) { + if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; } + return cooked; + };` + }, rLe = { + name: "typescript:read", + importName: "__read", + scoped: !1, + text: ` + var __read = (this && this.__read) || function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; + };` + }, nLe = { + name: "typescript:spreadArray", + importName: "__spreadArray", + scoped: !1, + text: ` + var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { + if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) ar = Array.prototype.slice.call(from, 0, i); + ar[i] = from[i]; + } + } + return to.concat(ar || Array.prototype.slice.call(from)); + };` + }, iLe = { + name: "typescript:propKey", + importName: "__propKey", + scoped: !1, + text: ` + var __propKey = (this && this.__propKey) || function (x) { + return typeof x === "symbol" ? x : "".concat(x); + };` + }, sLe = { + name: "typescript:setFunctionName", + importName: "__setFunctionName", + scoped: !1, + text: ` + var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) { + if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : ""; + return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name }); + };` + }, aLe = { + name: "typescript:values", + importName: "__values", + scoped: !1, + text: ` + var __values = (this && this.__values) || function(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); + };` + }, oLe = { + name: "typescript:generator", + importName: "__generator", + scoped: !1, + priority: 6, + text: ` + var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype); + return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (g && (g = 0, op[0] && (_ = 0)), _) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } + };` + }, wte = { + name: "typescript:commonjscreatebinding", + importName: "__createBinding", + scoped: !1, + priority: 1, + text: ` + var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); + }) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; + }));` + }, cLe = { + name: "typescript:commonjscreatevalue", + importName: "__setModuleDefault", + scoped: !1, + priority: 1, + text: ` + var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + }) : function(o, v) { + o["default"] = v; + });` + }, m0e = { + name: "typescript:commonjsimportstar", + importName: "__importStar", + scoped: !1, + dependencies: [wte, cLe], + priority: 2, + text: ` + var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; + })();` + }, lLe = { + name: "typescript:commonjsimportdefault", + importName: "__importDefault", + scoped: !1, + text: ` + var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; + };` + }, uLe = { + name: "typescript:export-star", + importName: "__exportStar", + scoped: !1, + dependencies: [wte], + priority: 2, + text: ` + var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); + };` + }, _Le = { + name: "typescript:classPrivateFieldGet", + importName: "__classPrivateFieldGet", + scoped: !1, + text: ` + var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); + };` + }, fLe = { + name: "typescript:classPrivateFieldSet", + importName: "__classPrivateFieldSet", + scoped: !1, + text: ` + var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; + };` + }, pLe = { + name: "typescript:classPrivateFieldIn", + importName: "__classPrivateFieldIn", + scoped: !1, + text: ` + var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(state, receiver) { + if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object"); + return typeof state === "function" ? receiver === state : state.has(receiver); + };` + }, dLe = { + name: "typescript:addDisposableResource", + importName: "__addDisposableResource", + scoped: !1, + text: ` + var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) inner = dispose; + } + if (typeof dispose !== "function") throw new TypeError("Object not disposable."); + if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } }; + env.stack.push({ value: value, dispose: dispose, async: async }); + } + else if (async) { + env.stack.push({ async: true }); + } + return value; + };` + }, mLe = { + name: "typescript:disposeResources", + importName: "__disposeResources", + scoped: !1, + text: ` + var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) { + return function (env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); }); + } + else s |= 1; + } + catch (e) { + fail(e); + } + } + if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) throw env.error; + } + return next(); + }; + })(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; + });` + }, gLe = { + name: "typescript:rewriteRelativeImportExtensions", + importName: "__rewriteRelativeImportExtension", + scoped: !1, + text: ` + var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) { + if (typeof path === "string" && /^\\.\\.?\\//.test(path)) { + return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) { + return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js"); + }); + } + return path; + };` + }, vF = { + name: "typescript:async-super", + scoped: !0, + text: d0e` + const ${"_superIndex"} = name => super[name];` + }, bF = { + name: "typescript:advanced-async-super", + scoped: !0, + text: d0e` + const ${"_superIndex"} = (function (geti, seti) { + const cache = Object.create(null); + return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } }); + })(name => super[name], (name, value) => super[name] = value);` + }; + function E4(e, t) { + return Ps(e) && Me(e.expression) && (Ea(e.expression) & 8192) !== 0 && e.expression.escapedText === t; + } + function E_(e) { + return e.kind === 9; + } + function u6(e) { + return e.kind === 10; + } + function ca(e) { + return e.kind === 11; + } + function Bx(e) { + return e.kind === 12; + } + function lz(e) { + return e.kind === 14; + } + function TS(e) { + return e.kind === 15; + } + function Jx(e) { + return e.kind === 16; + } + function uz(e) { + return e.kind === 17; + } + function SF(e) { + return e.kind === 18; + } + function TF(e) { + return e.kind === 26; + } + function Pte(e) { + return e.kind === 28; + } + function _z(e) { + return e.kind === 40; + } + function fz(e) { + return e.kind === 41; + } + function MN(e) { + return e.kind === 42; + } + function RN(e) { + return e.kind === 54; + } + function Vy(e) { + return e.kind === 58; + } + function Nte(e) { + return e.kind === 59; + } + function xF(e) { + return e.kind === 29; + } + function Ate(e) { + return e.kind === 39; + } + function Me(e) { + return e.kind === 80; + } + function Ai(e) { + return e.kind === 81; + } + function zx(e) { + return e.kind === 95; + } + function kF(e) { + return e.kind === 90; + } + function D4(e) { + return e.kind === 134; + } + function Ite(e) { + return e.kind === 131; + } + function pz(e) { + return e.kind === 135; + } + function Fte(e) { + return e.kind === 148; + } + function Wx(e) { + return e.kind === 126; + } + function Ote(e) { + return e.kind === 128; + } + function Lte(e) { + return e.kind === 164; + } + function dz(e) { + return e.kind === 129; + } + function w4(e) { + return e.kind === 108; + } + function P4(e) { + return e.kind === 102; + } + function Mte(e) { + return e.kind === 84; + } + function s_(e) { + return e.kind === 167; + } + function Gs(e) { + return e.kind === 168; + } + function Lo(e) { + return e.kind === 169; + } + function Ii(e) { + return e.kind === 170; + } + function ul(e) { + return e.kind === 171; + } + function $u(e) { + return e.kind === 172; + } + function os(e) { + return e.kind === 173; + } + function cd(e) { + return e.kind === 174; + } + function rc(e) { + return e.kind === 175; + } + function kc(e) { + return e.kind === 176; + } + function nc(e) { + return e.kind === 177; + } + function pp(e) { + return e.kind === 178; + } + function z_(e) { + return e.kind === 179; + } + function Ux(e) { + return e.kind === 180; + } + function N4(e) { + return e.kind === 181; + } + function qy(e) { + return e.kind === 182; + } + function Vx(e) { + return e.kind === 183; + } + function of(e) { + return e.kind === 184; + } + function Zm(e) { + return e.kind === 185; + } + function _6(e) { + return e.kind === 186; + } + function Hb(e) { + return e.kind === 187; + } + function a_(e) { + return e.kind === 188; + } + function jN(e) { + return e.kind === 189; + } + function qx(e) { + return e.kind === 190; + } + function f6(e) { + return e.kind === 203; + } + function CF(e) { + return e.kind === 191; + } + function EF(e) { + return e.kind === 192; + } + function C0(e) { + return e.kind === 193; + } + function Hx(e) { + return e.kind === 194; + } + function Gb(e) { + return e.kind === 195; + } + function xS(e) { + return e.kind === 196; + } + function kS(e) { + return e.kind === 197; + } + function A4(e) { + return e.kind === 198; + } + function rv(e) { + return e.kind === 199; + } + function $b(e) { + return e.kind === 200; + } + function CS(e) { + return e.kind === 201; + } + function E0(e) { + return e.kind === 202; + } + function ym(e) { + return e.kind === 206; + } + function mz(e) { + return e.kind === 205; + } + function Rte(e) { + return e.kind === 204; + } + function Of(e) { + return e.kind === 207; + } + function D0(e) { + return e.kind === 208; + } + function ya(e) { + return e.kind === 209; + } + function nu(e) { + return e.kind === 210; + } + function _a(e) { + return e.kind === 211; + } + function wn(e) { + return e.kind === 212; + } + function uo(e) { + return e.kind === 213; + } + function Ps(e) { + return e.kind === 214; + } + function Xb(e) { + return e.kind === 215; + } + function nv(e) { + return e.kind === 216; + } + function DF(e) { + return e.kind === 217; + } + function o_(e) { + return e.kind === 218; + } + function yo(e) { + return e.kind === 219; + } + function xo(e) { + return e.kind === 220; + } + function jte(e) { + return e.kind === 221; + } + function p6(e) { + return e.kind === 222; + } + function Gx(e) { + return e.kind === 223; + } + function Hy(e) { + return e.kind === 224; + } + function iv(e) { + return e.kind === 225; + } + function gz(e) { + return e.kind === 226; + } + function _n(e) { + return e.kind === 227; + } + function ES(e) { + return e.kind === 228; + } + function wF(e) { + return e.kind === 229; + } + function BN(e) { + return e.kind === 230; + } + function dp(e) { + return e.kind === 231; + } + function Rc(e) { + return e.kind === 232; + } + function vl(e) { + return e.kind === 233; + } + function Dh(e) { + return e.kind === 234; + } + function d6(e) { + return e.kind === 235; + } + function m6(e) { + return e.kind === 239; + } + function $x(e) { + return e.kind === 236; + } + function DS(e) { + return e.kind === 237; + } + function g0e(e) { + return e.kind === 238; + } + function Bte(e) { + return e.kind === 356; + } + function I4(e) { + return e.kind === 357; + } + function g6(e) { + return e.kind === 240; + } + function Jte(e) { + return e.kind === 241; + } + function Ns(e) { + return e.kind === 242; + } + function Ic(e) { + return e.kind === 244; + } + function hz(e) { + return e.kind === 243; + } + function Al(e) { + return e.kind === 245; + } + function sv(e) { + return e.kind === 246; + } + function h0e(e) { + return e.kind === 247; + } + function yz(e) { + return e.kind === 248; + } + function av(e) { + return e.kind === 249; + } + function PF(e) { + return e.kind === 250; + } + function JN(e) { + return e.kind === 251; + } + function y0e(e) { + return e.kind === 252; + } + function v0e(e) { + return e.kind === 253; + } + function Cf(e) { + return e.kind === 254; + } + function zte(e) { + return e.kind === 255; + } + function F4(e) { + return e.kind === 256; + } + function Gy(e) { + return e.kind === 257; + } + function vz(e) { + return e.kind === 258; + } + function wS(e) { + return e.kind === 259; + } + function b0e(e) { + return e.kind === 260; + } + function ei(e) { + return e.kind === 261; + } + function Ul(e) { + return e.kind === 262; + } + function Cc(e) { + return e.kind === 263; + } + function tl(e) { + return e.kind === 264; + } + function Vl(e) { + return e.kind === 265; + } + function Wp(e) { + return e.kind === 266; + } + function ov(e) { + return e.kind === 267; + } + function jc(e) { + return e.kind === 268; + } + function vm(e) { + return e.kind === 269; + } + function O4(e) { + return e.kind === 270; + } + function zN(e) { + return e.kind === 271; + } + function _l(e) { + return e.kind === 272; + } + function qo(e) { + return e.kind === 273; + } + function ld(e) { + return e.kind === 274; + } + function S0e(e) { + return e.kind === 303; + } + function Wte(e) { + return e.kind === 301; + } + function T0e(e) { + return e.kind === 302; + } + function PS(e) { + return e.kind === 301; + } + function Ute(e) { + return e.kind === 302; + } + function Ug(e) { + return e.kind === 275; + } + function Km(e) { + return e.kind === 281; + } + function bm(e) { + return e.kind === 276; + } + function Xu(e) { + return e.kind === 277; + } + function Mo(e) { + return e.kind === 278; + } + function Bc(e) { + return e.kind === 279; + } + function mp(e) { + return e.kind === 280; + } + function Nu(e) { + return e.kind === 282; + } + function NF(e) { + return e.kind === 80 || e.kind === 11; + } + function x0e(e) { + return e.kind === 283; + } + function Vte(e) { + return e.kind === 354; + } + function Xx(e) { + return e.kind === 358; + } + function wh(e) { + return e.kind === 284; + } + function Sm(e) { + return e.kind === 285; + } + function NS(e) { + return e.kind === 286; + } + function Id(e) { + return e.kind === 287; + } + function Qb(e) { + return e.kind === 288; + } + function cv(e) { + return e.kind === 289; + } + function ud(e) { + return e.kind === 290; + } + function qte(e) { + return e.kind === 291; + } + function Tm(e) { + return e.kind === 292; + } + function Yb(e) { + return e.kind === 293; + } + function Qx(e) { + return e.kind === 294; + } + function h6(e) { + return e.kind === 295; + } + function Fd(e) { + return e.kind === 296; + } + function y6(e) { + return e.kind === 297; + } + function L4(e) { + return e.kind === 298; + } + function cf(e) { + return e.kind === 299; + } + function Zb(e) { + return e.kind === 300; + } + function rl(e) { + return e.kind === 304; + } + function gu(e) { + return e.kind === 305; + } + function Vg(e) { + return e.kind === 306; + } + function Ph(e) { + return e.kind === 307; + } + function Di(e) { + return e.kind === 308; + } + function Hte(e) { + return e.kind === 309; + } + function lv(e) { + return e.kind === 310; + } + function M4(e) { + return e.kind === 311; + } + function uv(e) { + return e.kind === 312; + } + function Gte(e) { + return e.kind === 325; + } + function $te(e) { + return e.kind === 326; + } + function k0e(e) { + return e.kind === 327; + } + function Xte(e) { + return e.kind === 313; + } + function Qte(e) { + return e.kind === 314; + } + function v6(e) { + return e.kind === 315; + } + function AF(e) { + return e.kind === 316; + } + function bz(e) { + return e.kind === 317; + } + function b6(e) { + return e.kind === 318; + } + function IF(e) { + return e.kind === 319; + } + function C0e(e) { + return e.kind === 320; + } + function Od(e) { + return e.kind === 321; + } + function AS(e) { + return e.kind === 323; + } + function w0(e) { + return e.kind === 324; + } + function Yx(e) { + return e.kind === 329; + } + function E0e(e) { + return e.kind === 331; + } + function Yte(e) { + return e.kind === 333; + } + function Sz(e) { + return e.kind === 339; + } + function Tz(e) { + return e.kind === 334; + } + function xz(e) { + return e.kind === 335; + } + function kz(e) { + return e.kind === 336; + } + function Cz(e) { + return e.kind === 337; + } + function FF(e) { + return e.kind === 338; + } + function S6(e) { + return e.kind === 340; + } + function Ez(e) { + return e.kind === 332; + } + function D0e(e) { + return e.kind === 348; + } + function WN(e) { + return e.kind === 341; + } + function Lf(e) { + return e.kind === 342; + } + function OF(e) { + return e.kind === 343; + } + function Dz(e) { + return e.kind === 344; + } + function R4(e) { + return e.kind === 345; + } + function Up(e) { + return e.kind === 346; + } + function IS(e) { + return e.kind === 347; + } + function w0e(e) { + return e.kind === 328; + } + function Zte(e) { + return e.kind === 349; + } + function LF(e) { + return e.kind === 330; + } + function MF(e) { + return e.kind === 351; + } + function P0e(e) { + return e.kind === 350; + } + function xm(e) { + return e.kind === 352; + } + function T6(e) { + return e.kind === 353; + } + var j4 = /* @__PURE__ */ new WeakMap(); + function wz(e, t) { + var n; + const i = e.kind; + return C7(i) ? i === 353 ? e._children : (n = j4.get(t)) == null ? void 0 : n.get(e) : Ge; + } + function Kte(e, t, n) { + e.kind === 353 && E.fail("Should not need to re-set the children of a SyntaxList."); + let i = j4.get(t); + return i === void 0 && (i = /* @__PURE__ */ new WeakMap(), j4.set(t, i)), i.set(e, n), n; + } + function Pz(e, t) { + var n; + e.kind === 353 && E.fail("Did not expect to unset the children of a SyntaxList."), (n = j4.get(t)) == null || n.delete(e); + } + function ere(e, t) { + const n = j4.get(e); + n !== void 0 && (j4.delete(e), j4.set(t, n)); + } + function UN(e) { + return e.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + e.createNamedExports([]), + /*moduleSpecifier*/ + void 0 + ); + } + function FS(e, t, n, i) { + if (Gs(n)) + return ct(e.createElementAccessExpression(t, n.expression), i); + { + const s = ct( + wg(n) ? e.createPropertyAccessExpression(t, n) : e.createElementAccessExpression(t, n), + n + ); + return gm( + s, + 128 + /* NoNestedSourceMaps */ + ), s; + } + } + function tre(e, t) { + const n = fv.createIdentifier(e || "React"); + return za(n, vs(t)), n; + } + function rre(e, t, n) { + if (s_(t)) { + const i = rre(e, t.left, n), s = e.createIdentifier(An(t.right)); + return s.escapedText = t.right.escapedText, e.createPropertyAccessExpression(i, s); + } else + return tre(An(t), n); + } + function Nz(e, t, n, i) { + return t ? rre(e, t, i) : e.createPropertyAccessExpression( + tre(n, i), + "createElement" + ); + } + function hLe(e, t, n, i) { + return t ? rre(e, t, i) : e.createPropertyAccessExpression( + tre(n, i), + "Fragment" + ); + } + function nre(e, t, n, i, s, o) { + const c = [n]; + if (i && c.push(i), s && s.length > 0) + if (i || c.push(e.createNull()), s.length > 1) + for (const _ of s) + Au(_), c.push(_); + else + c.push(s[0]); + return ct( + e.createCallExpression( + t, + /*typeArguments*/ + void 0, + c + ), + o + ); + } + function ire(e, t, n, i, s, o, c) { + const u = [hLe(e, n, i, o), e.createNull()]; + if (s && s.length > 0) + if (s.length > 1) + for (const g of s) + Au(g), u.push(g); + else + u.push(s[0]); + return ct( + e.createCallExpression( + Nz(e, t, i, o), + /*typeArguments*/ + void 0, + u + ), + c + ); + } + function Az(e, t, n) { + if (Ul(t)) { + const i = Ca(t.declarations), s = e.updateVariableDeclaration( + i, + i.name, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + n + ); + return ct( + e.createVariableStatement( + /*modifiers*/ + void 0, + e.updateVariableDeclarationList(t, [s]) + ), + /*location*/ + t + ); + } else { + const i = ct( + e.createAssignment(t, n), + /*location*/ + t + ); + return ct( + e.createExpressionStatement(i), + /*location*/ + t + ); + } + } + function VN(e, t) { + if (s_(t)) { + const n = VN(e, t.left), i = za(ct(e.cloneNode(t.right), t.right), t.right.parent); + return ct(e.createPropertyAccessExpression(n, i), t); + } else + return za(ct(e.cloneNode(t), t), t.parent); + } + function Iz(e, t) { + return Me(t) ? e.createStringLiteralFromNode(t) : Gs(t) ? za(ct(e.cloneNode(t.expression), t.expression), t.expression.parent) : za(ct(e.cloneNode(t), t), t.parent); + } + function yLe(e, t, n, i, s) { + const { firstAccessor: o, getAccessor: c, setAccessor: _ } = Bb(t, n); + if (n === o) + return ct( + e.createObjectDefinePropertyCall( + i, + Iz(e, n.name), + e.createPropertyDescriptor({ + enumerable: e.createFalse(), + configurable: !0, + get: c && ct( + Cn( + e.createFunctionExpression( + Tb(c), + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + c.parameters, + /*type*/ + void 0, + c.body + // TODO: GH#18217 + ), + c + ), + c + ), + set: _ && ct( + Cn( + e.createFunctionExpression( + Tb(_), + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + _.parameters, + /*type*/ + void 0, + _.body + // TODO: GH#18217 + ), + _ + ), + _ + ) + }, !s) + ), + o + ); + } + function vLe(e, t, n) { + return Cn( + ct( + e.createAssignment( + FS( + e, + n, + t.name, + /*location*/ + t.name + ), + t.initializer + ), + t + ), + t + ); + } + function bLe(e, t, n) { + return Cn( + ct( + e.createAssignment( + FS( + e, + n, + t.name, + /*location*/ + t.name + ), + e.cloneNode(t.name) + ), + /*location*/ + t + ), + /*original*/ + t + ); + } + function SLe(e, t, n) { + return Cn( + ct( + e.createAssignment( + FS( + e, + n, + t.name, + /*location*/ + t.name + ), + Cn( + ct( + e.createFunctionExpression( + Tb(t), + t.asteriskToken, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + t.parameters, + /*type*/ + void 0, + t.body + // TODO: GH#18217 + ), + /*location*/ + t + ), + /*original*/ + t + ) + ), + /*location*/ + t + ), + /*original*/ + t + ); + } + function sre(e, t, n, i) { + switch (n.name && Ai(n.name) && E.failBadSyntaxKind(n.name, "Private identifiers are not allowed in object literals."), n.kind) { + case 178: + case 179: + return yLe(e, t.properties, n, i, !!t.multiLine); + case 304: + return vLe(e, n, i); + case 305: + return bLe(e, n, i); + case 175: + return SLe(e, n, i); + } + } + function RF(e, t, n, i, s) { + const o = t.operator; + E.assert(o === 46 || o === 47, "Expected 'node' to be a pre- or post-increment or pre- or post-decrement expression"); + const c = e.createTempVariable(i); + n = e.createAssignment(c, n), ct(n, t.operand); + let _ = iv(t) ? e.createPrefixUnaryExpression(o, c) : e.createPostfixUnaryExpression(c, o); + return ct(_, t), s && (_ = e.createAssignment(s, _), ct(_, t)), n = e.createComma(n, _), ct(n, t), gz(t) && (n = e.createComma(n, c), ct(n, t)), n; + } + function Fz(e) { + return (Ea(e) & 65536) !== 0; + } + function Nh(e) { + return (Ea(e) & 32768) !== 0; + } + function jF(e) { + return (Ea(e) & 16384) !== 0; + } + function N0e(e) { + return ca(e.expression) && e.expression.text === "use strict"; + } + function Oz(e) { + for (const t of e) + if (cm(t)) { + if (N0e(t)) + return t; + } else + break; + } + function are(e) { + const t = Yc(e); + return t !== void 0 && cm(t) && N0e(t); + } + function qN(e) { + return e.kind === 227 && e.operatorToken.kind === 28; + } + function B4(e) { + return qN(e) || I4(e); + } + function Kb(e) { + return o_(e) && an(e) && !!z1(e); + } + function x6(e) { + const t = f0(e); + return E.assertIsDefined(t), t; + } + function BF(e, t = 63) { + switch (e.kind) { + case 218: + return t & -2147483648 && Kb(e) ? !1 : (t & 1) !== 0; + case 217: + case 235: + return (t & 2) !== 0; + case 239: + return (t & 34) !== 0; + case 234: + return (t & 16) !== 0; + case 236: + return (t & 4) !== 0; + case 356: + return (t & 8) !== 0; + } + return !1; + } + function hc(e, t = 63) { + for (; BF(e, t); ) + e = e.expression; + return e; + } + function ore(e, t = 63) { + let n = e.parent; + for (; BF(n, t); ) + n = n.parent, E.assert(n); + return n; + } + function Au(e) { + return hF( + e, + /*newLine*/ + !0 + ); + } + function HN(e) { + const t = Vo(e, Di), n = t && t.emitNode; + return n && n.externalHelpersModuleName; + } + function cre(e) { + const t = Vo(e, Di), n = t && t.emitNode; + return !!n && (!!n.externalHelpersModuleName || !!n.externalHelpers); + } + function Lz(e, t, n, i, s, o, c) { + if (i.importHelpers && RC(n, i)) { + const _ = Hu(i), u = zS(n, i), g = TLe(n); + if (u !== 1 && (_ >= 5 && _ <= 99 || u === 99 || u === void 0 && _ === 200)) { + if (g) { + const m = []; + for (const h of g) { + const S = h.importName; + S && tp(m, S); + } + if (ot(m)) { + m.sort(_u); + const h = e.createNamedImports( + hr(m, (D) => W7(n, D) ? e.createImportSpecifier( + /*isTypeOnly*/ + !1, + /*propertyName*/ + void 0, + e.createIdentifier(D) + ) : e.createImportSpecifier( + /*isTypeOnly*/ + !1, + e.createIdentifier(D), + t.getUnscopedHelperName(D) + )) + ), S = Vo(n, Di), T = mu(S); + T.externalHelpers = !0; + const k = e.createImportDeclaration( + /*modifiers*/ + void 0, + e.createImportClause( + /*phaseModifier*/ + void 0, + /*name*/ + void 0, + h + ), + e.createStringLiteral(Py), + /*attributes*/ + void 0 + ); + return bS( + k, + 2 + /* NeverApplyImportHelper */ + ), k; + } + } + } else { + const m = xLe(e, n, i, g, s, o || c); + if (m) { + const h = e.createImportEqualsDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + m, + e.createExternalModuleReference(e.createStringLiteral(Py)) + ); + return bS( + h, + 2 + /* NeverApplyImportHelper */ + ), h; + } + } + } + } + function TLe(e) { + return kn(sz(e), (t) => !t.scoped); + } + function xLe(e, t, n, i, s, o) { + const c = HN(t); + if (c) + return c; + if (ot(i) || (s || mm(n) && o) && uw(t, n) < 4) { + const u = Vo(t, Di), g = mu(u); + return g.externalHelpersModuleName || (g.externalHelpersModuleName = e.createUniqueName(Py)); + } + } + function k6(e, t, n) { + const i = qC(t); + if (i && !fS(t) && !V7(t)) { + const s = i.name; + return s.kind === 11 ? e.getGeneratedNameForNode(t) : Bo(s) ? s : e.createIdentifier(Db(n, s) || An(s)); + } + if (t.kind === 273 && t.importClause || t.kind === 279 && t.moduleSpecifier) + return e.getGeneratedNameForNode(t); + } + function Zx(e, t, n, i, s, o) { + const c = hx(t); + if (c && ca(c)) + return CLe(t, i, e, s, o) || kLe(e, c, n) || e.cloneNode(c); + } + function kLe(e, t, n) { + const i = n.renamedDependencies && n.renamedDependencies.get(t.text); + return i ? e.createStringLiteral(i) : void 0; + } + function GN(e, t, n, i) { + if (t) { + if (t.moduleName) + return e.createStringLiteral(t.moduleName); + if (!t.isDeclarationFile && i.outFile) + return e.createStringLiteral(QB(n, t.fileName)); + } + } + function CLe(e, t, n, i, s) { + return GN(n, i.getExternalModuleFileFromDeclaration(e), t, s); + } + function $N(e) { + if (c3(e)) + return e.initializer; + if (rl(e)) { + const t = e.initializer; + return Nl( + t, + /*excludeCompoundAssignment*/ + !0 + ) ? t.right : void 0; + } + if (gu(e)) + return e.objectAssignmentInitializer; + if (Nl( + e, + /*excludeCompoundAssignment*/ + !0 + )) + return e.right; + if (dp(e)) + return $N(e.expression); + } + function $y(e) { + if (c3(e)) + return e.name; + if (vh(e)) { + switch (e.kind) { + case 304: + return $y(e.initializer); + case 305: + return e.name; + case 306: + return $y(e.expression); + } + return; + } + return Nl( + e, + /*excludeCompoundAssignment*/ + !0 + ) ? $y(e.left) : dp(e) ? $y(e.expression) : e; + } + function JF(e) { + switch (e.kind) { + case 170: + case 209: + return e.dotDotDotToken; + case 231: + case 306: + return e; + } + } + function Mz(e) { + const t = zF(e); + return E.assert(!!t || Vg(e), "Invalid property name for binding element."), t; + } + function zF(e) { + switch (e.kind) { + case 209: + if (e.propertyName) { + const n = e.propertyName; + return Ai(n) ? E.failBadSyntaxKind(n) : Gs(n) && A0e(n.expression) ? n.expression : n; + } + break; + case 304: + if (e.name) { + const n = e.name; + return Ai(n) ? E.failBadSyntaxKind(n) : Gs(n) && A0e(n.expression) ? n.expression : n; + } + break; + case 306: + return e.name && Ai(e.name) ? E.failBadSyntaxKind(e.name) : e.name; + } + const t = $y(e); + if (t && qc(t)) + return t; + } + function A0e(e) { + const t = e.kind; + return t === 11 || t === 9; + } + function C6(e) { + switch (e.kind) { + case 207: + case 208: + case 210: + return e.elements; + case 211: + return e.properties; + } + } + function Rz(e) { + if (e) { + let t = e; + for (; ; ) { + if (Me(t) || !t.body) + return Me(t) ? t : t.name; + t = t.body; + } + } + } + function I0e(e) { + const t = e.kind; + return t === 177 || t === 179; + } + function lre(e) { + const t = e.kind; + return t === 177 || t === 178 || t === 179; + } + function jz(e) { + const t = e.kind; + return t === 304 || t === 305 || t === 263 || t === 177 || t === 182 || t === 176 || t === 283 || t === 244 || t === 265 || t === 266 || t === 267 || t === 268 || t === 272 || t === 273 || t === 271 || t === 279 || t === 278; + } + function ure(e) { + const t = e.kind; + return t === 176 || t === 304 || t === 305 || t === 283 || t === 271; + } + function _re(e) { + return Vy(e) || RN(e); + } + function fre(e) { + return Me(e) || A4(e); + } + function pre(e) { + return Fte(e) || _z(e) || fz(e); + } + function dre(e) { + return Vy(e) || _z(e) || fz(e); + } + function mre(e) { + return Me(e) || ca(e); + } + function ELe(e) { + return e === 43; + } + function DLe(e) { + return e === 42 || e === 44 || e === 45; + } + function wLe(e) { + return ELe(e) || DLe(e); + } + function PLe(e) { + return e === 40 || e === 41; + } + function NLe(e) { + return PLe(e) || wLe(e); + } + function ALe(e) { + return e === 48 || e === 49 || e === 50; + } + function Bz(e) { + return ALe(e) || NLe(e); + } + function ILe(e) { + return e === 30 || e === 33 || e === 32 || e === 34 || e === 104 || e === 103; + } + function FLe(e) { + return ILe(e) || Bz(e); + } + function OLe(e) { + return e === 35 || e === 37 || e === 36 || e === 38; + } + function LLe(e) { + return OLe(e) || FLe(e); + } + function MLe(e) { + return e === 51 || e === 52 || e === 53; + } + function RLe(e) { + return MLe(e) || LLe(e); + } + function jLe(e) { + return e === 56 || e === 57; + } + function BLe(e) { + return jLe(e) || RLe(e); + } + function JLe(e) { + return e === 61 || BLe(e) || kh(e); + } + function zLe(e) { + return JLe(e) || e === 28; + } + function gre(e) { + return zLe(e.kind); + } + var Jz; + ((e) => { + function t(m, h, S, T, k, D, P) { + const A = h > 0 ? k[h - 1] : void 0; + return E.assertEqual(S[h], t), k[h] = m.onEnter(T[h], A, P), S[h] = _(m, t), h; + } + e.enter = t; + function n(m, h, S, T, k, D, P) { + E.assertEqual(S[h], n), E.assertIsDefined(m.onLeft), S[h] = _(m, n); + const A = m.onLeft(T[h].left, k[h], T[h]); + return A ? (g(h, T, A), u(h, S, T, k, A)) : h; + } + e.left = n; + function i(m, h, S, T, k, D, P) { + return E.assertEqual(S[h], i), E.assertIsDefined(m.onOperator), S[h] = _(m, i), m.onOperator(T[h].operatorToken, k[h], T[h]), h; + } + e.operator = i; + function s(m, h, S, T, k, D, P) { + E.assertEqual(S[h], s), E.assertIsDefined(m.onRight), S[h] = _(m, s); + const A = m.onRight(T[h].right, k[h], T[h]); + return A ? (g(h, T, A), u(h, S, T, k, A)) : h; + } + e.right = s; + function o(m, h, S, T, k, D, P) { + E.assertEqual(S[h], o), S[h] = _(m, o); + const A = m.onExit(T[h], k[h]); + if (h > 0) { + if (h--, m.foldState) { + const O = S[h] === o ? "right" : "left"; + k[h] = m.foldState(k[h], A, O); + } + } else + D.value = A; + return h; + } + e.exit = o; + function c(m, h, S, T, k, D, P) { + return E.assertEqual(S[h], c), h; + } + e.done = c; + function _(m, h) { + switch (h) { + case t: + if (m.onLeft) return n; + // falls through + case n: + if (m.onOperator) return i; + // falls through + case i: + if (m.onRight) return s; + // falls through + case s: + return o; + case o: + return c; + case c: + return c; + default: + E.fail("Invalid state"); + } + } + e.nextState = _; + function u(m, h, S, T, k) { + return m++, h[m] = t, S[m] = k, T[m] = void 0, m; + } + function g(m, h, S) { + if (E.shouldAssert( + 2 + /* Aggressive */ + )) + for (; m >= 0; ) + E.assert(h[m] !== S, "Circular traversal detected."), m--; + } + })(Jz || (Jz = {})); + var WLe = class { + constructor(e, t, n, i, s, o) { + this.onEnter = e, this.onLeft = t, this.onOperator = n, this.onRight = i, this.onExit = s, this.foldState = o; + } + }; + function WF(e, t, n, i, s, o) { + const c = new WLe(e, t, n, i, s, o); + return _; + function _(u, g) { + const m = { value: void 0 }, h = [Jz.enter], S = [u], T = [void 0]; + let k = 0; + for (; h[k] !== Jz.done; ) + k = h[k](c, k, h, S, T, m, g); + return E.assertEqual(k, 0), m.value; + } + } + function ULe(e) { + return e === 95 || e === 90; + } + function XN(e) { + const t = e.kind; + return ULe(t); + } + function hre(e, t) { + if (t !== void 0) + return t.length === 0 ? t : ct(e.createNodeArray([], t.hasTrailingComma), t); + } + function QN(e) { + var t; + const n = e.emitNode.autoGenerate; + if (n.flags & 4) { + const i = n.id; + let s = e, o = s.original; + for (; o; ) { + s = o; + const c = (t = s.emitNode) == null ? void 0 : t.autoGenerate; + if (wg(s) && (c === void 0 || c.flags & 4 && c.id !== i)) + break; + o = s.original; + } + return s; + } + return e; + } + function E6(e, t) { + return typeof e == "object" ? _v( + /*privateName*/ + !1, + e.prefix, + e.node, + e.suffix, + t + ) : typeof e == "string" ? e.length > 0 && e.charCodeAt(0) === 35 ? e.slice(1) : e : ""; + } + function VLe(e, t) { + return typeof e == "string" ? e : qLe(e, E.checkDefined(t)); + } + function qLe(e, t) { + return tS(e) ? t(e).slice(1) : Bo(e) ? t(e) : Ai(e) ? e.escapedText.slice(1) : An(e); + } + function _v(e, t, n, i, s) { + return t = E6(t, s), i = E6(i, s), n = VLe(n, s), `${e ? "#" : ""}${t}${n}${i}`; + } + function zz(e, t, n, i) { + return e.updatePropertyDeclaration( + t, + n, + e.getGeneratedPrivateNameForNode( + t.name, + /*prefix*/ + void 0, + "_accessor_storage" + ), + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + i + ); + } + function yre(e, t, n, i, s = e.createThis()) { + return e.createGetAccessorDeclaration( + n, + i, + [], + /*type*/ + void 0, + e.createBlock([ + e.createReturnStatement( + e.createPropertyAccessExpression( + s, + e.getGeneratedPrivateNameForNode( + t.name, + /*prefix*/ + void 0, + "_accessor_storage" + ) + ) + ) + ]) + ); + } + function vre(e, t, n, i, s = e.createThis()) { + return e.createSetAccessorDeclaration( + n, + i, + [e.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "value" + )], + e.createBlock([ + e.createExpressionStatement( + e.createAssignment( + e.createPropertyAccessExpression( + s, + e.getGeneratedPrivateNameForNode( + t.name, + /*prefix*/ + void 0, + "_accessor_storage" + ) + ), + e.createIdentifier("value") + ) + ) + ]) + ); + } + function UF(e) { + let t = e.expression; + for (; ; ) { + if (t = hc(t), I4(t)) { + t = pa(t.elements); + continue; + } + if (qN(t)) { + t = t.right; + continue; + } + if (Nl( + t, + /*excludeCompoundAssignment*/ + !0 + ) && Bo(t.left)) + return t; + break; + } + } + function HLe(e) { + return o_(e) && lo(e) && !e.emitNode; + } + function VF(e, t) { + if (HLe(e)) + VF(e.expression, t); + else if (qN(e)) + VF(e.left, t), VF(e.right, t); + else if (I4(e)) + for (const n of e.elements) + VF(n, t); + else + t.push(e); + } + function bre(e) { + const t = []; + return VF(e, t), t; + } + function YN(e) { + if (e.transformFlags & 65536) return !0; + if (e.transformFlags & 128) + for (const t of C6(e)) { + const n = $y(t); + if (n && wD(n) && (n.transformFlags & 65536 || n.transformFlags & 128 && YN(n))) + return !0; + } + return !1; + } + function ct(e, t) { + return t ? Ad(e, t.pos, t.end) : e; + } + function Vp(e) { + const t = e.kind; + return t === 169 || t === 170 || t === 172 || t === 173 || t === 174 || t === 175 || t === 177 || t === 178 || t === 179 || t === 182 || t === 186 || t === 219 || t === 220 || t === 232 || t === 244 || t === 263 || t === 264 || t === 265 || t === 266 || t === 267 || t === 268 || t === 272 || t === 273 || t === 278 || t === 279; + } + function e2(e) { + const t = e.kind; + return t === 170 || t === 173 || t === 175 || t === 178 || t === 179 || t === 232 || t === 264; + } + var F0e, O0e, L0e, M0e, R0e, Sre = { + createBaseSourceFileNode: (e) => new (R0e || (R0e = tu.getSourceFileConstructor()))(e, -1, -1), + createBaseIdentifierNode: (e) => new (L0e || (L0e = tu.getIdentifierConstructor()))(e, -1, -1), + createBasePrivateIdentifierNode: (e) => new (M0e || (M0e = tu.getPrivateIdentifierConstructor()))(e, -1, -1), + createBaseTokenNode: (e) => new (O0e || (O0e = tu.getTokenConstructor()))(e, -1, -1), + createBaseNode: (e) => new (F0e || (F0e = tu.getNodeConstructor()))(e, -1, -1) + }, fv = NN(1, Sre); + function Qt(e, t) { + return t && e(t); + } + function Ei(e, t, n) { + if (n) { + if (t) + return t(n); + for (const i of n) { + const s = e(i); + if (s) + return s; + } + } + } + function Wz(e, t) { + return e.charCodeAt(t + 1) === 42 && e.charCodeAt(t + 2) === 42 && e.charCodeAt(t + 3) !== 47; + } + function ZN(e) { + return lr(e.statements, GLe) || $Le(e); + } + function GLe(e) { + return Vp(e) && XLe( + e, + 95 + /* ExportKeyword */ + ) || _l(e) && wh(e.moduleReference) || qo(e) || Mo(e) || Bc(e) ? e : void 0; + } + function $Le(e) { + return e.flags & 8388608 ? j0e(e) : void 0; + } + function j0e(e) { + return QLe(e) ? e : xs(e, j0e); + } + function XLe(e, t) { + return ot(e.modifiers, (n) => n.kind === t); + } + function QLe(e) { + return DS(e) && e.keywordToken === 102 && e.name.escapedText === "meta"; + } + var YLe = { + 167: function(t, n, i) { + return Qt(n, t.left) || Qt(n, t.right); + }, + 169: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name) || Qt(n, t.constraint) || Qt(n, t.default) || Qt(n, t.expression); + }, + 305: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name) || Qt(n, t.questionToken) || Qt(n, t.exclamationToken) || Qt(n, t.equalsToken) || Qt(n, t.objectAssignmentInitializer); + }, + 306: function(t, n, i) { + return Qt(n, t.expression); + }, + 170: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.dotDotDotToken) || Qt(n, t.name) || Qt(n, t.questionToken) || Qt(n, t.type) || Qt(n, t.initializer); + }, + 173: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name) || Qt(n, t.questionToken) || Qt(n, t.exclamationToken) || Qt(n, t.type) || Qt(n, t.initializer); + }, + 172: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name) || Qt(n, t.questionToken) || Qt(n, t.type) || Qt(n, t.initializer); + }, + 304: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name) || Qt(n, t.questionToken) || Qt(n, t.exclamationToken) || Qt(n, t.initializer); + }, + 261: function(t, n, i) { + return Qt(n, t.name) || Qt(n, t.exclamationToken) || Qt(n, t.type) || Qt(n, t.initializer); + }, + 209: function(t, n, i) { + return Qt(n, t.dotDotDotToken) || Qt(n, t.propertyName) || Qt(n, t.name) || Qt(n, t.initializer); + }, + 182: function(t, n, i) { + return Ei(n, i, t.modifiers) || Ei(n, i, t.typeParameters) || Ei(n, i, t.parameters) || Qt(n, t.type); + }, + 186: function(t, n, i) { + return Ei(n, i, t.modifiers) || Ei(n, i, t.typeParameters) || Ei(n, i, t.parameters) || Qt(n, t.type); + }, + 185: function(t, n, i) { + return Ei(n, i, t.modifiers) || Ei(n, i, t.typeParameters) || Ei(n, i, t.parameters) || Qt(n, t.type); + }, + 180: B0e, + 181: B0e, + 175: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.asteriskToken) || Qt(n, t.name) || Qt(n, t.questionToken) || Qt(n, t.exclamationToken) || Ei(n, i, t.typeParameters) || Ei(n, i, t.parameters) || Qt(n, t.type) || Qt(n, t.body); + }, + 174: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name) || Qt(n, t.questionToken) || Ei(n, i, t.typeParameters) || Ei(n, i, t.parameters) || Qt(n, t.type); + }, + 177: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name) || Ei(n, i, t.typeParameters) || Ei(n, i, t.parameters) || Qt(n, t.type) || Qt(n, t.body); + }, + 178: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name) || Ei(n, i, t.typeParameters) || Ei(n, i, t.parameters) || Qt(n, t.type) || Qt(n, t.body); + }, + 179: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name) || Ei(n, i, t.typeParameters) || Ei(n, i, t.parameters) || Qt(n, t.type) || Qt(n, t.body); + }, + 263: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.asteriskToken) || Qt(n, t.name) || Ei(n, i, t.typeParameters) || Ei(n, i, t.parameters) || Qt(n, t.type) || Qt(n, t.body); + }, + 219: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.asteriskToken) || Qt(n, t.name) || Ei(n, i, t.typeParameters) || Ei(n, i, t.parameters) || Qt(n, t.type) || Qt(n, t.body); + }, + 220: function(t, n, i) { + return Ei(n, i, t.modifiers) || Ei(n, i, t.typeParameters) || Ei(n, i, t.parameters) || Qt(n, t.type) || Qt(n, t.equalsGreaterThanToken) || Qt(n, t.body); + }, + 176: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.body); + }, + 184: function(t, n, i) { + return Qt(n, t.typeName) || Ei(n, i, t.typeArguments); + }, + 183: function(t, n, i) { + return Qt(n, t.assertsModifier) || Qt(n, t.parameterName) || Qt(n, t.type); + }, + 187: function(t, n, i) { + return Qt(n, t.exprName) || Ei(n, i, t.typeArguments); + }, + 188: function(t, n, i) { + return Ei(n, i, t.members); + }, + 189: function(t, n, i) { + return Qt(n, t.elementType); + }, + 190: function(t, n, i) { + return Ei(n, i, t.elements); + }, + 193: J0e, + 194: J0e, + 195: function(t, n, i) { + return Qt(n, t.checkType) || Qt(n, t.extendsType) || Qt(n, t.trueType) || Qt(n, t.falseType); + }, + 196: function(t, n, i) { + return Qt(n, t.typeParameter); + }, + 206: function(t, n, i) { + return Qt(n, t.argument) || Qt(n, t.attributes) || Qt(n, t.qualifier) || Ei(n, i, t.typeArguments); + }, + 303: function(t, n, i) { + return Qt(n, t.assertClause); + }, + 197: z0e, + 199: z0e, + 200: function(t, n, i) { + return Qt(n, t.objectType) || Qt(n, t.indexType); + }, + 201: function(t, n, i) { + return Qt(n, t.readonlyToken) || Qt(n, t.typeParameter) || Qt(n, t.nameType) || Qt(n, t.questionToken) || Qt(n, t.type) || Ei(n, i, t.members); + }, + 202: function(t, n, i) { + return Qt(n, t.literal); + }, + 203: function(t, n, i) { + return Qt(n, t.dotDotDotToken) || Qt(n, t.name) || Qt(n, t.questionToken) || Qt(n, t.type); + }, + 207: W0e, + 208: W0e, + 210: function(t, n, i) { + return Ei(n, i, t.elements); + }, + 211: function(t, n, i) { + return Ei(n, i, t.properties); + }, + 212: function(t, n, i) { + return Qt(n, t.expression) || Qt(n, t.questionDotToken) || Qt(n, t.name); + }, + 213: function(t, n, i) { + return Qt(n, t.expression) || Qt(n, t.questionDotToken) || Qt(n, t.argumentExpression); + }, + 214: U0e, + 215: U0e, + 216: function(t, n, i) { + return Qt(n, t.tag) || Qt(n, t.questionDotToken) || Ei(n, i, t.typeArguments) || Qt(n, t.template); + }, + 217: function(t, n, i) { + return Qt(n, t.type) || Qt(n, t.expression); + }, + 218: function(t, n, i) { + return Qt(n, t.expression); + }, + 221: function(t, n, i) { + return Qt(n, t.expression); + }, + 222: function(t, n, i) { + return Qt(n, t.expression); + }, + 223: function(t, n, i) { + return Qt(n, t.expression); + }, + 225: function(t, n, i) { + return Qt(n, t.operand); + }, + 230: function(t, n, i) { + return Qt(n, t.asteriskToken) || Qt(n, t.expression); + }, + 224: function(t, n, i) { + return Qt(n, t.expression); + }, + 226: function(t, n, i) { + return Qt(n, t.operand); + }, + 227: function(t, n, i) { + return Qt(n, t.left) || Qt(n, t.operatorToken) || Qt(n, t.right); + }, + 235: function(t, n, i) { + return Qt(n, t.expression) || Qt(n, t.type); + }, + 236: function(t, n, i) { + return Qt(n, t.expression); + }, + 239: function(t, n, i) { + return Qt(n, t.expression) || Qt(n, t.type); + }, + 237: function(t, n, i) { + return Qt(n, t.name); + }, + 228: function(t, n, i) { + return Qt(n, t.condition) || Qt(n, t.questionToken) || Qt(n, t.whenTrue) || Qt(n, t.colonToken) || Qt(n, t.whenFalse); + }, + 231: function(t, n, i) { + return Qt(n, t.expression); + }, + 242: V0e, + 269: V0e, + 308: function(t, n, i) { + return Ei(n, i, t.statements) || Qt(n, t.endOfFileToken); + }, + 244: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.declarationList); + }, + 262: function(t, n, i) { + return Ei(n, i, t.declarations); + }, + 245: function(t, n, i) { + return Qt(n, t.expression); + }, + 246: function(t, n, i) { + return Qt(n, t.expression) || Qt(n, t.thenStatement) || Qt(n, t.elseStatement); + }, + 247: function(t, n, i) { + return Qt(n, t.statement) || Qt(n, t.expression); + }, + 248: function(t, n, i) { + return Qt(n, t.expression) || Qt(n, t.statement); + }, + 249: function(t, n, i) { + return Qt(n, t.initializer) || Qt(n, t.condition) || Qt(n, t.incrementor) || Qt(n, t.statement); + }, + 250: function(t, n, i) { + return Qt(n, t.initializer) || Qt(n, t.expression) || Qt(n, t.statement); + }, + 251: function(t, n, i) { + return Qt(n, t.awaitModifier) || Qt(n, t.initializer) || Qt(n, t.expression) || Qt(n, t.statement); + }, + 252: q0e, + 253: q0e, + 254: function(t, n, i) { + return Qt(n, t.expression); + }, + 255: function(t, n, i) { + return Qt(n, t.expression) || Qt(n, t.statement); + }, + 256: function(t, n, i) { + return Qt(n, t.expression) || Qt(n, t.caseBlock); + }, + 270: function(t, n, i) { + return Ei(n, i, t.clauses); + }, + 297: function(t, n, i) { + return Qt(n, t.expression) || Ei(n, i, t.statements); + }, + 298: function(t, n, i) { + return Ei(n, i, t.statements); + }, + 257: function(t, n, i) { + return Qt(n, t.label) || Qt(n, t.statement); + }, + 258: function(t, n, i) { + return Qt(n, t.expression); + }, + 259: function(t, n, i) { + return Qt(n, t.tryBlock) || Qt(n, t.catchClause) || Qt(n, t.finallyBlock); + }, + 300: function(t, n, i) { + return Qt(n, t.variableDeclaration) || Qt(n, t.block); + }, + 171: function(t, n, i) { + return Qt(n, t.expression); + }, + 264: H0e, + 232: H0e, + 265: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name) || Ei(n, i, t.typeParameters) || Ei(n, i, t.heritageClauses) || Ei(n, i, t.members); + }, + 266: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name) || Ei(n, i, t.typeParameters) || Qt(n, t.type); + }, + 267: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name) || Ei(n, i, t.members); + }, + 307: function(t, n, i) { + return Qt(n, t.name) || Qt(n, t.initializer); + }, + 268: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name) || Qt(n, t.body); + }, + 272: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name) || Qt(n, t.moduleReference); + }, + 273: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.importClause) || Qt(n, t.moduleSpecifier) || Qt(n, t.attributes); + }, + 274: function(t, n, i) { + return Qt(n, t.name) || Qt(n, t.namedBindings); + }, + 301: function(t, n, i) { + return Ei(n, i, t.elements); + }, + 302: function(t, n, i) { + return Qt(n, t.name) || Qt(n, t.value); + }, + 271: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.name); + }, + 275: function(t, n, i) { + return Qt(n, t.name); + }, + 281: function(t, n, i) { + return Qt(n, t.name); + }, + 276: G0e, + 280: G0e, + 279: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.exportClause) || Qt(n, t.moduleSpecifier) || Qt(n, t.attributes); + }, + 277: $0e, + 282: $0e, + 278: function(t, n, i) { + return Ei(n, i, t.modifiers) || Qt(n, t.expression); + }, + 229: function(t, n, i) { + return Qt(n, t.head) || Ei(n, i, t.templateSpans); + }, + 240: function(t, n, i) { + return Qt(n, t.expression) || Qt(n, t.literal); + }, + 204: function(t, n, i) { + return Qt(n, t.head) || Ei(n, i, t.templateSpans); + }, + 205: function(t, n, i) { + return Qt(n, t.type) || Qt(n, t.literal); + }, + 168: function(t, n, i) { + return Qt(n, t.expression); + }, + 299: function(t, n, i) { + return Ei(n, i, t.types); + }, + 234: function(t, n, i) { + return Qt(n, t.expression) || Ei(n, i, t.typeArguments); + }, + 284: function(t, n, i) { + return Qt(n, t.expression); + }, + 283: function(t, n, i) { + return Ei(n, i, t.modifiers); + }, + 357: function(t, n, i) { + return Ei(n, i, t.elements); + }, + 285: function(t, n, i) { + return Qt(n, t.openingElement) || Ei(n, i, t.children) || Qt(n, t.closingElement); + }, + 289: function(t, n, i) { + return Qt(n, t.openingFragment) || Ei(n, i, t.children) || Qt(n, t.closingFragment); + }, + 286: X0e, + 287: X0e, + 293: function(t, n, i) { + return Ei(n, i, t.properties); + }, + 292: function(t, n, i) { + return Qt(n, t.name) || Qt(n, t.initializer); + }, + 294: function(t, n, i) { + return Qt(n, t.expression); + }, + 295: function(t, n, i) { + return Qt(n, t.dotDotDotToken) || Qt(n, t.expression); + }, + 288: function(t, n, i) { + return Qt(n, t.tagName); + }, + 296: function(t, n, i) { + return Qt(n, t.namespace) || Qt(n, t.name); + }, + 191: J4, + 192: J4, + 310: J4, + 316: J4, + 315: J4, + 317: J4, + 319: J4, + 318: function(t, n, i) { + return Ei(n, i, t.parameters) || Qt(n, t.type); + }, + 321: function(t, n, i) { + return (typeof t.comment == "string" ? void 0 : Ei(n, i, t.comment)) || Ei(n, i, t.tags); + }, + 348: function(t, n, i) { + return Qt(n, t.tagName) || Qt(n, t.name) || (typeof t.comment == "string" ? void 0 : Ei(n, i, t.comment)); + }, + 311: function(t, n, i) { + return Qt(n, t.name); + }, + 312: function(t, n, i) { + return Qt(n, t.left) || Qt(n, t.right); + }, + 342: Q0e, + 349: Q0e, + 331: function(t, n, i) { + return Qt(n, t.tagName) || (typeof t.comment == "string" ? void 0 : Ei(n, i, t.comment)); + }, + 330: function(t, n, i) { + return Qt(n, t.tagName) || Qt(n, t.class) || (typeof t.comment == "string" ? void 0 : Ei(n, i, t.comment)); + }, + 329: function(t, n, i) { + return Qt(n, t.tagName) || Qt(n, t.class) || (typeof t.comment == "string" ? void 0 : Ei(n, i, t.comment)); + }, + 346: function(t, n, i) { + return Qt(n, t.tagName) || Qt(n, t.constraint) || Ei(n, i, t.typeParameters) || (typeof t.comment == "string" ? void 0 : Ei(n, i, t.comment)); + }, + 347: function(t, n, i) { + return Qt(n, t.tagName) || (t.typeExpression && t.typeExpression.kind === 310 ? Qt(n, t.typeExpression) || Qt(n, t.fullName) || (typeof t.comment == "string" ? void 0 : Ei(n, i, t.comment)) : Qt(n, t.fullName) || Qt(n, t.typeExpression) || (typeof t.comment == "string" ? void 0 : Ei(n, i, t.comment))); + }, + 339: function(t, n, i) { + return Qt(n, t.tagName) || Qt(n, t.fullName) || Qt(n, t.typeExpression) || (typeof t.comment == "string" ? void 0 : Ei(n, i, t.comment)); + }, + 343: z4, + 345: z4, + 344: z4, + 341: z4, + 351: z4, + 350: z4, + 340: z4, + 324: function(t, n, i) { + return lr(t.typeParameters, n) || lr(t.parameters, n) || Qt(n, t.type); + }, + 325: Tre, + 326: Tre, + 327: Tre, + 323: function(t, n, i) { + return lr(t.jsDocPropertyTags, n); + }, + 328: D6, + 333: D6, + 334: D6, + 335: D6, + 336: D6, + 337: D6, + 332: D6, + 338: D6, + 352: ZLe, + 356: KLe + }; + function B0e(e, t, n) { + return Ei(t, n, e.typeParameters) || Ei(t, n, e.parameters) || Qt(t, e.type); + } + function J0e(e, t, n) { + return Ei(t, n, e.types); + } + function z0e(e, t, n) { + return Qt(t, e.type); + } + function W0e(e, t, n) { + return Ei(t, n, e.elements); + } + function U0e(e, t, n) { + return Qt(t, e.expression) || // TODO: should we separate these branches out? + Qt(t, e.questionDotToken) || Ei(t, n, e.typeArguments) || Ei(t, n, e.arguments); + } + function V0e(e, t, n) { + return Ei(t, n, e.statements); + } + function q0e(e, t, n) { + return Qt(t, e.label); + } + function H0e(e, t, n) { + return Ei(t, n, e.modifiers) || Qt(t, e.name) || Ei(t, n, e.typeParameters) || Ei(t, n, e.heritageClauses) || Ei(t, n, e.members); + } + function G0e(e, t, n) { + return Ei(t, n, e.elements); + } + function $0e(e, t, n) { + return Qt(t, e.propertyName) || Qt(t, e.name); + } + function X0e(e, t, n) { + return Qt(t, e.tagName) || Ei(t, n, e.typeArguments) || Qt(t, e.attributes); + } + function J4(e, t, n) { + return Qt(t, e.type); + } + function Q0e(e, t, n) { + return Qt(t, e.tagName) || (e.isNameFirst ? Qt(t, e.name) || Qt(t, e.typeExpression) : Qt(t, e.typeExpression) || Qt(t, e.name)) || (typeof e.comment == "string" ? void 0 : Ei(t, n, e.comment)); + } + function z4(e, t, n) { + return Qt(t, e.tagName) || Qt(t, e.typeExpression) || (typeof e.comment == "string" ? void 0 : Ei(t, n, e.comment)); + } + function Tre(e, t, n) { + return Qt(t, e.name); + } + function D6(e, t, n) { + return Qt(t, e.tagName) || (typeof e.comment == "string" ? void 0 : Ei(t, n, e.comment)); + } + function ZLe(e, t, n) { + return Qt(t, e.tagName) || Qt(t, e.importClause) || Qt(t, e.moduleSpecifier) || Qt(t, e.attributes) || (typeof e.comment == "string" ? void 0 : Ei(t, n, e.comment)); + } + function KLe(e, t, n) { + return Qt(t, e.expression); + } + function xs(e, t, n) { + if (e === void 0 || e.kind <= 166) + return; + const i = YLe[e.kind]; + return i === void 0 ? void 0 : i(e, t, n); + } + function Kx(e, t, n) { + const i = Y0e(e), s = []; + for (; s.length < i.length; ) + s.push(e); + for (; i.length !== 0; ) { + const o = i.pop(), c = s.pop(); + if (as(o)) { + if (n) { + const _ = n(o, c); + if (_) { + if (_ === "skip") continue; + return _; + } + } + for (let _ = o.length - 1; _ >= 0; --_) + i.push(o[_]), s.push(c); + } else { + const _ = t(o, c); + if (_) { + if (_ === "skip") continue; + return _; + } + if (o.kind >= 167) + for (const u of Y0e(o)) + i.push(u), s.push(o); + } + } + } + function Y0e(e) { + const t = []; + return xs(e, n, n), t; + function n(i) { + t.unshift(i); + } + } + function Z0e(e) { + e.externalModuleIndicator = ZN(e); + } + function ek(e, t, n, i = !1, s) { + var o, c; + (o = on) == null || o.push( + on.Phase.Parse, + "createSourceFile", + { path: e }, + /*separateBeginAndEnd*/ + !0 + ), Ko("beforeParse"); + let _; + const { + languageVersion: u, + setExternalModuleIndicator: g, + impliedNodeFormat: m, + jsDocParsingMode: h + } = typeof n == "object" ? n : { languageVersion: n }; + if (u === 100) + _ = pv.parseSourceFile( + e, + t, + u, + /*syntaxCursor*/ + void 0, + i, + 6, + Ha, + h + ); + else { + const S = m === void 0 ? g : (T) => (T.impliedNodeFormat = m, (g || Z0e)(T)); + _ = pv.parseSourceFile( + e, + t, + u, + /*syntaxCursor*/ + void 0, + i, + s, + S, + h + ); + } + return Ko("afterParse"), rp("Parse", "beforeParse", "afterParse"), (c = on) == null || c.pop(), _; + } + function tk(e, t) { + return pv.parseIsolatedEntityName(e, t); + } + function KN(e, t) { + return pv.parseJsonText(e, t); + } + function fl(e) { + return e.externalModuleIndicator !== void 0; + } + function Uz(e, t, n, i = !1) { + const s = Vz.updateSourceFile(e, t, n, i); + return s.flags |= e.flags & 12582912, s; + } + function xre(e, t, n) { + const i = pv.JSDocParser.parseIsolatedJSDocComment(e, t, n); + return i && i.jsDoc && pv.fixupParentReferences(i.jsDoc), i; + } + function K0e(e, t, n) { + return pv.JSDocParser.parseJSDocTypeExpressionForTests(e, t, n); + } + var pv; + ((e) => { + var t = Dg( + 99, + /*skipTrivia*/ + !0 + ), n = 40960, i, s, o, c, _; + function u(X) { + return Ce++, X; + } + var g = { + createBaseSourceFileNode: (X) => u(new _( + X, + /*pos*/ + 0, + /*end*/ + 0 + )), + createBaseIdentifierNode: (X) => u(new o( + X, + /*pos*/ + 0, + /*end*/ + 0 + )), + createBasePrivateIdentifierNode: (X) => u(new c( + X, + /*pos*/ + 0, + /*end*/ + 0 + )), + createBaseTokenNode: (X) => u(new s( + X, + /*pos*/ + 0, + /*end*/ + 0 + )), + createBaseNode: (X) => u(new i( + X, + /*pos*/ + 0, + /*end*/ + 0 + )) + }, m = NN(11, g), { + createNodeArray: h, + createNumericLiteral: S, + createStringLiteral: T, + createLiteralLikeNode: k, + createIdentifier: D, + createPrivateIdentifier: P, + createToken: A, + createArrayLiteralExpression: O, + createObjectLiteralExpression: F, + createPropertyAccessExpression: R, + createPropertyAccessChain: B, + createElementAccessExpression: U, + createElementAccessChain: $, + createCallExpression: W, + createCallChain: _e, + createNewExpression: K, + createParenthesizedExpression: V, + createBlock: ae, + createVariableStatement: se, + createExpressionStatement: ce, + createIfStatement: fe, + createWhileStatement: he, + createForStatement: q, + createForOfStatement: be, + createVariableDeclaration: je, + createVariableDeclarationList: me + } = m, Z, pe, Te, Fe, Ye, ne, Se, ie, Ne, Ee, Ce, Ve, St, Bt, tr, Nr, st = !0, Wt = !1; + function Jr(X, De, He, bt, Vt = !1, rr, Rn, gn = 0) { + var Gr; + if (rr = Z5(X, rr), rr === 6) { + const ji = Ji(X, De, He, bt, Vt); + return iA( + ji, + (Gr = ji.statements[0]) == null ? void 0 : Gr.expression, + ji.parseDiagnostics, + /*returnValue*/ + !1, + /*jsonConversionNotifier*/ + void 0 + ), ji.referencedFiles = Ge, ji.typeReferenceDirectives = Ge, ji.libReferenceDirectives = Ge, ji.amdDependencies = Ge, ji.hasNoDefaultLib = !1, ji.pragmas = SR, ji; + } + Dt(X, De, He, bt, rr, gn); + const ii = ai(He, Vt, rr, Rn || Z0e, gn); + return Mn(), ii; + } + e.parseSourceFile = Jr; + function ui(X, De) { + Dt( + "", + X, + De, + /*syntaxCursor*/ + void 0, + 1, + 0 + /* ParseAll */ + ), ke(); + const He = et( + /*allowReservedWords*/ + !0 + ), bt = Q() === 1 && !Se.length; + return Mn(), bt ? He : void 0; + } + e.parseIsolatedEntityName = ui; + function Ji(X, De, He = 2, bt, Vt = !1) { + Dt( + X, + De, + He, + bt, + 6, + 0 + /* ParseAll */ + ), pe = Nr, ke(); + const rr = M(); + let Rn, gn; + if (Q() === 1) + Rn = va([], rr, rr), gn = Ec(); + else { + let ji; + for (; Q() !== 1; ) { + let La; + switch (Q()) { + case 23: + La = d1(); + break; + case 112: + case 97: + case 106: + La = Ec(); + break; + case 41: + kt( + () => ke() === 9 && ke() !== 59 + /* ColonToken */ + ) ? La = z0() : La = V0(); + break; + case 9: + case 11: + if (kt( + () => ke() !== 59 + /* ColonToken */ + )) { + La = xt(); + break; + } + // falls through + default: + La = V0(); + break; + } + ji && as(ji) ? ji.push(La) : ji ? ji = [ji, La] : (ji = La, Q() !== 1 && Lt(p.Unexpected_token)); + } + const fo = as(ji) ? zt(O(ji), rr) : E.checkDefined(ji), Ka = ce(fo); + zt(Ka, rr), Rn = va([Ka], rr), gn = Co(1, p.Unexpected_token); + } + const Gr = ft( + X, + 2, + 6, + /*isDeclarationFile*/ + !1, + Rn, + gn, + pe, + Ha + ); + Vt && Je(Gr), Gr.nodeCount = Ce, Gr.identifierCount = St, Gr.identifiers = Ve, Gr.parseDiagnostics = Px(Se, Gr), ie && (Gr.jsDocDiagnostics = Px(ie, Gr)); + const ii = Gr; + return Mn(), ii; + } + e.parseJsonText = Ji; + function Dt(X, De, He, bt, Vt, rr) { + switch (i = tu.getNodeConstructor(), s = tu.getTokenConstructor(), o = tu.getIdentifierConstructor(), c = tu.getPrivateIdentifierConstructor(), _ = tu.getSourceFileConstructor(), Z = Hs(X), Te = De, Fe = He, Ne = bt, Ye = Vt, ne = fN(Vt), Se = [], Bt = 0, Ve = /* @__PURE__ */ new Map(), St = 0, Ce = 0, pe = 0, st = !0, Ye) { + case 1: + case 2: + Nr = 524288; + break; + case 6: + Nr = 134742016; + break; + default: + Nr = 0; + break; + } + Wt = !1, t.setText(Te), t.setOnError(ue), t.setScriptTarget(Fe), t.setLanguageVariant(ne), t.setScriptKind(Ye), t.setJSDocParsingMode(rr); + } + function Mn() { + t.clearCommentDirectives(), t.setText(""), t.setOnError(void 0), t.setScriptKind( + 0 + /* Unknown */ + ), t.setJSDocParsingMode( + 0 + /* ParseAll */ + ), Te = void 0, Fe = void 0, Ne = void 0, Ye = void 0, ne = void 0, pe = 0, Se = void 0, ie = void 0, Bt = 0, Ve = void 0, tr = void 0, st = !0; + } + function ai(X, De, He, bt, Vt) { + const rr = Il(Z); + rr && (Nr |= 33554432), pe = Nr, ke(); + const Rn = ma(0, V_); + E.assert( + Q() === 1 + /* EndOfFileToken */ + ); + const gn = ye(), Gr = pn(Ec(), gn), ii = ft(Z, X, He, rr, Rn, Gr, pe, bt); + return qz(ii, Te), Hz(ii, ji), ii.commentDirectives = t.getCommentDirectives(), ii.nodeCount = Ce, ii.identifierCount = St, ii.identifiers = Ve, ii.parseDiagnostics = Px(Se, ii), ii.jsDocParsingMode = Vt, ie && (ii.jsDocDiagnostics = Px(ie, ii)), De && Je(ii), ii; + function ji(fo, Ka, La) { + Se.push(wx(Z, Te, fo, Ka, La)); + } + } + let fi = !1; + function pn(X, De) { + if (!De) + return X; + E.assert(!X.jsDoc); + const He = Fi(bB(X, Te), (bt) => Lm.parseJSDocComment(X, bt.pos, bt.end - bt.pos)); + return He.length && (X.jsDoc = He), fi && (fi = !1, X.flags |= 536870912), X; + } + function _i(X) { + const De = Ne, He = Vz.createSyntaxCursor(X); + Ne = { currentNode: ji }; + const bt = [], Vt = Se; + Se = []; + let rr = 0, Rn = Gr(X.statements, 0); + for (; Rn !== -1; ) { + const fo = X.statements[rr], Ka = X.statements[Rn]; + In(bt, X.statements, rr, Rn), rr = ii(X.statements, Rn); + const La = oc(Vt, (Gf) => Gf.start >= fo.pos), Tp = La >= 0 ? oc(Vt, (Gf) => Gf.start >= Ka.pos, La) : -1; + La >= 0 && In(Se, Vt, La, Tp >= 0 ? Tp : void 0), nr( + () => { + const Gf = Nr; + for (Nr |= 65536, t.resetTokenState(Ka.pos), ke(); Q() !== 1; ) { + const X0 = t.getTokenFullStart(), Q0 = il(0, V_); + if (bt.push(Q0), X0 === t.getTokenFullStart() && ke(), rr >= 0) { + const rh = X.statements[rr]; + if (Q0.end === rh.pos) + break; + Q0.end > rh.pos && (rr = ii(X.statements, rr + 1)); + } + } + Nr = Gf; + }, + 2 + /* Reparse */ + ), Rn = rr >= 0 ? Gr(X.statements, rr) : -1; + } + if (rr >= 0) { + const fo = X.statements[rr]; + In(bt, X.statements, rr); + const Ka = oc(Vt, (La) => La.start >= fo.pos); + Ka >= 0 && In(Se, Vt, Ka); + } + return Ne = De, m.updateSourceFile(X, ct(h(bt), X.statements)); + function gn(fo) { + return !(fo.flags & 65536) && !!(fo.transformFlags & 67108864); + } + function Gr(fo, Ka) { + for (let La = Ka; La < fo.length; La++) + if (gn(fo[La])) + return La; + return -1; + } + function ii(fo, Ka) { + for (let La = Ka; La < fo.length; La++) + if (!gn(fo[La])) + return La; + return -1; + } + function ji(fo) { + const Ka = He.currentNode(fo); + return st && Ka && gn(Ka) && kre(Ka), Ka; + } + } + function Je(X) { + ev( + X, + /*incremental*/ + !0 + ); + } + e.fixupParentReferences = Je; + function ft(X, De, He, bt, Vt, rr, Rn, gn) { + let Gr = m.createSourceFile(Vt, rr, Rn); + if (JJ(Gr, 0, Te.length), ii(Gr), !bt && fl(Gr) && Gr.transformFlags & 67108864) { + const ji = Gr; + Gr = _i(Gr), ji !== Gr && ii(Gr); + } + return Gr; + function ii(ji) { + ji.text = Te, ji.bindDiagnostics = [], ji.bindSuggestionDiagnostics = void 0, ji.languageVersion = De, ji.fileName = X, ji.languageVariant = fN(He), ji.isDeclarationFile = bt, ji.scriptKind = He, gn(ji), ji.setExternalModuleIndicator = gn; + } + } + function er(X, De) { + X ? Nr |= De : Nr &= ~De; + } + function qr(X) { + er( + X, + 8192 + /* DisallowInContext */ + ); + } + function Jn(X) { + er( + X, + 16384 + /* YieldContext */ + ); + } + function Un(X) { + er( + X, + 32768 + /* DecoratorContext */ + ); + } + function ki(X) { + er( + X, + 65536 + /* AwaitContext */ + ); + } + function Ds(X, De) { + const He = X & Nr; + if (He) { + er( + /*val*/ + !1, + He + ); + const bt = De(); + return er( + /*val*/ + !0, + He + ), bt; + } + return De(); + } + function Ks(X, De) { + const He = X & ~Nr; + if (He) { + er( + /*val*/ + !0, + He + ); + const bt = De(); + return er( + /*val*/ + !1, + He + ), bt; + } + return De(); + } + function yr(X) { + return Ds(8192, X); + } + function bs(X) { + return Ks(8192, X); + } + function Xe(X) { + return Ds(131072, X); + } + function Et(X) { + return Ks(131072, X); + } + function re(X) { + return Ks(16384, X); + } + function it(X) { + return Ks(32768, X); + } + function Y(X) { + return Ks(65536, X); + } + function Ae(X) { + return Ds(65536, X); + } + function $e(X) { + return Ks(81920, X); + } + function Ke(X) { + return Ds(81920, X); + } + function Tt(X) { + return (Nr & X) !== 0; + } + function Le() { + return Tt( + 16384 + /* YieldContext */ + ); + } + function mt() { + return Tt( + 8192 + /* DisallowInContext */ + ); + } + function pt() { + return Tt( + 131072 + /* DisallowConditionalTypesContext */ + ); + } + function Ct() { + return Tt( + 32768 + /* DecoratorContext */ + ); + } + function qe() { + return Tt( + 65536 + /* AwaitContext */ + ); + } + function Lt(X, ...De) { + return Pe(t.getTokenStart(), t.getTokenEnd(), X, ...De); + } + function rn(X, De, He, ...bt) { + const Vt = Do(Se); + let rr; + return (!Vt || X !== Vt.start) && (rr = wx(Z, Te, X, De, He, ...bt), Se.push(rr)), Wt = !0, rr; + } + function Pe(X, De, He, ...bt) { + return rn(X, De - X, He, ...bt); + } + function yt(X, De, ...He) { + Pe(X.pos, X.end, De, ...He); + } + function ue(X, De, He) { + rn(t.getTokenEnd(), De, X, He); + } + function M() { + return t.getTokenFullStart(); + } + function ye() { + return t.hasPrecedingJSDocComment(); + } + function Q() { + return Ee; + } + function dt() { + return Ee = t.scan(); + } + function Mt(X) { + return ke(), X(); + } + function ke() { + return k_(Ee) && (t.hasUnicodeEscape() || t.hasExtendedUnicodeEscape()) && Pe(t.getTokenStart(), t.getTokenEnd(), p.Keywords_cannot_contain_escape_characters), dt(); + } + function at() { + return Ee = t.scanJsDocToken(); + } + function wt(X) { + return Ee = t.scanJSDocCommentTextToken(X); + } + function Zr() { + return Ee = t.reScanGreaterToken(); + } + function Rr() { + return Ee = t.reScanSlashToken(); + } + function Pr(X) { + return Ee = t.reScanTemplateToken(X); + } + function rt() { + return Ee = t.reScanLessThanToken(); + } + function vt() { + return Ee = t.reScanHashToken(); + } + function Nt() { + return Ee = t.scanJsxIdentifier(); + } + function Jt() { + return Ee = t.scanJsxToken(); + } + function _r() { + return Ee = t.scanJsxAttributeValue(); + } + function nr(X, De) { + const He = Ee, bt = Se.length, Vt = Wt, rr = Nr, Rn = De !== 0 ? t.lookAhead(X) : t.tryScan(X); + return E.assert(rr === Nr), (!Rn || De !== 0) && (Ee = He, De !== 2 && (Se.length = bt), Wt = Vt), Rn; + } + function kt(X) { + return nr( + X, + 1 + /* Lookahead */ + ); + } + function cr(X) { + return nr( + X, + 0 + /* TryParse */ + ); + } + function fr() { + return Q() === 80 ? !0 : Q() > 118; + } + function vr() { + return Q() === 80 ? !0 : Q() === 127 && Le() || Q() === 135 && qe() ? !1 : Q() > 118; + } + function Xt(X, De, He = !0) { + return Q() === X ? (He && ke(), !0) : (De ? Lt(De) : Lt(p._0_expected, qs(X)), !1); + } + const oi = Object.keys(f7).filter((X) => X.length > 2); + function Fs(X) { + if (nv(X)) { + Pe(oa(Te, X.template.pos), X.template.end, p.Module_declaration_names_may_only_use_or_quoted_strings); + return; + } + const De = Me(X) ? An(X) : void 0; + if (!De || !R_(De, Fe)) { + Lt(p._0_expected, qs( + 27 + /* SemicolonToken */ + )); + return; + } + const He = oa(Te, X.pos); + switch (De) { + case "const": + case "let": + case "var": + Pe(He, X.end, p.Variable_declaration_not_allowed_at_this_location); + return; + case "declare": + return; + case "interface": + Rs( + p.Interface_name_cannot_be_0, + p.Interface_must_be_given_a_name, + 19 + /* OpenBraceToken */ + ); + return; + case "is": + Pe(He, t.getTokenStart(), p.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); + return; + case "module": + case "namespace": + Rs( + p.Namespace_name_cannot_be_0, + p.Namespace_must_be_given_a_name, + 19 + /* OpenBraceToken */ + ); + return; + case "type": + Rs( + p.Type_alias_name_cannot_be_0, + p.Type_alias_must_be_given_a_name, + 64 + /* EqualsToken */ + ); + return; + } + const bt = Sb(De, oi, go) ?? ds(De); + if (bt) { + Pe(He, X.end, p.Unknown_keyword_or_identifier_Did_you_mean_0, bt); + return; + } + Q() !== 0 && Pe(He, X.end, p.Unexpected_keyword_or_identifier); + } + function Rs(X, De, He) { + Q() === He ? Lt(De) : Lt(X, t.getTokenValue()); + } + function ds(X) { + for (const De of oi) + if (X.length > De.length + 2 && Ui(X, De)) + return `${De} ${X.slice(De.length)}`; + } + function pc(X, De, He) { + if (Q() === 60 && !t.hasPrecedingLineBreak()) { + Lt(p.Decorators_must_precede_the_name_and_all_keywords_of_property_declarations); + return; + } + if (Q() === 21) { + Lt(p.Cannot_start_a_function_call_in_a_type_annotation), ke(); + return; + } + if (De && !cs()) { + He ? Lt(p._0_expected, qs( + 27 + /* SemicolonToken */ + )) : Lt(p.Expected_for_property_initializer); + return; + } + if (!Ws()) { + if (He) { + Lt(p._0_expected, qs( + 27 + /* SemicolonToken */ + )); + return; + } + Fs(X); + } + } + function Zo(X) { + return Q() === X ? (at(), !0) : (E.assert(g5(X)), Lt(p._0_expected, qs(X)), !1); + } + function so(X, De, He, bt) { + if (Q() === De) { + ke(); + return; + } + const Vt = Lt(p._0_expected, qs(De)); + He && Vt && zs( + Vt, + wx(Z, Te, bt, 1, p.The_parser_expected_to_find_a_1_to_match_the_0_token_here, qs(X), qs(De)) + ); + } + function zi(X) { + return Q() === X ? (ke(), !0) : !1; + } + function hs(X) { + if (Q() === X) + return Ec(); + } + function Gc(X) { + if (Q() === X) + return zf(); + } + function Co(X, De, He) { + return hs(X) || Za( + X, + /*reportAtCurrentPosition*/ + !1, + De || p._0_expected, + He || qs(X) + ); + } + function ta(X) { + const De = Gc(X); + return De || (E.assert(g5(X)), Za( + X, + /*reportAtCurrentPosition*/ + !1, + p._0_expected, + qs(X) + )); + } + function Ec() { + const X = M(), De = Q(); + return ke(), zt(A(De), X); + } + function zf() { + const X = M(), De = Q(); + return at(), zt(A(De), X); + } + function cs() { + return Q() === 27 ? !0 : Q() === 20 || Q() === 1 || t.hasPrecedingLineBreak(); + } + function Ws() { + return cs() ? (Q() === 27 && ke(), !0) : !1; + } + function Fa() { + return Ws() || Xt( + 27 + /* SemicolonToken */ + ); + } + function va(X, De, He, bt) { + const Vt = h(X, bt); + return Ad(Vt, De, He ?? t.getTokenFullStart()), Vt; + } + function zt(X, De, He) { + return Ad(X, De, He ?? t.getTokenFullStart()), Nr && (X.flags |= Nr), Wt && (Wt = !1, X.flags |= 262144), X; + } + function Za(X, De, He, ...bt) { + De ? rn(t.getTokenFullStart(), 0, He, ...bt) : He && Lt(He, ...bt); + const Vt = M(), rr = X === 80 ? D( + "", + /*originalKeywordKind*/ + void 0 + ) : ky(X) ? m.createTemplateLiteralLikeNode( + X, + "", + "", + /*templateFlags*/ + void 0 + ) : X === 9 ? S( + "", + /*numericLiteralFlags*/ + void 0 + ) : X === 11 ? T( + "", + /*isSingleQuote*/ + void 0 + ) : X === 283 ? m.createMissingDeclaration() : A(X); + return zt(rr, Vt); + } + function yc(X) { + let De = Ve.get(X); + return De === void 0 && Ve.set(X, De = X), De; + } + function Fc(X, De, He) { + if (X) { + St++; + const gn = t.hasPrecedingJSDocLeadingAsterisks() ? t.getTokenStart() : M(), Gr = Q(), ii = yc(t.getTokenValue()), ji = t.hasExtendedUnicodeEscape(); + return dt(), zt(D(ii, Gr, ji), gn); + } + if (Q() === 81) + return Lt(He || p.Private_identifiers_are_not_allowed_outside_class_bodies), Fc( + /*isIdentifier*/ + !0 + ); + if (Q() === 0 && t.tryScan( + () => t.reScanInvalidIdentifier() === 80 + /* Identifier */ + )) + return Fc( + /*isIdentifier*/ + !0 + ); + St++; + const bt = Q() === 1, Vt = t.isReservedWord(), rr = t.getTokenText(), Rn = Vt ? p.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here : p.Identifier_expected; + return Za(80, bt, De || Rn, rr); + } + function Hl(X) { + return Fc( + fr(), + /*diagnosticMessage*/ + void 0, + X + ); + } + function _o(X, De) { + return Fc(vr(), X, De); + } + function ge(X) { + return Fc(v_(Q()), X); + } + function H() { + return (t.hasUnicodeEscape() || t.hasExtendedUnicodeEscape()) && Lt(p.Unicode_escape_sequence_cannot_appear_here), Fc(v_(Q())); + } + function tt() { + return v_(Q()) || Q() === 11 || Q() === 9 || Q() === 10; + } + function Ft() { + return v_(Q()) || Q() === 11; + } + function Kt(X) { + if (Q() === 11 || Q() === 9 || Q() === 10) { + const De = xt(); + return De.text = yc(De.text), De; + } + return Q() === 23 ? Vn() : Q() === 81 ? ln() : ge(); + } + function Hr() { + return Kt(); + } + function Vn() { + const X = M(); + Xt( + 23 + /* OpenBracketToken */ + ); + const De = yr(Yu); + return Xt( + 24 + /* CloseBracketToken */ + ), zt(m.createComputedPropertyName(De), X); + } + function ln() { + const X = M(), De = P(yc(t.getTokenValue())); + return ke(), zt(De, X); + } + function kr(X) { + return Q() === X && cr(Yi); + } + function Li() { + return ke(), t.hasPrecedingLineBreak() ? !1 : $c(); + } + function Yi() { + switch (Q()) { + case 87: + return ke() === 94; + case 95: + return ke(), Q() === 90 ? kt(vo) : Q() === 156 ? kt(ra) : no(); + case 90: + return vo(); + case 126: + return ke(), $c(); + case 139: + case 153: + return ke(), Jc(); + default: + return Li(); + } + } + function no() { + return Q() === 60 || Q() !== 42 && Q() !== 130 && Q() !== 19 && $c(); + } + function ra() { + return ke(), no(); + } + function Eo() { + return Ey(Q()) && cr(Yi); + } + function $c() { + return Q() === 23 || Q() === 19 || Q() === 42 || Q() === 26 || tt(); + } + function Jc() { + return Q() === 23 || tt(); + } + function vo() { + return ke(), Q() === 86 || Q() === 100 || Q() === 120 || Q() === 60 || Q() === 128 && kt(O_) || Q() === 134 && kt(Sp); + } + function ic(X, De) { + if (Po(X)) + return !0; + switch (X) { + case 0: + case 1: + case 3: + return !(Q() === 27 && De) && q0(); + case 2: + return Q() === 84 || Q() === 90; + case 4: + return kt(Qp); + case 5: + return kt(yT) || Q() === 27 && !De; + case 6: + return Q() === 23 || tt(); + case 12: + switch (Q()) { + case 23: + case 42: + case 26: + case 25: + return !0; + default: + return tt(); + } + case 18: + return tt(); + case 9: + return Q() === 23 || Q() === 26 || tt(); + case 24: + return Ft(); + case 7: + return Q() === 19 ? kt(Bd) : De ? vr() && !Ie() : I_() && !Ie(); + case 8: + return Vk(); + case 10: + return Q() === 28 || Q() === 26 || Vk(); + case 19: + return Q() === 103 || Q() === 87 || vr(); + case 15: + switch (Q()) { + case 28: + case 25: + return !0; + } + // falls through + case 11: + return Q() === 26 || vu(); + case 16: + return nt( + /*isJSDocParameter*/ + !1 + ); + case 17: + return nt( + /*isJSDocParameter*/ + !0 + ); + case 20: + case 21: + return Q() === 28 || a1(); + case 22: + return vT(); + case 23: + return Q() === 161 && kt(th) ? !1 : Q() === 11 ? !0 : v_(Q()); + case 13: + return v_(Q()) || Q() === 19; + case 14: + return !0; + case 25: + return !0; + case 26: + return E.fail("ParsingContext.Count used as a context"); + // Not a real context, only a marker. + default: + E.assertNever(X, "Non-exhaustive case in 'isListElement'."); + } + } + function Bd() { + if (E.assert( + Q() === 19 + /* OpenBraceToken */ + ), ke() === 20) { + const X = ke(); + return X === 28 || X === 19 || X === 96 || X === 119; + } + return !0; + } + function au() { + return ke(), vr(); + } + function Ef() { + return ke(), v_(Q()); + } + function P_() { + return ke(), RY(Q()); + } + function Ie() { + return Q() === 119 || Q() === 96 ? kt(Ot) : !1; + } + function Ot() { + return ke(), vu(); + } + function Mr() { + return ke(), a1(); + } + function Gi(X) { + if (Q() === 1) + return !0; + switch (X) { + case 1: + case 2: + case 4: + case 5: + case 6: + case 12: + case 9: + case 23: + case 24: + return Q() === 20; + case 3: + return Q() === 20 || Q() === 84 || Q() === 90; + case 7: + return Q() === 19 || Q() === 96 || Q() === 119; + case 8: + return Da(); + case 19: + return Q() === 32 || Q() === 21 || Q() === 19 || Q() === 96 || Q() === 119; + case 11: + return Q() === 22 || Q() === 27; + case 15: + case 21: + case 10: + return Q() === 24; + case 17: + case 16: + case 18: + return Q() === 22 || Q() === 24; + case 20: + return Q() !== 28; + case 22: + return Q() === 19 || Q() === 20; + case 13: + return Q() === 32 || Q() === 44; + case 14: + return Q() === 30 && kt(HL); + default: + return !1; + } + } + function Da() { + return !!(cs() || Zu(Q()) || Q() === 39); + } + function wa() { + E.assert(Bt, "Missing parsing context"); + for (let X = 0; X < 26; X++) + if (Bt & 1 << X && (ic( + X, + /*inErrorRecovery*/ + !0 + ) || Gi(X))) + return !0; + return !1; + } + function ma(X, De) { + const He = Bt; + Bt |= 1 << X; + const bt = [], Vt = M(); + for (; !Gi(X); ) { + if (ic( + X, + /*inErrorRecovery*/ + !1 + )) { + bt.push(il(X, De)); + continue; + } + if ($g(X)) + break; + } + return Bt = He, va(bt, Vt); + } + function il(X, De) { + const He = Po(X); + return He ? sc(He) : De(); + } + function Po(X, De) { + var He; + if (!Ne || !vc(X) || Wt) + return; + const bt = Ne.currentNode(De ?? t.getTokenFullStart()); + if (!(lc(bt) || tMe(bt) || fx(bt) || (bt.flags & 101441536) !== Nr) && Df(bt, X)) + return H3(bt) && ((He = bt.jsDoc) != null && He.jsDocCache) && (bt.jsDoc.jsDocCache = void 0), bt; + } + function sc(X) { + return t.resetTokenState(X.end), ke(), X; + } + function vc(X) { + switch (X) { + case 5: + case 2: + case 0: + case 1: + case 3: + case 6: + case 4: + case 8: + case 17: + case 16: + return !0; + } + return !1; + } + function Df(X, De) { + switch (De) { + case 5: + return Gl(X); + case 2: + return Ol(X); + case 0: + case 1: + case 3: + return pf(X); + case 6: + return Qu(X); + case 4: + return hp(X); + case 8: + return ig(X); + case 17: + case 16: + return Gg(X); + } + return !1; + } + function Gl(X) { + if (X) + switch (X.kind) { + case 177: + case 182: + case 178: + case 179: + case 173: + case 241: + return !0; + case 175: + const De = X; + return !(De.name.kind === 80 && De.name.escapedText === "constructor"); + } + return !1; + } + function Ol(X) { + if (X) + switch (X.kind) { + case 297: + case 298: + return !0; + } + return !1; + } + function pf(X) { + if (X) + switch (X.kind) { + case 263: + case 244: + case 242: + case 246: + case 245: + case 258: + case 254: + case 256: + case 253: + case 252: + case 250: + case 251: + case 249: + case 248: + case 255: + case 243: + case 259: + case 257: + case 247: + case 260: + case 273: + case 272: + case 279: + case 278: + case 268: + case 264: + case 265: + case 267: + case 266: + return !0; + } + return !1; + } + function Qu(X) { + return X.kind === 307; + } + function hp(X) { + if (X) + switch (X.kind) { + case 181: + case 174: + case 182: + case 172: + case 180: + return !0; + } + return !1; + } + function ig(X) { + return X.kind !== 261 ? !1 : X.initializer === void 0; + } + function Gg(X) { + return X.kind !== 170 ? !1 : X.initializer === void 0; + } + function $g(X) { + return N_(X), wa() ? !0 : (ke(), !1); + } + function N_(X) { + switch (X) { + case 0: + return Q() === 90 ? Lt(p._0_expected, qs( + 95 + /* ExportKeyword */ + )) : Lt(p.Declaration_or_statement_expected); + case 1: + return Lt(p.Declaration_or_statement_expected); + case 2: + return Lt(p.case_or_default_expected); + case 3: + return Lt(p.Statement_expected); + case 18: + // fallthrough + case 4: + return Lt(p.Property_or_signature_expected); + case 5: + return Lt(p.Unexpected_token_A_constructor_method_accessor_or_property_was_expected); + case 6: + return Lt(p.Enum_member_expected); + case 7: + return Lt(p.Expression_expected); + case 8: + return k_(Q()) ? Lt(p._0_is_not_allowed_as_a_variable_declaration_name, qs(Q())) : Lt(p.Variable_declaration_expected); + case 9: + return Lt(p.Property_destructuring_pattern_expected); + case 10: + return Lt(p.Array_element_destructuring_pattern_expected); + case 11: + return Lt(p.Argument_expression_expected); + case 12: + return Lt(p.Property_assignment_expected); + case 15: + return Lt(p.Expression_or_comma_expected); + case 17: + return Lt(p.Parameter_declaration_expected); + case 16: + return k_(Q()) ? Lt(p._0_is_not_allowed_as_a_parameter_name, qs(Q())) : Lt(p.Parameter_declaration_expected); + case 19: + return Lt(p.Type_parameter_declaration_expected); + case 20: + return Lt(p.Type_argument_expected); + case 21: + return Lt(p.Type_expected); + case 22: + return Lt(p.Unexpected_token_expected); + case 23: + return Q() === 161 ? Lt(p._0_expected, "}") : Lt(p.Identifier_expected); + case 13: + return Lt(p.Identifier_expected); + case 14: + return Lt(p.Identifier_expected); + case 24: + return Lt(p.Identifier_or_string_literal_expected); + case 25: + return Lt(p.Identifier_expected); + case 26: + return E.fail("ParsingContext.Count used as a context"); + // Not a real context, only a marker. + default: + E.assertNever(X); + } + } + function Sl(X, De, He) { + const bt = Bt; + Bt |= 1 << X; + const Vt = [], rr = M(); + let Rn = -1; + for (; ; ) { + if (ic( + X, + /*inErrorRecovery*/ + !1 + )) { + const gn = t.getTokenFullStart(), Gr = il(X, De); + if (!Gr) { + Bt = bt; + return; + } + if (Vt.push(Gr), Rn = t.getTokenStart(), zi( + 28 + /* CommaToken */ + )) + continue; + if (Rn = -1, Gi(X)) + break; + Xt(28, Jd(X)), He && Q() === 27 && !t.hasPrecedingLineBreak() && ke(), gn === t.getTokenFullStart() && ke(); + continue; + } + if (Gi(X) || $g(X)) + break; + } + return Bt = bt, va( + Vt, + rr, + /*end*/ + void 0, + Rn >= 0 + ); + } + function Jd(X) { + return X === 6 ? p.An_enum_member_name_must_be_followed_by_a_or : void 0; + } + function Wf() { + const X = va([], M()); + return X.isMissingList = !0, X; + } + function Nm(X) { + return !!X.isMissingList; + } + function ee(X, De, He, bt) { + if (Xt(He)) { + const Vt = Sl(X, De); + return Xt(bt), Vt; + } + return Wf(); + } + function et(X, De) { + const He = M(); + let bt = X ? ge(De) : _o(De); + for (; zi( + 25 + /* DotToken */ + ) && Q() !== 30; ) + bt = zt( + m.createQualifiedName( + bt, + Gt( + X, + /*allowPrivateIdentifiers*/ + !1, + /*allowUnicodeEscapeSequenceInIdentifierName*/ + !0 + ) + ), + He + ); + return bt; + } + function Ut(X, De) { + return zt(m.createQualifiedName(X, De), X.pos); + } + function Gt(X, De, He) { + if (t.hasPrecedingLineBreak() && v_(Q()) && kt(jk)) + return Za( + 80, + /*reportAtCurrentPosition*/ + !0, + p.Identifier_expected + ); + if (Q() === 81) { + const bt = ln(); + return De ? bt : Za( + 80, + /*reportAtCurrentPosition*/ + !0, + p.Identifier_expected + ); + } + return X ? He ? ge() : H() : _o(); + } + function Sr(X) { + const De = M(), He = []; + let bt; + do + bt = Oe(X), He.push(bt); + while (bt.literal.kind === 17); + return va(He, De); + } + function zr(X) { + const De = M(); + return zt( + m.createTemplateExpression( + Tr(X), + Sr(X) + ), + De + ); + } + function jn() { + const X = M(); + return zt( + m.createTemplateLiteralType( + Tr( + /*isTaggedTemplate*/ + !1 + ), + ni() + ), + X + ); + } + function ni() { + const X = M(), De = []; + let He; + do + He = wi(), De.push(He); + while (He.literal.kind === 17); + return va(De, X); + } + function wi() { + const X = M(); + return zt( + m.createTemplateLiteralTypeSpan( + Ro(), + L( + /*isTaggedTemplate*/ + !1 + ) + ), + X + ); + } + function L(X) { + return Q() === 20 ? (Pr(X), $i()) : Co(18, p._0_expected, qs( + 20 + /* CloseBraceToken */ + )); + } + function Oe(X) { + const De = M(); + return zt( + m.createTemplateSpan( + yr(Yu), + L(X) + ), + De + ); + } + function xt() { + return Zi(Q()); + } + function Tr(X) { + !X && t.getTokenFlags() & 26656 && Pr( + /*isTaggedTemplate*/ + !1 + ); + const De = Zi(Q()); + return E.assert(De.kind === 16, "Template head has wrong token kind"), De; + } + function $i() { + const X = Zi(Q()); + return E.assert(X.kind === 17 || X.kind === 18, "Template fragment has wrong token kind"), X; + } + function As(X) { + const De = X === 15 || X === 18, He = t.getTokenText(); + return He.substring(1, He.length - (t.isUnterminated() ? 0 : De ? 1 : 2)); + } + function Zi(X) { + const De = M(), He = ky(X) ? m.createTemplateLiteralLikeNode( + X, + t.getTokenValue(), + As(X), + t.getTokenFlags() & 7176 + /* TemplateLiteralLikeFlags */ + ) : ( + // Note that theoretically the following condition would hold true literals like 009, + // which is not octal. But because of how the scanner separates the tokens, we would + // never get a token like this. Instead, we would get 00 and 9 as two separate tokens. + // We also do not need to check for negatives because any prefix operator would be part of a + // parent unary expression. + X === 9 ? S(t.getTokenValue(), t.getNumericLiteralFlags()) : X === 11 ? T( + t.getTokenValue(), + /*isSingleQuote*/ + void 0, + t.hasExtendedUnicodeEscape() + ) : CD(X) ? k(X, t.getTokenValue()) : E.fail() + ); + return t.hasExtendedUnicodeEscape() && (He.hasExtendedUnicodeEscape = !0), t.isUnterminated() && (He.isUnterminated = !0), ke(), zt(He, De); + } + function ys() { + return et( + /*allowReservedWords*/ + !0, + p.Type_expected + ); + } + function zo() { + if (!t.hasPrecedingLineBreak() && rt() === 30) + return ee( + 20, + Ro, + 30, + 32 + /* GreaterThanToken */ + ); + } + function na() { + const X = M(); + return zt( + m.createTypeReferenceNode( + ys(), + zo() + ), + X + ); + } + function Ll(X) { + switch (X.kind) { + case 184: + return lc(X.typeName); + case 185: + case 186: { + const { parameters: De, type: He } = X; + return Nm(De) || Ll(He); + } + case 197: + return Ll(X.type); + default: + return !1; + } + } + function df(X) { + return ke(), zt(m.createTypePredicateNode( + /*assertsModifier*/ + void 0, + X, + Ro() + ), X.pos); + } + function Uf() { + const X = M(); + return ke(), zt(m.createThisTypeNode(), X); + } + function yp() { + const X = M(); + return ke(), zt(m.createJSDocAllType(), X); + } + function jh() { + const X = M(); + return ke(), zt(m.createJSDocNonNullableType( + g2(), + /*postfix*/ + !1 + ), X); + } + function M0() { + const X = M(); + return ke(), Q() === 28 || Q() === 20 || Q() === 22 || Q() === 32 || Q() === 64 || Q() === 52 ? zt(m.createJSDocUnknownType(), X) : zt(m.createJSDocNullableType( + Ro(), + /*postfix*/ + !1 + ), X); + } + function __() { + const X = M(), De = ye(); + if (cr(Gk)) { + const He = Zn( + 36 + /* JSDoc */ + ), bt = Vr( + 59, + /*isType*/ + !1 + ); + return pn(zt(m.createJSDocFunctionType(He, bt), X), De); + } + return zt(m.createTypeReferenceNode( + ge(), + /*typeArguments*/ + void 0 + ), X); + } + function sg() { + const X = M(); + let De; + return (Q() === 110 || Q() === 105) && (De = ge(), Xt( + 59 + /* ColonToken */ + )), zt( + m.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + // TODO(rbuckton): JSDoc parameters don't have names (except `this`/`new`), should we manufacture an empty identifier? + De, + /*questionToken*/ + void 0, + zd(), + /*initializer*/ + void 0 + ), + X + ); + } + function zd() { + t.setSkipJsDocLeadingAsterisks(!0); + const X = M(); + if (zi( + 144 + /* ModuleKeyword */ + )) { + const bt = m.createJSDocNamepathType( + /*type*/ + void 0 + ); + e: + for (; ; ) + switch (Q()) { + case 20: + case 1: + case 28: + case 5: + break e; + default: + at(); + } + return t.setSkipJsDocLeadingAsterisks(!1), zt(bt, X); + } + const De = zi( + 26 + /* DotDotDotToken */ + ); + let He = Wh(); + return t.setSkipJsDocLeadingAsterisks(!1), De && (He = zt(m.createJSDocVariadicType(He), X)), Q() === 64 ? (ke(), zt(m.createJSDocOptionalType(He), X)) : He; + } + function $p() { + const X = M(); + Xt( + 114 + /* TypeOfKeyword */ + ); + const De = et( + /*allowReservedWords*/ + !0 + ), He = t.hasPrecedingLineBreak() ? void 0 : Ho(); + return zt(m.createTypeQueryNode(De, He), X); + } + function s1() { + const X = M(), De = gi( + /*allowDecorators*/ + !1, + /*permitConstAsModifier*/ + !0 + ), He = _o(); + let bt, Vt; + zi( + 96 + /* ExtendsKeyword */ + ) && (a1() || !vu() ? bt = Ro() : Vt = jv()); + const rr = zi( + 64 + /* EqualsToken */ + ) ? Ro() : void 0, Rn = m.createTypeParameterDeclaration(De, He, bt, rr); + return Rn.expression = Vt, zt(Rn, X); + } + function Be() { + if (Q() === 30) + return ee( + 19, + s1, + 30, + 32 + /* GreaterThanToken */ + ); + } + function nt(X) { + return Q() === 26 || Vk() || Ey(Q()) || Q() === 60 || a1( + /*inStartOfParameter*/ + !X + ); + } + function Rt(X) { + const De = H0(p.Private_identifiers_cannot_be_used_as_parameters); + return h3(De) === 0 && !ot(X) && Ey(Q()) && ke(), De; + } + function pr() { + return fr() || Q() === 23 || Q() === 19; + } + function Or(X) { + return Ir(X); + } + function dn(X) { + return Ir( + X, + /*allowAmbiguity*/ + !1 + ); + } + function Ir(X, De = !0) { + const He = M(), bt = ye(), Vt = X ? Y(() => gi( + /*allowDecorators*/ + !0 + )) : Ae(() => gi( + /*allowDecorators*/ + !0 + )); + if (Q() === 110) { + const Gr = m.createParameterDeclaration( + Vt, + /*dotDotDotToken*/ + void 0, + Fc( + /*isIdentifier*/ + !0 + ), + /*questionToken*/ + void 0, + yu(), + /*initializer*/ + void 0 + ), ii = Yc(Vt); + return ii && yt(ii, p.Neither_decorators_nor_modifiers_may_be_applied_to_this_parameters), pn(zt(Gr, He), bt); + } + const rr = st; + st = !1; + const Rn = hs( + 26 + /* DotDotDotToken */ + ); + if (!De && !pr()) + return; + const gn = pn( + zt( + m.createParameterDeclaration( + Vt, + Rn, + Rt(Vt), + hs( + 58 + /* QuestionToken */ + ), + yu(), + lg() + ), + He + ), + bt + ); + return st = rr, gn; + } + function Vr(X, De) { + if (hi(X, De)) + return Xe(Wh); + } + function hi(X, De) { + return X === 39 ? (Xt(X), !0) : zi( + 59 + /* ColonToken */ + ) ? !0 : De && Q() === 39 ? (Lt(p._0_expected, qs( + 59 + /* ColonToken */ + )), ke(), !0) : !1; + } + function rs(X, De) { + const He = Le(), bt = qe(); + Jn(!!(X & 1)), ki(!!(X & 2)); + const Vt = X & 32 ? Sl(17, sg) : Sl(16, () => De ? Or(bt) : dn(bt)); + return Jn(He), ki(bt), Vt; + } + function Zn(X) { + if (!Xt( + 21 + /* OpenParenToken */ + )) + return Wf(); + const De = rs( + X, + /*allowAmbiguity*/ + !0 + ); + return Xt( + 22 + /* CloseParenToken */ + ), De; + } + function ns() { + zi( + 28 + /* CommaToken */ + ) || Fa(); + } + function Pi(X) { + const De = M(), He = ye(); + X === 181 && Xt( + 105 + /* NewKeyword */ + ); + const bt = Be(), Vt = Zn( + 4 + /* Type */ + ), rr = Vr( + 59, + /*isType*/ + !0 + ); + ns(); + const Rn = X === 180 ? m.createCallSignature(bt, Vt, rr) : m.createConstructSignature(bt, Vt, rr); + return pn(zt(Rn, De), He); + } + function Wo() { + return Q() === 23 && kt(A_); + } + function A_() { + if (ke(), Q() === 26 || Q() === 24) + return !0; + if (Ey(Q())) { + if (ke(), vr()) + return !0; + } else if (vr()) + ke(); + else + return !1; + return Q() === 59 || Q() === 28 ? !0 : Q() !== 58 ? !1 : (ke(), Q() === 59 || Q() === 28 || Q() === 24); + } + function Xp(X, De, He) { + const bt = ee( + 16, + () => Or( + /*inOuterAwaitContext*/ + !1 + ), + 23, + 24 + /* CloseBracketToken */ + ), Vt = yu(); + ns(); + const rr = m.createIndexSignature(He, bt, Vt); + return pn(zt(rr, X), De); + } + function $l(X, De, He) { + const bt = Hr(), Vt = hs( + 58 + /* QuestionToken */ + ); + let rr; + if (Q() === 21 || Q() === 30) { + const Rn = Be(), gn = Zn( + 4 + /* Type */ + ), Gr = Vr( + 59, + /*isType*/ + !0 + ); + rr = m.createMethodSignature(He, bt, Vt, Rn, gn, Gr); + } else { + const Rn = yu(); + rr = m.createPropertySignature(He, bt, Vt, Rn), Q() === 64 && (rr.initializer = lg()); + } + return ns(), pn(zt(rr, X), De); + } + function Qp() { + if (Q() === 21 || Q() === 30 || Q() === 139 || Q() === 153) + return !0; + let X = !1; + for (; Ey(Q()); ) + X = !0, ke(); + return Q() === 23 ? !0 : (tt() && (X = !0, ke()), X ? Q() === 21 || Q() === 30 || Q() === 58 || Q() === 59 || Q() === 28 || cs() : !1); + } + function mf() { + if (Q() === 21 || Q() === 30) + return Pi( + 180 + /* CallSignature */ + ); + if (Q() === 105 && kt(wv)) + return Pi( + 181 + /* ConstructSignature */ + ); + const X = M(), De = ye(), He = gi( + /*allowDecorators*/ + !1 + ); + return kr( + 139 + /* GetKeyword */ + ) ? $v( + X, + De, + He, + 178, + 4 + /* Type */ + ) : kr( + 153 + /* SetKeyword */ + ) ? $v( + X, + De, + He, + 179, + 4 + /* Type */ + ) : Wo() ? Xp(X, De, He) : $l(X, De, He); + } + function wv() { + return ke(), Q() === 21 || Q() === 30; + } + function Am() { + return ke() === 25; + } + function ag() { + switch (ke()) { + case 21: + case 30: + case 25: + return !0; + } + return !1; + } + function Pv() { + const X = M(); + return zt(m.createTypeLiteralNode(og()), X); + } + function og() { + let X; + return Xt( + 19 + /* OpenBraceToken */ + ) ? (X = ma(4, mf), Xt( + 20 + /* CloseBraceToken */ + )) : X = Wf(), X; + } + function pE() { + return ke(), Q() === 40 || Q() === 41 ? ke() === 148 : (Q() === 148 && ke(), Q() === 23 && au() && ke() === 103); + } + function Vw() { + const X = M(), De = ge(); + Xt( + 103 + /* InKeyword */ + ); + const He = Ro(); + return zt(m.createTypeParameterDeclaration( + /*modifiers*/ + void 0, + De, + He, + /*defaultType*/ + void 0 + ), X); + } + function dE() { + const X = M(); + Xt( + 19 + /* OpenBraceToken */ + ); + let De; + (Q() === 148 || Q() === 40 || Q() === 41) && (De = Ec(), De.kind !== 148 && Xt( + 148 + /* ReadonlyKeyword */ + )), Xt( + 23 + /* OpenBracketToken */ + ); + const He = Vw(), bt = zi( + 130 + /* AsKeyword */ + ) ? Ro() : void 0; + Xt( + 24 + /* CloseBracketToken */ + ); + let Vt; + (Q() === 58 || Q() === 40 || Q() === 41) && (Vt = Ec(), Vt.kind !== 58 && Xt( + 58 + /* QuestionToken */ + )); + const rr = yu(); + Fa(); + const Rn = ma(4, mf); + return Xt( + 20 + /* CloseBraceToken */ + ), zt(m.createMappedTypeNode(De, He, bt, Vt, rr, Rn), X); + } + function Xg() { + const X = M(); + if (zi( + 26 + /* DotDotDotToken */ + )) + return zt(m.createRestTypeNode(Ro()), X); + const De = Ro(); + if (v6(De) && De.pos === De.type.pos) { + const He = m.createOptionalTypeNode(De.type); + return ct(He, De), He.flags = De.flags, He; + } + return De; + } + function Nv() { + return ke() === 59 || Q() === 58 && ke() === 59; + } + function YS() { + return Q() === 26 ? v_(ke()) && Nv() : v_(Q()) && Nv(); + } + function R0() { + if (kt(YS)) { + const X = M(), De = ye(), He = hs( + 26 + /* DotDotDotToken */ + ), bt = ge(), Vt = hs( + 58 + /* QuestionToken */ + ); + Xt( + 59 + /* ColonToken */ + ); + const rr = Xg(), Rn = m.createNamedTupleMember(He, bt, Vt, rr); + return pn(zt(Rn, X), De); + } + return Xg(); + } + function ZS() { + const X = M(); + return zt( + m.createTupleTypeNode( + ee( + 21, + R0, + 23, + 24 + /* CloseBracketToken */ + ) + ), + X + ); + } + function Dk() { + const X = M(); + Xt( + 21 + /* OpenParenToken */ + ); + const De = Ro(); + return Xt( + 22 + /* CloseParenToken */ + ), zt(m.createParenthesizedType(De), X); + } + function qw() { + let X; + if (Q() === 128) { + const De = M(); + ke(); + const He = zt(A( + 128 + /* AbstractKeyword */ + ), De); + X = va([He], De); + } + return X; + } + function KS() { + const X = M(), De = ye(), He = qw(), bt = zi( + 105 + /* NewKeyword */ + ); + E.assert(!He || bt, "Per isStartOfFunctionOrConstructorType, a function type cannot have modifiers."); + const Vt = Be(), rr = Zn( + 4 + /* Type */ + ), Rn = Vr( + 39, + /*isType*/ + !1 + ), gn = bt ? m.createConstructorTypeNode(He, Vt, rr, Rn) : m.createFunctionTypeNode(Vt, rr, Rn); + return pn(zt(gn, X), De); + } + function wk() { + const X = Ec(); + return Q() === 25 ? void 0 : X; + } + function Av(X) { + const De = M(); + X && ke(); + let He = Q() === 112 || Q() === 97 || Q() === 106 ? Ec() : Zi(Q()); + return X && (He = zt(m.createPrefixUnaryExpression(41, He), De)), zt(m.createLiteralTypeNode(He), De); + } + function mE() { + return ke(), Q() === 102; + } + function eT() { + pe |= 4194304; + const X = M(), De = zi( + 114 + /* TypeOfKeyword */ + ); + Xt( + 102 + /* ImportKeyword */ + ), Xt( + 21 + /* OpenParenToken */ + ); + const He = Ro(); + let bt; + if (zi( + 28 + /* CommaToken */ + )) { + const Rn = t.getTokenStart(); + Xt( + 19 + /* OpenBraceToken */ + ); + const gn = Q(); + if (gn === 118 || gn === 132 ? ke() : Lt(p._0_expected, qs( + 118 + /* WithKeyword */ + )), Xt( + 59 + /* ColonToken */ + ), bt = b1( + gn, + /*skipKeyword*/ + !0 + ), zi( + 28 + /* CommaToken */ + ), !Xt( + 20 + /* CloseBraceToken */ + )) { + const Gr = Do(Se); + Gr && Gr.code === p._0_expected.code && zs( + Gr, + wx(Z, Te, Rn, 1, p.The_parser_expected_to_find_a_1_to_match_the_0_token_here, "{", "}") + ); + } + } + Xt( + 22 + /* CloseParenToken */ + ); + const Vt = zi( + 25 + /* DotToken */ + ) ? ys() : void 0, rr = zo(); + return zt(m.createImportTypeNode(He, bt, Vt, rr, De), X); + } + function Pk() { + return ke(), Q() === 9 || Q() === 10; + } + function g2() { + switch (Q()) { + case 133: + case 159: + case 154: + case 150: + case 163: + case 155: + case 136: + case 157: + case 146: + case 151: + return cr(wk) || na(); + case 67: + t.reScanAsteriskEqualsToken(); + // falls through + case 42: + return yp(); + case 61: + t.reScanQuestionToken(); + // falls through + case 58: + return M0(); + case 100: + return __(); + case 54: + return jh(); + case 15: + case 11: + case 9: + case 10: + case 112: + case 97: + case 106: + return Av(); + case 41: + return kt(Pk) ? Av( + /*negative*/ + !0 + ) : na(); + case 116: + return Ec(); + case 110: { + const X = Uf(); + return Q() === 142 && !t.hasPrecedingLineBreak() ? df(X) : X; + } + case 114: + return kt(mE) ? eT() : $p(); + case 19: + return kt(pE) ? dE() : Pv(); + case 23: + return ZS(); + case 21: + return Dk(); + case 102: + return eT(); + case 131: + return kt(jk) ? cg() : na(); + case 16: + return jn(); + default: + return na(); + } + } + function a1(X) { + switch (Q()) { + case 133: + case 159: + case 154: + case 150: + case 163: + case 136: + case 148: + case 155: + case 158: + case 116: + case 157: + case 106: + case 110: + case 114: + case 146: + case 19: + case 23: + case 30: + case 52: + case 51: + case 105: + case 11: + case 9: + case 10: + case 112: + case 97: + case 151: + case 42: + case 58: + case 54: + case 26: + case 140: + case 102: + case 131: + case 15: + case 16: + return !0; + case 100: + return !X; + case 41: + return !X && kt(Pk); + case 21: + return !X && kt(Nk); + default: + return vr(); + } + } + function Nk() { + return ke(), Q() === 22 || nt( + /*isJSDocParameter*/ + !1 + ) || a1(); + } + function Ak() { + const X = M(); + let De = g2(); + for (; !t.hasPrecedingLineBreak(); ) + switch (Q()) { + case 54: + ke(), De = zt(m.createJSDocNonNullableType( + De, + /*postfix*/ + !0 + ), X); + break; + case 58: + if (kt(Mr)) + return De; + ke(), De = zt(m.createJSDocNullableType( + De, + /*postfix*/ + !0 + ), X); + break; + case 23: + if (Xt( + 23 + /* OpenBracketToken */ + ), a1()) { + const He = Ro(); + Xt( + 24 + /* CloseBracketToken */ + ), De = zt(m.createIndexedAccessTypeNode(De, He), X); + } else + Xt( + 24 + /* CloseBracketToken */ + ), De = zt(m.createArrayTypeNode(De), X); + break; + default: + return De; + } + return De; + } + function h2(X) { + const De = M(); + return Xt(X), zt(m.createTypeOperatorNode(X, Jh()), De); + } + function o1() { + if (zi( + 96 + /* ExtendsKeyword */ + )) { + const X = Et(Ro); + if (pt() || Q() !== 58) + return X; + } + } + function j0() { + const X = M(), De = _o(), He = cr(o1), bt = m.createTypeParameterDeclaration( + /*modifiers*/ + void 0, + De, + He + ); + return zt(bt, X); + } + function Bh() { + const X = M(); + return Xt( + 140 + /* InferKeyword */ + ), zt(m.createInferTypeNode(j0()), X); + } + function Jh() { + const X = Q(); + switch (X) { + case 143: + case 158: + case 148: + return h2(X); + case 140: + return Bh(); + } + return Xe(Ak); + } + function zh(X) { + if (Aa()) { + const De = KS(); + let He; + return Zm(De) ? He = X ? p.Function_type_notation_must_be_parenthesized_when_used_in_a_union_type : p.Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type : He = X ? p.Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type : p.Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type, yt(De, He), De; + } + } + function c1(X, De, He) { + const bt = M(), Vt = X === 52, rr = zi(X); + let Rn = rr && zh(Vt) || De(); + if (Q() === X || rr) { + const gn = [Rn]; + for (; zi(X); ) + gn.push(zh(Vt) || De()); + Rn = zt(He(va(gn, bt)), bt); + } + return Rn; + } + function Iv() { + return c1(51, Jh, m.createIntersectionTypeNode); + } + function tT() { + return c1(52, Iv, m.createUnionTypeNode); + } + function Fv() { + return ke(), Q() === 105; + } + function Aa() { + return Q() === 30 || Q() === 21 && kt(gE) ? !0 : Q() === 105 || Q() === 128 && kt(Fv); + } + function rT() { + if (Ey(Q()) && gi( + /*allowDecorators*/ + !1 + ), vr() || Q() === 110) + return ke(), !0; + if (Q() === 23 || Q() === 19) { + const X = Se.length; + return H0(), X === Se.length; + } + return !1; + } + function gE() { + return ke(), !!(Q() === 22 || Q() === 26 || rT() && (Q() === 59 || Q() === 28 || Q() === 58 || Q() === 64 || Q() === 22 && (ke(), Q() === 39))); + } + function Wh() { + const X = M(), De = vr() && cr(Uh), He = Ro(); + return De ? zt(m.createTypePredicateNode( + /*assertsModifier*/ + void 0, + De, + He + ), X) : He; + } + function Uh() { + const X = _o(); + if (Q() === 142 && !t.hasPrecedingLineBreak()) + return ke(), X; + } + function cg() { + const X = M(), De = Co( + 131 + /* AssertsKeyword */ + ), He = Q() === 110 ? Uf() : _o(), bt = zi( + 142 + /* IsKeyword */ + ) ? Ro() : void 0; + return zt(m.createTypePredicateNode(De, He, bt), X); + } + function Ro() { + if (Nr & 81920) + return Ds(81920, Ro); + if (Aa()) + return KS(); + const X = M(), De = tT(); + if (!pt() && !t.hasPrecedingLineBreak() && zi( + 96 + /* ExtendsKeyword */ + )) { + const He = Et(Ro); + Xt( + 58 + /* QuestionToken */ + ); + const bt = Xe(Ro); + Xt( + 59 + /* ColonToken */ + ); + const Vt = Xe(Ro); + return zt(m.createConditionalTypeNode(De, He, bt, Vt), X); + } + return De; + } + function yu() { + return zi( + 59 + /* ColonToken */ + ) ? Ro() : void 0; + } + function I_() { + switch (Q()) { + case 110: + case 108: + case 106: + case 112: + case 97: + case 9: + case 10: + case 11: + case 15: + case 16: + case 21: + case 23: + case 19: + case 100: + case 86: + case 105: + case 44: + case 69: + case 80: + return !0; + case 102: + return kt(ag); + default: + return vr(); + } + } + function vu() { + if (I_()) + return !0; + switch (Q()) { + case 40: + case 41: + case 55: + case 54: + case 91: + case 114: + case 116: + case 46: + case 47: + case 30: + case 135: + case 127: + case 81: + case 60: + return !0; + default: + return Zp() ? !0 : vr(); + } + } + function Ov() { + return Q() !== 19 && Q() !== 100 && Q() !== 86 && Q() !== 60 && vu(); + } + function Yu() { + const X = Ct(); + X && Un( + /*val*/ + !1 + ); + const De = M(); + let He = f_( + /*allowReturnTypeInArrowFunction*/ + !0 + ), bt; + for (; bt = hs( + 28 + /* CommaToken */ + ); ) + He = ga(He, bt, f_( + /*allowReturnTypeInArrowFunction*/ + !0 + ), De); + return X && Un( + /*val*/ + !0 + ), He; + } + function lg() { + return zi( + 64 + /* EqualsToken */ + ) ? f_( + /*allowReturnTypeInArrowFunction*/ + !0 + ) : void 0; + } + function f_(X) { + if (Yp()) + return Lv(); + const De = Hw(X) || ze(X); + if (De) + return De; + const He = M(), bt = ye(), Vt = l1( + 0 + /* Lowest */ + ); + return Vt.kind === 80 && Q() === 39 ? Mv( + He, + Vt, + X, + bt, + /*asyncModifier*/ + void 0 + ) : S_(Vt) && kh(Zr()) ? ga(Vt, Ec(), f_(X), He) : J0(Vt, He, X); + } + function Yp() { + return Q() === 127 ? Le() ? !0 : kt(x2) : !1; + } + function pd() { + return ke(), !t.hasPrecedingLineBreak() && vr(); + } + function Lv() { + const X = M(); + return ke(), !t.hasPrecedingLineBreak() && (Q() === 42 || vu()) ? zt( + m.createYieldExpression( + hs( + 42 + /* AsteriskToken */ + ), + f_( + /*allowReturnTypeInArrowFunction*/ + !0 + ) + ), + X + ) : zt(m.createYieldExpression( + /*asteriskToken*/ + void 0, + /*expression*/ + void 0 + ), X); + } + function Mv(X, De, He, bt, Vt) { + E.assert(Q() === 39, "parseSimpleArrowFunctionExpression should only have been called if we had a =>"); + const rr = m.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + De, + /*questionToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + ); + zt(rr, De.pos); + const Rn = va([rr], rr.pos, rr.end), gn = Co( + 39 + /* EqualsGreaterThanToken */ + ), Gr = dd( + /*isAsync*/ + !!Vt, + He + ), ii = m.createArrowFunction( + Vt, + /*typeParameters*/ + void 0, + Rn, + /*type*/ + void 0, + gn, + Gr + ); + return pn(zt(ii, X), bt); + } + function Hw(X) { + const De = hE(); + if (De !== 0) + return De === 1 ? Qg( + /*allowAmbiguity*/ + !0, + /*allowReturnTypeInArrowFunction*/ + !0 + ) : cr(() => y2(X)); + } + function hE() { + return Q() === 21 || Q() === 30 || Q() === 134 ? kt(B0) : Q() === 39 ? 1 : 0; + } + function B0() { + if (Q() === 134 && (ke(), t.hasPrecedingLineBreak() || Q() !== 21 && Q() !== 30)) + return 0; + const X = Q(), De = ke(); + if (X === 21) { + if (De === 22) + switch (ke()) { + case 39: + case 59: + case 19: + return 1; + default: + return 0; + } + if (De === 23 || De === 19) + return 2; + if (De === 26) + return 1; + if (Ey(De) && De !== 134 && kt(au)) + return ke() === 130 ? 0 : 1; + if (!vr() && De !== 110) + return 0; + switch (ke()) { + case 59: + return 1; + case 58: + return ke(), Q() === 59 || Q() === 28 || Q() === 64 || Q() === 22 ? 1 : 0; + case 28: + case 64: + case 22: + return 2; + } + return 0; + } else + return E.assert( + X === 30 + /* LessThanToken */ + ), !vr() && Q() !== 87 ? 0 : ne === 1 ? kt(() => { + zi( + 87 + /* ConstKeyword */ + ); + const bt = ke(); + if (bt === 96) + switch (ke()) { + case 64: + case 32: + case 44: + return !1; + default: + return !0; + } + else if (bt === 28 || bt === 64) + return !0; + return !1; + }) ? 1 : 0 : 2; + } + function y2(X) { + const De = t.getTokenStart(); + if (tr?.has(De)) + return; + const He = Qg( + /*allowAmbiguity*/ + !1, + X + ); + return He || (tr || (tr = /* @__PURE__ */ new Set())).add(De), He; + } + function ze(X) { + if (Q() === 134 && kt(nT) === 1) { + const De = M(), He = ye(), bt = Ki(), Vt = l1( + 0 + /* Lowest */ + ); + return Mv(De, Vt, X, He, bt); + } + } + function nT() { + if (Q() === 134) { + if (ke(), t.hasPrecedingLineBreak() || Q() === 39) + return 0; + const X = l1( + 0 + /* Lowest */ + ); + if (!t.hasPrecedingLineBreak() && X.kind === 80 && Q() === 39) + return 1; + } + return 0; + } + function Qg(X, De) { + const He = M(), bt = ye(), Vt = Ki(), rr = ot(Vt, D4) ? 2 : 0, Rn = Be(); + let gn; + if (Xt( + 21 + /* OpenParenToken */ + )) { + if (X) + gn = rs(rr, X); + else { + const X0 = rs(rr, X); + if (!X0) + return; + gn = X0; + } + if (!Xt( + 22 + /* CloseParenToken */ + ) && !X) + return; + } else { + if (!X) + return; + gn = Wf(); + } + const Gr = Q() === 59, ii = Vr( + 59, + /*isType*/ + !1 + ); + if (ii && !X && Ll(ii)) + return; + let ji = ii; + for (; ji?.kind === 197; ) + ji = ji.type; + const fo = ji && b6(ji); + if (!X && Q() !== 39 && (fo || Q() !== 19)) + return; + const Ka = Q(), La = Co( + 39 + /* EqualsGreaterThanToken */ + ), Tp = Ka === 39 || Ka === 19 ? dd(ot(Vt, D4), De) : _o(); + if (!De && Gr && Q() !== 59) + return; + const Gf = m.createArrowFunction(Vt, Rn, gn, ii, La, Tp); + return pn(zt(Gf, He), bt); + } + function dd(X, De) { + if (Q() === 19) + return g1( + X ? 2 : 0 + /* None */ + ); + if (Q() !== 27 && Q() !== 100 && Q() !== 86 && q0() && !Ov()) + return g1(16 | (X ? 2 : 0)); + const He = Le(); + Jn(!1); + const bt = st; + st = !1; + const Vt = X ? Y(() => f_(De)) : Ae(() => f_(De)); + return st = bt, Jn(He), Vt; + } + function J0(X, De, He) { + const bt = hs( + 58 + /* QuestionToken */ + ); + if (!bt) + return X; + let Vt; + return zt( + m.createConditionalExpression( + X, + bt, + Ds(n, () => f_( + /*allowReturnTypeInArrowFunction*/ + !1 + )), + Vt = Co( + 59 + /* ColonToken */ + ), + Mp(Vt) ? f_(He) : Za( + 80, + /*reportAtCurrentPosition*/ + !1, + p._0_expected, + qs( + 59 + /* ColonToken */ + ) + ) + ), + De + ); + } + function l1(X) { + const De = M(), He = jv(); + return Wd(X, He, De); + } + function Zu(X) { + return X === 103 || X === 165; + } + function Wd(X, De, He) { + for (; ; ) { + Zr(); + const bt = eN(Q()); + if (!(Q() === 43 ? bt >= X : bt > X) || Q() === 103 && mt()) + break; + if (Q() === 130 || Q() === 152) { + if (t.hasPrecedingLineBreak()) + break; + { + const rr = Q(); + ke(), De = rr === 152 ? Rv(De, Ro()) : Vf(De, Ro()); + } + } else + De = ga(De, Ec(), l1(bt), He); + } + return De; + } + function Zp() { + return mt() && Q() === 103 ? !1 : eN(Q()) > 0; + } + function Rv(X, De) { + return zt(m.createSatisfiesExpression(X, De), X.pos); + } + function ga(X, De, He, bt) { + return zt(m.createBinaryExpression(X, De, He), bt); + } + function Vf(X, De) { + return zt(m.createAsExpression(X, De), X.pos); + } + function z0() { + const X = M(); + return zt(m.createPrefixUnaryExpression(Q(), Mt(W0)), X); + } + function iT() { + const X = M(); + return zt(m.createDeleteExpression(Mt(W0)), X); + } + function Vh() { + const X = M(); + return zt(m.createTypeOfExpression(Mt(W0)), X); + } + function v2() { + const X = M(); + return zt(m.createVoidExpression(Mt(W0)), X); + } + function vp() { + return Q() === 135 ? qe() ? !0 : kt(x2) : !1; + } + function Yg() { + const X = M(); + return zt(m.createAwaitExpression(Mt(W0)), X); + } + function jv() { + if (Im()) { + const He = M(), bt = b2(); + return Q() === 43 ? Wd(eN(Q()), bt, He) : bt; + } + const X = Q(), De = W0(); + if (Q() === 43) { + const He = oa(Te, De.pos), { end: bt } = De; + De.kind === 217 ? Pe(He, bt, p.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses) : (E.assert(g5(X)), Pe(He, bt, p.An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses, qs(X))); + } + return De; + } + function W0() { + switch (Q()) { + case 40: + case 41: + case 55: + case 54: + return z0(); + case 91: + return iT(); + case 114: + return Vh(); + case 116: + return v2(); + case 30: + return ne === 1 ? Xl( + /*inExpressionContext*/ + !0, + /*topInvalidNodePosition*/ + void 0, + /*openingTag*/ + void 0, + /*mustBeUnary*/ + !0 + ) : Lu(); + case 135: + if (vp()) + return Yg(); + // falls through + default: + return b2(); + } + } + function Im() { + switch (Q()) { + case 40: + case 41: + case 55: + case 54: + case 91: + case 114: + case 116: + case 135: + return !1; + case 30: + if (ne !== 1) + return !1; + // We are in JSX context and the token is part of JSXElement. + // falls through + default: + return !0; + } + } + function b2() { + if (Q() === 46 || Q() === 47) { + const De = M(); + return zt(m.createPrefixUnaryExpression(Q(), Mt(Bv)), De); + } else if (ne === 1 && Q() === 30 && kt(P_)) + return Xl( + /*inExpressionContext*/ + !0 + ); + const X = Bv(); + if (E.assert(S_(X)), (Q() === 46 || Q() === 47) && !t.hasPrecedingLineBreak()) { + const De = Q(); + return ke(), zt(m.createPostfixUnaryExpression(X, De), X.pos); + } + return X; + } + function Bv() { + const X = M(); + let De; + return Q() === 102 ? kt(wv) ? (pe |= 4194304, De = Ec()) : kt(Am) ? (ke(), ke(), De = zt(m.createMetaProperty(102, ge()), X), De.name.escapedText === "defer" ? (Q() === 21 || Q() === 30) && (pe |= 4194304) : pe |= 8388608) : De = Pn() : De = Q() === 108 ? xn() : Pn(), F_(X, De); + } + function Pn() { + const X = M(), De = zv(); + return qf( + X, + De, + /*allowOptionalChain*/ + !0 + ); + } + function xn() { + const X = M(); + let De = Ec(); + if (Q() === 30) { + const He = M(), bt = cr(Jv); + bt !== void 0 && (Pe(He, M(), p.super_may_not_use_type_arguments), md() || (De = m.createExpressionWithTypeArguments(De, bt))); + } + return Q() === 21 || Q() === 25 || Q() === 23 ? De : (Co(25, p.super_must_be_followed_by_an_argument_list_or_member_access), zt(R(De, Gt( + /*allowIdentifierNames*/ + !0, + /*allowPrivateIdentifiers*/ + !0, + /*allowUnicodeEscapeSequenceInIdentifierName*/ + !0 + )), X)); + } + function Xl(X, De, He, bt = !1) { + const Vt = M(), rr = Gw(X); + let Rn; + if (rr.kind === 287) { + let gn = S2(rr), Gr; + const ii = gn[gn.length - 1]; + if (ii?.kind === 285 && !dv(ii.openingElement.tagName, ii.closingElement.tagName) && dv(rr.tagName, ii.closingElement.tagName)) { + const ji = ii.children.end, fo = zt( + m.createJsxElement( + ii.openingElement, + ii.children, + zt(m.createJsxClosingElement(zt(D(""), ji, ji)), ji, ji) + ), + ii.openingElement.pos, + ji + ); + gn = va([...gn.slice(0, gn.length - 1), fo], gn.pos, ji), Gr = ii.closingElement; + } else + Gr = vE(rr, X), dv(rr.tagName, Gr.tagName) || (He && Id(He) && dv(Gr.tagName, He.tagName) ? yt(rr.tagName, p.JSX_element_0_has_no_corresponding_closing_tag, ID(Te, rr.tagName)) : yt(Gr.tagName, p.Expected_corresponding_JSX_closing_tag_for_0, ID(Te, rr.tagName))); + Rn = zt(m.createJsxElement(rr, gn, Gr), Vt); + } else rr.kind === 290 ? Rn = zt(m.createJsxFragment(rr, S2(rr), Ik(X)), Vt) : (E.assert( + rr.kind === 286 + /* JsxSelfClosingElement */ + ), Rn = rr); + if (!bt && X && Q() === 30) { + const gn = typeof De > "u" ? Rn.pos : De, Gr = cr(() => Xl( + /*inExpressionContext*/ + !0, + gn + )); + if (Gr) { + const ii = Za( + 28, + /*reportAtCurrentPosition*/ + !1 + ); + return JJ(ii, Gr.pos, 0), Pe(oa(Te, gn), Gr.end, p.JSX_expressions_must_have_one_parent_element), zt(m.createBinaryExpression(Rn, ii, Gr), Vt); + } + } + return Rn; + } + function sT() { + const X = M(), De = m.createJsxText( + t.getTokenValue(), + Ee === 13 + /* JsxTextAllWhiteSpaces */ + ); + return Ee = t.scanJsxToken(), zt(De, X); + } + function qh(X, De) { + switch (De) { + case 1: + if (ud(X)) + yt(X, p.JSX_fragment_has_no_corresponding_closing_tag); + else { + const He = X.tagName, bt = Math.min(oa(Te, He.pos), He.end); + Pe(bt, He.end, p.JSX_element_0_has_no_corresponding_closing_tag, ID(Te, X.tagName)); + } + return; + case 31: + case 7: + return; + case 12: + case 13: + return sT(); + case 19: + return fs( + /*inExpressionContext*/ + !1 + ); + case 30: + return Xl( + /*inExpressionContext*/ + !1, + /*topInvalidNodePosition*/ + void 0, + X + ); + default: + return E.assertNever(De); + } + } + function S2(X) { + const De = [], He = M(), bt = Bt; + for (Bt |= 16384; ; ) { + const Vt = qh(X, Ee = t.reScanJsxToken()); + if (!Vt || (De.push(Vt), Id(X) && Vt?.kind === 285 && !dv(Vt.openingElement.tagName, Vt.closingElement.tagName) && dv(X.tagName, Vt.closingElement.tagName))) + break; + } + return Bt = bt, va(De, He); + } + function yE() { + const X = M(); + return zt(m.createJsxAttributes(ma(13, U_)), X); + } + function Gw(X) { + const De = M(); + if (Xt( + 30 + /* LessThanToken */ + ), Q() === 32) + return Jt(), zt(m.createJsxOpeningFragment(), De); + const He = bn(), bt = (Nr & 524288) === 0 ? Ho() : void 0, Vt = yE(); + let rr; + return Q() === 32 ? (Jt(), rr = m.createJsxOpeningElement(He, bt, Vt)) : (Xt( + 44 + /* SlashToken */ + ), Xt( + 32, + /*diagnosticMessage*/ + void 0, + /*shouldAdvance*/ + !1 + ) && (X ? ke() : Jt()), rr = m.createJsxSelfClosingElement(He, bt, Vt)), zt(rr, De); + } + function bn() { + const X = M(), De = Ku(); + if (Fd(De)) + return De; + let He = De; + for (; zi( + 25 + /* DotToken */ + ); ) + He = zt(R(He, Gt( + /*allowIdentifierNames*/ + !0, + /*allowPrivateIdentifiers*/ + !1, + /*allowUnicodeEscapeSequenceInIdentifierName*/ + !1 + )), X); + return He; + } + function Ku() { + const X = M(); + Nt(); + const De = Q() === 110, He = H(); + return zi( + 59 + /* ColonToken */ + ) ? (Nt(), zt(m.createJsxNamespacedName(He, H()), X)) : De ? zt(m.createToken( + 110 + /* ThisKeyword */ + ), X) : He; + } + function fs(X) { + const De = M(); + if (!Xt( + 19 + /* OpenBraceToken */ + )) + return; + let He, bt; + return Q() !== 20 && (X || (He = hs( + 26 + /* DotDotDotToken */ + )), bt = Yu()), X ? Xt( + 20 + /* CloseBraceToken */ + ) : Xt( + 20, + /*diagnosticMessage*/ + void 0, + /*shouldAdvance*/ + !1 + ) && Jt(), zt(m.createJsxExpression(He, bt), De); + } + function U_() { + if (Q() === 19) + return fn(); + const X = M(); + return zt(m.createJsxAttribute(u1(), aT()), X); + } + function aT() { + if (Q() === 64) { + if (_r() === 11) + return xt(); + if (Q() === 19) + return fs( + /*inExpressionContext*/ + !0 + ); + if (Q() === 30) + return Xl( + /*inExpressionContext*/ + !0 + ); + Lt(p.or_JSX_element_expected); + } + } + function u1() { + const X = M(); + Nt(); + const De = H(); + return zi( + 59 + /* ColonToken */ + ) ? (Nt(), zt(m.createJsxNamespacedName(De, H()), X)) : De; + } + function fn() { + const X = M(); + Xt( + 19 + /* OpenBraceToken */ + ), Xt( + 26 + /* DotDotDotToken */ + ); + const De = Yu(); + return Xt( + 20 + /* CloseBraceToken */ + ), zt(m.createJsxSpreadAttribute(De), X); + } + function vE(X, De) { + const He = M(); + Xt( + 31 + /* LessThanSlashToken */ + ); + const bt = bn(); + return Xt( + 32, + /*diagnosticMessage*/ + void 0, + /*shouldAdvance*/ + !1 + ) && (De || !dv(X.tagName, bt) ? ke() : Jt()), zt(m.createJsxClosingElement(bt), He); + } + function Ik(X) { + const De = M(); + return Xt( + 31 + /* LessThanSlashToken */ + ), Xt( + 32, + p.Expected_corresponding_closing_tag_for_JSX_fragment, + /*shouldAdvance*/ + !1 + ) && (X ? ke() : Jt()), zt(m.createJsxJsxClosingFragment(), De); + } + function Lu() { + E.assert(ne !== 1, "Type assertions should never be parsed in JSX; they should be parsed as comparisons or JSX elements/fragments."); + const X = M(); + Xt( + 30 + /* LessThanToken */ + ); + const De = Ro(); + Xt( + 32 + /* GreaterThanToken */ + ); + const He = W0(); + return zt(m.createTypeAssertion(De, He), X); + } + function ug() { + return ke(), v_(Q()) || Q() === 23 || md(); + } + function Ud() { + return Q() === 29 && kt(ug); + } + function _1(X) { + if (X.flags & 64) + return !0; + if ($x(X)) { + let De = X.expression; + for (; $x(De) && !(De.flags & 64); ) + De = De.expression; + if (De.flags & 64) { + for (; $x(X); ) + X.flags |= 64, X = X.expression; + return !0; + } + } + return !1; + } + function oT(X, De, He) { + const bt = Gt( + /*allowIdentifierNames*/ + !0, + /*allowPrivateIdentifiers*/ + !0, + /*allowUnicodeEscapeSequenceInIdentifierName*/ + !0 + ), Vt = He || _1(De), rr = Vt ? B(De, He, bt) : R(De, bt); + if (Vt && Ai(rr.name) && yt(rr.name, p.An_optional_chain_cannot_contain_private_identifiers), Dh(De) && De.typeArguments) { + const Rn = De.typeArguments.pos - 1, gn = oa(Te, De.typeArguments.end) + 1; + Pe(Rn, gn, p.An_instantiation_expression_cannot_be_followed_by_a_property_access); + } + return zt(rr, X); + } + function f1(X, De, He) { + let bt; + if (Q() === 24) + bt = Za( + 80, + /*reportAtCurrentPosition*/ + !0, + p.An_element_access_expression_should_take_an_argument + ); + else { + const rr = yr(Yu); + If(rr) && (rr.text = yc(rr.text)), bt = rr; + } + Xt( + 24 + /* CloseBracketToken */ + ); + const Vt = He || _1(De) ? $(De, He, bt) : U(De, bt); + return zt(Vt, X); + } + function qf(X, De, He) { + for (; ; ) { + let bt, Vt = !1; + if (He && Ud() ? (bt = Co( + 29 + /* QuestionDotToken */ + ), Vt = v_(Q())) : Vt = zi( + 25 + /* DotToken */ + ), Vt) { + De = oT(X, De, bt); + continue; + } + if ((bt || !Ct()) && zi( + 23 + /* OpenBracketToken */ + )) { + De = f1(X, De, bt); + continue; + } + if (md()) { + De = !bt && De.kind === 234 ? bp(X, De.expression, bt, De.typeArguments) : bp( + X, + De, + bt, + /*typeArguments*/ + void 0 + ); + continue; + } + if (!bt) { + if (Q() === 54 && !t.hasPrecedingLineBreak()) { + ke(), De = zt(m.createNonNullExpression(De), X); + continue; + } + const rr = cr(Jv); + if (rr) { + De = zt(m.createExpressionWithTypeArguments(De, rr), X); + continue; + } + } + return De; + } + } + function md() { + return Q() === 15 || Q() === 16; + } + function bp(X, De, He, bt) { + const Vt = m.createTaggedTemplateExpression( + De, + bt, + Q() === 15 ? (Pr( + /*isTaggedTemplate*/ + !0 + ), xt()) : zr( + /*isTaggedTemplate*/ + !0 + ) + ); + return (He || De.flags & 64) && (Vt.flags |= 64), Vt.questionDotToken = He, zt(Vt, X); + } + function F_(X, De) { + for (; ; ) { + De = qf( + X, + De, + /*allowOptionalChain*/ + !0 + ); + let He; + const bt = hs( + 29 + /* QuestionDotToken */ + ); + if (bt && (He = cr(Jv), md())) { + De = bp(X, De, bt, He); + continue; + } + if (He || Q() === 21) { + !bt && De.kind === 234 && (He = De.typeArguments, De = De.expression); + const Vt = U0(), rr = bt || _1(De) ? _e(De, bt, He, Vt) : W(De, He, Vt); + De = zt(rr, X); + continue; + } + if (bt) { + const Vt = Za( + 80, + /*reportAtCurrentPosition*/ + !1, + p.Identifier_expected + ); + De = zt(B(De, bt, Vt), X); + } + break; + } + return De; + } + function U0() { + Xt( + 21 + /* OpenParenToken */ + ); + const X = Sl(11, Fm); + return Xt( + 22 + /* CloseParenToken */ + ), X; + } + function Jv() { + if ((Nr & 524288) !== 0 || rt() !== 30) + return; + ke(); + const X = Sl(20, Ro); + if (Zr() === 32) + return ke(), X && Fk() ? X : void 0; + } + function Fk() { + switch (Q()) { + // These tokens can follow a type argument list in a call expression. + case 21: + // foo( + case 15: + // foo `...` + case 16: + return !0; + // A type argument list followed by `<` never makes sense, and a type argument list followed + // by `>` is ambiguous with a (re-scanned) `>>` operator, so we disqualify both. Also, in + // this context, `+` and `-` are unary operators, not binary operators. + case 30: + case 32: + case 40: + case 41: + return !1; + } + return t.hasPrecedingLineBreak() || Zp() || !vu(); + } + function zv() { + switch (Q()) { + case 15: + t.getTokenFlags() & 26656 && Pr( + /*isTaggedTemplate*/ + !1 + ); + // falls through + case 9: + case 10: + case 11: + return xt(); + case 110: + case 108: + case 106: + case 112: + case 97: + return Ec(); + case 21: + return p1(); + case 23: + return d1(); + case 19: + return V0(); + case 134: + if (!kt(Sp)) + break; + return m1(); + case 60: + return ba(); + case 86: + return Wc(); + case 100: + return m1(); + case 105: + return Gh(); + case 44: + case 69: + if (Rr() === 14) + return xt(); + break; + case 16: + return zr( + /*isTaggedTemplate*/ + !1 + ); + case 81: + return ln(); + } + return _o(p.Expression_expected); + } + function p1() { + const X = M(), De = ye(); + Xt( + 21 + /* OpenParenToken */ + ); + const He = yr(Yu); + return Xt( + 22 + /* CloseParenToken */ + ), pn(zt(V(He), X), De); + } + function Ok() { + const X = M(); + Xt( + 26 + /* DotDotDotToken */ + ); + const De = f_( + /*allowReturnTypeInArrowFunction*/ + !0 + ); + return zt(m.createSpreadElement(De), X); + } + function Hh() { + return Q() === 26 ? Ok() : Q() === 28 ? zt(m.createOmittedExpression(), M()) : f_( + /*allowReturnTypeInArrowFunction*/ + !0 + ); + } + function Fm() { + return Ds(n, Hh); + } + function d1() { + const X = M(), De = t.getTokenStart(), He = Xt( + 23 + /* OpenBracketToken */ + ), bt = t.hasPrecedingLineBreak(), Vt = Sl(15, Hh); + return so(23, 24, He, De), zt(O(Vt, bt), X); + } + function Wv() { + const X = M(), De = ye(); + if (hs( + 26 + /* DotDotDotToken */ + )) { + const ji = f_( + /*allowReturnTypeInArrowFunction*/ + !0 + ); + return pn(zt(m.createSpreadAssignment(ji), X), De); + } + const He = gi( + /*allowDecorators*/ + !0 + ); + if (kr( + 139 + /* GetKeyword */ + )) + return $v( + X, + De, + He, + 178, + 0 + /* None */ + ); + if (kr( + 153 + /* SetKeyword */ + )) + return $v( + X, + De, + He, + 179, + 0 + /* None */ + ); + const bt = hs( + 42 + /* AsteriskToken */ + ), Vt = vr(), rr = Hr(), Rn = hs( + 58 + /* QuestionToken */ + ), gn = hs( + 54 + /* ExclamationToken */ + ); + if (bt || Q() === 21 || Q() === 30) + return Gv(X, De, He, bt, rr, Rn, gn); + let Gr; + if (Vt && Q() !== 59) { + const ji = hs( + 64 + /* EqualsToken */ + ), fo = ji ? yr(() => f_( + /*allowReturnTypeInArrowFunction*/ + !0 + )) : void 0; + Gr = m.createShorthandPropertyAssignment(rr, fo), Gr.equalsToken = ji; + } else { + Xt( + 59 + /* ColonToken */ + ); + const ji = yr(() => f_( + /*allowReturnTypeInArrowFunction*/ + !0 + )); + Gr = m.createPropertyAssignment(rr, ji); + } + return Gr.modifiers = He, Gr.questionToken = Rn, Gr.exclamationToken = gn, pn(zt(Gr, X), De); + } + function V0() { + const X = M(), De = t.getTokenStart(), He = Xt( + 19 + /* OpenBraceToken */ + ), bt = t.hasPrecedingLineBreak(), Vt = Sl( + 12, + Wv, + /*considerSemicolonAsDelimiter*/ + !0 + ); + return so(19, 20, He, De), zt(F(Vt, bt), X); + } + function m1() { + const X = Ct(); + Un( + /*val*/ + !1 + ); + const De = M(), He = ye(), bt = gi( + /*allowDecorators*/ + !1 + ); + Xt( + 100 + /* FunctionKeyword */ + ); + const Vt = hs( + 42 + /* AsteriskToken */ + ), rr = Vt ? 1 : 0, Rn = ot(bt, D4) ? 2 : 0, gn = rr && Rn ? $e(gd) : rr ? re(gd) : Rn ? Y(gd) : gd(), Gr = Be(), ii = Zn(rr | Rn), ji = Vr( + 59, + /*isType*/ + !1 + ), fo = g1(rr | Rn); + Un(X); + const Ka = m.createFunctionExpression(bt, Vt, gn, Gr, ii, ji, fo); + return pn(zt(Ka, De), He); + } + function gd() { + return fr() ? Hl() : void 0; + } + function Gh() { + const X = M(); + if (Xt( + 105 + /* NewKeyword */ + ), zi( + 25 + /* DotToken */ + )) { + const rr = ge(); + return zt(m.createMetaProperty(105, rr), X); + } + const De = M(); + let He = qf( + De, + zv(), + /*allowOptionalChain*/ + !1 + ), bt; + He.kind === 234 && (bt = He.typeArguments, He = He.expression), Q() === 29 && Lt(p.Invalid_optional_chain_from_new_expression_Did_you_mean_to_call_0, ID(Te, He)); + const Vt = Q() === 21 ? U0() : void 0; + return zt(K(He, bt, Vt), X); + } + function Zg(X, De) { + const He = M(), bt = ye(), Vt = t.getTokenStart(), rr = Xt(19, De); + if (rr || X) { + const Rn = t.hasPrecedingLineBreak(), gn = ma(1, V_); + so(19, 20, rr, Vt); + const Gr = pn(zt(ae(gn, Rn), He), bt); + return Q() === 64 && (Lt(p.Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_whole_assignment_in_parentheses), ke()), Gr; + } else { + const Rn = Wf(); + return pn(zt(ae( + Rn, + /*multiLine*/ + void 0 + ), He), bt); + } + } + function g1(X, De) { + const He = Le(); + Jn(!!(X & 1)); + const bt = qe(); + ki(!!(X & 2)); + const Vt = st; + st = !1; + const rr = Ct(); + rr && Un( + /*val*/ + !1 + ); + const Rn = Zg(!!(X & 16), De); + return rr && Un( + /*val*/ + !0 + ), st = Vt, Jn(He), ki(bt), Rn; + } + function Ml() { + const X = M(), De = ye(); + return Xt( + 27 + /* SemicolonToken */ + ), pn(zt(m.createEmptyStatement(), X), De); + } + function T2() { + const X = M(), De = ye(); + Xt( + 101 + /* IfKeyword */ + ); + const He = t.getTokenStart(), bt = Xt( + 21 + /* OpenParenToken */ + ), Vt = yr(Yu); + so(21, 22, bt, He); + const rr = V_(), Rn = zi( + 93 + /* ElseKeyword */ + ) ? V_() : void 0; + return pn(zt(fe(Vt, rr, Rn), X), De); + } + function Kg() { + const X = M(), De = ye(); + Xt( + 92 + /* DoKeyword */ + ); + const He = V_(); + Xt( + 117 + /* WhileKeyword */ + ); + const bt = t.getTokenStart(), Vt = Xt( + 21 + /* OpenParenToken */ + ), rr = yr(Yu); + return so(21, 22, Vt, bt), zi( + 27 + /* SemicolonToken */ + ), pn(zt(m.createDoStatement(He, rr), X), De); + } + function Uv() { + const X = M(), De = ye(); + Xt( + 117 + /* WhileKeyword */ + ); + const He = t.getTokenStart(), bt = Xt( + 21 + /* OpenParenToken */ + ), Vt = yr(Yu); + so(21, 22, bt, He); + const rr = V_(); + return pn(zt(he(Vt, rr), X), De); + } + function cT() { + const X = M(), De = ye(); + Xt( + 99 + /* ForKeyword */ + ); + const He = hs( + 135 + /* AwaitKeyword */ + ); + Xt( + 21 + /* OpenParenToken */ + ); + let bt; + Q() !== 27 && (Q() === 115 || Q() === 121 || Q() === 87 || Q() === 160 && kt(dc) || // this one is meant to allow of + Q() === 135 && kt(Jk) ? bt = mT( + /*inForStatementInitializer*/ + !0 + ) : bt = bs(Yu)); + let Vt; + if (He ? Xt( + 165 + /* OfKeyword */ + ) : zi( + 165 + /* OfKeyword */ + )) { + const rr = yr(() => f_( + /*allowReturnTypeInArrowFunction*/ + !0 + )); + Xt( + 22 + /* CloseParenToken */ + ), Vt = be(He, bt, rr, V_()); + } else if (zi( + 103 + /* InKeyword */ + )) { + const rr = yr(Yu); + Xt( + 22 + /* CloseParenToken */ + ), Vt = m.createForInStatement(bt, rr, V_()); + } else { + Xt( + 27 + /* SemicolonToken */ + ); + const rr = Q() !== 27 && Q() !== 22 ? yr(Yu) : void 0; + Xt( + 27 + /* SemicolonToken */ + ); + const Rn = Q() !== 22 ? yr(Yu) : void 0; + Xt( + 22 + /* CloseParenToken */ + ), Vt = q(bt, rr, Rn, V_()); + } + return pn(zt(Vt, X), De); + } + function eh(X) { + const De = M(), He = ye(); + Xt( + X === 253 ? 83 : 88 + /* ContinueKeyword */ + ); + const bt = cs() ? void 0 : _o(); + Fa(); + const Vt = X === 253 ? m.createBreakStatement(bt) : m.createContinueStatement(bt); + return pn(zt(Vt, De), He); + } + function bE() { + const X = M(), De = ye(); + Xt( + 107 + /* ReturnKeyword */ + ); + const He = cs() ? void 0 : yr(Yu); + return Fa(), pn(zt(m.createReturnStatement(He), X), De); + } + function Lk() { + const X = M(), De = ye(); + Xt( + 118 + /* WithKeyword */ + ); + const He = t.getTokenStart(), bt = Xt( + 21 + /* OpenParenToken */ + ), Vt = yr(Yu); + so(21, 22, bt, He); + const rr = Ks(67108864, V_); + return pn(zt(m.createWithStatement(Vt, rr), X), De); + } + function Mk() { + const X = M(), De = ye(); + Xt( + 84 + /* CaseKeyword */ + ); + const He = yr(Yu); + Xt( + 59 + /* ColonToken */ + ); + const bt = ma(3, V_); + return pn(zt(m.createCaseClause(He, bt), X), De); + } + function $w() { + const X = M(); + Xt( + 90 + /* DefaultKeyword */ + ), Xt( + 59 + /* ColonToken */ + ); + const De = ma(3, V_); + return zt(m.createDefaultClause(De), X); + } + function Rk() { + return Q() === 84 ? Mk() : $w(); + } + function Vv() { + const X = M(); + Xt( + 19 + /* OpenBraceToken */ + ); + const De = ma(2, Rk); + return Xt( + 20 + /* CloseBraceToken */ + ), zt(m.createCaseBlock(De), X); + } + function $h() { + const X = M(), De = ye(); + Xt( + 109 + /* SwitchKeyword */ + ), Xt( + 21 + /* OpenParenToken */ + ); + const He = yr(Yu); + Xt( + 22 + /* CloseParenToken */ + ); + const bt = Vv(); + return pn(zt(m.createSwitchStatement(He, bt), X), De); + } + function SE() { + const X = M(), De = ye(); + Xt( + 111 + /* ThrowKeyword */ + ); + let He = t.hasPrecedingLineBreak() ? void 0 : yr(Yu); + return He === void 0 && (St++, He = zt(D(""), M())), Ws() || Fs(He), pn(zt(m.createThrowStatement(He), X), De); + } + function qv() { + const X = M(), De = ye(); + Xt( + 113 + /* TryKeyword */ + ); + const He = Zg( + /*ignoreMissingOpenBrace*/ + !1 + ), bt = Q() === 85 ? lT() : void 0; + let Vt; + return (!bt || Q() === 98) && (Xt(98, p.catch_or_finally_expected), Vt = Zg( + /*ignoreMissingOpenBrace*/ + !1 + )), pn(zt(m.createTryStatement(He, bt, Vt), X), De); + } + function lT() { + const X = M(); + Xt( + 85 + /* CatchKeyword */ + ); + let De; + zi( + 21 + /* OpenParenToken */ + ) ? (De = Om(), Xt( + 22 + /* CloseParenToken */ + )) : De = void 0; + const He = Zg( + /*ignoreMissingOpenBrace*/ + !1 + ); + return zt(m.createCatchClause(De, He), X); + } + function zc() { + const X = M(), De = ye(); + return Xt( + 89 + /* DebuggerKeyword */ + ), Fa(), pn(zt(m.createDebuggerStatement(), X), De); + } + function Rl() { + const X = M(); + let De = ye(), He; + const bt = Q() === 21, Vt = yr(Yu); + return Me(Vt) && zi( + 59 + /* ColonToken */ + ) ? He = m.createLabeledStatement(Vt, V_()) : (Ws() || Fs(Vt), He = ce(Vt), bt && (De = !1)), pn(zt(He, X), De); + } + function jk() { + return ke(), v_(Q()) && !t.hasPrecedingLineBreak(); + } + function O_() { + return ke(), Q() === 86 && !t.hasPrecedingLineBreak(); + } + function Sp() { + return ke(), Q() === 100 && !t.hasPrecedingLineBreak(); + } + function x2() { + return ke(), (v_(Q()) || Q() === 9 || Q() === 10 || Q() === 11) && !t.hasPrecedingLineBreak(); + } + function Vd() { + for (; ; ) + switch (Q()) { + case 115: + case 121: + case 87: + case 100: + case 86: + case 94: + return !0; + case 160: + return k2(); + case 135: + return Mu(); + // 'declare', 'module', 'namespace', 'interface'* and 'type' are all legal JavaScript identifiers; + // however, an identifier cannot be followed by another identifier on the same line. This is what we + // count on to parse out the respective declarations. For instance, we exploit this to say that + // + // namespace n + // + // can be none other than the beginning of a namespace declaration, but need to respect that JavaScript sees + // + // namespace + // n + // + // as the identifier 'namespace' on one line followed by the identifier 'n' on another. + // We need to look one token ahead to see if it permissible to try parsing a declaration. + // + // *Note*: 'interface' is actually a strict mode reserved word. So while + // + // "use strict" + // interface + // I {} + // + // could be legal, it would add complexity for very little gain. + case 120: + case 156: + case 166: + return pd(); + case 144: + case 145: + return pT(); + case 128: + case 129: + case 134: + case 138: + case 123: + case 124: + case 125: + case 148: + const X = Q(); + if (ke(), t.hasPrecedingLineBreak()) + return !1; + if (X === 138 && Q() === 156) + return !0; + continue; + case 162: + return ke(), Q() === 19 || Q() === 80 || Q() === 95; + case 102: + return ke(), Q() === 166 || Q() === 11 || Q() === 42 || Q() === 19 || v_(Q()); + case 95: + let De = ke(); + if (De === 156 && (De = kt(ke)), De === 64 || De === 42 || De === 19 || De === 90 || De === 130 || De === 60) + return !0; + continue; + case 126: + ke(); + continue; + default: + return !1; + } + } + function h1() { + return kt(Vd); + } + function q0() { + switch (Q()) { + case 60: + case 27: + case 19: + case 115: + case 121: + case 160: + case 100: + case 86: + case 94: + case 101: + case 92: + case 117: + case 99: + case 88: + case 83: + case 107: + case 118: + case 109: + case 111: + case 113: + case 89: + // 'catch' and 'finally' do not actually indicate that the code is part of a statement, + // however, we say they are here so that we may gracefully parse them and error later. + // falls through + case 85: + case 98: + return !0; + case 102: + return h1() || kt(ag); + case 87: + case 95: + return h1(); + case 134: + case 138: + case 120: + case 144: + case 145: + case 156: + case 162: + case 166: + return !0; + case 129: + case 125: + case 123: + case 124: + case 126: + case 148: + return h1() || !kt(jk); + default: + return vu(); + } + } + function Bk() { + return ke(), fr() || Q() === 19 || Q() === 23; + } + function Xw() { + return kt(Bk); + } + function dc() { + return uT( + /*disallowOf*/ + !0 + ); + } + function TE() { + return ke(), Q() === 64 || Q() === 27 || Q() === 59; + } + function uT(X) { + return ke(), X && Q() === 165 ? kt(TE) : (fr() || Q() === 19) && !t.hasPrecedingLineBreak(); + } + function k2() { + return kt(uT); + } + function Jk(X) { + return ke() === 160 ? uT(X) : !1; + } + function Mu() { + return kt(Jk); + } + function V_() { + switch (Q()) { + case 27: + return Ml(); + case 19: + return Zg( + /*ignoreMissingOpenBrace*/ + !1 + ); + case 115: + return Oa( + M(), + ye(), + /*modifiers*/ + void 0 + ); + case 121: + if (Xw()) + return Oa( + M(), + ye(), + /*modifiers*/ + void 0 + ); + break; + case 135: + if (Mu()) + return Oa( + M(), + ye(), + /*modifiers*/ + void 0 + ); + break; + case 160: + if (k2()) + return Oa( + M(), + ye(), + /*modifiers*/ + void 0 + ); + break; + case 100: + return yn( + M(), + ye(), + /*modifiers*/ + void 0 + ); + case 86: + return bu( + M(), + ye(), + /*modifiers*/ + void 0 + ); + case 101: + return T2(); + case 92: + return Kg(); + case 117: + return Uv(); + case 99: + return cT(); + case 88: + return eh( + 252 + /* ContinueStatement */ + ); + case 83: + return eh( + 253 + /* BreakStatement */ + ); + case 107: + return bE(); + case 118: + return Lk(); + case 109: + return $h(); + case 111: + return SE(); + case 113: + // Include 'catch' and 'finally' for error recovery. + // falls through + case 85: + case 98: + return qv(); + case 89: + return zc(); + case 60: + return Hv(); + case 134: + case 120: + case 156: + case 144: + case 145: + case 138: + case 87: + case 94: + case 95: + case 102: + case 123: + case 124: + case 125: + case 128: + case 129: + case 126: + case 148: + case 162: + if (h1()) + return Hv(); + break; + } + return Rl(); + } + function _T(X) { + return X.kind === 138; + } + function Hv() { + const X = M(), De = ye(), He = gi( + /*allowDecorators*/ + !0 + ); + if (ot(He, _T)) { + const Vt = q_(X); + if (Vt) + return Vt; + for (const rr of He) + rr.flags |= 33554432; + return Ks(33554432, () => fT(X, De, He)); + } else + return fT(X, De, He); + } + function q_(X) { + return Ks(33554432, () => { + const De = Po(Bt, X); + if (De) + return sc(De); + }); + } + function fT(X, De, He) { + switch (Q()) { + case 115: + case 121: + case 87: + case 160: + case 135: + return Oa(X, De, He); + case 100: + return yn(X, De, He); + case 86: + return bu(X, De, He); + case 120: + return yd(X, De, He); + case 156: + return $0(X, De, He); + case 94: + return qL(X, De, He); + case 162: + case 144: + case 145: + return U8(X, De, He); + case 102: + return ST(X, De, He); + case 95: + switch (ke(), Q()) { + case 90: + case 64: + return Yv(X, De, He); + case 130: + return D2(X, De, He); + default: + return tP(X, De, He); + } + default: + if (He) { + const bt = Za( + 283, + /*reportAtCurrentPosition*/ + !0, + p.Declaration_expected + ); + return h4(bt, X), bt.modifiers = He, bt; + } + return; + } + } + function th() { + return ke() === 11; + } + function zk() { + return ke(), Q() === 161 || Q() === 64; + } + function pT() { + return ke(), !t.hasPrecedingLineBreak() && (vr() || Q() === 11); + } + function hd(X, De) { + if (Q() !== 19) { + if (X & 4) { + ns(); + return; + } + if (cs()) { + Fa(); + return; + } + } + return g1(X, De); + } + function Wk() { + const X = M(); + if (Q() === 28) + return zt(m.createOmittedExpression(), X); + const De = hs( + 26 + /* DotDotDotToken */ + ), He = H0(), bt = lg(); + return zt(m.createBindingElement( + De, + /*propertyName*/ + void 0, + He, + bt + ), X); + } + function xE() { + const X = M(), De = hs( + 26 + /* DotDotDotToken */ + ), He = fr(); + let bt = Hr(), Vt; + He && Q() !== 59 ? (Vt = bt, bt = void 0) : (Xt( + 59 + /* ColonToken */ + ), Vt = H0()); + const rr = lg(); + return zt(m.createBindingElement(De, bt, Vt, rr), X); + } + function Uk() { + const X = M(); + Xt( + 19 + /* OpenBraceToken */ + ); + const De = yr(() => Sl(9, xE)); + return Xt( + 20 + /* CloseBraceToken */ + ), zt(m.createObjectBindingPattern(De), X); + } + function dT() { + const X = M(); + Xt( + 23 + /* OpenBracketToken */ + ); + const De = yr(() => Sl(10, Wk)); + return Xt( + 24 + /* CloseBracketToken */ + ), zt(m.createArrayBindingPattern(De), X); + } + function Vk() { + return Q() === 19 || Q() === 23 || Q() === 81 || fr(); + } + function H0(X) { + return Q() === 23 ? dT() : Q() === 19 ? Uk() : Hl(X); + } + function gf() { + return Om( + /*allowExclamation*/ + !0 + ); + } + function Om(X) { + const De = M(), He = ye(), bt = H0(p.Private_identifiers_are_not_allowed_in_variable_declarations); + let Vt; + X && bt.kind === 80 && Q() === 54 && !t.hasPrecedingLineBreak() && (Vt = Ec()); + const rr = yu(), Rn = Zu(Q()) ? void 0 : lg(), gn = je(bt, Vt, rr, Rn); + return pn(zt(gn, De), He); + } + function mT(X) { + const De = M(); + let He = 0; + switch (Q()) { + case 115: + break; + case 121: + He |= 1; + break; + case 87: + He |= 2; + break; + case 160: + He |= 4; + break; + case 135: + E.assert(Mu()), He |= 6, ke(); + break; + default: + E.fail(); + } + ke(); + let bt; + if (Q() === 165 && kt(gT)) + bt = Wf(); + else { + const Vt = mt(); + qr(X), bt = Sl( + 8, + X ? Om : gf + ), qr(Vt); + } + return zt(me(bt, He), De); + } + function gT() { + return au() && ke() === 22; + } + function Oa(X, De, He) { + const bt = mT( + /*inForStatementInitializer*/ + !1 + ); + Fa(); + const Vt = se(He, bt); + return pn(zt(Vt, X), De); + } + function yn(X, De, He) { + const bt = qe(), Vt = pm(He); + Xt( + 100 + /* FunctionKeyword */ + ); + const rr = hs( + 42 + /* AsteriskToken */ + ), Rn = Vt & 2048 ? gd() : Hl(), gn = rr ? 1 : 0, Gr = Vt & 1024 ? 2 : 0, ii = Be(); + Vt & 32 && ki( + /*value*/ + !0 + ); + const ji = Zn(gn | Gr), fo = Vr( + 59, + /*isType*/ + !1 + ), Ka = hd(gn | Gr, p.or_expected); + ki(bt); + const La = m.createFunctionDeclaration(He, rr, Rn, ii, ji, fo, Ka); + return pn(zt(La, X), De); + } + function Hf() { + if (Q() === 137) + return Xt( + 137 + /* ConstructorKeyword */ + ); + if (Q() === 11 && kt(ke) === 21) + return cr(() => { + const X = xt(); + return X.text === "constructor" ? X : void 0; + }); + } + function Tl(X, De, He) { + return cr(() => { + if (Hf()) { + const bt = Be(), Vt = Zn( + 0 + /* None */ + ), rr = Vr( + 59, + /*isType*/ + !1 + ), Rn = hd(0, p.or_expected), gn = m.createConstructorDeclaration(He, Vt, Rn); + return gn.typeParameters = bt, gn.type = rr, pn(zt(gn, X), De); + } + }); + } + function Gv(X, De, He, bt, Vt, rr, Rn, gn) { + const Gr = bt ? 1 : 0, ii = ot(He, D4) ? 2 : 0, ji = Be(), fo = Zn(Gr | ii), Ka = Vr( + 59, + /*isType*/ + !1 + ), La = hd(Gr | ii, gn), Tp = m.createMethodDeclaration( + He, + bt, + Vt, + rr, + ji, + fo, + Ka, + La + ); + return Tp.exclamationToken = Rn, pn(zt(Tp, X), De); + } + function hT(X, De, He, bt, Vt) { + const rr = !Vt && !t.hasPrecedingLineBreak() ? hs( + 54 + /* ExclamationToken */ + ) : void 0, Rn = yu(), gn = Ds(90112, lg); + pc(bt, Rn, gn); + const Gr = m.createPropertyDeclaration( + He, + bt, + Vt || rr, + Rn, + gn + ); + return pn(zt(Gr, X), De); + } + function C2(X, De, He) { + const bt = hs( + 42 + /* AsteriskToken */ + ), Vt = Hr(), rr = hs( + 58 + /* QuestionToken */ + ); + return bt || Q() === 21 || Q() === 30 ? Gv( + X, + De, + He, + bt, + Vt, + rr, + /*exclamationToken*/ + void 0, + p.or_expected + ) : hT(X, De, He, Vt, rr); + } + function $v(X, De, He, bt, Vt) { + const rr = Hr(), Rn = Be(), gn = Zn( + 0 + /* None */ + ), Gr = Vr( + 59, + /*isType*/ + !1 + ), ii = hd(Vt), ji = bt === 178 ? m.createGetAccessorDeclaration(He, rr, gn, Gr, ii) : m.createSetAccessorDeclaration(He, rr, gn, ii); + return ji.typeParameters = Rn, z_(ji) && (ji.type = Gr), pn(zt(ji, X), De); + } + function yT() { + let X; + if (Q() === 60) + return !0; + for (; Ey(Q()); ) { + if (X = Q(), Uj(X)) + return !0; + ke(); + } + if (Q() === 42 || (tt() && (X = Q(), ke()), Q() === 23)) + return !0; + if (X !== void 0) { + if (!k_(X) || X === 153 || X === 139) + return !0; + switch (Q()) { + case 21: + // Method declaration + case 30: + // Generic Method declaration + case 54: + // Non-null assertion on property name + case 59: + // Type Annotation for declaration + case 64: + // Initializer for declaration + case 58: + return !0; + default: + return cs(); + } + } + return !1; + } + function C(X, De, He) { + Co( + 126 + /* StaticKeyword */ + ); + const bt = le(), Vt = pn(zt(m.createClassStaticBlockDeclaration(bt), X), De); + return Vt.modifiers = He, Vt; + } + function le() { + const X = Le(), De = qe(); + Jn(!1), ki(!0); + const He = Zg( + /*ignoreMissingOpenBrace*/ + !1 + ); + return Jn(X), ki(De), He; + } + function _t() { + if (qe() && Q() === 135) { + const X = M(), De = _o(p.Expression_expected); + ke(); + const He = qf( + X, + De, + /*allowOptionalChain*/ + !0 + ); + return F_(X, He); + } + return Bv(); + } + function ur() { + const X = M(); + if (!zi( + 60 + /* AtToken */ + )) + return; + const De = it(_t); + return zt(m.createDecorator(De), X); + } + function ti(X, De, He) { + const bt = M(), Vt = Q(); + if (Q() === 87 && De) { + if (!cr(Li)) + return; + } else { + if (He && Q() === 126 && kt(bT)) + return; + if (X && Q() === 126) + return; + if (!Eo()) + return; + } + return zt(A(Vt), bt); + } + function gi(X, De, He) { + const bt = M(); + let Vt, rr, Rn, gn = !1, Gr = !1, ii = !1; + if (X && Q() === 60) + for (; rr = ur(); ) + Vt = Er(Vt, rr); + for (; Rn = ti(gn, De, He); ) + Rn.kind === 126 && (gn = !0), Vt = Er(Vt, Rn), Gr = !0; + if (Gr && X && Q() === 60) + for (; rr = ur(); ) + Vt = Er(Vt, rr), ii = !0; + if (ii) + for (; Rn = ti(gn, De, He); ) + Rn.kind === 126 && (gn = !0), Vt = Er(Vt, Rn); + return Vt && va(Vt, bt); + } + function Ki() { + let X; + if (Q() === 134) { + const De = M(); + ke(); + const He = zt(A( + 134 + /* AsyncKeyword */ + ), De); + X = va([He], De); + } + return X; + } + function mi() { + const X = M(), De = ye(); + if (Q() === 27) + return ke(), pn(zt(m.createSemicolonClassElement(), X), De); + const He = gi( + /*allowDecorators*/ + !0, + /*permitConstAsModifier*/ + !0, + /*stopOnStartOfClassStaticBlock*/ + !0 + ); + if (Q() === 126 && kt(bT)) + return C(X, De, He); + if (kr( + 139 + /* GetKeyword */ + )) + return $v( + X, + De, + He, + 178, + 0 + /* None */ + ); + if (kr( + 153 + /* SetKeyword */ + )) + return $v( + X, + De, + He, + 179, + 0 + /* None */ + ); + if (Q() === 137 || Q() === 11) { + const bt = Tl(X, De, He); + if (bt) + return bt; + } + if (Wo()) + return Xp(X, De, He); + if (v_(Q()) || Q() === 11 || Q() === 9 || Q() === 10 || Q() === 42 || Q() === 23) + if (ot(He, _T)) { + for (const Vt of He) + Vt.flags |= 33554432; + return Ks(33554432, () => C2(X, De, He)); + } else + return C2(X, De, He); + if (He) { + const bt = Za( + 80, + /*reportAtCurrentPosition*/ + !0, + p.Declaration_expected + ); + return hT( + X, + De, + He, + bt, + /*questionToken*/ + void 0 + ); + } + return E.fail("Should not have attempted to parse class member declaration."); + } + function ba() { + const X = M(), De = ye(), He = gi( + /*allowDecorators*/ + !0 + ); + if (Q() === 86) + return p_( + X, + De, + He, + 232 + /* ClassExpression */ + ); + const bt = Za( + 283, + /*reportAtCurrentPosition*/ + !0, + p.Expression_expected + ); + return h4(bt, X), bt.modifiers = He, bt; + } + function Wc() { + return p_( + M(), + ye(), + /*modifiers*/ + void 0, + 232 + /* ClassExpression */ + ); + } + function bu(X, De, He) { + return p_( + X, + De, + He, + 264 + /* ClassDeclaration */ + ); + } + function p_(X, De, He, bt) { + const Vt = qe(); + Xt( + 86 + /* ClassKeyword */ + ); + const rr = Xv(), Rn = Be(); + ot(He, zx) && ki( + /*value*/ + !0 + ); + const gn = y1(); + let Gr; + Xt( + 19 + /* OpenBraceToken */ + ) ? (Gr = G0(), Xt( + 20 + /* CloseBraceToken */ + )) : Gr = Wf(), ki(Vt); + const ii = bt === 264 ? m.createClassDeclaration(He, rr, Rn, gn, Gr) : m.createClassExpression(He, rr, Rn, gn, Gr); + return pn(zt(ii, X), De); + } + function Xv() { + return fr() && !d_() ? Fc(fr()) : void 0; + } + function d_() { + return Q() === 119 && kt(Ef); + } + function y1() { + if (vT()) + return ma(22, qk); + } + function qk() { + const X = M(), De = Q(); + E.assert( + De === 96 || De === 119 + /* ImplementsKeyword */ + ), ke(); + const He = Sl(7, Kp); + return zt(m.createHeritageClause(De, He), X); + } + function Kp() { + const X = M(), De = Bv(); + if (De.kind === 234) + return De; + const He = Ho(); + return zt(m.createExpressionWithTypeArguments(De, He), X); + } + function Ho() { + return Q() === 30 ? ee( + 20, + Ro, + 30, + 32 + /* GreaterThanToken */ + ) : void 0; + } + function vT() { + return Q() === 96 || Q() === 119; + } + function G0() { + return ma(5, mi); + } + function yd(X, De, He) { + Xt( + 120 + /* InterfaceKeyword */ + ); + const bt = _o(), Vt = Be(), rr = y1(), Rn = og(), gn = m.createInterfaceDeclaration(He, bt, Vt, rr, Rn); + return pn(zt(gn, X), De); + } + function $0(X, De, He) { + Xt( + 156 + /* TypeKeyword */ + ), t.hasPrecedingLineBreak() && Lt(p.Line_break_not_permitted_here); + const bt = _o(), Vt = Be(); + Xt( + 64 + /* EqualsToken */ + ); + const rr = Q() === 141 && cr(wk) || Ro(); + Fa(); + const Rn = m.createTypeAliasDeclaration(He, bt, Vt, rr); + return pn(zt(Rn, X), De); + } + function E2() { + const X = M(), De = ye(), He = Hr(), bt = yr(lg); + return pn(zt(m.createEnumMember(He, bt), X), De); + } + function qL(X, De, He) { + Xt( + 94 + /* EnumKeyword */ + ); + const bt = _o(); + let Vt; + Xt( + 19 + /* OpenBraceToken */ + ) ? (Vt = Ke(() => Sl(6, E2)), Xt( + 20 + /* CloseBraceToken */ + )) : Vt = Wf(); + const rr = m.createEnumDeclaration(He, bt, Vt); + return pn(zt(rr, X), De); + } + function Qw() { + const X = M(); + let De; + return Xt( + 19 + /* OpenBraceToken */ + ) ? (De = ma(1, V_), Xt( + 20 + /* CloseBraceToken */ + )) : De = Wf(), zt(m.createModuleBlock(De), X); + } + function Hk(X, De, He, bt) { + const Vt = bt & 32, rr = bt & 8 ? ge() : _o(), Rn = zi( + 25 + /* DotToken */ + ) ? Hk( + M(), + /*hasJSDoc*/ + !1, + /*modifiers*/ + void 0, + 8 | Vt + ) : Qw(), gn = m.createModuleDeclaration(He, rr, Rn, bt); + return pn(zt(gn, X), De); + } + function Yw(X, De, He) { + let bt = 0, Vt; + Q() === 162 ? (Vt = _o(), bt |= 2048) : (Vt = xt(), Vt.text = yc(Vt.text)); + let rr; + Q() === 19 ? rr = Qw() : Fa(); + const Rn = m.createModuleDeclaration(He, Vt, rr, bt); + return pn(zt(Rn, X), De); + } + function U8(X, De, He) { + let bt = 0; + if (Q() === 162) + return Yw(X, De, He); + if (zi( + 145 + /* NamespaceKeyword */ + )) + bt |= 32; + else if (Xt( + 144 + /* ModuleKeyword */ + ), Q() === 11) + return Yw(X, De, He); + return Hk(X, De, He, bt); + } + function v1() { + return Q() === 149 && kt(Gk); + } + function Gk() { + return ke() === 21; + } + function bT() { + return ke() === 19; + } + function HL() { + return ke() === 44; + } + function D2(X, De, He) { + Xt( + 130 + /* AsKeyword */ + ), Xt( + 145 + /* NamespaceKeyword */ + ); + const bt = _o(); + Fa(); + const Vt = m.createNamespaceExportDeclaration(bt); + return Vt.modifiers = He, pn(zt(Vt, X), De); + } + function ST(X, De, He) { + Xt( + 102 + /* ImportKeyword */ + ); + const bt = t.getTokenFullStart(); + let Vt; + vr() && (Vt = _o()); + let rr; + if (Vt?.escapedText === "type" && (Q() !== 161 || vr() && kt(zk)) && (vr() || Wr()) ? (rr = 156, Vt = vr() ? _o() : void 0) : Vt?.escapedText === "defer" && (Q() === 161 ? !kt(th) : Q() !== 28 && Q() !== 64) && (rr = 166, Vt = vr() ? _o() : void 0), Vt && !Kw() && rr !== 166) + return kE( + X, + De, + He, + Vt, + rr === 156 + /* TypeKeyword */ + ); + const Rn = Zw( + Vt, + bt, + rr, + /*skipJsDocLeadingAsterisks*/ + void 0 + ), gn = TT(), Gr = $k(); + Fa(); + const ii = m.createImportDeclaration(He, Rn, gn, Gr); + return pn(zt(ii, X), De); + } + function Zw(X, De, He, bt = !1) { + let Vt; + return (X || // import id + Q() === 42 || // import * + Q() === 19) && (Vt = CE(X, De, He, bt), Xt( + 161 + /* FromKeyword */ + )), Vt; + } + function $k() { + const X = Q(); + if ((X === 118 || X === 132) && !t.hasPrecedingLineBreak()) + return b1(X); + } + function Wi() { + const X = M(), De = v_(Q()) ? ge() : Zi( + 11 + /* StringLiteral */ + ); + Xt( + 59 + /* ColonToken */ + ); + const He = f_( + /*allowReturnTypeInArrowFunction*/ + !0 + ); + return zt(m.createImportAttribute(De, He), X); + } + function b1(X, De) { + const He = M(); + De || Xt(X); + const bt = t.getTokenStart(); + if (Xt( + 19 + /* OpenBraceToken */ + )) { + const Vt = t.hasPrecedingLineBreak(), rr = Sl( + 24, + Wi, + /*considerSemicolonAsDelimiter*/ + !0 + ); + if (!Xt( + 20 + /* CloseBraceToken */ + )) { + const Rn = Do(Se); + Rn && Rn.code === p._0_expected.code && zs( + Rn, + wx(Z, Te, bt, 1, p.The_parser_expected_to_find_a_1_to_match_the_0_token_here, "{", "}") + ); + } + return zt(m.createImportAttributes(rr, Vt, X), He); + } else { + const Vt = va( + [], + M(), + /*end*/ + void 0, + /*hasTrailingComma*/ + !1 + ); + return zt(m.createImportAttributes( + Vt, + /*multiLine*/ + !1, + X + ), He); + } + } + function Wr() { + return Q() === 42 || Q() === 19; + } + function Kw() { + return Q() === 28 || Q() === 161; + } + function kE(X, De, He, bt, Vt) { + Xt( + 64 + /* EqualsToken */ + ); + const rr = w2(); + Fa(); + const Rn = m.createImportEqualsDeclaration(He, Vt, bt, rr); + return pn(zt(Rn, X), De); + } + function CE(X, De, He, bt) { + let Vt; + return (!X || zi( + 28 + /* CommaToken */ + )) && (bt && t.setSkipJsDocLeadingAsterisks(!0), Q() === 42 ? Vt = GL() : Vt = q8( + 276 + /* NamedImports */ + ), bt && t.setSkipJsDocLeadingAsterisks(!1)), zt(m.createImportClause(He, X, Vt), De); + } + function w2() { + return v1() ? V8() : et( + /*allowReservedWords*/ + !1 + ); + } + function V8() { + const X = M(); + Xt( + 149 + /* RequireKeyword */ + ), Xt( + 21 + /* OpenParenToken */ + ); + const De = TT(); + return Xt( + 22 + /* CloseParenToken */ + ), zt(m.createExternalModuleReference(De), X); + } + function TT() { + if (Q() === 11) { + const X = xt(); + return X.text = yc(X.text), X; + } else + return Yu(); + } + function GL() { + const X = M(); + Xt( + 42 + /* AsteriskToken */ + ), Xt( + 130 + /* AsKeyword */ + ); + const De = _o(); + return zt(m.createNamespaceImport(De), X); + } + function EE() { + return v_(Q()) || Q() === 11; + } + function _g(X) { + return Q() === 11 ? xt() : X(); + } + function q8(X) { + const De = M(), He = X === 276 ? m.createNamedImports(ee( + 23, + $L, + 19, + 20 + /* CloseBraceToken */ + )) : m.createNamedExports(ee( + 23, + Qv, + 19, + 20 + /* CloseBraceToken */ + )); + return zt(He, De); + } + function Qv() { + const X = ye(); + return pn(eP( + 282 + /* ExportSpecifier */ + ), X); + } + function $L() { + return eP( + 277 + /* ImportSpecifier */ + ); + } + function eP(X) { + const De = M(); + let He = k_(Q()) && !vr(), bt = t.getTokenStart(), Vt = t.getTokenEnd(), rr = !1, Rn, gn = !0, Gr = _g(ge); + if (Gr.kind === 80 && Gr.escapedText === "type") + if (Q() === 130) { + const fo = ge(); + if (Q() === 130) { + const Ka = ge(); + EE() ? (rr = !0, Rn = fo, Gr = _g(ji), gn = !1) : (Rn = Gr, Gr = Ka, gn = !1); + } else EE() ? (Rn = Gr, gn = !1, Gr = _g(ji)) : (rr = !0, Gr = fo); + } else EE() && (rr = !0, Gr = _g(ji)); + gn && Q() === 130 && (Rn = Gr, Xt( + 130 + /* AsKeyword */ + ), Gr = _g(ji)), X === 277 && (Gr.kind !== 80 ? (Pe(oa(Te, Gr.pos), Gr.end, p.Identifier_expected), Gr = Ad(Za( + 80, + /*reportAtCurrentPosition*/ + !1 + ), Gr.pos, Gr.pos)) : He && Pe(bt, Vt, p.Identifier_expected)); + const ii = X === 277 ? m.createImportSpecifier(rr, Rn, Gr) : m.createExportSpecifier(rr, Rn, Gr); + return zt(ii, De); + function ji() { + return He = k_(Q()) && !vr(), bt = t.getTokenStart(), Vt = t.getTokenEnd(), ge(); + } + } + function H8(X) { + return zt(m.createNamespaceExport(_g(ge)), X); + } + function tP(X, De, He) { + const bt = qe(); + ki( + /*value*/ + !0 + ); + let Vt, rr, Rn; + const gn = zi( + 156 + /* TypeKeyword */ + ), Gr = M(); + zi( + 42 + /* AsteriskToken */ + ) ? (zi( + 130 + /* AsKeyword */ + ) && (Vt = H8(Gr)), Xt( + 161 + /* FromKeyword */ + ), rr = TT()) : (Vt = q8( + 280 + /* NamedExports */ + ), (Q() === 161 || Q() === 11 && !t.hasPrecedingLineBreak()) && (Xt( + 161 + /* FromKeyword */ + ), rr = TT())); + const ii = Q(); + rr && (ii === 118 || ii === 132) && !t.hasPrecedingLineBreak() && (Rn = b1(ii)), Fa(), ki(bt); + const ji = m.createExportDeclaration(He, gn, Vt, rr, Rn); + return pn(zt(ji, X), De); + } + function Yv(X, De, He) { + const bt = qe(); + ki( + /*value*/ + !0 + ); + let Vt; + zi( + 64 + /* EqualsToken */ + ) ? Vt = !0 : Xt( + 90 + /* DefaultKeyword */ + ); + const rr = f_( + /*allowReturnTypeInArrowFunction*/ + !0 + ); + Fa(), ki(bt); + const Rn = m.createExportAssignment(He, Vt, rr); + return pn(zt(Rn, X), De); + } + let fg; + ((X) => { + X[X.SourceElements = 0] = "SourceElements", X[X.BlockStatements = 1] = "BlockStatements", X[X.SwitchClauses = 2] = "SwitchClauses", X[X.SwitchClauseStatements = 3] = "SwitchClauseStatements", X[X.TypeMembers = 4] = "TypeMembers", X[X.ClassMembers = 5] = "ClassMembers", X[X.EnumMembers = 6] = "EnumMembers", X[X.HeritageClauseElement = 7] = "HeritageClauseElement", X[X.VariableDeclarations = 8] = "VariableDeclarations", X[X.ObjectBindingElements = 9] = "ObjectBindingElements", X[X.ArrayBindingElements = 10] = "ArrayBindingElements", X[X.ArgumentExpressions = 11] = "ArgumentExpressions", X[X.ObjectLiteralMembers = 12] = "ObjectLiteralMembers", X[X.JsxAttributes = 13] = "JsxAttributes", X[X.JsxChildren = 14] = "JsxChildren", X[X.ArrayLiteralMembers = 15] = "ArrayLiteralMembers", X[X.Parameters = 16] = "Parameters", X[X.JSDocParameters = 17] = "JSDocParameters", X[X.RestProperties = 18] = "RestProperties", X[X.TypeParameters = 19] = "TypeParameters", X[X.TypeArguments = 20] = "TypeArguments", X[X.TupleElementTypes = 21] = "TupleElementTypes", X[X.HeritageClauses = 22] = "HeritageClauses", X[X.ImportOrExportSpecifiers = 23] = "ImportOrExportSpecifiers", X[X.ImportAttributes = 24] = "ImportAttributes", X[X.JSDocComment = 25] = "JSDocComment", X[X.Count = 26] = "Count"; + })(fg || (fg = {})); + let DE; + ((X) => { + X[X.False = 0] = "False", X[X.True = 1] = "True", X[X.Unknown = 2] = "Unknown"; + })(DE || (DE = {})); + let Lm; + ((X) => { + function De(ii, ji, fo) { + Dt( + "file.js", + ii, + 99, + /*syntaxCursor*/ + void 0, + 1, + 0 + /* ParseAll */ + ), t.setText(ii, ji, fo), Ee = t.scan(); + const Ka = He(), La = ft( + "file.js", + 99, + 1, + /*isDeclarationFile*/ + !1, + [], + A( + 1 + /* EndOfFileToken */ + ), + 0, + Ha + ), Tp = Px(Se, La); + return ie && (La.jsDocDiagnostics = Px(ie, La)), Mn(), Ka ? { jsDocTypeExpression: Ka, diagnostics: Tp } : void 0; + } + X.parseJSDocTypeExpressionForTests = De; + function He(ii) { + const ji = M(), fo = (ii ? zi : Xt)( + 19 + /* OpenBraceToken */ + ), Ka = Ks(16777216, zd); + (!ii || fo) && Zo( + 20 + /* CloseBraceToken */ + ); + const La = m.createJSDocTypeExpression(Ka); + return Je(La), zt(La, ji); + } + X.parseJSDocTypeExpression = He; + function bt() { + const ii = M(), ji = zi( + 19 + /* OpenBraceToken */ + ), fo = M(); + let Ka = et( + /*allowReservedWords*/ + !1 + ); + for (; Q() === 81; ) + vt(), at(), Ka = zt(m.createJSDocMemberName(Ka, _o()), fo); + ji && Zo( + 20 + /* CloseBraceToken */ + ); + const La = m.createJSDocNameReference(Ka); + return Je(La), zt(La, ii); + } + X.parseJSDocNameReference = bt; + function Vt(ii, ji, fo) { + Dt( + "", + ii, + 99, + /*syntaxCursor*/ + void 0, + 1, + 0 + /* ParseAll */ + ); + const Ka = Ks(16777216, () => Gr(ji, fo)), Tp = Px(Se, { languageVariant: 0, text: ii }); + return Mn(), Ka ? { jsDoc: Ka, diagnostics: Tp } : void 0; + } + X.parseIsolatedJSDocComment = Vt; + function rr(ii, ji, fo) { + const Ka = Ee, La = Se.length, Tp = Wt, Gf = Ks(16777216, () => Gr(ji, fo)); + return za(Gf, ii), Nr & 524288 && (ie || (ie = []), In(ie, Se, La)), Ee = Ka, Se.length = La, Wt = Tp, Gf; + } + X.parseJSDocComment = rr; + let Rn; + ((ii) => { + ii[ii.BeginningOfLine = 0] = "BeginningOfLine", ii[ii.SawAsterisk = 1] = "SawAsterisk", ii[ii.SavingComments = 2] = "SavingComments", ii[ii.SavingBackticks = 3] = "SavingBackticks"; + })(Rn || (Rn = {})); + let gn; + ((ii) => { + ii[ii.Property = 1] = "Property", ii[ii.Parameter = 2] = "Parameter", ii[ii.CallbackParameter = 4] = "CallbackParameter"; + })(gn || (gn = {})); + function Gr(ii = 0, ji) { + const fo = Te, Ka = ji === void 0 ? fo.length : ii + ji; + if (ji = Ka - ii, E.assert(ii >= 0), E.assert(ii <= Ka), E.assert(Ka <= fo.length), !Wz(fo, ii)) + return; + let La, Tp, Gf, X0, Q0, rh = []; + const S1 = [], Ra = Bt; + Bt |= 1 << 25; + const dl = t.scanRange(ii + 3, ji - 5, Y0); + return Bt = Ra, dl; + function Y0() { + let Cr = 1, En, Ln = ii - (fo.lastIndexOf(` +`, ii) + 1) + 4; + function pi(po) { + En || (En = Ln), rh.push(po), Ln += po.length; + } + for (at(); Hd( + 5 + /* WhitespaceTrivia */ + ); ) ; + Hd( + 4 + /* NewLineTrivia */ + ) && (Cr = 0, Ln = 0); + e: + for (; ; ) { + switch (Q()) { + case 60: + Xk(rh), Q0 || (Q0 = M()), No(v(Ln)), Cr = 0, En = void 0; + break; + case 4: + rh.push(t.getTokenText()), Cr = 0, Ln = 0; + break; + case 42: + const po = t.getTokenText(); + Cr === 1 ? (Cr = 2, pi(po)) : (E.assert( + Cr === 0 + /* BeginningOfLine */ + ), Cr = 1, Ln += po.length); + break; + case 5: + E.assert(Cr !== 2, "whitespace shouldn't come from the scanner while saving top-level comment text"); + const Ql = t.getTokenText(); + En !== void 0 && Ln + Ql.length > En && rh.push(Ql.slice(En - Ln)), Ln += Ql.length; + break; + case 1: + break e; + case 82: + Cr = 2, pi(t.getTokenValue()); + break; + case 19: + Cr = 2; + const Gd = t.getTokenFullStart(), ed = t.getTokenEnd() - 1, vd = oe(ed); + if (vd) { + X0 || Ru(rh), S1.push(zt(m.createJSDocText(rh.join("")), X0 ?? ii, Gd)), S1.push(vd), rh = [], X0 = t.getTokenEnd(); + break; + } + // fallthrough if it's not a {@link sequence + default: + Cr = 2, pi(t.getTokenText()); + break; + } + Cr === 2 ? wt( + /*inBackticks*/ + !1 + ) : at(); + } + const yi = rh.join("").trimEnd(); + S1.length && yi.length && S1.push(zt(m.createJSDocText(yi), X0 ?? ii, Q0)), S1.length && La && E.assertIsDefined(Q0, "having parsed tags implies that the end of the comment span should be set"); + const ia = La && va(La, Tp, Gf); + return zt(m.createJSDocComment(S1.length ? va(S1, ii, Q0) : yi.length ? yi : void 0, ia), ii, Ka); + } + function Ru(Cr) { + for (; Cr.length && (Cr[0] === ` +` || Cr[0] === "\r"); ) + Cr.shift(); + } + function Xk(Cr) { + for (; Cr.length; ) { + const En = Cr[Cr.length - 1].trimEnd(); + if (En === "") + Cr.pop(); + else if (En.length < Cr[Cr.length - 1].length) { + Cr[Cr.length - 1] = En; + break; + } else + break; + } + } + function nh() { + for (; ; ) { + if (at(), Q() === 1) + return !0; + if (!(Q() === 5 || Q() === 4)) + return !1; + } + } + function pg() { + if (!((Q() === 5 || Q() === 4) && kt(nh))) + for (; Q() === 5 || Q() === 4; ) + at(); + } + function tn() { + if ((Q() === 5 || Q() === 4) && kt(nh)) + return ""; + let Cr = t.hasPrecedingLineBreak(), En = !1, Ln = ""; + for (; Cr && Q() === 42 || Q() === 5 || Q() === 4; ) + Ln += t.getTokenText(), Q() === 4 ? (Cr = !0, En = !0, Ln = "") : Q() === 42 && (Cr = !1), at(); + return En ? Ln : ""; + } + function v(Cr) { + E.assert( + Q() === 60 + /* AtToken */ + ); + const En = t.getTokenStart(); + at(); + const Ln = hf( + /*message*/ + void 0 + ), pi = tn(); + let yi; + switch (Ln.escapedText) { + case "author": + yi = G8(En, Ln, Cr, pi); + break; + case "implements": + yi = x1(En, Ln, Cr, pi); + break; + case "augments": + case "extends": + yi = Tfe(En, Ln, Cr, pi); + break; + case "class": + case "constructor": + yi = Zk(En, m.createJSDocClassTag, Ln, Cr, pi); + break; + case "public": + yi = Zk(En, m.createJSDocPublicTag, Ln, Cr, pi); + break; + case "private": + yi = Zk(En, m.createJSDocPrivateTag, Ln, Cr, pi); + break; + case "protected": + yi = Zk(En, m.createJSDocProtectedTag, Ln, Cr, pi); + break; + case "readonly": + yi = Zk(En, m.createJSDocReadonlyTag, Ln, Cr, pi); + break; + case "override": + yi = Zk(En, m.createJSDocOverrideTag, Ln, Cr, pi); + break; + case "deprecated": + fi = !0, yi = Zk(En, m.createJSDocDeprecatedTag, Ln, Cr, pi); + break; + case "this": + yi = WG(En, Ln, Cr, pi); + break; + case "enum": + yi = iP(En, Ln, Cr, pi); + break; + case "arg": + case "argument": + case "param": + return Qk(En, Ln, 2, Cr); + case "return": + case "returns": + yi = rP(En, Ln, Cr, pi); + break; + case "template": + yi = Yr(En, Ln, Cr, pi); + break; + case "type": + yi = Yk(En, Ln, Cr, pi); + break; + case "typedef": + yi = UG(En, Ln, Cr, pi); + break; + case "callback": + yi = qG(En, Ln, Cr, pi); + break; + case "overload": + yi = Cfe(En, Ln, Cr, pi); + break; + case "satisfies": + yi = xfe(En, Ln, Cr, pi); + break; + case "see": + yi = bfe(En, Ln, Cr, pi); + break; + case "exception": + case "throws": + yi = Sfe(En, Ln, Cr, pi); + break; + case "import": + yi = kfe(En, Ln, Cr, pi); + break; + default: + yi = ls(En, Ln, Cr, pi); + break; + } + return yi; + } + function w(Cr, En, Ln, pi) { + return pi || (Ln += En - Cr), j(Ln, pi.slice(Ln)); + } + function j(Cr, En) { + const Ln = M(); + let pi = []; + const yi = []; + let ia, po = 0, Ql; + function Gd(ih) { + Ql || (Ql = Cr), pi.push(ih), Cr += ih.length; + } + En !== void 0 && (En !== "" && Gd(En), po = 1); + let ed = Q(); + e: + for (; ; ) { + switch (ed) { + case 4: + po = 0, pi.push(t.getTokenText()), Cr = 0; + break; + case 60: + t.resetTokenState(t.getTokenEnd() - 1); + break e; + case 1: + break e; + case 5: + E.assert(po !== 2 && po !== 3, "whitespace shouldn't come from the scanner while saving comment text"); + const ih = t.getTokenText(); + Ql !== void 0 && Cr + ih.length > Ql && (pi.push(ih.slice(Ql - Cr)), po = 2), Cr += ih.length; + break; + case 19: + po = 2; + const Xh = t.getTokenFullStart(), wE = t.getTokenEnd() - 1, aP = oe(wE); + aP ? (yi.push(zt(m.createJSDocText(pi.join("")), ia ?? Ln, Xh)), yi.push(aP), pi = [], ia = t.getTokenEnd()) : Gd(t.getTokenText()); + break; + case 62: + po === 3 ? po = 2 : po = 3, Gd(t.getTokenText()); + break; + case 82: + po !== 3 && (po = 2), Gd(t.getTokenValue()); + break; + case 42: + if (po === 0) { + po = 1, Cr += 1; + break; + } + // record the * as a comment + // falls through + default: + po !== 3 && (po = 2), Gd(t.getTokenText()); + break; + } + po === 2 || po === 3 ? ed = wt( + po === 3 + /* SavingBackticks */ + ) : ed = at(); + } + Ru(pi); + const vd = pi.join("").trimEnd(); + if (yi.length) + return vd.length && yi.push(zt(m.createJSDocText(vd), ia ?? Ln)), va(yi, Ln, t.getTokenEnd()); + if (vd.length) + return vd; + } + function oe(Cr) { + const En = cr(qt); + if (!En) + return; + at(), pg(); + const Ln = Ue(), pi = []; + for (; Q() !== 20 && Q() !== 4 && Q() !== 1; ) + pi.push(t.getTokenText()), at(); + const yi = En === "link" ? m.createJSDocLink : En === "linkcode" ? m.createJSDocLinkCode : m.createJSDocLinkPlain; + return zt(yi(Ln, pi.join("")), Cr, t.getTokenEnd()); + } + function Ue() { + if (v_(Q())) { + const Cr = M(); + let En = ge(); + for (; zi( + 25 + /* DotToken */ + ); ) + En = zt(m.createQualifiedName(En, Q() === 81 ? Za( + 80, + /*reportAtCurrentPosition*/ + !1 + ) : ge()), Cr); + for (; Q() === 81; ) + vt(), at(), En = zt(m.createJSDocMemberName(En, _o()), Cr); + return En; + } + } + function qt() { + if (tn(), Q() === 19 && at() === 60 && v_(at())) { + const Cr = t.getTokenValue(); + if (hn(Cr)) return Cr; + } + } + function hn(Cr) { + return Cr === "link" || Cr === "linkcode" || Cr === "linkplain"; + } + function ls(Cr, En, Ln, pi) { + return zt(m.createJSDocUnknownTag(En, w(Cr, M(), Ln, pi)), Cr); + } + function No(Cr) { + Cr && (La ? La.push(Cr) : (La = [Cr], Tp = Cr.pos), Gf = Cr.end); + } + function wf() { + return tn(), Q() === 19 ? He() : void 0; + } + function T1() { + const Cr = Hd( + 23 + /* OpenBracketToken */ + ); + Cr && pg(); + const En = Hd( + 62 + /* BacktickToken */ + ), Ln = GG(); + return En && ta( + 62 + /* BacktickToken */ + ), Cr && (pg(), hs( + 64 + /* EqualsToken */ + ) && Yu(), Xt( + 24 + /* CloseBracketToken */ + )), { name: Ln, isBracketed: Cr }; + } + function qd(Cr) { + switch (Cr.kind) { + case 151: + return !0; + case 189: + return qd(Cr.elementType); + default: + return of(Cr) && Me(Cr.typeName) && Cr.typeName.escapedText === "Object" && !Cr.typeArguments; + } + } + function Qk(Cr, En, Ln, pi) { + let yi = wf(), ia = !yi; + tn(); + const { name: po, isBracketed: Ql } = T1(), Gd = tn(); + ia && !kt(qt) && (yi = wf()); + const ed = w(Cr, M(), pi, Gd), vd = vfe(yi, po, Ln, pi); + vd && (yi = vd, ia = !0); + const ih = Ln === 1 ? m.createJSDocPropertyTag(En, po, Ql, yi, ia, ed) : m.createJSDocParameterTag(En, po, Ql, yi, ia, ed); + return zt(ih, Cr); + } + function vfe(Cr, En, Ln, pi) { + if (Cr && qd(Cr.type)) { + const yi = M(); + let ia, po; + for (; ia = cr(() => xT(Ln, pi, En)); ) + ia.kind === 342 || ia.kind === 349 ? po = Er(po, ia) : ia.kind === 346 && yt(ia.tagName, p.A_JSDoc_template_tag_may_not_follow_a_typedef_callback_or_overload_tag); + if (po) { + const Ql = zt(m.createJSDocTypeLiteral( + po, + Cr.type.kind === 189 + /* ArrayType */ + ), yi); + return zt(m.createJSDocTypeExpression(Ql), yi); + } + } + } + function rP(Cr, En, Ln, pi) { + ot(La, OF) && Pe(En.pos, t.getTokenStart(), p._0_tag_already_specified, Si(En.escapedText)); + const yi = wf(); + return zt(m.createJSDocReturnTag(En, yi, w(Cr, M(), Ln, pi)), Cr); + } + function Yk(Cr, En, Ln, pi) { + ot(La, R4) && Pe(En.pos, t.getTokenStart(), p._0_tag_already_specified, Si(En.escapedText)); + const yi = He( + /*mayOmitBraces*/ + !0 + ), ia = Ln !== void 0 && pi !== void 0 ? w(Cr, M(), Ln, pi) : void 0; + return zt(m.createJSDocTypeTag(En, yi, ia), Cr); + } + function bfe(Cr, En, Ln, pi) { + const ia = Q() === 23 || kt(() => at() === 60 && v_(at()) && hn(t.getTokenValue())) ? void 0 : bt(), po = Ln !== void 0 && pi !== void 0 ? w(Cr, M(), Ln, pi) : void 0; + return zt(m.createJSDocSeeTag(En, ia, po), Cr); + } + function Sfe(Cr, En, Ln, pi) { + const yi = wf(), ia = w(Cr, M(), Ln, pi); + return zt(m.createJSDocThrowsTag(En, yi, ia), Cr); + } + function G8(Cr, En, Ln, pi) { + const yi = M(), ia = zG(); + let po = t.getTokenFullStart(); + const Ql = w(Cr, po, Ln, pi); + Ql || (po = t.getTokenFullStart()); + const Gd = typeof Ql != "string" ? va(Bi([zt(ia, yi, po)], Ql), yi) : ia.text + Ql; + return zt(m.createJSDocAuthorTag(En, Gd), Cr); + } + function zG() { + const Cr = []; + let En = !1, Ln = t.getToken(); + for (; Ln !== 1 && Ln !== 4; ) { + if (Ln === 30) + En = !0; + else { + if (Ln === 60 && !En) + break; + if (Ln === 32 && En) { + Cr.push(t.getTokenText()), t.resetTokenState(t.getTokenEnd()); + break; + } + } + Cr.push(t.getTokenText()), Ln = at(); + } + return m.createJSDocText(Cr.join("")); + } + function x1(Cr, En, Ln, pi) { + const yi = P2(); + return zt(m.createJSDocImplementsTag(En, yi, w(Cr, M(), Ln, pi)), Cr); + } + function Tfe(Cr, En, Ln, pi) { + const yi = P2(); + return zt(m.createJSDocAugmentsTag(En, yi, w(Cr, M(), Ln, pi)), Cr); + } + function xfe(Cr, En, Ln, pi) { + const yi = He( + /*mayOmitBraces*/ + !1 + ), ia = Ln !== void 0 && pi !== void 0 ? w(Cr, M(), Ln, pi) : void 0; + return zt(m.createJSDocSatisfiesTag(En, yi, ia), Cr); + } + function kfe(Cr, En, Ln, pi) { + const yi = t.getTokenFullStart(); + let ia; + vr() && (ia = _o()); + const po = Zw( + ia, + yi, + 156, + /*skipJsDocLeadingAsterisks*/ + !0 + ), Ql = TT(), Gd = $k(), ed = Ln !== void 0 && pi !== void 0 ? w(Cr, M(), Ln, pi) : void 0; + return zt(m.createJSDocImportTag(En, po, Ql, Gd, ed), Cr); + } + function P2() { + const Cr = zi( + 19 + /* OpenBraceToken */ + ), En = M(), Ln = nP(); + t.setSkipJsDocLeadingAsterisks(!0); + const pi = Ho(); + t.setSkipJsDocLeadingAsterisks(!1); + const yi = m.createExpressionWithTypeArguments(Ln, pi), ia = zt(yi, En); + return Cr && (pg(), Xt( + 20 + /* CloseBraceToken */ + )), ia; + } + function nP() { + const Cr = M(); + let En = hf(); + for (; zi( + 25 + /* DotToken */ + ); ) { + const Ln = hf(); + En = zt(R(En, Ln), Cr); + } + return En; + } + function Zk(Cr, En, Ln, pi, yi) { + return zt(En(Ln, w(Cr, M(), pi, yi)), Cr); + } + function WG(Cr, En, Ln, pi) { + const yi = He( + /*mayOmitBraces*/ + !0 + ); + return pg(), zt(m.createJSDocThisTag(En, yi, w(Cr, M(), Ln, pi)), Cr); + } + function iP(Cr, En, Ln, pi) { + const yi = He( + /*mayOmitBraces*/ + !0 + ); + return pg(), zt(m.createJSDocEnumTag(En, yi, w(Cr, M(), Ln, pi)), Cr); + } + function UG(Cr, En, Ln, pi) { + let yi = wf(); + tn(); + const ia = $8(); + pg(); + let po = j(Ln), Ql; + if (!yi || qd(yi.type)) { + let ed, vd, ih, Xh = !1; + for (; (ed = cr(() => Dfe(Ln))) && ed.kind !== 346; ) + if (Xh = !0, ed.kind === 345) + if (vd) { + const wE = Lt(p.A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags); + wE && zs(wE, wx(Z, Te, 0, 0, p.The_tag_was_first_specified_here)); + break; + } else + vd = ed; + else + ih = Er(ih, ed); + if (Xh) { + const wE = yi && yi.type.kind === 189, aP = m.createJSDocTypeLiteral(ih, wE); + yi = vd && vd.typeExpression && !qd(vd.typeExpression.type) ? vd.typeExpression : zt(aP, Cr), Ql = yi.end; + } + } + Ql = Ql || po !== void 0 ? M() : (ia ?? yi ?? En).end, po || (po = w(Cr, Ql, Ln, pi)); + const Gd = m.createJSDocTypedefTag(En, yi, ia, po); + return zt(Gd, Cr, Ql); + } + function $8(Cr) { + const En = t.getTokenStart(); + if (!v_(Q())) + return; + const Ln = hf(); + if (zi( + 25 + /* DotToken */ + )) { + const pi = $8( + /*nested*/ + !0 + ), yi = m.createModuleDeclaration( + /*modifiers*/ + void 0, + Ln, + pi, + Cr ? 8 : void 0 + ); + return zt(yi, En); + } + return Cr && (Ln.flags |= 4096), Ln; + } + function sP(Cr) { + const En = M(); + let Ln, pi; + for (; Ln = cr(() => xT(4, Cr)); ) { + if (Ln.kind === 346) { + yt(Ln.tagName, p.A_JSDoc_template_tag_may_not_follow_a_typedef_callback_or_overload_tag); + break; + } + pi = Er(pi, Ln); + } + return va(pi || [], En); + } + function VG(Cr, En) { + const Ln = sP(En), pi = cr(() => { + if (Hd( + 60 + /* AtToken */ + )) { + const yi = v(En); + if (yi && yi.kind === 343) + return yi; + } + }); + return zt(m.createJSDocSignature( + /*typeParameters*/ + void 0, + Ln, + pi + ), Cr); + } + function qG(Cr, En, Ln, pi) { + const yi = $8(); + pg(); + let ia = j(Ln); + const po = VG(Cr, Ln); + ia || (ia = w(Cr, M(), Ln, pi)); + const Ql = ia !== void 0 ? M() : po.end; + return zt(m.createJSDocCallbackTag(En, po, yi, ia), Cr, Ql); + } + function Cfe(Cr, En, Ln, pi) { + pg(); + let yi = j(Ln); + const ia = VG(Cr, Ln); + yi || (yi = w(Cr, M(), Ln, pi)); + const po = yi !== void 0 ? M() : ia.end; + return zt(m.createJSDocOverloadTag(En, ia, yi), Cr, po); + } + function Efe(Cr, En) { + for (; !Me(Cr) || !Me(En); ) + if (!Me(Cr) && !Me(En) && Cr.right.escapedText === En.right.escapedText) + Cr = Cr.left, En = En.left; + else + return !1; + return Cr.escapedText === En.escapedText; + } + function Dfe(Cr) { + return xT(1, Cr); + } + function xT(Cr, En, Ln) { + let pi = !0, yi = !1; + for (; ; ) + switch (at()) { + case 60: + if (pi) { + const ia = HG(Cr, En); + return ia && (ia.kind === 342 || ia.kind === 349) && Ln && (Me(ia.name) || !Efe(Ln, ia.name.left)) ? !1 : ia; + } + yi = !1; + break; + case 4: + pi = !0, yi = !1; + break; + case 42: + yi && (pi = !1), yi = !0; + break; + case 80: + pi = !1; + break; + case 1: + return !1; + } + } + function HG(Cr, En) { + E.assert( + Q() === 60 + /* AtToken */ + ); + const Ln = t.getTokenFullStart(); + at(); + const pi = hf(), yi = tn(); + let ia; + switch (pi.escapedText) { + case "type": + return Cr === 1 && Yk(Ln, pi); + case "prop": + case "property": + ia = 1; + break; + case "arg": + case "argument": + case "param": + ia = 6; + break; + case "template": + return Yr(Ln, pi, En, yi); + case "this": + return WG(Ln, pi, En, yi); + default: + return !1; + } + return Cr & ia ? Qk(Ln, pi, Cr, En) : !1; + } + function wfe() { + const Cr = M(), En = Hd( + 23 + /* OpenBracketToken */ + ); + En && pg(); + const Ln = gi( + /*allowDecorators*/ + !1, + /*permitConstAsModifier*/ + !0 + ), pi = hf(p.Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces); + let yi; + if (En && (pg(), Xt( + 64 + /* EqualsToken */ + ), yi = Ks(16777216, zd), Xt( + 24 + /* CloseBracketToken */ + )), !lc(pi)) + return zt(m.createTypeParameterDeclaration( + Ln, + pi, + /*constraint*/ + void 0, + yi + ), Cr); + } + function Z0() { + const Cr = M(), En = []; + do { + pg(); + const Ln = wfe(); + Ln !== void 0 && En.push(Ln), tn(); + } while (Hd( + 28 + /* CommaToken */ + )); + return va(En, Cr); + } + function Yr(Cr, En, Ln, pi) { + const yi = Q() === 19 ? He() : void 0, ia = Z0(); + return zt(m.createJSDocTemplateTag(En, yi, ia, w(Cr, M(), Ln, pi)), Cr); + } + function Hd(Cr) { + return Q() === Cr ? (at(), !0) : !1; + } + function GG() { + let Cr = hf(); + for (zi( + 23 + /* OpenBracketToken */ + ) && Xt( + 24 + /* CloseBracketToken */ + ); zi( + 25 + /* DotToken */ + ); ) { + const En = hf(); + zi( + 23 + /* OpenBracketToken */ + ) && Xt( + 24 + /* CloseBracketToken */ + ), Cr = Ut(Cr, En); + } + return Cr; + } + function hf(Cr) { + if (!v_(Q())) + return Za( + 80, + /*reportAtCurrentPosition*/ + !Cr, + Cr || p.Identifier_expected + ); + St++; + const En = t.getTokenStart(), Ln = t.getTokenEnd(), pi = Q(), yi = yc(t.getTokenValue()), ia = zt(D(yi, pi), En, Ln); + return at(), ia; + } + } + })(Lm = e.JSDocParser || (e.JSDocParser = {})); + })(pv || (pv = {})); + var eye = /* @__PURE__ */ new WeakSet(); + function eMe(e) { + eye.has(e) && E.fail("Source file has already been incrementally parsed"), eye.add(e); + } + var tye = /* @__PURE__ */ new WeakSet(); + function tMe(e) { + return tye.has(e); + } + function kre(e) { + tye.add(e); + } + var Vz; + ((e) => { + function t(T, k, D, P) { + if (P = P || E.shouldAssert( + 2 + /* Aggressive */ + ), m(T, k, D, P), eZ(D)) + return T; + if (T.statements.length === 0) + return pv.parseSourceFile( + T.fileName, + k, + T.languageVersion, + /*syntaxCursor*/ + void 0, + /*setParentNodes*/ + !0, + T.scriptKind, + T.setExternalModuleIndicator, + T.jsDocParsingMode + ); + eMe(T), pv.fixupParentReferences(T); + const A = T.text, O = h(T), F = u(T, D); + m(T, k, F, P), E.assert(F.span.start <= D.span.start), E.assert(ec(F.span) === ec(D.span)), E.assert(ec(vD(F)) === ec(vD(D))); + const R = vD(F).length - F.span.length; + _(T, F.span.start, ec(F.span), ec(vD(F)), R, A, k, P); + const B = pv.parseSourceFile( + T.fileName, + k, + T.languageVersion, + O, + /*setParentNodes*/ + !0, + T.scriptKind, + T.setExternalModuleIndicator, + T.jsDocParsingMode + ); + return B.commentDirectives = n( + T.commentDirectives, + B.commentDirectives, + F.span.start, + ec(F.span), + R, + A, + k, + P + ), B.impliedNodeFormat = T.impliedNodeFormat, ere(T, B), B; + } + e.updateSourceFile = t; + function n(T, k, D, P, A, O, F, R) { + if (!T) return k; + let B, U = !1; + for (const W of T) { + const { range: _e, type: K } = W; + if (_e.end < D) + B = Er(B, W); + else if (_e.pos > P) { + $(); + const V = { + range: { pos: _e.pos + A, end: _e.end + A }, + type: K + }; + B = Er(B, V), R && E.assert(O.substring(_e.pos, _e.end) === F.substring(V.range.pos, V.range.end)); + } + } + return $(), B; + function $() { + U || (U = !0, B ? k && B.push(...k) : B = k); + } + } + function i(T, k, D, P, A, O, F) { + D ? B(T) : R(T); + return; + function R(U) { + let $ = ""; + if (F && s(U) && ($ = A.substring(U.pos, U.end)), Pz(U, k), Ad(U, U.pos + P, U.end + P), F && s(U) && E.assert($ === O.substring(U.pos, U.end)), xs(U, R, B), kf(U)) + for (const W of U.jsDoc) + R(W); + c(U, F); + } + function B(U) { + Ad(U, U.pos + P, U.end + P); + for (const $ of U) + R($); + } + } + function s(T) { + switch (T.kind) { + case 11: + case 9: + case 80: + return !0; + } + return !1; + } + function o(T, k, D, P, A) { + E.assert(T.end >= k, "Adjusting an element that was entirely before the change range"), E.assert(T.pos <= D, "Adjusting an element that was entirely after the change range"), E.assert(T.pos <= T.end); + const O = Math.min(T.pos, P), F = T.end >= D ? ( + // Element ends after the change range. Always adjust the end pos. + T.end + A + ) : ( + // Element ends in the change range. The element will keep its position if + // possible. Or Move backward to the new-end if it's in the 'Y' range. + Math.min(T.end, P) + ); + if (E.assert(O <= F), T.parent) { + const R = T.parent; + E.assertGreaterThanOrEqual(O, R.pos), E.assertLessThanOrEqual(F, R.end); + } + Ad(T, O, F); + } + function c(T, k) { + if (k) { + let D = T.pos; + const P = (A) => { + E.assert(A.pos >= D), D = A.end; + }; + if (kf(T)) + for (const A of T.jsDoc) + P(A); + xs(T, P), E.assert(D <= T.end); + } + } + function _(T, k, D, P, A, O, F, R) { + B(T); + return; + function B($) { + if (E.assert($.pos <= $.end), $.pos > D) { + i( + $, + T, + /*isArray*/ + !1, + A, + O, + F, + R + ); + return; + } + const W = $.end; + if (W >= k) { + if (kre($), Pz($, T), o($, k, D, P, A), xs($, B, U), kf($)) + for (const _e of $.jsDoc) + B(_e); + c($, R); + return; + } + E.assert(W < k); + } + function U($) { + if (E.assert($.pos <= $.end), $.pos > D) { + i( + $, + T, + /*isArray*/ + !0, + A, + O, + F, + R + ); + return; + } + const W = $.end; + if (W >= k) { + kre($), o($, k, D, P, A); + for (const _e of $) + B(_e); + return; + } + E.assert(W < k); + } + } + function u(T, k) { + let P = k.span.start; + for (let F = 0; P > 0 && F <= 1; F++) { + const R = g(T, P); + E.assert(R.pos <= P); + const B = R.pos; + P = Math.max(0, B - 1); + } + const A = Nc(P, ec(k.span)), O = k.newLength + (k.span.start - P); + return r3(A, O); + } + function g(T, k) { + let D = T, P; + if (xs(T, O), P) { + const F = A(P); + F.pos > D.pos && (D = F); + } + return D; + function A(F) { + for (; ; ) { + const R = hJ(F); + if (R) + F = R; + else + return F; + } + } + function O(F) { + if (!lc(F)) + if (F.pos <= k) { + if (F.pos >= D.pos && (D = F), k < F.end) + return xs(F, O), !0; + E.assert(F.end <= k), P = F; + } else + return E.assert(F.pos > k), !0; + } + } + function m(T, k, D, P) { + const A = T.text; + if (D && (E.assert(A.length - D.span.length + D.newLength === k.length), P || E.shouldAssert( + 3 + /* VeryAggressive */ + ))) { + const O = A.substr(0, D.span.start), F = k.substr(0, D.span.start); + E.assert(O === F); + const R = A.substring(ec(D.span), A.length), B = k.substring(ec(vD(D)), k.length); + E.assert(R === B); + } + } + function h(T) { + let k = T.statements, D = 0; + E.assert(D < k.length); + let P = k[D], A = -1; + return { + currentNode(F) { + return F !== A && (P && P.end === F && D < k.length - 1 && (D++, P = k[D]), (!P || P.pos !== F) && O(F)), A = F, E.assert(!P || P.pos === F), P; + } + }; + function O(F) { + k = void 0, D = -1, P = void 0, xs(T, R, B); + return; + function R(U) { + return F >= U.pos && F < U.end ? (xs(U, R, B), !0) : !1; + } + function B(U) { + if (F >= U.pos && F < U.end) + for (let $ = 0; $ < U.length; $++) { + const W = U[$]; + if (W) { + if (W.pos === F) + return k = U, D = $, P = W, !0; + if (W.pos < F && F < W.end) + return xs(W, R, B), !0; + } + } + return !1; + } + } + } + e.createSyntaxCursor = h; + let S; + ((T) => { + T[T.Value = -1] = "Value"; + })(S || (S = {})); + })(Vz || (Vz = {})); + function Il(e) { + return qF(e) !== void 0; + } + function qF(e) { + const t = ex( + e, + tF, + /*ignoreCase*/ + !1 + ); + if (t) + return t; + if (Xo( + e, + ".ts" + /* Ts */ + )) { + const n = Zc(e), i = n.lastIndexOf(".d."); + if (i >= 0) + return n.substring(i); + } + } + function rMe(e, t, n, i) { + if (e) { + if (e === "import") + return 99; + if (e === "require") + return 1; + i(t, n - t, p.resolution_mode_should_be_either_require_or_import); + } + } + function qz(e, t) { + const n = []; + for (const i of Eg(t, 0) || Ge) { + const s = t.substring(i.pos, i.end); + aMe(n, i, s); + } + e.pragmas = /* @__PURE__ */ new Map(); + for (const i of n) { + if (e.pragmas.has(i.name)) { + const s = e.pragmas.get(i.name); + s instanceof Array ? s.push(i.args) : e.pragmas.set(i.name, [s, i.args]); + continue; + } + e.pragmas.set(i.name, i.args); + } + } + function Hz(e, t) { + e.checkJsDirective = void 0, e.referencedFiles = [], e.typeReferenceDirectives = [], e.libReferenceDirectives = [], e.amdDependencies = [], e.hasNoDefaultLib = !1, e.pragmas.forEach((n, i) => { + switch (i) { + case "reference": { + const s = e.referencedFiles, o = e.typeReferenceDirectives, c = e.libReferenceDirectives; + lr(QT(n), (_) => { + const { types: u, lib: g, path: m, ["resolution-mode"]: h, preserve: S } = _.arguments, T = S === "true" ? !0 : void 0; + if (_.arguments["no-default-lib"] === "true") + e.hasNoDefaultLib = !0; + else if (u) { + const k = rMe(h, u.pos, u.end, t); + o.push({ pos: u.pos, end: u.end, fileName: u.value, ...k ? { resolutionMode: k } : {}, ...T ? { preserve: T } : {} }); + } else g ? c.push({ pos: g.pos, end: g.end, fileName: g.value, ...T ? { preserve: T } : {} }) : m ? s.push({ pos: m.pos, end: m.end, fileName: m.value, ...T ? { preserve: T } : {} }) : t(_.range.pos, _.range.end - _.range.pos, p.Invalid_reference_directive_syntax); + }); + break; + } + case "amd-dependency": { + e.amdDependencies = hr( + QT(n), + (s) => ({ name: s.arguments.name, path: s.arguments.path }) + ); + break; + } + case "amd-module": { + if (n instanceof Array) + for (const s of n) + e.moduleName && t(s.range.pos, s.range.end - s.range.pos, p.An_AMD_module_cannot_have_multiple_name_assignments), e.moduleName = s.arguments.name; + else + e.moduleName = n.arguments.name; + break; + } + case "ts-nocheck": + case "ts-check": { + lr(QT(n), (s) => { + (!e.checkJsDirective || s.range.pos > e.checkJsDirective.pos) && (e.checkJsDirective = { + enabled: i === "ts-check", + end: s.range.end, + pos: s.range.pos + }); + }); + break; + } + case "jsx": + case "jsxfrag": + case "jsximportsource": + case "jsxruntime": + return; + // Accessed directly + default: + E.fail("Unhandled pragma kind"); + } + }); + } + var Cre = /* @__PURE__ */ new Map(); + function nMe(e) { + if (Cre.has(e)) + return Cre.get(e); + const t = new RegExp(`(\\s${e}\\s*=\\s*)(?:(?:'([^']*)')|(?:"([^"]*)"))`, "im"); + return Cre.set(e, t), t; + } + var iMe = /^\/\/\/\s*<(\S+)\s.*?\/>/m, sMe = /^\/\/\/?\s*@([^\s:]+)((?:[^\S\r\n]|:).*)?$/m; + function aMe(e, t, n) { + const i = t.kind === 2 && iMe.exec(n); + if (i) { + const o = i[1].toLowerCase(), c = i7[o]; + if (!c || !(c.kind & 1)) + return; + if (c.args) { + const _ = {}; + for (const u of c.args) { + const m = nMe(u.name).exec(n); + if (!m && !u.optional) + return; + if (m) { + const h = m[2] || m[3]; + if (u.captureSpan) { + const S = t.pos + m.index + m[1].length + 1; + _[u.name] = { + value: h, + pos: S, + end: S + h.length + }; + } else + _[u.name] = h; + } + } + e.push({ name: o, args: { arguments: _, range: t } }); + } else + e.push({ name: o, args: { arguments: {}, range: t } }); + return; + } + const s = t.kind === 2 && sMe.exec(n); + if (s) + return rye(e, t, 2, s); + if (t.kind === 3) { + const o = /@(\S+)(\s+(?:\S.*)?)?$/gm; + let c; + for (; c = o.exec(n); ) + rye(e, t, 4, c); + } + } + function rye(e, t, n, i) { + if (!i) return; + const s = i[1].toLowerCase(), o = i7[s]; + if (!o || !(o.kind & n)) + return; + const c = i[2], _ = oMe(o, c); + _ !== "fail" && e.push({ name: s, args: { arguments: _, range: t } }); + } + function oMe(e, t) { + if (!t) return {}; + if (!e.args) return {}; + const n = t.trim().split(/\s+/), i = {}; + for (let s = 0; s < e.args.length; s++) { + const o = e.args[s]; + if (!n[s] && !o.optional) + return "fail"; + if (o.captureSpan) + return E.fail("Capture spans not yet implemented for non-xml pragmas"); + i[o.name] = n[s]; + } + return i; + } + function dv(e, t) { + return e.kind !== t.kind ? !1 : e.kind === 80 ? e.escapedText === t.escapedText : e.kind === 110 ? !0 : e.kind === 296 ? e.namespace.escapedText === t.namespace.escapedText && e.name.escapedText === t.name.escapedText : e.name.escapedText === t.name.escapedText && dv(e.expression, t.expression); + } + var Ere = { + name: "compileOnSave", + type: "boolean", + defaultValueDescription: !1 + }, nye = new Map(Object.entries({ + preserve: 1, + "react-native": 3, + "react-jsx": 4, + "react-jsxdev": 5, + react: 2 + /* React */ + })), eA = new Map(ZE(nye.entries(), ([e, t]) => ["" + t, e])), iye = [ + // JavaScript only + ["es5", "lib.es5.d.ts"], + ["es6", "lib.es2015.d.ts"], + ["es2015", "lib.es2015.d.ts"], + ["es7", "lib.es2016.d.ts"], + ["es2016", "lib.es2016.d.ts"], + ["es2017", "lib.es2017.d.ts"], + ["es2018", "lib.es2018.d.ts"], + ["es2019", "lib.es2019.d.ts"], + ["es2020", "lib.es2020.d.ts"], + ["es2021", "lib.es2021.d.ts"], + ["es2022", "lib.es2022.d.ts"], + ["es2023", "lib.es2023.d.ts"], + ["es2024", "lib.es2024.d.ts"], + ["esnext", "lib.esnext.d.ts"], + // Host only + ["dom", "lib.dom.d.ts"], + ["dom.iterable", "lib.dom.iterable.d.ts"], + ["dom.asynciterable", "lib.dom.asynciterable.d.ts"], + ["webworker", "lib.webworker.d.ts"], + ["webworker.importscripts", "lib.webworker.importscripts.d.ts"], + ["webworker.iterable", "lib.webworker.iterable.d.ts"], + ["webworker.asynciterable", "lib.webworker.asynciterable.d.ts"], + ["scripthost", "lib.scripthost.d.ts"], + // ES2015 Or ESNext By-feature options + ["es2015.core", "lib.es2015.core.d.ts"], + ["es2015.collection", "lib.es2015.collection.d.ts"], + ["es2015.generator", "lib.es2015.generator.d.ts"], + ["es2015.iterable", "lib.es2015.iterable.d.ts"], + ["es2015.promise", "lib.es2015.promise.d.ts"], + ["es2015.proxy", "lib.es2015.proxy.d.ts"], + ["es2015.reflect", "lib.es2015.reflect.d.ts"], + ["es2015.symbol", "lib.es2015.symbol.d.ts"], + ["es2015.symbol.wellknown", "lib.es2015.symbol.wellknown.d.ts"], + ["es2016.array.include", "lib.es2016.array.include.d.ts"], + ["es2016.intl", "lib.es2016.intl.d.ts"], + ["es2017.arraybuffer", "lib.es2017.arraybuffer.d.ts"], + ["es2017.date", "lib.es2017.date.d.ts"], + ["es2017.object", "lib.es2017.object.d.ts"], + ["es2017.sharedmemory", "lib.es2017.sharedmemory.d.ts"], + ["es2017.string", "lib.es2017.string.d.ts"], + ["es2017.intl", "lib.es2017.intl.d.ts"], + ["es2017.typedarrays", "lib.es2017.typedarrays.d.ts"], + ["es2018.asyncgenerator", "lib.es2018.asyncgenerator.d.ts"], + ["es2018.asynciterable", "lib.es2018.asynciterable.d.ts"], + ["es2018.intl", "lib.es2018.intl.d.ts"], + ["es2018.promise", "lib.es2018.promise.d.ts"], + ["es2018.regexp", "lib.es2018.regexp.d.ts"], + ["es2019.array", "lib.es2019.array.d.ts"], + ["es2019.object", "lib.es2019.object.d.ts"], + ["es2019.string", "lib.es2019.string.d.ts"], + ["es2019.symbol", "lib.es2019.symbol.d.ts"], + ["es2019.intl", "lib.es2019.intl.d.ts"], + ["es2020.bigint", "lib.es2020.bigint.d.ts"], + ["es2020.date", "lib.es2020.date.d.ts"], + ["es2020.promise", "lib.es2020.promise.d.ts"], + ["es2020.sharedmemory", "lib.es2020.sharedmemory.d.ts"], + ["es2020.string", "lib.es2020.string.d.ts"], + ["es2020.symbol.wellknown", "lib.es2020.symbol.wellknown.d.ts"], + ["es2020.intl", "lib.es2020.intl.d.ts"], + ["es2020.number", "lib.es2020.number.d.ts"], + ["es2021.promise", "lib.es2021.promise.d.ts"], + ["es2021.string", "lib.es2021.string.d.ts"], + ["es2021.weakref", "lib.es2021.weakref.d.ts"], + ["es2021.intl", "lib.es2021.intl.d.ts"], + ["es2022.array", "lib.es2022.array.d.ts"], + ["es2022.error", "lib.es2022.error.d.ts"], + ["es2022.intl", "lib.es2022.intl.d.ts"], + ["es2022.object", "lib.es2022.object.d.ts"], + ["es2022.string", "lib.es2022.string.d.ts"], + ["es2022.regexp", "lib.es2022.regexp.d.ts"], + ["es2023.array", "lib.es2023.array.d.ts"], + ["es2023.collection", "lib.es2023.collection.d.ts"], + ["es2023.intl", "lib.es2023.intl.d.ts"], + ["es2024.arraybuffer", "lib.es2024.arraybuffer.d.ts"], + ["es2024.collection", "lib.es2024.collection.d.ts"], + ["es2024.object", "lib.es2024.object.d.ts"], + ["es2024.promise", "lib.es2024.promise.d.ts"], + ["es2024.regexp", "lib.es2024.regexp.d.ts"], + ["es2024.sharedmemory", "lib.es2024.sharedmemory.d.ts"], + ["es2024.string", "lib.es2024.string.d.ts"], + ["esnext.array", "lib.es2023.array.d.ts"], + ["esnext.collection", "lib.esnext.collection.d.ts"], + ["esnext.symbol", "lib.es2019.symbol.d.ts"], + ["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"], + ["esnext.intl", "lib.esnext.intl.d.ts"], + ["esnext.disposable", "lib.esnext.disposable.d.ts"], + ["esnext.bigint", "lib.es2020.bigint.d.ts"], + ["esnext.string", "lib.es2022.string.d.ts"], + ["esnext.promise", "lib.es2024.promise.d.ts"], + ["esnext.weakref", "lib.es2021.weakref.d.ts"], + ["esnext.decorators", "lib.esnext.decorators.d.ts"], + ["esnext.object", "lib.es2024.object.d.ts"], + ["esnext.array", "lib.esnext.array.d.ts"], + ["esnext.regexp", "lib.es2024.regexp.d.ts"], + ["esnext.string", "lib.es2024.string.d.ts"], + ["esnext.iterator", "lib.esnext.iterator.d.ts"], + ["esnext.promise", "lib.esnext.promise.d.ts"], + ["esnext.float16", "lib.esnext.float16.d.ts"], + ["esnext.error", "lib.esnext.error.d.ts"], + ["esnext.sharedmemory", "lib.esnext.sharedmemory.d.ts"], + ["decorators", "lib.decorators.d.ts"], + ["decorators.legacy", "lib.decorators.legacy.d.ts"] + ], HF = iye.map((e) => e[0]), Gz = new Map(iye), rk = [ + { + name: "watchFile", + type: new Map(Object.entries({ + fixedpollinginterval: 0, + prioritypollinginterval: 1, + dynamicprioritypolling: 2, + fixedchunksizepolling: 3, + usefsevents: 4, + usefseventsonparentdirectory: 5 + /* UseFsEventsOnParentDirectory */ + })), + category: p.Watch_and_Build_Modes, + description: p.Specify_how_the_TypeScript_watch_mode_works, + defaultValueDescription: 4 + /* UseFsEvents */ + }, + { + name: "watchDirectory", + type: new Map(Object.entries({ + usefsevents: 0, + fixedpollinginterval: 1, + dynamicprioritypolling: 2, + fixedchunksizepolling: 3 + /* FixedChunkSizePolling */ + })), + category: p.Watch_and_Build_Modes, + description: p.Specify_how_directories_are_watched_on_systems_that_lack_recursive_file_watching_functionality, + defaultValueDescription: 0 + /* UseFsEvents */ + }, + { + name: "fallbackPolling", + type: new Map(Object.entries({ + fixedinterval: 0, + priorityinterval: 1, + dynamicpriority: 2, + fixedchunksize: 3 + /* FixedChunkSize */ + })), + category: p.Watch_and_Build_Modes, + description: p.Specify_what_approach_the_watcher_should_use_if_the_system_runs_out_of_native_file_watchers, + defaultValueDescription: 1 + /* PriorityInterval */ + }, + { + name: "synchronousWatchDirectory", + type: "boolean", + category: p.Watch_and_Build_Modes, + description: p.Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively, + defaultValueDescription: !1 + }, + { + name: "excludeDirectories", + type: "list", + element: { + name: "excludeDirectory", + type: "string", + isFilePath: !0, + extraValidation: Hre + }, + allowConfigDirTemplateSubstitution: !0, + category: p.Watch_and_Build_Modes, + description: p.Remove_a_list_of_directories_from_the_watch_process + }, + { + name: "excludeFiles", + type: "list", + element: { + name: "excludeFile", + type: "string", + isFilePath: !0, + extraValidation: Hre + }, + allowConfigDirTemplateSubstitution: !0, + category: p.Watch_and_Build_Modes, + description: p.Remove_a_list_of_files_from_the_watch_mode_s_processing + } + ], GF = [ + { + name: "help", + shortName: "h", + type: "boolean", + showInSimplifiedHelpView: !0, + isCommandLineOnly: !0, + category: p.Command_line_Options, + description: p.Print_this_message, + defaultValueDescription: !1 + }, + { + name: "help", + shortName: "?", + type: "boolean", + isCommandLineOnly: !0, + category: p.Command_line_Options, + defaultValueDescription: !1 + }, + { + name: "watch", + shortName: "w", + type: "boolean", + showInSimplifiedHelpView: !0, + isCommandLineOnly: !0, + category: p.Command_line_Options, + description: p.Watch_input_files, + defaultValueDescription: !1 + }, + { + name: "preserveWatchOutput", + type: "boolean", + showInSimplifiedHelpView: !1, + category: p.Output_Formatting, + description: p.Disable_wiping_the_console_in_watch_mode, + defaultValueDescription: !1 + }, + { + name: "listFiles", + type: "boolean", + category: p.Compiler_Diagnostics, + description: p.Print_all_of_the_files_read_during_the_compilation, + defaultValueDescription: !1 + }, + { + name: "explainFiles", + type: "boolean", + category: p.Compiler_Diagnostics, + description: p.Print_files_read_during_the_compilation_including_why_it_was_included, + defaultValueDescription: !1 + }, + { + name: "listEmittedFiles", + type: "boolean", + category: p.Compiler_Diagnostics, + description: p.Print_the_names_of_emitted_files_after_a_compilation, + defaultValueDescription: !1 + }, + { + name: "pretty", + type: "boolean", + showInSimplifiedHelpView: !0, + category: p.Output_Formatting, + description: p.Enable_color_and_formatting_in_TypeScript_s_output_to_make_compiler_errors_easier_to_read, + defaultValueDescription: !0 + }, + { + name: "traceResolution", + type: "boolean", + category: p.Compiler_Diagnostics, + description: p.Log_paths_used_during_the_moduleResolution_process, + defaultValueDescription: !1 + }, + { + name: "diagnostics", + type: "boolean", + category: p.Compiler_Diagnostics, + description: p.Output_compiler_performance_information_after_building, + defaultValueDescription: !1 + }, + { + name: "extendedDiagnostics", + type: "boolean", + category: p.Compiler_Diagnostics, + description: p.Output_more_detailed_compiler_performance_information_after_building, + defaultValueDescription: !1 + }, + { + name: "generateCpuProfile", + type: "string", + isFilePath: !0, + paramType: p.FILE_OR_DIRECTORY, + category: p.Compiler_Diagnostics, + description: p.Emit_a_v8_CPU_profile_of_the_compiler_run_for_debugging, + defaultValueDescription: "profile.cpuprofile" + }, + { + name: "generateTrace", + type: "string", + isFilePath: !0, + paramType: p.DIRECTORY, + category: p.Compiler_Diagnostics, + description: p.Generates_an_event_trace_and_a_list_of_types + }, + { + name: "incremental", + shortName: "i", + type: "boolean", + category: p.Projects, + description: p.Save_tsbuildinfo_files_to_allow_for_incremental_compilation_of_projects, + transpileOptionValue: void 0, + defaultValueDescription: p.false_unless_composite_is_set + }, + { + name: "declaration", + shortName: "d", + type: "boolean", + // Not setting affectsEmit because we calculate this flag might not affect full emit + affectsBuildInfo: !0, + showInSimplifiedHelpView: !0, + category: p.Emit, + transpileOptionValue: void 0, + description: p.Generate_d_ts_files_from_TypeScript_and_JavaScript_files_in_your_project, + defaultValueDescription: p.false_unless_composite_is_set + }, + { + name: "declarationMap", + type: "boolean", + // Not setting affectsEmit because we calculate this flag might not affect full emit + affectsBuildInfo: !0, + showInSimplifiedHelpView: !0, + category: p.Emit, + defaultValueDescription: !1, + description: p.Create_sourcemaps_for_d_ts_files + }, + { + name: "emitDeclarationOnly", + type: "boolean", + // Not setting affectsEmit because we calculate this flag might not affect full emit + affectsBuildInfo: !0, + showInSimplifiedHelpView: !0, + category: p.Emit, + description: p.Only_output_d_ts_files_and_not_JavaScript_files, + transpileOptionValue: void 0, + defaultValueDescription: !1 + }, + { + name: "sourceMap", + type: "boolean", + // Not setting affectsEmit because we calculate this flag might not affect full emit + affectsBuildInfo: !0, + showInSimplifiedHelpView: !0, + category: p.Emit, + defaultValueDescription: !1, + description: p.Create_source_map_files_for_emitted_JavaScript_files + }, + { + name: "inlineSourceMap", + type: "boolean", + // Not setting affectsEmit because we calculate this flag might not affect full emit + affectsBuildInfo: !0, + category: p.Emit, + description: p.Include_sourcemap_files_inside_the_emitted_JavaScript, + defaultValueDescription: !1 + }, + { + name: "noCheck", + type: "boolean", + showInSimplifiedHelpView: !1, + category: p.Compiler_Diagnostics, + description: p.Disable_full_type_checking_only_critical_parse_and_emit_errors_will_be_reported, + transpileOptionValue: !0, + defaultValueDescription: !1 + // Not setting affectsSemanticDiagnostics or affectsBuildInfo because we dont want all diagnostics to go away, its handled in builder + }, + { + name: "noEmit", + type: "boolean", + showInSimplifiedHelpView: !0, + category: p.Emit, + description: p.Disable_emitting_files_from_a_compilation, + transpileOptionValue: void 0, + defaultValueDescription: !1 + }, + { + name: "assumeChangesOnlyAffectDirectDependencies", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsEmit: !0, + affectsBuildInfo: !0, + category: p.Watch_and_Build_Modes, + description: p.Have_recompiles_in_projects_that_use_incremental_and_watch_mode_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it, + defaultValueDescription: !1 + }, + { + name: "locale", + type: "string", + category: p.Command_line_Options, + isCommandLineOnly: !0, + description: p.Set_the_language_of_the_messaging_from_TypeScript_This_does_not_affect_emit, + defaultValueDescription: p.Platform_specific + } + ], $z = { + name: "target", + shortName: "t", + type: new Map(Object.entries({ + es3: 0, + es5: 1, + es6: 2, + es2015: 2, + es2016: 3, + es2017: 4, + es2018: 5, + es2019: 6, + es2020: 7, + es2021: 8, + es2022: 9, + es2023: 10, + es2024: 11, + esnext: 99 + /* ESNext */ + })), + affectsSourceFile: !0, + affectsModuleResolution: !0, + affectsEmit: !0, + affectsBuildInfo: !0, + deprecatedKeys: /* @__PURE__ */ new Set(["es3"]), + paramType: p.VERSION, + showInSimplifiedHelpView: !0, + category: p.Language_and_Environment, + description: p.Set_the_JavaScript_language_version_for_emitted_JavaScript_and_include_compatible_library_declarations, + defaultValueDescription: 1 + /* ES5 */ + }, Dre = { + name: "module", + shortName: "m", + type: new Map(Object.entries({ + none: 0, + commonjs: 1, + amd: 2, + system: 4, + umd: 3, + es6: 5, + es2015: 5, + es2020: 6, + es2022: 7, + esnext: 99, + node16: 100, + node18: 101, + node20: 102, + nodenext: 199, + preserve: 200 + /* Preserve */ + })), + affectsSourceFile: !0, + affectsModuleResolution: !0, + affectsEmit: !0, + affectsBuildInfo: !0, + paramType: p.KIND, + showInSimplifiedHelpView: !0, + category: p.Modules, + description: p.Specify_what_module_code_is_generated, + defaultValueDescription: void 0 + }, sye = [ + // CommandLine only options + { + name: "all", + type: "boolean", + showInSimplifiedHelpView: !0, + category: p.Command_line_Options, + description: p.Show_all_compiler_options, + defaultValueDescription: !1 + }, + { + name: "version", + shortName: "v", + type: "boolean", + showInSimplifiedHelpView: !0, + category: p.Command_line_Options, + description: p.Print_the_compiler_s_version, + defaultValueDescription: !1 + }, + { + name: "init", + type: "boolean", + showInSimplifiedHelpView: !0, + category: p.Command_line_Options, + description: p.Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file, + defaultValueDescription: !1 + }, + { + name: "project", + shortName: "p", + type: "string", + isFilePath: !0, + showInSimplifiedHelpView: !0, + category: p.Command_line_Options, + paramType: p.FILE_OR_DIRECTORY, + description: p.Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json + }, + { + name: "showConfig", + type: "boolean", + showInSimplifiedHelpView: !0, + category: p.Command_line_Options, + isCommandLineOnly: !0, + description: p.Print_the_final_configuration_instead_of_building, + defaultValueDescription: !1 + }, + { + name: "listFilesOnly", + type: "boolean", + category: p.Command_line_Options, + isCommandLineOnly: !0, + description: p.Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing, + defaultValueDescription: !1 + }, + // Basic + $z, + Dre, + { + name: "lib", + type: "list", + element: { + name: "lib", + type: Gz, + defaultValueDescription: void 0 + }, + affectsProgramStructure: !0, + showInSimplifiedHelpView: !0, + category: p.Language_and_Environment, + description: p.Specify_a_set_of_bundled_library_declaration_files_that_describe_the_target_runtime_environment, + transpileOptionValue: void 0 + }, + { + name: "allowJs", + type: "boolean", + allowJsFlag: !0, + affectsBuildInfo: !0, + showInSimplifiedHelpView: !0, + category: p.JavaScript_Support, + description: p.Allow_JavaScript_files_to_be_a_part_of_your_program_Use_the_checkJs_option_to_get_errors_from_these_files, + defaultValueDescription: !1 + }, + { + name: "checkJs", + type: "boolean", + affectsModuleResolution: !0, + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + showInSimplifiedHelpView: !0, + category: p.JavaScript_Support, + description: p.Enable_error_reporting_in_type_checked_JavaScript_files, + defaultValueDescription: !1 + }, + { + name: "jsx", + type: nye, + affectsSourceFile: !0, + affectsEmit: !0, + affectsBuildInfo: !0, + affectsModuleResolution: !0, + // The checker emits an error when it sees JSX but this option is not set in compilerOptions. + // This is effectively a semantic error, so mark this option as affecting semantic diagnostics + // so we know to refresh errors when this option is changed. + affectsSemanticDiagnostics: !0, + paramType: p.KIND, + showInSimplifiedHelpView: !0, + category: p.Language_and_Environment, + description: p.Specify_what_JSX_code_is_generated, + defaultValueDescription: void 0 + }, + { + name: "outFile", + type: "string", + affectsEmit: !0, + affectsBuildInfo: !0, + affectsDeclarationPath: !0, + isFilePath: !0, + paramType: p.FILE, + showInSimplifiedHelpView: !0, + category: p.Emit, + description: p.Specify_a_file_that_bundles_all_outputs_into_one_JavaScript_file_If_declaration_is_true_also_designates_a_file_that_bundles_all_d_ts_output, + transpileOptionValue: void 0 + }, + { + name: "outDir", + type: "string", + affectsEmit: !0, + affectsBuildInfo: !0, + affectsDeclarationPath: !0, + isFilePath: !0, + paramType: p.DIRECTORY, + showInSimplifiedHelpView: !0, + category: p.Emit, + description: p.Specify_an_output_folder_for_all_emitted_files + }, + { + name: "rootDir", + type: "string", + affectsEmit: !0, + affectsBuildInfo: !0, + affectsDeclarationPath: !0, + isFilePath: !0, + paramType: p.LOCATION, + category: p.Modules, + description: p.Specify_the_root_folder_within_your_source_files, + defaultValueDescription: p.Computed_from_the_list_of_input_files + }, + { + name: "composite", + type: "boolean", + // Not setting affectsEmit because we calculate this flag might not affect full emit + affectsBuildInfo: !0, + isTSConfigOnly: !0, + category: p.Projects, + transpileOptionValue: void 0, + defaultValueDescription: !1, + description: p.Enable_constraints_that_allow_a_TypeScript_project_to_be_used_with_project_references + }, + { + name: "tsBuildInfoFile", + type: "string", + affectsEmit: !0, + affectsBuildInfo: !0, + isFilePath: !0, + paramType: p.FILE, + category: p.Projects, + transpileOptionValue: void 0, + defaultValueDescription: ".tsbuildinfo", + description: p.Specify_the_path_to_tsbuildinfo_incremental_compilation_file + }, + { + name: "removeComments", + type: "boolean", + affectsEmit: !0, + affectsBuildInfo: !0, + showInSimplifiedHelpView: !0, + category: p.Emit, + defaultValueDescription: !1, + description: p.Disable_emitting_comments + }, + { + name: "importHelpers", + type: "boolean", + affectsEmit: !0, + affectsBuildInfo: !0, + affectsSourceFile: !0, + category: p.Emit, + description: p.Allow_importing_helper_functions_from_tslib_once_per_project_instead_of_including_them_per_file, + defaultValueDescription: !1 + }, + { + name: "importsNotUsedAsValues", + type: new Map(Object.entries({ + remove: 0, + preserve: 1, + error: 2 + /* Error */ + })), + affectsEmit: !0, + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Backwards_Compatibility, + description: p.Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types, + defaultValueDescription: 0 + /* Remove */ + }, + { + name: "downlevelIteration", + type: "boolean", + affectsEmit: !0, + affectsBuildInfo: !0, + category: p.Emit, + description: p.Emit_more_compliant_but_verbose_and_less_performant_JavaScript_for_iteration, + defaultValueDescription: !1 + }, + { + name: "isolatedModules", + type: "boolean", + category: p.Interop_Constraints, + description: p.Ensure_that_each_file_can_be_safely_transpiled_without_relying_on_other_imports, + transpileOptionValue: !0, + defaultValueDescription: !1 + }, + { + name: "verbatimModuleSyntax", + type: "boolean", + affectsEmit: !0, + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Interop_Constraints, + description: p.Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_in_the_output_file_s_format_based_on_the_module_setting, + defaultValueDescription: !1 + }, + { + name: "isolatedDeclarations", + type: "boolean", + category: p.Interop_Constraints, + description: p.Require_sufficient_annotation_on_exports_so_other_tools_can_trivially_generate_declaration_files, + defaultValueDescription: !1, + affectsBuildInfo: !0, + affectsSemanticDiagnostics: !0 + }, + { + name: "erasableSyntaxOnly", + type: "boolean", + category: p.Interop_Constraints, + description: p.Do_not_allow_runtime_constructs_that_are_not_part_of_ECMAScript, + defaultValueDescription: !1, + affectsBuildInfo: !0, + affectsSemanticDiagnostics: !0 + }, + { + name: "libReplacement", + type: "boolean", + affectsProgramStructure: !0, + category: p.Language_and_Environment, + description: p.Enable_lib_replacement, + defaultValueDescription: !0 + }, + // Strict Type Checks + { + name: "strict", + type: "boolean", + // Though this affects semantic diagnostics, affectsSemanticDiagnostics is not set here + // The value of each strictFlag depends on own strictFlag value or this and never accessed directly. + // But we need to store `strict` in builf info, even though it won't be examined directly, so that the + // flags it controls (e.g. `strictNullChecks`) will be retrieved correctly + affectsBuildInfo: !0, + showInSimplifiedHelpView: !0, + category: p.Type_Checking, + description: p.Enable_all_strict_type_checking_options, + defaultValueDescription: !1 + }, + { + name: "noImplicitAny", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + strictFlag: !0, + category: p.Type_Checking, + description: p.Enable_error_reporting_for_expressions_and_declarations_with_an_implied_any_type, + defaultValueDescription: p.false_unless_strict_is_set + }, + { + name: "strictNullChecks", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + strictFlag: !0, + category: p.Type_Checking, + description: p.When_type_checking_take_into_account_null_and_undefined, + defaultValueDescription: p.false_unless_strict_is_set + }, + { + name: "strictFunctionTypes", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + strictFlag: !0, + category: p.Type_Checking, + description: p.When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible, + defaultValueDescription: p.false_unless_strict_is_set + }, + { + name: "strictBindCallApply", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + strictFlag: !0, + category: p.Type_Checking, + description: p.Check_that_the_arguments_for_bind_call_and_apply_methods_match_the_original_function, + defaultValueDescription: p.false_unless_strict_is_set + }, + { + name: "strictPropertyInitialization", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + strictFlag: !0, + category: p.Type_Checking, + description: p.Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor, + defaultValueDescription: p.false_unless_strict_is_set + }, + { + name: "strictBuiltinIteratorReturn", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + strictFlag: !0, + category: p.Type_Checking, + description: p.Built_in_iterators_are_instantiated_with_a_TReturn_type_of_undefined_instead_of_any, + defaultValueDescription: p.false_unless_strict_is_set + }, + { + name: "noImplicitThis", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + strictFlag: !0, + category: p.Type_Checking, + description: p.Enable_error_reporting_when_this_is_given_the_type_any, + defaultValueDescription: p.false_unless_strict_is_set + }, + { + name: "useUnknownInCatchVariables", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + strictFlag: !0, + category: p.Type_Checking, + description: p.Default_catch_clause_variables_as_unknown_instead_of_any, + defaultValueDescription: p.false_unless_strict_is_set + }, + { + name: "alwaysStrict", + type: "boolean", + affectsSourceFile: !0, + affectsEmit: !0, + affectsBuildInfo: !0, + strictFlag: !0, + category: p.Type_Checking, + description: p.Ensure_use_strict_is_always_emitted, + defaultValueDescription: p.false_unless_strict_is_set + }, + // Additional Checks + { + name: "noUnusedLocals", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Type_Checking, + description: p.Enable_error_reporting_when_local_variables_aren_t_read, + defaultValueDescription: !1 + }, + { + name: "noUnusedParameters", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Type_Checking, + description: p.Raise_an_error_when_a_function_parameter_isn_t_read, + defaultValueDescription: !1 + }, + { + name: "exactOptionalPropertyTypes", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Type_Checking, + description: p.Interpret_optional_property_types_as_written_rather_than_adding_undefined, + defaultValueDescription: !1 + }, + { + name: "noImplicitReturns", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Type_Checking, + description: p.Enable_error_reporting_for_codepaths_that_do_not_explicitly_return_in_a_function, + defaultValueDescription: !1 + }, + { + name: "noFallthroughCasesInSwitch", + type: "boolean", + affectsBindDiagnostics: !0, + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Type_Checking, + description: p.Enable_error_reporting_for_fallthrough_cases_in_switch_statements, + defaultValueDescription: !1 + }, + { + name: "noUncheckedIndexedAccess", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Type_Checking, + description: p.Add_undefined_to_a_type_when_accessed_using_an_index, + defaultValueDescription: !1 + }, + { + name: "noImplicitOverride", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Type_Checking, + description: p.Ensure_overriding_members_in_derived_classes_are_marked_with_an_override_modifier, + defaultValueDescription: !1 + }, + { + name: "noPropertyAccessFromIndexSignature", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + showInSimplifiedHelpView: !1, + category: p.Type_Checking, + description: p.Enforces_using_indexed_accessors_for_keys_declared_using_an_indexed_type, + defaultValueDescription: !1 + }, + // Module Resolution + { + name: "moduleResolution", + type: new Map(Object.entries({ + // N.B. The first entry specifies the value shown in `tsc --init` + node10: 2, + node: 2, + classic: 1, + node16: 3, + nodenext: 99, + bundler: 100 + /* Bundler */ + })), + deprecatedKeys: /* @__PURE__ */ new Set(["node"]), + affectsSourceFile: !0, + affectsModuleResolution: !0, + paramType: p.STRATEGY, + category: p.Modules, + description: p.Specify_how_TypeScript_looks_up_a_file_from_a_given_module_specifier, + defaultValueDescription: p.module_AMD_or_UMD_or_System_or_ES6_then_Classic_Otherwise_Node + }, + { + name: "baseUrl", + type: "string", + affectsModuleResolution: !0, + isFilePath: !0, + category: p.Modules, + description: p.Specify_the_base_directory_to_resolve_non_relative_module_names + }, + { + // this option can only be specified in tsconfig.json + // use type = object to copy the value as-is + name: "paths", + type: "object", + affectsModuleResolution: !0, + allowConfigDirTemplateSubstitution: !0, + isTSConfigOnly: !0, + category: p.Modules, + description: p.Specify_a_set_of_entries_that_re_map_imports_to_additional_lookup_locations, + transpileOptionValue: void 0 + }, + { + // this option can only be specified in tsconfig.json + // use type = object to copy the value as-is + name: "rootDirs", + type: "list", + isTSConfigOnly: !0, + element: { + name: "rootDirs", + type: "string", + isFilePath: !0 + }, + affectsModuleResolution: !0, + allowConfigDirTemplateSubstitution: !0, + category: p.Modules, + description: p.Allow_multiple_folders_to_be_treated_as_one_when_resolving_modules, + transpileOptionValue: void 0, + defaultValueDescription: p.Computed_from_the_list_of_input_files + }, + { + name: "typeRoots", + type: "list", + element: { + name: "typeRoots", + type: "string", + isFilePath: !0 + }, + affectsModuleResolution: !0, + allowConfigDirTemplateSubstitution: !0, + category: p.Modules, + description: p.Specify_multiple_folders_that_act_like_Slashnode_modules_Slash_types + }, + { + name: "types", + type: "list", + element: { + name: "types", + type: "string" + }, + affectsProgramStructure: !0, + showInSimplifiedHelpView: !0, + category: p.Modules, + description: p.Specify_type_package_names_to_be_included_without_being_referenced_in_a_source_file, + transpileOptionValue: void 0 + }, + { + name: "allowSyntheticDefaultImports", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Interop_Constraints, + description: p.Allow_import_x_from_y_when_a_module_doesn_t_have_a_default_export, + defaultValueDescription: p.module_system_or_esModuleInterop + }, + { + name: "esModuleInterop", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsEmit: !0, + affectsBuildInfo: !0, + showInSimplifiedHelpView: !0, + category: p.Interop_Constraints, + description: p.Emit_additional_JavaScript_to_ease_support_for_importing_CommonJS_modules_This_enables_allowSyntheticDefaultImports_for_type_compatibility, + defaultValueDescription: !1 + }, + { + name: "preserveSymlinks", + type: "boolean", + category: p.Interop_Constraints, + description: p.Disable_resolving_symlinks_to_their_realpath_This_correlates_to_the_same_flag_in_node, + defaultValueDescription: !1 + }, + { + name: "allowUmdGlobalAccess", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Modules, + description: p.Allow_accessing_UMD_globals_from_modules, + defaultValueDescription: !1 + }, + { + name: "moduleSuffixes", + type: "list", + element: { + name: "suffix", + type: "string" + }, + listPreserveFalsyValues: !0, + affectsModuleResolution: !0, + category: p.Modules, + description: p.List_of_file_name_suffixes_to_search_when_resolving_a_module + }, + { + name: "allowImportingTsExtensions", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Modules, + description: p.Allow_imports_to_include_TypeScript_file_extensions_Requires_moduleResolution_bundler_and_either_noEmit_or_emitDeclarationOnly_to_be_set, + defaultValueDescription: !1, + transpileOptionValue: void 0 + }, + { + name: "rewriteRelativeImportExtensions", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Modules, + description: p.Rewrite_ts_tsx_mts_and_cts_file_extensions_in_relative_import_paths_to_their_JavaScript_equivalent_in_output_files, + defaultValueDescription: !1 + }, + { + name: "resolvePackageJsonExports", + type: "boolean", + affectsModuleResolution: !0, + category: p.Modules, + description: p.Use_the_package_json_exports_field_when_resolving_package_imports, + defaultValueDescription: p.true_when_moduleResolution_is_node16_nodenext_or_bundler_otherwise_false + }, + { + name: "resolvePackageJsonImports", + type: "boolean", + affectsModuleResolution: !0, + category: p.Modules, + description: p.Use_the_package_json_imports_field_when_resolving_imports, + defaultValueDescription: p.true_when_moduleResolution_is_node16_nodenext_or_bundler_otherwise_false + }, + { + name: "customConditions", + type: "list", + element: { + name: "condition", + type: "string" + }, + affectsModuleResolution: !0, + category: p.Modules, + description: p.Conditions_to_set_in_addition_to_the_resolver_specific_defaults_when_resolving_imports + }, + { + name: "noUncheckedSideEffectImports", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Modules, + description: p.Check_side_effect_imports, + defaultValueDescription: !1 + }, + // Source Maps + { + name: "sourceRoot", + type: "string", + affectsEmit: !0, + affectsBuildInfo: !0, + paramType: p.LOCATION, + category: p.Emit, + description: p.Specify_the_root_path_for_debuggers_to_find_the_reference_source_code + }, + { + name: "mapRoot", + type: "string", + affectsEmit: !0, + affectsBuildInfo: !0, + paramType: p.LOCATION, + category: p.Emit, + description: p.Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations + }, + { + name: "inlineSources", + type: "boolean", + affectsEmit: !0, + affectsBuildInfo: !0, + category: p.Emit, + description: p.Include_source_code_in_the_sourcemaps_inside_the_emitted_JavaScript, + defaultValueDescription: !1 + }, + // Experimental + { + name: "experimentalDecorators", + type: "boolean", + affectsEmit: !0, + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Language_and_Environment, + description: p.Enable_experimental_support_for_legacy_experimental_decorators, + defaultValueDescription: !1 + }, + { + name: "emitDecoratorMetadata", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsEmit: !0, + affectsBuildInfo: !0, + category: p.Language_and_Environment, + description: p.Emit_design_type_metadata_for_decorated_declarations_in_source_files, + defaultValueDescription: !1 + }, + // Advanced + { + name: "jsxFactory", + type: "string", + category: p.Language_and_Environment, + description: p.Specify_the_JSX_factory_function_used_when_targeting_React_JSX_emit_e_g_React_createElement_or_h, + defaultValueDescription: "`React.createElement`" + }, + { + name: "jsxFragmentFactory", + type: "string", + category: p.Language_and_Environment, + description: p.Specify_the_JSX_Fragment_reference_used_for_fragments_when_targeting_React_JSX_emit_e_g_React_Fragment_or_Fragment, + defaultValueDescription: "React.Fragment" + }, + { + name: "jsxImportSource", + type: "string", + affectsSemanticDiagnostics: !0, + affectsEmit: !0, + affectsBuildInfo: !0, + affectsModuleResolution: !0, + affectsSourceFile: !0, + category: p.Language_and_Environment, + description: p.Specify_module_specifier_used_to_import_the_JSX_factory_functions_when_using_jsx_Colon_react_jsx_Asterisk, + defaultValueDescription: "react" + }, + { + name: "resolveJsonModule", + type: "boolean", + affectsModuleResolution: !0, + category: p.Modules, + description: p.Enable_importing_json_files, + defaultValueDescription: !1 + }, + { + name: "allowArbitraryExtensions", + type: "boolean", + affectsProgramStructure: !0, + category: p.Modules, + description: p.Enable_importing_files_with_any_extension_provided_a_declaration_file_is_present, + defaultValueDescription: !1 + }, + { + name: "out", + type: "string", + affectsEmit: !0, + affectsBuildInfo: !0, + affectsDeclarationPath: !0, + isFilePath: !1, + // This is intentionally broken to support compatibility with existing tsconfig files + // for correct behaviour, please use outFile + category: p.Backwards_Compatibility, + paramType: p.FILE, + transpileOptionValue: void 0, + description: p.Deprecated_setting_Use_outFile_instead + }, + { + name: "reactNamespace", + type: "string", + affectsEmit: !0, + affectsBuildInfo: !0, + category: p.Language_and_Environment, + description: p.Specify_the_object_invoked_for_createElement_This_only_applies_when_targeting_react_JSX_emit, + defaultValueDescription: "`React`" + }, + { + name: "skipDefaultLibCheck", + type: "boolean", + // We need to store these to determine whether `lib` files need to be rechecked + affectsBuildInfo: !0, + category: p.Completeness, + description: p.Skip_type_checking_d_ts_files_that_are_included_with_TypeScript, + defaultValueDescription: !1 + }, + { + name: "charset", + type: "string", + category: p.Backwards_Compatibility, + description: p.No_longer_supported_In_early_versions_manually_set_the_text_encoding_for_reading_files, + defaultValueDescription: "utf8" + }, + { + name: "emitBOM", + type: "boolean", + affectsEmit: !0, + affectsBuildInfo: !0, + category: p.Emit, + description: p.Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files, + defaultValueDescription: !1 + }, + { + name: "newLine", + type: new Map(Object.entries({ + crlf: 0, + lf: 1 + /* LineFeed */ + })), + affectsEmit: !0, + affectsBuildInfo: !0, + paramType: p.NEWLINE, + category: p.Emit, + description: p.Set_the_newline_character_for_emitting_files, + defaultValueDescription: "lf" + }, + { + name: "noErrorTruncation", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Output_Formatting, + description: p.Disable_truncating_types_in_error_messages, + defaultValueDescription: !1 + }, + { + name: "noLib", + type: "boolean", + category: p.Language_and_Environment, + affectsProgramStructure: !0, + description: p.Disable_including_any_library_files_including_the_default_lib_d_ts, + // We are not returning a sourceFile for lib file when asked by the program, + // so pass --noLib to avoid reporting a file not found error. + transpileOptionValue: !0, + defaultValueDescription: !1 + }, + { + name: "noResolve", + type: "boolean", + affectsModuleResolution: !0, + category: p.Modules, + description: p.Disallow_import_s_require_s_or_reference_s_from_expanding_the_number_of_files_TypeScript_should_add_to_a_project, + // We are not doing a full typecheck, we are not resolving the whole context, + // so pass --noResolve to avoid reporting missing file errors. + transpileOptionValue: !0, + defaultValueDescription: !1 + }, + { + name: "stripInternal", + type: "boolean", + affectsEmit: !0, + affectsBuildInfo: !0, + category: p.Emit, + description: p.Disable_emitting_declarations_that_have_internal_in_their_JSDoc_comments, + defaultValueDescription: !1 + }, + { + name: "disableSizeLimit", + type: "boolean", + affectsProgramStructure: !0, + category: p.Editor_Support, + description: p.Remove_the_20mb_cap_on_total_source_code_size_for_JavaScript_files_in_the_TypeScript_language_server, + defaultValueDescription: !1 + }, + { + name: "disableSourceOfProjectReferenceRedirect", + type: "boolean", + isTSConfigOnly: !0, + category: p.Projects, + description: p.Disable_preferring_source_files_instead_of_declaration_files_when_referencing_composite_projects, + defaultValueDescription: !1 + }, + { + name: "disableSolutionSearching", + type: "boolean", + isTSConfigOnly: !0, + category: p.Projects, + description: p.Opt_a_project_out_of_multi_project_reference_checking_when_editing, + defaultValueDescription: !1 + }, + { + name: "disableReferencedProjectLoad", + type: "boolean", + isTSConfigOnly: !0, + category: p.Projects, + description: p.Reduce_the_number_of_projects_loaded_automatically_by_TypeScript, + defaultValueDescription: !1 + }, + { + name: "noImplicitUseStrict", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Backwards_Compatibility, + description: p.Disable_adding_use_strict_directives_in_emitted_JavaScript_files, + defaultValueDescription: !1 + }, + { + name: "noEmitHelpers", + type: "boolean", + affectsEmit: !0, + affectsBuildInfo: !0, + category: p.Emit, + description: p.Disable_generating_custom_helper_functions_like_extends_in_compiled_output, + defaultValueDescription: !1 + }, + { + name: "noEmitOnError", + type: "boolean", + affectsEmit: !0, + affectsBuildInfo: !0, + category: p.Emit, + transpileOptionValue: void 0, + description: p.Disable_emitting_files_if_any_type_checking_errors_are_reported, + defaultValueDescription: !1 + }, + { + name: "preserveConstEnums", + type: "boolean", + affectsEmit: !0, + affectsBuildInfo: !0, + category: p.Emit, + description: p.Disable_erasing_const_enum_declarations_in_generated_code, + defaultValueDescription: !1 + }, + { + name: "declarationDir", + type: "string", + affectsEmit: !0, + affectsBuildInfo: !0, + affectsDeclarationPath: !0, + isFilePath: !0, + paramType: p.DIRECTORY, + category: p.Emit, + transpileOptionValue: void 0, + description: p.Specify_the_output_directory_for_generated_declaration_files + }, + { + name: "skipLibCheck", + type: "boolean", + // We need to store these to determine whether `lib` files need to be rechecked + affectsBuildInfo: !0, + category: p.Completeness, + description: p.Skip_type_checking_all_d_ts_files, + defaultValueDescription: !1 + }, + { + name: "allowUnusedLabels", + type: "boolean", + affectsBindDiagnostics: !0, + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Type_Checking, + description: p.Disable_error_reporting_for_unused_labels, + defaultValueDescription: void 0 + }, + { + name: "allowUnreachableCode", + type: "boolean", + affectsBindDiagnostics: !0, + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Type_Checking, + description: p.Disable_error_reporting_for_unreachable_code, + defaultValueDescription: void 0 + }, + { + name: "suppressExcessPropertyErrors", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Backwards_Compatibility, + description: p.Disable_reporting_of_excess_property_errors_during_the_creation_of_object_literals, + defaultValueDescription: !1 + }, + { + name: "suppressImplicitAnyIndexErrors", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Backwards_Compatibility, + description: p.Suppress_noImplicitAny_errors_when_indexing_objects_that_lack_index_signatures, + defaultValueDescription: !1 + }, + { + name: "forceConsistentCasingInFileNames", + type: "boolean", + affectsModuleResolution: !0, + category: p.Interop_Constraints, + description: p.Ensure_that_casing_is_correct_in_imports, + defaultValueDescription: !0 + }, + { + name: "maxNodeModuleJsDepth", + type: "number", + affectsModuleResolution: !0, + category: p.JavaScript_Support, + description: p.Specify_the_maximum_folder_depth_used_for_checking_JavaScript_files_from_node_modules_Only_applicable_with_allowJs, + defaultValueDescription: 0 + }, + { + name: "noStrictGenericChecks", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsBuildInfo: !0, + category: p.Backwards_Compatibility, + description: p.Disable_strict_checking_of_generic_signatures_in_function_types, + defaultValueDescription: !1 + }, + { + name: "useDefineForClassFields", + type: "boolean", + affectsSemanticDiagnostics: !0, + affectsEmit: !0, + affectsBuildInfo: !0, + category: p.Language_and_Environment, + description: p.Emit_ECMAScript_standard_compliant_class_fields, + defaultValueDescription: p.true_for_ES2022_and_above_including_ESNext + }, + { + name: "preserveValueImports", + type: "boolean", + affectsEmit: !0, + affectsBuildInfo: !0, + category: p.Backwards_Compatibility, + description: p.Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed, + defaultValueDescription: !1 + }, + { + name: "keyofStringsOnly", + type: "boolean", + category: p.Backwards_Compatibility, + description: p.Make_keyof_only_return_strings_instead_of_string_numbers_or_symbols_Legacy_option, + defaultValueDescription: !1 + }, + { + // A list of plugins to load in the language service + name: "plugins", + type: "list", + isTSConfigOnly: !0, + element: { + name: "plugin", + type: "object" + }, + description: p.Specify_a_list_of_language_service_plugins_to_include, + category: p.Editor_Support + }, + { + name: "moduleDetection", + type: new Map(Object.entries({ + auto: 2, + legacy: 1, + force: 3 + /* Force */ + })), + affectsSourceFile: !0, + affectsModuleResolution: !0, + description: p.Control_what_method_is_used_to_detect_module_format_JS_files, + category: p.Language_and_Environment, + defaultValueDescription: p.auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node16_as_modules + }, + { + name: "ignoreDeprecations", + type: "string", + defaultValueDescription: void 0 + } + ], _d = [ + ...GF, + ...sye + ], wre = _d.filter((e) => !!e.affectsSemanticDiagnostics), Pre = _d.filter((e) => !!e.affectsEmit), Nre = _d.filter((e) => !!e.affectsDeclarationPath), Xz = _d.filter((e) => !!e.affectsModuleResolution), Qz = _d.filter((e) => !!e.affectsSourceFile || !!e.affectsBindDiagnostics), Are = _d.filter((e) => !!e.affectsProgramStructure), Ire = _d.filter((e) => eo(e, "transpileOptionValue")), cMe = _d.filter( + (e) => e.allowConfigDirTemplateSubstitution || !e.isCommandLineOnly && e.isFilePath + ), lMe = rk.filter( + (e) => e.allowConfigDirTemplateSubstitution || !e.isCommandLineOnly && e.isFilePath + ), Fre = _d.filter(uMe); + function uMe(e) { + return !gs(e.type); + } + var OS = { + name: "build", + type: "boolean", + shortName: "b", + showInSimplifiedHelpView: !0, + category: p.Command_line_Options, + description: p.Build_one_or_more_projects_and_their_dependencies_if_out_of_date, + defaultValueDescription: !1 + }, Yz = [ + OS, + { + name: "verbose", + shortName: "v", + category: p.Command_line_Options, + description: p.Enable_verbose_logging, + type: "boolean", + defaultValueDescription: !1 + }, + { + name: "dry", + shortName: "d", + category: p.Command_line_Options, + description: p.Show_what_would_be_built_or_deleted_if_specified_with_clean, + type: "boolean", + defaultValueDescription: !1 + }, + { + name: "force", + shortName: "f", + category: p.Command_line_Options, + description: p.Build_all_projects_including_those_that_appear_to_be_up_to_date, + type: "boolean", + defaultValueDescription: !1 + }, + { + name: "clean", + category: p.Command_line_Options, + description: p.Delete_the_outputs_of_all_projects, + type: "boolean", + defaultValueDescription: !1 + }, + { + name: "stopBuildOnErrors", + category: p.Command_line_Options, + description: p.Skip_building_downstream_projects_on_error_in_upstream_project, + type: "boolean", + defaultValueDescription: !1 + } + ], tA = [ + ...GF, + ...Yz + ], $F = [ + { + name: "enable", + type: "boolean", + defaultValueDescription: !1 + }, + { + name: "include", + type: "list", + element: { + name: "include", + type: "string" + } + }, + { + name: "exclude", + type: "list", + element: { + name: "exclude", + type: "string" + } + }, + { + name: "disableFilenameBasedTypeAcquisition", + type: "boolean", + defaultValueDescription: !1 + } + ]; + function XF(e) { + const t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(); + return lr(e, (i) => { + t.set(i.name.toLowerCase(), i), i.shortName && n.set(i.shortName, i.name); + }), { optionsNameMap: t, shortOptionNames: n }; + } + var aye; + function w6() { + return aye || (aye = XF(_d)); + } + var _Me = { + diagnostic: p.Compiler_option_0_may_only_be_used_with_build, + getOptionsNameMap: fye + }, oye = { + module: 1, + target: 3, + strict: !0, + esModuleInterop: !0, + forceConsistentCasingInFileNames: !0, + skipLibCheck: !0 + }; + function Ore(e) { + return cye(e, Yo); + } + function cye(e, t) { + const n = is(e.type.keys()), i = (e.deprecatedKeys ? n.filter((s) => !e.deprecatedKeys.has(s)) : n).map((s) => `'${s}'`).join(", "); + return t(p.Argument_for_0_option_must_be_Colon_1, `--${e.name}`, i); + } + function QF(e, t, n) { + return Hye(e, (t ?? "").trim(), n); + } + function Lre(e, t = "", n) { + if (t = t.trim(), Ui(t, "-")) + return; + if (e.type === "listOrElement" && !t.includes(",")) + return nk(e, t, n); + if (t === "") + return []; + const i = t.split(","); + switch (e.element.type) { + case "number": + return Fi(i, (s) => nk(e.element, parseInt(s), n)); + case "string": + return Fi(i, (s) => nk(e.element, s || "", n)); + case "boolean": + case "object": + return E.fail(`List of ${e.element.type} is not yet supported.`); + default: + return Fi(i, (s) => QF(e.element, s, n)); + } + } + function lye(e) { + return e.name; + } + function Mre(e, t, n, i, s) { + var o; + const c = (o = t.alternateMode) == null ? void 0 : o.getOptionsNameMap().optionsNameMap.get(e.toLowerCase()); + if (c) + return mv( + s, + i, + c !== OS ? t.alternateMode.diagnostic : p.Option_build_must_be_the_first_command_line_argument, + e + ); + const _ = Sb(e, t.optionDeclarations, lye); + return _ ? mv(s, i, t.unknownDidYouMeanDiagnostic, n || e, _.name) : mv(s, i, t.unknownOptionDiagnostic, n || e); + } + function Zz(e, t, n) { + const i = {}; + let s; + const o = [], c = []; + return _(t), { + options: i, + watchOptions: s, + fileNames: o, + errors: c + }; + function _(g) { + let m = 0; + for (; m < g.length; ) { + const h = g[m]; + if (m++, h.charCodeAt(0) === 64) + u(h.slice(1)); + else if (h.charCodeAt(0) === 45) { + const S = h.slice(h.charCodeAt(1) === 45 ? 2 : 1), T = jre( + e.getOptionsNameMap, + S, + /*allowShort*/ + !0 + ); + if (T) + m = uye(g, m, e, T, i, c); + else { + const k = jre( + rW.getOptionsNameMap, + S, + /*allowShort*/ + !0 + ); + k ? m = uye(g, m, rW, k, s || (s = {}), c) : c.push(Mre(S, e, h)); + } + } else + o.push(h); + } + } + function u(g) { + const m = W4(g, n || ((T) => ml.readFile(T))); + if (!gs(m)) { + c.push(m); + return; + } + const h = []; + let S = 0; + for (; ; ) { + for (; S < m.length && m.charCodeAt(S) <= 32; ) S++; + if (S >= m.length) break; + const T = S; + if (m.charCodeAt(T) === 34) { + for (S++; S < m.length && m.charCodeAt(S) !== 34; ) S++; + S < m.length ? (h.push(m.substring(T + 1, S)), S++) : c.push(Yo(p.Unterminated_quoted_string_in_response_file_0, g)); + } else { + for (; m.charCodeAt(S) > 32; ) S++; + h.push(m.substring(T, S)); + } + } + _(h); + } + } + function uye(e, t, n, i, s, o) { + if (i.isTSConfigOnly) { + const c = e[t]; + c === "null" ? (s[i.name] = void 0, t++) : i.type === "boolean" ? c === "false" ? (s[i.name] = nk( + i, + /*value*/ + !1, + o + ), t++) : (c === "true" && t++, o.push(Yo(p.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line, i.name))) : (o.push(Yo(p.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line, i.name)), c && !Ui(c, "-") && t++); + } else if (!e[t] && i.type !== "boolean" && o.push(Yo(n.optionTypeMismatchDiagnostic, i.name, nW(i))), e[t] !== "null") + switch (i.type) { + case "number": + s[i.name] = nk(i, parseInt(e[t]), o), t++; + break; + case "boolean": + const c = e[t]; + s[i.name] = nk(i, c !== "false", o), (c === "false" || c === "true") && t++; + break; + case "string": + s[i.name] = nk(i, e[t] || "", o), t++; + break; + case "list": + const _ = Lre(i, e[t], o); + s[i.name] = _ || [], _ && t++; + break; + case "listOrElement": + E.fail("listOrElement not supported here"); + break; + // If not a primitive, the possible types are specified in what is effectively a map of options. + default: + s[i.name] = QF(i, e[t], o), t++; + break; + } + else + s[i.name] = void 0, t++; + return t; + } + var YF = { + alternateMode: _Me, + getOptionsNameMap: w6, + optionDeclarations: _d, + unknownOptionDiagnostic: p.Unknown_compiler_option_0, + unknownDidYouMeanDiagnostic: p.Unknown_compiler_option_0_Did_you_mean_1, + optionTypeMismatchDiagnostic: p.Compiler_option_0_expects_an_argument + }; + function Rre(e, t) { + return Zz(YF, e, t); + } + function Kz(e, t) { + return jre(w6, e, t); + } + function jre(e, t, n = !1) { + t = t.toLowerCase(); + const { optionsNameMap: i, shortOptionNames: s } = e(); + if (n) { + const o = s.get(t); + o !== void 0 && (t = o); + } + return i.get(t); + } + var _ye; + function fye() { + return _ye || (_ye = XF(tA)); + } + var fMe = { + diagnostic: p.Compiler_option_0_may_not_be_used_with_build, + getOptionsNameMap: w6 + }, pMe = { + alternateMode: fMe, + getOptionsNameMap: fye, + optionDeclarations: tA, + unknownOptionDiagnostic: p.Unknown_build_option_0, + unknownDidYouMeanDiagnostic: p.Unknown_build_option_0_Did_you_mean_1, + optionTypeMismatchDiagnostic: p.Build_option_0_requires_a_value_of_type_1 + }; + function Bre(e) { + const { options: t, watchOptions: n, fileNames: i, errors: s } = Zz( + pMe, + e + ), o = t; + return i.length === 0 && i.push("."), o.clean && o.force && s.push(Yo(p.Options_0_and_1_cannot_be_combined, "clean", "force")), o.clean && o.verbose && s.push(Yo(p.Options_0_and_1_cannot_be_combined, "clean", "verbose")), o.clean && o.watch && s.push(Yo(p.Options_0_and_1_cannot_be_combined, "clean", "watch")), o.watch && o.dry && s.push(Yo(p.Options_0_and_1_cannot_be_combined, "watch", "dry")), { buildOptions: o, watchOptions: n, projects: i, errors: s }; + } + function D_(e, ...t) { + return Us(Yo(e, ...t).messageText, gs); + } + function rA(e, t, n, i, s, o) { + const c = W4(e, (g) => n.readFile(g)); + if (!gs(c)) { + n.onUnRecoverableConfigFileDiagnostic(c); + return; + } + const _ = KN(e, c), u = n.getCurrentDirectory(); + return _.path = oo(e, u, Zl(n.useCaseSensitiveFileNames)), _.resolvedPath = _.path, _.originalFileName = _.fileName, sA( + _, + n, + Qi(Hn(e), u), + t, + Qi(e, u), + /*resolutionStack*/ + void 0, + o, + i, + s + ); + } + function nA(e, t) { + const n = W4(e, t); + return gs(n) ? eW(e, n) : { config: {}, error: n }; + } + function eW(e, t) { + const n = KN(e, t); + return { + config: Cye( + n, + n.parseDiagnostics, + /*jsonConversionNotifier*/ + void 0 + ), + error: n.parseDiagnostics.length ? n.parseDiagnostics[0] : void 0 + }; + } + function Jre(e, t) { + const n = W4(e, t); + return gs(n) ? KN(e, n) : { fileName: e, parseDiagnostics: [n] }; + } + function W4(e, t) { + let n; + try { + n = t(e); + } catch (i) { + return Yo(p.Cannot_read_file_0_Colon_1, e, i.message); + } + return n === void 0 ? Yo(p.Cannot_read_file_0, e) : n; + } + function tW(e) { + return hC(e, lye); + } + var pye = { + optionDeclarations: $F, + unknownOptionDiagnostic: p.Unknown_type_acquisition_option_0, + unknownDidYouMeanDiagnostic: p.Unknown_type_acquisition_option_0_Did_you_mean_1 + }, dye; + function mye() { + return dye || (dye = XF(rk)); + } + var rW = { + getOptionsNameMap: mye, + optionDeclarations: rk, + unknownOptionDiagnostic: p.Unknown_watch_option_0, + unknownDidYouMeanDiagnostic: p.Unknown_watch_option_0_Did_you_mean_1, + optionTypeMismatchDiagnostic: p.Watch_option_0_requires_a_value_of_type_1 + }, gye; + function hye() { + return gye || (gye = tW(_d)); + } + var yye; + function vye() { + return yye || (yye = tW(rk)); + } + var bye; + function Sye() { + return bye || (bye = tW($F)); + } + var ZF = { + name: "extends", + type: "listOrElement", + element: { + name: "extends", + type: "string" + }, + category: p.File_Management, + disallowNullOrUndefined: !0 + }, Tye = { + name: "compilerOptions", + type: "object", + elementOptions: hye(), + extraKeyDiagnostics: YF + }, xye = { + name: "watchOptions", + type: "object", + elementOptions: vye(), + extraKeyDiagnostics: rW + }, kye = { + name: "typeAcquisition", + type: "object", + elementOptions: Sye(), + extraKeyDiagnostics: pye + }, zre; + function dMe() { + return zre === void 0 && (zre = { + name: void 0, + // should never be needed since this is root + type: "object", + elementOptions: tW([ + Tye, + xye, + kye, + ZF, + { + name: "references", + type: "list", + element: { + name: "references", + type: "object" + }, + category: p.Projects + }, + { + name: "files", + type: "list", + element: { + name: "files", + type: "string" + }, + category: p.File_Management + }, + { + name: "include", + type: "list", + element: { + name: "include", + type: "string" + }, + category: p.File_Management, + defaultValueDescription: p.if_files_is_specified_otherwise_Asterisk_Asterisk_Slash_Asterisk + }, + { + name: "exclude", + type: "list", + element: { + name: "exclude", + type: "string" + }, + category: p.File_Management, + defaultValueDescription: p.node_modules_bower_components_jspm_packages_plus_the_value_of_outDir_if_one_is_specified + }, + Ere + ]) + }), zre; + } + function Cye(e, t, n) { + var i; + const s = (i = e.statements[0]) == null ? void 0 : i.expression; + if (s && s.kind !== 211) { + if (t.push(sp( + e, + s, + p.The_root_value_of_a_0_file_must_be_an_object, + Zc(e.fileName) === "jsconfig.json" ? "jsconfig.json" : "tsconfig.json" + )), nu(s)) { + const o = Nn(s.elements, _a); + if (o) + return iA( + e, + o, + t, + /*returnValue*/ + !0, + n + ); + } + return {}; + } + return iA( + e, + s, + t, + /*returnValue*/ + !0, + n + ); + } + function Wre(e, t) { + var n; + return iA( + e, + (n = e.statements[0]) == null ? void 0 : n.expression, + t, + /*returnValue*/ + !0, + /*jsonConversionNotifier*/ + void 0 + ); + } + function iA(e, t, n, i, s) { + if (!t) + return i ? {} : void 0; + return _(t, s?.rootOptions); + function o(g, m) { + var h; + const S = i ? {} : void 0; + for (const T of g.properties) { + if (T.kind !== 304) { + n.push(sp(e, T, p.Property_assignment_expected)); + continue; + } + T.questionToken && n.push(sp(e, T.questionToken, p.The_0_modifier_can_only_be_used_in_TypeScript_files, "?")), u(T.name) || n.push(sp(e, T.name, p.String_literal_with_double_quotes_expected)); + const k = x3(T.name) ? void 0 : dx(T.name), D = k && Si(k), P = D ? (h = m?.elementOptions) == null ? void 0 : h.get(D) : void 0, A = _(T.initializer, P); + typeof D < "u" && (i && (S[D] = A), s?.onPropertySet(D, A, T, m, P)); + } + return S; + } + function c(g, m) { + if (!i) { + g.forEach((h) => _(h, m)); + return; + } + return kn(g.map((h) => _(h, m)), (h) => h !== void 0); + } + function _(g, m) { + switch (g.kind) { + case 112: + return !0; + case 97: + return !1; + case 106: + return null; + // eslint-disable-line no-restricted-syntax + case 11: + return u(g) || n.push(sp(e, g, p.String_literal_with_double_quotes_expected)), g.text; + case 9: + return Number(g.text); + case 225: + if (g.operator !== 41 || g.operand.kind !== 9) + break; + return -Number(g.operand.text); + case 211: + return o(g, m); + case 210: + return c( + g.elements, + m && m.element + ); + } + m ? n.push(sp(e, g, p.Compiler_option_0_requires_a_value_of_type_1, m.name, nW(m))) : n.push(sp(e, g, p.Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal)); + } + function u(g) { + return ca(g) && _5(g, e); + } + } + function nW(e) { + return e.type === "listOrElement" ? `${nW(e.element)} or Array` : e.type === "list" ? "Array" : gs(e.type) ? e.type : "string"; + } + function Eye(e, t) { + if (e) { + if (aA(t)) return !e.disallowNullOrUndefined; + if (e.type === "list") + return as(t); + if (e.type === "listOrElement") + return as(t) || Eye(e.element, t); + const n = gs(e.type) ? e.type : "string"; + return typeof t === n; + } + return !1; + } + function iW(e, t, n) { + var i, s, o; + const c = Zl(n.useCaseSensitiveFileNames), _ = hr( + kn( + e.fileNames, + (s = (i = e.options.configFile) == null ? void 0 : i.configFileSpecs) != null && s.validatedIncludeSpecs ? hMe( + t, + e.options.configFile.configFileSpecs.validatedIncludeSpecs, + e.options.configFile.configFileSpecs.validatedExcludeSpecs, + n + ) : yb + ), + (k) => kC(Qi(t, n.getCurrentDirectory()), Qi(k, n.getCurrentDirectory()), c) + ), u = { configFilePath: Qi(t, n.getCurrentDirectory()), useCaseSensitiveFileNames: n.useCaseSensitiveFileNames }, g = sW(e.options, u), m = e.watchOptions && yMe(e.watchOptions), h = { + compilerOptions: { + ...KF(g), + showConfig: void 0, + configFile: void 0, + configFilePath: void 0, + help: void 0, + init: void 0, + listFiles: void 0, + listEmittedFiles: void 0, + project: void 0, + build: void 0, + version: void 0 + }, + watchOptions: m && KF(m), + references: hr(e.projectReferences, (k) => ({ ...k, path: k.originalPath ? k.originalPath : "", originalPath: void 0 })), + files: wr(_) ? _ : void 0, + ...(o = e.options.configFile) != null && o.configFileSpecs ? { + include: gMe(e.options.configFile.configFileSpecs.validatedIncludeSpecs), + exclude: e.options.configFile.configFileSpecs.validatedExcludeSpecs + } : {}, + compileOnSave: e.compileOnSave ? !0 : void 0 + }, S = new Set(g.keys()), T = {}; + for (const k in l4) + if (!S.has(k) && mMe(k, S)) { + const D = l4[k].computeValue(e.options), P = l4[k].computeValue({}); + D !== P && (T[k] = l4[k].computeValue(e.options)); + } + return H2(h.compilerOptions, KF(sW(T, u))), h; + } + function mMe(e, t) { + const n = /* @__PURE__ */ new Set(); + return i(e); + function i(s) { + var o; + return Jp(n, s) ? ot((o = l4[s]) == null ? void 0 : o.dependencies, (c) => t.has(c) || i(c)) : !1; + } + } + function KF(e) { + return Object.fromEntries(e); + } + function gMe(e) { + if (wr(e)) { + if (wr(e) !== 1) return e; + if (e[0] !== Aye) + return e; + } + } + function hMe(e, t, n, i) { + if (!t) return yb; + const s = Y5(e, n, t, i.useCaseSensitiveFileNames, i.getCurrentDirectory()), o = s.excludePattern && b0(s.excludePattern, i.useCaseSensitiveFileNames), c = s.includeFilePattern && b0(s.includeFilePattern, i.useCaseSensitiveFileNames); + return c ? o ? (_) => !(c.test(_) && !o.test(_)) : (_) => !c.test(_) : o ? (_) => o.test(_) : yb; + } + function Dye(e) { + switch (e.type) { + case "string": + case "number": + case "boolean": + case "object": + return; + case "list": + case "listOrElement": + return Dye(e.element); + default: + return e.type; + } + } + function eO(e, t) { + return hl(t, (n, i) => { + if (n === e) + return i; + }); + } + function sW(e, t) { + return wye(e, w6(), t); + } + function yMe(e) { + return wye(e, mye()); + } + function wye(e, { optionsNameMap: t }, n) { + const i = /* @__PURE__ */ new Map(), s = n && Zl(n.useCaseSensitiveFileNames); + for (const o in e) + if (eo(e, o)) { + if (t.has(o) && (t.get(o).category === p.Command_line_Options || t.get(o).category === p.Output_Formatting)) + continue; + const c = e[o], _ = t.get(o.toLowerCase()); + if (_) { + E.assert(_.type !== "listOrElement"); + const u = Dye(_); + u ? _.type === "list" ? i.set(o, c.map((g) => eO(g, u))) : i.set(o, eO(c, u)) : n && _.isFilePath ? i.set(o, kC(n.configFilePath, Qi(c, Hn(n.configFilePath)), s)) : n && _.type === "list" && _.element.isFilePath ? i.set(o, c.map((g) => kC(n.configFilePath, Qi(g, Hn(n.configFilePath)), s))) : i.set(o, c); + } + } + return i; + } + function Ure(e, t) { + const n = " ", i = [], s = Object.keys(e).filter((m) => m !== "init" && m !== "help" && m !== "watch"); + if (i.push("{"), i.push(`${n}// ${Ss(p.Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_to_read_more_about_this_file)}`), i.push(`${n}"compilerOptions": {`), c(p.File_Layout), _("rootDir", "./src", "optional"), _("outDir", "./dist", "optional"), o(), c(p.Environment_Settings), c(p.See_also_https_Colon_Slash_Slashaka_ms_Slashtsconfig_Slashmodule), _( + "module", + 199 + /* NodeNext */ + ), _( + "target", + 99 + /* ESNext */ + ), _("types", []), e.lib && _("lib", e.lib), c(p.For_nodejs_Colon), i.push(`${n}${n}// "lib": ["esnext"],`), i.push(`${n}${n}// "types": ["node"],`), c(p.and_npm_install_D_types_Slashnode), o(), c(p.Other_Outputs), _( + "sourceMap", + /*defaultValue*/ + !0 + ), _( + "declaration", + /*defaultValue*/ + !0 + ), _( + "declarationMap", + /*defaultValue*/ + !0 + ), o(), c(p.Stricter_Typechecking_Options), _( + "noUncheckedIndexedAccess", + /*defaultValue*/ + !0 + ), _( + "exactOptionalPropertyTypes", + /*defaultValue*/ + !0 + ), o(), c(p.Style_Options), _( + "noImplicitReturns", + /*defaultValue*/ + !0, + "optional" + ), _( + "noImplicitOverride", + /*defaultValue*/ + !0, + "optional" + ), _( + "noUnusedLocals", + /*defaultValue*/ + !0, + "optional" + ), _( + "noUnusedParameters", + /*defaultValue*/ + !0, + "optional" + ), _( + "noFallthroughCasesInSwitch", + /*defaultValue*/ + !0, + "optional" + ), _( + "noPropertyAccessFromIndexSignature", + /*defaultValue*/ + !0, + "optional" + ), o(), c(p.Recommended_Options), _( + "strict", + /*defaultValue*/ + !0 + ), _( + "jsx", + 4 + /* ReactJSX */ + ), _( + "verbatimModuleSyntax", + /*defaultValue*/ + !0 + ), _( + "isolatedModules", + /*defaultValue*/ + !0 + ), _( + "noUncheckedSideEffectImports", + /*defaultValue*/ + !0 + ), _( + "moduleDetection", + 3 + /* Force */ + ), _( + "skipLibCheck", + /*defaultValue*/ + !0 + ), s.length > 0) + for (o(); s.length > 0; ) + _(s[0], e[s[0]]); + function o() { + i.push(""); + } + function c(m) { + i.push(`${n}${n}// ${Ss(m)}`); + } + function _(m, h, S = "never") { + const T = s.indexOf(m); + T >= 0 && s.splice(T, 1); + let k; + S === "always" ? k = !0 : S === "never" ? k = !1 : k = !eo(e, m); + const D = e[m] ?? h; + k ? i.push(`${n}${n}// "${m}": ${u(m, D)},`) : i.push(`${n}${n}"${m}": ${u(m, D)},`); + } + function u(m, h) { + const S = _d.filter((k) => k.name === m)[0]; + S || E.fail(`No option named ${m}?`); + const T = S.type instanceof Map ? S.type : void 0; + if (as(h)) { + const k = "element" in S && S.element.type instanceof Map ? S.element.type : void 0; + return `[${h.map((D) => g(D, k)).join(", ")}]`; + } else + return g(h, T); + } + function g(m, h) { + return h && (m = eO(m, h) ?? E.fail(`No matching value of ${m}`)), JSON.stringify(m); + } + return i.push(`${n}}`), i.push("}"), i.push(""), i.join(t); + } + function tO(e, t) { + const n = {}, i = w6().optionsNameMap; + for (const s in e) + eo(e, s) && (n[s] = vMe( + i.get(s.toLowerCase()), + e[s], + t + )); + return n.configFilePath && (n.configFilePath = t(n.configFilePath)), n; + } + function vMe(e, t, n) { + if (e && !aA(t)) { + if (e.type === "list") { + const i = t; + if (e.element.isFilePath && i.length) + return i.map(n); + } else if (e.isFilePath) + return n(t); + E.assert(e.type !== "listOrElement"); + } + return t; + } + function Pye(e, t, n, i, s, o, c, _, u) { + return Iye( + e, + /*sourceFile*/ + void 0, + t, + n, + i, + u, + s, + o, + c, + _ + ); + } + function sA(e, t, n, i, s, o, c, _, u) { + var g, m; + (g = on) == null || g.push(on.Phase.Parse, "parseJsonSourceFileConfigFileContent", { path: e.fileName }); + const h = Iye( + /*json*/ + void 0, + e, + t, + n, + i, + u, + s, + o, + c, + _ + ); + return (m = on) == null || m.pop(), h; + } + function aW(e, t) { + t && Object.defineProperty(e, "configFile", { enumerable: !1, writable: !1, value: t }); + } + function aA(e) { + return e == null; + } + function Nye(e, t) { + return Hn(Qi(e, t)); + } + var Aye = "**/*"; + function Iye(e, t, n, i, s = {}, o, c, _ = [], u = [], g) { + E.assert(e === void 0 && t !== void 0 || e !== void 0 && t === void 0); + const m = [], h = jye(e, t, n, i, c, _, m, g), { raw: S } = h, T = Fye( + MR(s, h.options || {}), + cMe, + i + ), k = rO( + o && h.watchOptions ? MR(o, h.watchOptions) : h.watchOptions || o, + i + ); + T.configFilePath = c && zl(c); + const D = Hs(c ? Nye(c, i) : i), P = A(); + return t && (t.configFileSpecs = P), aW(T, t), { + options: T, + watchOptions: k, + fileNames: O(D), + projectReferences: F(D), + typeAcquisition: h.typeAcquisition || lW(), + raw: S, + errors: m, + // Wildcard directories (provided as part of a wildcard path) are stored in a + // file map that marks whether it was a regular wildcard match (with a `*` or `?` token), + // or a recursive directory. This information is used by filesystem watchers to monitor for + // new entries in these paths. + wildcardDirectories: AMe(P, D, n.useCaseSensitiveFileNames), + compileOnSave: !!S.compileOnSave + }; + function A() { + const W = U("references", (me) => typeof me == "object", "object"), _e = R(B("files")); + if (_e) { + const me = W === "no-prop" || as(W) && W.length === 0, Z = eo(S, "extends"); + if (_e.length === 0 && me && !Z) + if (t) { + const pe = c || "tsconfig.json", Te = p.The_files_list_in_config_file_0_is_empty, Fe = P3(t, "files", (ne) => ne.initializer), Ye = mv(t, Fe, Te, pe); + m.push(Ye); + } else + $(p.The_files_list_in_config_file_0_is_empty, c || "tsconfig.json"); + } + let K = R(B("include")); + const V = B("exclude"); + let ae = !1, se = R(V); + if (V === "no-prop") { + const me = T.outDir, Z = T.declarationDir; + (me || Z) && (se = kn([me, Z], (pe) => !!pe)); + } + _e === void 0 && K === void 0 && (K = [Aye], ae = !0); + let ce, fe, he, q; + K && (ce = Xye( + K, + m, + /*disallowTrailingRecursion*/ + !0, + t, + "include" + ), he = nO( + ce, + D + ) || ce), se && (fe = Xye( + se, + m, + /*disallowTrailingRecursion*/ + !1, + t, + "exclude" + ), q = nO( + fe, + D + ) || fe); + const be = kn(_e, gs), je = nO( + be, + D + ) || be; + return { + filesSpecs: _e, + includeSpecs: K, + excludeSpecs: se, + validatedFilesSpec: je, + validatedIncludeSpecs: he, + validatedExcludeSpecs: q, + validatedFilesSpecBeforeSubstitution: be, + validatedIncludeSpecsBeforeSubstitution: ce, + validatedExcludeSpecsBeforeSubstitution: fe, + isDefaultIncludeSpec: ae + }; + } + function O(W) { + const _e = U4(P, W, T, n, u); + return Rye(_e, oA(S), _) && m.push(Mye(P, c)), _e; + } + function F(W) { + let _e; + const K = U("references", (V) => typeof V == "object", "object"); + if (as(K)) + for (const V of K) + typeof V.path != "string" ? $(p.Compiler_option_0_requires_a_value_of_type_1, "reference.path", "string") : (_e || (_e = [])).push({ + path: Qi(V.path, W), + originalPath: V.path, + prepend: V.prepend, + circular: V.circular + }); + return _e; + } + function R(W) { + return as(W) ? W : void 0; + } + function B(W) { + return U(W, gs, "string"); + } + function U(W, _e, K) { + if (eo(S, W) && !aA(S[W])) + if (as(S[W])) { + const V = S[W]; + return !t && !Ni(V, _e) && m.push(Yo(p.Compiler_option_0_requires_a_value_of_type_1, W, K)), V; + } else + return $(p.Compiler_option_0_requires_a_value_of_type_1, W, "Array"), "not-array"; + return "no-prop"; + } + function $(W, ..._e) { + t || m.push(Yo(W, ..._e)); + } + } + function rO(e, t) { + return Fye(e, lMe, t); + } + function Fye(e, t, n) { + if (!e) return e; + let i; + for (const o of t) + if (e[o.name] !== void 0) { + const c = e[o.name]; + switch (o.type) { + case "string": + E.assert(o.isFilePath), oW(c) && s(o, Lye(c, n)); + break; + case "list": + E.assert(o.element.isFilePath); + const _ = nO(c, n); + _ && s(o, _); + break; + case "object": + E.assert(o.name === "paths"); + const u = bMe(c, n); + u && s(o, u); + break; + default: + E.fail("option type not supported"); + } + } + return i || e; + function s(o, c) { + (i ?? (i = H2({}, e)))[o.name] = c; + } + } + var Oye = "${configDir}"; + function oW(e) { + return gs(e) && Ui( + e, + Oye, + /*ignoreCase*/ + !0 + ); + } + function Lye(e, t) { + return Qi(e.replace(Oye, "./"), t); + } + function nO(e, t) { + if (!e) return e; + let n; + return e.forEach((i, s) => { + oW(i) && ((n ?? (n = e.slice()))[s] = Lye(i, t)); + }), n; + } + function bMe(e, t) { + let n; + return rm(e).forEach((s) => { + if (!as(e[s])) return; + const o = nO(e[s], t); + o && ((n ?? (n = H2({}, e)))[s] = o); + }), n; + } + function SMe(e) { + return e.code === p.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2.code; + } + function Mye({ includeSpecs: e, excludeSpecs: t }, n) { + return Yo( + p.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2, + n || "tsconfig.json", + JSON.stringify(e || []), + JSON.stringify(t || []) + ); + } + function Rye(e, t, n) { + return e.length === 0 && t && (!n || n.length === 0); + } + function cW(e) { + return !e.fileNames.length && eo(e.raw, "references"); + } + function oA(e) { + return !eo(e, "files") && !eo(e, "references"); + } + function iO(e, t, n, i, s) { + const o = i.length; + return Rye(e, s) ? i.push(Mye(n, t)) : kR(i, (c) => !SMe(c)), o !== i.length; + } + function TMe(e) { + return !!e.options; + } + function jye(e, t, n, i, s, o, c, _) { + var u; + i = zl(i); + const g = Qi(s || "", i); + if (o.includes(g)) + return c.push(Yo(p.Circularity_detected_while_resolving_configuration_Colon_0, [...o, g].join(" -> "))), { raw: e || Wre(t, c) }; + const m = e ? xMe(e, n, i, s, c) : kMe(t, n, i, s, c); + if ((u = m.options) != null && u.paths && (m.options.pathsBasePath = i), m.extendedConfigPath) { + o = o.concat([g]); + const T = { options: {} }; + gs(m.extendedConfigPath) ? h(T, m.extendedConfigPath) : m.extendedConfigPath.forEach((k) => h(T, k)), T.include && (m.raw.include = T.include), T.exclude && (m.raw.exclude = T.exclude), T.files && (m.raw.files = T.files), m.raw.compileOnSave === void 0 && T.compileOnSave && (m.raw.compileOnSave = T.compileOnSave), t && T.extendedSourceFiles && (t.extendedSourceFiles = is(T.extendedSourceFiles.keys())), m.options = H2(T.options, m.options), m.watchOptions = m.watchOptions && T.watchOptions ? S(T, m.watchOptions) : m.watchOptions || T.watchOptions; + } + return m; + function h(T, k) { + const D = CMe(t, k, n, o, c, _, T); + if (D && TMe(D)) { + const P = D.raw; + let A; + const O = (F) => { + m.raw[F] || P[F] && (T[F] = hr(P[F], (R) => oW(R) || Z_(R) ? R : On( + A || (A = fD(Hn(k), i, Zl(n.useCaseSensitiveFileNames))), + R + ))); + }; + O("include"), O("exclude"), O("files"), P.compileOnSave !== void 0 && (T.compileOnSave = P.compileOnSave), H2(T.options, D.options), T.watchOptions = T.watchOptions && D.watchOptions ? S(T, D.watchOptions) : T.watchOptions || D.watchOptions; + } + } + function S(T, k) { + return T.watchOptionsCopied ? H2(T.watchOptions, k) : (T.watchOptionsCopied = !0, H2({}, T.watchOptions, k)); + } + } + function xMe(e, t, n, i, s) { + eo(e, "excludes") && s.push(Yo(p.Unknown_option_excludes_Did_you_mean_exclude)); + const o = Vye(e.compilerOptions, n, s, i), c = qye(e.typeAcquisition, n, s, i), _ = DMe(e.watchOptions, n, s); + e.compileOnSave = EMe(e, n, s); + const u = e.extends || e.extends === "" ? Bye(e.extends, t, n, i, s) : void 0; + return { raw: e, options: o, watchOptions: _, typeAcquisition: c, extendedConfigPath: u }; + } + function Bye(e, t, n, i, s, o, c, _) { + let u; + const g = i ? Nye(i, n) : n; + if (gs(e)) + u = Jye( + e, + t, + g, + s, + c, + _ + ); + else if (as(e)) { + u = []; + for (let m = 0; m < e.length; m++) { + const h = e[m]; + gs(h) ? u = Er( + u, + Jye( + h, + t, + g, + s, + c?.elements[m], + _ + ) + ) : LS(ZF.element, e, n, s, o, c?.elements[m], _); + } + } else + LS(ZF, e, n, s, o, c, _); + return u; + } + function kMe(e, t, n, i, s) { + const o = Uye(i); + let c, _, u, g; + const m = dMe(), h = Cye( + e, + s, + { rootOptions: m, onPropertySet: S } + ); + return c || (c = lW(i)), g && h && h.compilerOptions === void 0 && s.push(sp(e, g[0], p._0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file, dx(g[0]))), { raw: h, options: o, watchOptions: _, typeAcquisition: c, extendedConfigPath: u }; + function S(T, k, D, P, A) { + if (A && A !== ZF && (k = LS(A, k, n, s, D, D.initializer, e)), P?.name) + if (A) { + let O; + P === Tye ? O = o : P === xye ? O = _ ?? (_ = {}) : P === kye ? O = c ?? (c = lW(i)) : E.fail("Unknown option"), O[A.name] = k; + } else T && P?.extraKeyDiagnostics && (P.elementOptions ? s.push(Mre( + T, + P.extraKeyDiagnostics, + /*unknownOptionErrorText*/ + void 0, + D.name, + e + )) : s.push(sp(e, D.name, P.extraKeyDiagnostics.unknownOptionDiagnostic, T))); + else P === m && (A === ZF ? u = Bye(k, t, n, i, s, D, D.initializer, e) : A || (T === "excludes" && s.push(sp(e, D.name, p.Unknown_option_excludes_Did_you_mean_exclude)), Nn(sye, (O) => O.name === T) && (g = Er(g, D.name)))); + } + } + function Jye(e, t, n, i, s, o) { + if (e = zl(e), Z_(e) || Ui(e, "./") || Ui(e, "../")) { + let _ = Qi(e, n); + if (!t.fileExists(_) && !wo( + _, + ".json" + /* Json */ + ) && (_ = `${_}.json`, !t.fileExists(_))) { + i.push(mv(o, s, p.File_0_not_found, e)); + return; + } + return _; + } + const c = cne(e, On(n, "tsconfig.json"), t); + if (c.resolvedModule) + return c.resolvedModule.resolvedFileName; + e === "" ? i.push(mv(o, s, p.Compiler_option_0_cannot_be_given_an_empty_string, "extends")) : i.push(mv(o, s, p.File_0_not_found, e)); + } + function CMe(e, t, n, i, s, o, c) { + const _ = n.useCaseSensitiveFileNames ? t : my(t); + let u, g, m; + if (o && (u = o.get(_)) ? { extendedResult: g, extendedConfig: m } = u : (g = Jre(t, (h) => n.readFile(h)), g.parseDiagnostics.length || (m = jye( + /*json*/ + void 0, + g, + n, + Hn(t), + Zc(t), + i, + s, + o + )), o && o.set(_, { extendedResult: g, extendedConfig: m })), e && ((c.extendedSourceFiles ?? (c.extendedSourceFiles = /* @__PURE__ */ new Set())).add(g.fileName), g.extendedSourceFiles)) + for (const h of g.extendedSourceFiles) + c.extendedSourceFiles.add(h); + if (g.parseDiagnostics.length) { + s.push(...g.parseDiagnostics); + return; + } + return m; + } + function EMe(e, t, n) { + if (!eo(e, Ere.name)) + return !1; + const i = LS(Ere, e.compileOnSave, t, n); + return typeof i == "boolean" && i; + } + function zye(e, t, n) { + const i = []; + return { options: Vye(e, t, i, n), errors: i }; + } + function Wye(e, t, n) { + const i = []; + return { options: qye(e, t, i, n), errors: i }; + } + function Uye(e) { + return e && Zc(e) === "jsconfig.json" ? { allowJs: !0, maxNodeModuleJsDepth: 2, allowSyntheticDefaultImports: !0, skipLibCheck: !0, noEmit: !0 } : {}; + } + function Vye(e, t, n, i) { + const s = Uye(i); + return Vre(hye(), e, t, s, YF, n), i && (s.configFilePath = zl(i)), s; + } + function lW(e) { + return { enable: !!e && Zc(e) === "jsconfig.json", include: [], exclude: [] }; + } + function qye(e, t, n, i) { + const s = lW(i); + return Vre(Sye(), e, t, s, pye, n), s; + } + function DMe(e, t, n) { + return Vre( + vye(), + e, + t, + /*defaultOptions*/ + void 0, + rW, + n + ); + } + function Vre(e, t, n, i, s, o) { + if (t) { + for (const c in t) { + const _ = e.get(c); + _ ? (i || (i = {}))[_.name] = LS(_, t[c], n, o) : o.push(Mre(c, s)); + } + return i; + } + } + function mv(e, t, n, ...i) { + return e && t ? sp(e, t, n, ...i) : Yo(n, ...i); + } + function LS(e, t, n, i, s, o, c) { + if (e.isCommandLineOnly) { + i.push(mv(c, s?.name, p.Option_0_can_only_be_specified_on_command_line, e.name)); + return; + } + if (Eye(e, t)) { + const _ = e.type; + if (_ === "list" && as(t)) + return Gye(e, t, n, i, s, o, c); + if (_ === "listOrElement") + return as(t) ? Gye(e, t, n, i, s, o, c) : LS(e.element, t, n, i, s, o, c); + if (!gs(e.type)) + return Hye(e, t, i, o, c); + const u = nk(e, t, i, o, c); + return aA(u) ? u : wMe(e, n, u); + } else + i.push(mv(c, o, p.Compiler_option_0_requires_a_value_of_type_1, e.name, nW(e))); + } + function wMe(e, t, n) { + return e.isFilePath && (n = zl(n), n = oW(n) ? n : Qi(n, t), n === "" && (n = ".")), n; + } + function nk(e, t, n, i, s) { + var o; + if (aA(t)) return; + const c = (o = e.extraValidation) == null ? void 0 : o.call(e, t); + if (!c) return t; + n.push(mv(s, i, ...c)); + } + function Hye(e, t, n, i, s) { + if (aA(t)) return; + const o = t.toLowerCase(), c = e.type.get(o); + if (c !== void 0) + return nk(e, c, n, i, s); + n.push(cye(e, (_, ...u) => mv(s, i, _, ...u))); + } + function Gye(e, t, n, i, s, o, c) { + return kn(hr(t, (_, u) => LS(e.element, _, n, i, s, o?.elements[u], c)), (_) => e.listPreserveFalsyValues ? !0 : !!_); + } + var PMe = /(?:^|\/)\*\*\/?$/, NMe = /^[^*?]*(?=\/[^/]*[*?])/; + function U4(e, t, n, i, s = Ge) { + t = Hs(t); + const o = Zl(i.useCaseSensitiveFileNames), c = /* @__PURE__ */ new Map(), _ = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), { validatedFilesSpec: g, validatedIncludeSpecs: m, validatedExcludeSpecs: h } = e, S = _4(n, s), T = bN(n, S); + if (g) + for (const A of g) { + const O = Qi(A, t); + c.set(o(O), O); + } + let k; + if (m && m.length > 0) + for (const A of i.readDirectory( + t, + Ip(T), + h, + m, + /*depth*/ + void 0 + )) { + if (Xo( + A, + ".json" + /* Json */ + )) { + if (!k) { + const R = m.filter((U) => wo( + U, + ".json" + /* Json */ + )), B = hr(X5(R, t, "files"), (U) => `^${U}$`); + k = B ? B.map((U) => b0(U, i.useCaseSensitiveFileNames)) : Ge; + } + if (oc(k, (R) => R.test(A)) !== -1) { + const R = o(A); + !c.has(R) && !u.has(R) && u.set(R, A); + } + continue; + } + if (FMe(A, c, _, S, o)) + continue; + OMe(A, _, S, o); + const O = o(A); + !c.has(O) && !_.has(O) && _.set(O, A); + } + const D = is(c.values()), P = is(_.values()); + return D.concat(P, is(u.values())); + } + function qre(e, t, n, i, s) { + const { validatedFilesSpec: o, validatedIncludeSpecs: c, validatedExcludeSpecs: _ } = t; + if (!wr(c) || !wr(_)) return !1; + n = Hs(n); + const u = Zl(i); + if (o) { + for (const g of o) + if (u(Qi(g, n)) === e) return !1; + } + return aO(e, _, i, s, n); + } + function $ye(e) { + const t = Ui(e, "**/") ? 0 : e.indexOf("/**/"); + return t === -1 ? !1 : (wo(e, "/..") ? e.length : e.lastIndexOf("/../")) > t; + } + function sO(e, t, n, i) { + return aO( + e, + kn(t, (s) => !$ye(s)), + n, + i + ); + } + function aO(e, t, n, i, s) { + const o = u4(t, On(Hs(i), s), "exclude"), c = o && b0(o, n); + return c ? c.test(e) ? !0 : !xC(e) && c.test(gl(e)) : !1; + } + function Xye(e, t, n, i, s) { + return e.filter((c) => { + if (!gs(c)) return !1; + const _ = Hre(c, n); + return _ !== void 0 && t.push(o(..._)), _ === void 0; + }); + function o(c, _) { + const u = e5(i, s, _); + return mv(i, u, c, _); + } + } + function Hre(e, t) { + if (E.assert(typeof e == "string"), t && PMe.test(e)) + return [p.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, e]; + if ($ye(e)) + return [p.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, e]; + } + function AMe({ validatedIncludeSpecs: e, validatedExcludeSpecs: t }, n, i) { + const s = u4(t, n, "exclude"), o = s && new RegExp(s, i ? "" : "i"), c = {}, _ = /* @__PURE__ */ new Map(); + if (e !== void 0) { + const u = []; + for (const g of e) { + const m = Hs(On(n, g)); + if (o && o.test(m)) + continue; + const h = IMe(m, i); + if (h) { + const { key: S, path: T, flags: k } = h, D = _.get(S), P = D !== void 0 ? c[D] : void 0; + (P === void 0 || P < k) && (c[D !== void 0 ? D : T] = k, D === void 0 && _.set(S, T), k === 1 && u.push(S)); + } + } + for (const g in c) + if (eo(c, g)) + for (const m of u) { + const h = Gre(g, i); + h !== m && np(m, h, n, !i) && delete c[g]; + } + } + return c; + } + function Gre(e, t) { + return t ? e : my(e); + } + function IMe(e, t) { + const n = NMe.exec(e); + if (n) { + const i = e.indexOf("?"), s = e.indexOf("*"), o = e.lastIndexOf(So); + return { + key: Gre(n[0], t), + path: n[0], + flags: i !== -1 && i < o || s !== -1 && s < o ? 1 : 0 + /* None */ + }; + } + if (wJ(e.substring(e.lastIndexOf(So) + 1))) { + const i = _0(e); + return { + key: Gre(i, t), + path: i, + flags: 1 + /* Recursive */ + }; + } + } + function FMe(e, t, n, i, s) { + const o = lr(i, (c) => xc(e, c) ? c : void 0); + if (!o) + return !1; + for (const c of o) { + if (Xo(e, c) && (c !== ".ts" || !Xo( + e, + ".d.ts" + /* Dts */ + ))) + return !1; + const _ = s(S0(e, c)); + if (t.has(_) || n.has(_)) { + if (c === ".d.ts" && (Xo( + e, + ".js" + /* Js */ + ) || Xo( + e, + ".jsx" + /* Jsx */ + ))) + continue; + return !0; + } + } + return !1; + } + function OMe(e, t, n, i) { + const s = lr(n, (o) => xc(e, o) ? o : void 0); + if (s) + for (let o = s.length - 1; o >= 0; o--) { + const c = s[o]; + if (Xo(e, c)) + return; + const _ = i(S0(e, c)); + t.delete(_); + } + } + function $re(e) { + const t = {}; + for (const n in e) + if (eo(e, n)) { + const i = Kz(n); + i !== void 0 && (t[n] = Xre(e[n], i)); + } + return t; + } + function Xre(e, t) { + if (e === void 0) return e; + switch (t.type) { + case "object": + return ""; + case "string": + return ""; + case "number": + return typeof e == "number" ? e : ""; + case "boolean": + return typeof e == "boolean" ? e : ""; + case "listOrElement": + if (!as(e)) return Xre(e, t.element); + // fall through to list + case "list": + const n = t.element; + return as(e) ? Fi(e, (i) => Xre(i, n)) : ""; + default: + return hl(t.type, (i, s) => { + if (i === e) + return s; + }); + } + } + function ts(e, t, ...n) { + e.trace(Nx(t, ...n)); + } + function Xy(e, t) { + return !!e.traceResolution && t.trace !== void 0; + } + function ik(e, t, n) { + let i; + if (t && e) { + const s = e.contents.packageJsonContent; + typeof s.name == "string" && typeof s.version == "string" && (i = { + name: s.name, + subModuleName: t.path.slice(e.packageDirectory.length + So.length), + version: s.version, + peerDependencies: tRe(e, n) + }); + } + return t && { path: t.path, extension: t.ext, packageId: i, resolvedUsingTsExtension: t.resolvedUsingTsExtension }; + } + function uW(e) { + return ik( + /*packageInfo*/ + void 0, + e, + /*state*/ + void 0 + ); + } + function Qye(e) { + if (e) + return E.assert(e.packageId === void 0), { path: e.path, ext: e.extension, resolvedUsingTsExtension: e.resolvedUsingTsExtension }; + } + function oO(e) { + const t = []; + return e & 1 && t.push("TypeScript"), e & 2 && t.push("JavaScript"), e & 4 && t.push("Declaration"), e & 8 && t.push("JSON"), t.join(", "); + } + function LMe(e) { + const t = []; + return e & 1 && t.push(...vN), e & 2 && t.push(...s6), e & 4 && t.push(...tF), e & 8 && t.push( + ".json" + /* Json */ + ), t; + } + function Qre(e) { + if (e) + return E.assert(nF(e.extension)), { fileName: e.path, packageId: e.packageId }; + } + function Yye(e, t, n, i, s, o, c, _, u) { + if (!c.resultFromCache && !c.compilerOptions.preserveSymlinks && t && n && !t.originalPath && !Dl(e)) { + const { resolvedFileName: g, originalPath: m } = e1e(t.path, c.host, c.traceEnabled); + m && (t = { ...t, path: g, originalPath: m }); + } + return Zye( + t, + n, + i, + s, + o, + c.resultFromCache, + _, + u + ); + } + function Zye(e, t, n, i, s, o, c, _) { + return o ? c?.isReadonly ? { + ...o, + failedLookupLocations: Yre(o.failedLookupLocations, n), + affectingLocations: Yre(o.affectingLocations, i), + resolutionDiagnostics: Yre(o.resolutionDiagnostics, s) + } : (o.failedLookupLocations = P6(o.failedLookupLocations, n), o.affectingLocations = P6(o.affectingLocations, i), o.resolutionDiagnostics = P6(o.resolutionDiagnostics, s), o) : { + resolvedModule: e && { + resolvedFileName: e.path, + originalPath: e.originalPath === !0 ? void 0 : e.originalPath, + extension: e.extension, + isExternalLibraryImport: t, + packageId: e.packageId, + resolvedUsingTsExtension: !!e.resolvedUsingTsExtension + }, + failedLookupLocations: V4(n), + affectingLocations: V4(i), + resolutionDiagnostics: V4(s), + alternateResult: _ + }; + } + function V4(e) { + return e.length ? e : void 0; + } + function P6(e, t) { + return t?.length ? e?.length ? (e.push(...t), e) : t : e; + } + function Yre(e, t) { + return e?.length ? t.length ? [...e, ...t] : e.slice() : V4(t); + } + function Zre(e, t, n, i) { + if (!eo(e, t)) { + i.traceEnabled && ts(i.host, p.package_json_does_not_have_a_0_field, t); + return; + } + const s = e[t]; + if (typeof s !== n || s === null) { + i.traceEnabled && ts(i.host, p.Expected_type_of_0_field_in_package_json_to_be_1_got_2, t, n, s === null ? "null" : typeof s); + return; + } + return s; + } + function _W(e, t, n, i) { + const s = Zre(e, t, "string", i); + if (s === void 0) + return; + if (!s) { + i.traceEnabled && ts(i.host, p.package_json_had_a_falsy_0_field, t); + return; + } + const o = Hs(On(n, s)); + return i.traceEnabled && ts(i.host, p.package_json_has_0_field_1_that_references_2, t, s, o), o; + } + function MMe(e, t, n) { + return _W(e, "typings", t, n) || _W(e, "types", t, n); + } + function RMe(e, t, n) { + return _W(e, "tsconfig", t, n); + } + function jMe(e, t, n) { + return _W(e, "main", t, n); + } + function BMe(e, t) { + const n = Zre(e, "typesVersions", "object", t); + if (n !== void 0) + return t.traceEnabled && ts(t.host, p.package_json_has_a_typesVersions_field_with_version_specific_path_mappings), n; + } + function JMe(e, t) { + const n = BMe(e, t); + if (n === void 0) return; + if (t.traceEnabled) + for (const c in n) + eo(n, c) && !t7.tryParse(c) && ts(t.host, p.package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range, c); + const i = cO(n); + if (!i) { + t.traceEnabled && ts(t.host, p.package_json_does_not_have_a_typesVersions_entry_that_matches_version_0, q2); + return; + } + const { version: s, paths: o } = i; + if (typeof o != "object") { + t.traceEnabled && ts(t.host, p.Expected_type_of_0_field_in_package_json_to_be_1_got_2, `typesVersions['${s}']`, "object", typeof o); + return; + } + return i; + } + var Kre; + function cO(e) { + Kre || (Kre = new xd(ep)); + for (const t in e) { + if (!eo(e, t)) continue; + const n = t7.tryParse(t); + if (n !== void 0 && n.test(Kre)) + return { version: t, paths: e[t] }; + } + } + function q4(e, t) { + if (e.typeRoots) + return e.typeRoots; + let n; + if (e.configFilePath ? n = Hn(e.configFilePath) : t.getCurrentDirectory && (n = t.getCurrentDirectory()), n !== void 0) + return zMe(n); + } + function zMe(e) { + let t; + return pD(Hs(e), (n) => { + const i = On(n, WMe); + (t ?? (t = [])).push(i); + }), t; + } + var WMe = On("node_modules", "@types"); + function Kye(e, t, n) { + const i = typeof n.useCaseSensitiveFileNames == "function" ? n.useCaseSensitiveFileNames() : n.useCaseSensitiveFileNames; + return gh(e, t, !i) === 0; + } + function e1e(e, t, n) { + const i = l1e(e, t, n), s = Kye(e, i, t); + return { + // If the fileName and realpath are differing only in casing prefer fileName so that we can issue correct errors for casing under forceConsistentCasingInFileNames + resolvedFileName: s ? e : i, + originalPath: s ? void 0 : e + }; + } + function t1e(e, t, n) { + const i = wo(e, "/node_modules/@types") || wo(e, "/node_modules/@types/") ? T1e(t, n) : t; + return On(e, i); + } + function ene(e, t, n, i, s, o, c) { + E.assert(typeof e == "string", "Non-string value passed to `ts.resolveTypeReferenceDirective`, likely by a wrapping package working with an outdated `resolveTypeReferenceDirectives` signature. This is probably not a problem in TS itself."); + const _ = Xy(n, i); + s && (n = s.commandLine.options); + const u = t ? Hn(t) : void 0; + let g = u ? o?.getFromDirectoryCache(e, c, u, s) : void 0; + if (!g && u && !Dl(e) && (g = o?.getFromNonRelativeNameCache(e, c, u, s)), g) + return _ && (ts(i, p.Resolving_type_reference_directive_0_containing_file_1, e, t), s && ts(i, p.Using_compiler_options_of_project_reference_redirect_0, s.sourceFile.fileName), ts(i, p.Resolution_for_type_reference_directive_0_was_found_in_cache_from_location_1, e, u), B(g)), g; + const m = q4(n, i); + _ && (t === void 0 ? m === void 0 ? ts(i, p.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, e) : ts(i, p.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, e, m) : m === void 0 ? ts(i, p.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, e, t) : ts(i, p.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, e, t, m), s && ts(i, p.Using_compiler_options_of_project_reference_redirect_0, s.sourceFile.fileName)); + const h = [], S = []; + let T = tne(n); + c !== void 0 && (T |= 30); + const k = Pu(n); + c === 99 && 3 <= k && k <= 99 && (T |= 32); + const D = T & 8 ? Qy(n, c) : [], P = [], A = { + compilerOptions: n, + host: i, + traceEnabled: _, + failedLookupLocations: h, + affectingLocations: S, + packageJsonInfoCache: o, + features: T, + conditions: D, + requestContainingDirectory: u, + reportDiagnostic: (W) => void P.push(W), + isConfigLookup: !1, + candidateIsFromPackageJsonField: !1, + resolvedPackageDirectory: !1 + }; + let O = U(), F = !0; + O || (O = $(), F = !1); + let R; + if (O) { + const { fileName: W, packageId: _e } = O; + let K = W, V; + n.preserveSymlinks || ({ resolvedFileName: K, originalPath: V } = e1e(W, i, _)), R = { + primary: F, + resolvedFileName: K, + originalPath: V, + packageId: _e, + isExternalLibraryImport: Yy(W) + }; + } + return g = { + resolvedTypeReferenceDirective: R, + failedLookupLocations: V4(h), + affectingLocations: V4(S), + resolutionDiagnostics: V4(P) + }, u && o && !o.isReadonly && (o.getOrCreateCacheForDirectory(u, s).set( + e, + /*mode*/ + c, + g + ), Dl(e) || o.getOrCreateCacheForNonRelativeName(e, c, s).set(u, g)), _ && B(g), g; + function B(W) { + var _e; + (_e = W.resolvedTypeReferenceDirective) != null && _e.resolvedFileName ? W.resolvedTypeReferenceDirective.packageId ? ts(i, p.Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3, e, W.resolvedTypeReferenceDirective.resolvedFileName, U1(W.resolvedTypeReferenceDirective.packageId), W.resolvedTypeReferenceDirective.primary) : ts(i, p.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, e, W.resolvedTypeReferenceDirective.resolvedFileName, W.resolvedTypeReferenceDirective.primary) : ts(i, p.Type_reference_directive_0_was_not_resolved, e); + } + function U() { + if (m && m.length) + return _ && ts(i, p.Resolving_with_primary_search_path_0, m.join(", ")), Lc(m, (W) => { + const _e = t1e(W, e, A), K = Pd(W, i); + if (!K && _ && ts(i, p.Directory_0_does_not_exist_skipping_all_lookups_in_it, W), n.typeRoots) { + const V = I6(4, _e, !K, A); + if (V) { + const ae = lA(V.path), se = ae ? RS( + ae, + /*onlyRecordFailures*/ + !1, + A + ) : void 0; + return Qre(ik(se, V, A)); + } + } + return Qre( + une(4, _e, !K, A) + ); + }); + _ && ts(i, p.Root_directory_cannot_be_determined_skipping_primary_search_paths); + } + function $() { + const W = t && Hn(t); + if (W !== void 0) { + let _e; + if (!n.typeRoots || !wo(t, cw)) + if (_ && ts(i, p.Looking_up_in_node_modules_folder_initial_location_0, W), Dl(e)) { + const { path: K } = c1e(W, e); + _e = mW( + 4, + K, + /*onlyRecordFailures*/ + !1, + A, + /*considerPackageJson*/ + !0 + ); + } else { + const K = y1e( + 4, + e, + W, + A, + /*cache*/ + void 0, + /*redirectedReference*/ + void 0 + ); + _e = K && K.value; + } + else _ && ts(i, p.Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_node_modules_folder); + return Qre(_e); + } else + _ && ts(i, p.Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder); + } + } + function tne(e) { + let t = 0; + switch (Pu(e)) { + case 3: + t = 30; + break; + case 99: + t = 30; + break; + case 100: + t = 30; + break; + } + return e.resolvePackageJsonExports ? t |= 8 : e.resolvePackageJsonExports === !1 && (t &= -9), e.resolvePackageJsonImports ? t |= 2 : e.resolvePackageJsonImports === !1 && (t &= -3), t; + } + function Qy(e, t) { + const n = Pu(e); + if (t === void 0) { + if (n === 100) + t = 99; + else if (n === 2) + return []; + } + const i = t === 99 ? ["import"] : ["require"]; + return e.noDtsResolution || i.push("types"), n !== 100 && i.push("node"), Bi(i, e.customConditions); + } + function fW(e, t, n, i, s) { + const o = G4(s?.getPackageJsonInfoCache(), i, n); + return eg(i, t, (c) => { + if (Zc(c) !== "node_modules") { + const _ = On(c, "node_modules"), u = On(_, e); + return RS( + u, + /*onlyRecordFailures*/ + !1, + o + ); + } + }); + } + function lO(e, t) { + if (e.types) + return e.types; + const n = []; + if (t.directoryExists && t.getDirectories) { + const i = q4(e, t); + if (i) { + for (const s of i) + if (t.directoryExists(s)) + for (const o of t.getDirectories(s)) { + const c = Hs(o), _ = On(s, c, "package.json"); + if (!(t.fileExists(_) && e6(_, t).typings === null)) { + const g = Zc(c); + g.charCodeAt(0) !== 46 && n.push(g); + } + } + } + } + return n; + } + function uO(e) { + return !!e?.contents; + } + function rne(e) { + return !!e && !e.contents; + } + function nne(e) { + var t; + if (e === null || typeof e != "object") + return "" + e; + if (as(e)) + return `[${(t = e.map((i) => nne(i))) == null ? void 0 : t.join(",")}]`; + let n = "{"; + for (const i in e) + eo(e, i) && (n += `${i}: ${nne(e[i])}`); + return n + "}"; + } + function pW(e, t) { + return t.map((n) => nne(H5(e, n))).join("|") + `|${e.pathsBasePath}`; + } + function r1e(e, t) { + const n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(); + let s = /* @__PURE__ */ new Map(); + return e && n.set(e, s), { + getMapOfCacheRedirects: o, + getOrCreateMapOfCacheRedirects: c, + update: _, + clear: g, + getOwnMap: () => s + }; + function o(h) { + return h ? u( + h.commandLine.options, + /*create*/ + !1 + ) : s; + } + function c(h) { + return h ? u( + h.commandLine.options, + /*create*/ + !0 + ) : s; + } + function _(h) { + e !== h && (e ? s = u( + h, + /*create*/ + !0 + ) : n.set(h, s), e = h); + } + function u(h, S) { + let T = n.get(h); + if (T) return T; + const k = m(h); + if (T = i.get(k), !T) { + if (e) { + const D = m(e); + D === k ? T = s : i.has(D) || i.set(D, s); + } + S && (T ?? (T = /* @__PURE__ */ new Map())), T && i.set(k, T); + } + return T && n.set(h, T), T; + } + function g() { + const h = e && t.get(e); + s.clear(), n.clear(), t.clear(), i.clear(), e && (h && t.set(e, h), n.set(e, s)); + } + function m(h) { + let S = t.get(h); + return S || t.set(h, S = pW(h, Xz)), S; + } + } + function UMe(e, t) { + let n; + return { getPackageJsonInfo: i, setPackageJsonInfo: s, clear: o, getInternalMap: c }; + function i(_) { + return n?.get(oo(_, e, t)); + } + function s(_, u) { + (n || (n = /* @__PURE__ */ new Map())).set(oo(_, e, t), u); + } + function o() { + n = void 0; + } + function c() { + return n; + } + } + function n1e(e, t, n, i) { + const s = e.getOrCreateMapOfCacheRedirects(t); + let o = s.get(n); + return o || (o = i(), s.set(n, o)), o; + } + function VMe(e, t, n, i) { + const s = r1e(n, i); + return { + getFromDirectoryCache: u, + getOrCreateCacheForDirectory: _, + clear: o, + update: c, + directoryToModuleNameMap: s + }; + function o() { + s.clear(); + } + function c(g) { + s.update(g); + } + function _(g, m) { + const h = oo(g, e, t); + return n1e(s, m, h, () => N6()); + } + function u(g, m, h, S) { + var T, k; + const D = oo(h, e, t); + return (k = (T = s.getMapOfCacheRedirects(S)) == null ? void 0 : T.get(D)) == null ? void 0 : k.get(g, m); + } + } + function H4(e, t) { + return t === void 0 ? e : `${t}|${e}`; + } + function N6() { + const e = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), n = { + get(s, o) { + return e.get(i(s, o)); + }, + set(s, o, c) { + return e.set(i(s, o), c), n; + }, + delete(s, o) { + return e.delete(i(s, o)), n; + }, + has(s, o) { + return e.has(i(s, o)); + }, + forEach(s) { + return e.forEach((o, c) => { + const [_, u] = t.get(c); + return s(o, _, u); + }); + }, + size() { + return e.size; + } + }; + return n; + function i(s, o) { + const c = H4(s, o); + return t.set(c, [s, o]), c; + } + } + function qMe(e) { + return e.resolvedModule && (e.resolvedModule.originalPath || e.resolvedModule.resolvedFileName); + } + function HMe(e) { + return e.resolvedTypeReferenceDirective && (e.resolvedTypeReferenceDirective.originalPath || e.resolvedTypeReferenceDirective.resolvedFileName); + } + function GMe(e, t, n, i, s) { + const o = r1e(n, s); + return { + getFromNonRelativeNameCache: u, + getOrCreateCacheForNonRelativeName: g, + clear: c, + update: _ + }; + function c() { + o.clear(); + } + function _(h) { + o.update(h); + } + function u(h, S, T, k) { + var D, P; + return E.assert(!Dl(h)), (P = (D = o.getMapOfCacheRedirects(k)) == null ? void 0 : D.get(H4(h, S))) == null ? void 0 : P.get(T); + } + function g(h, S, T) { + return E.assert(!Dl(h)), n1e(o, T, H4(h, S), m); + } + function m() { + const h = /* @__PURE__ */ new Map(); + return { get: S, set: T }; + function S(D) { + return h.get(oo(D, e, t)); + } + function T(D, P) { + const A = oo(D, e, t); + if (h.has(A)) + return; + h.set(A, P); + const O = i(P), F = O && k(A, O); + let R = A; + for (; R !== F; ) { + const B = Hn(R); + if (B === R || h.has(B)) + break; + h.set(B, P), R = B; + } + } + function k(D, P) { + const A = oo(Hn(P), e, t); + let O = 0; + const F = Math.min(D.length, A.length); + for (; O < F && D.charCodeAt(O) === A.charCodeAt(O); ) + O++; + if (O === D.length && (A.length === O || A[O] === So)) + return D; + const R = kd(D); + if (O < R) + return; + const B = D.lastIndexOf(So, O - 1); + if (B !== -1) + return D.substr(0, Math.max(B, R)); + } + } + } + function i1e(e, t, n, i, s, o) { + o ?? (o = /* @__PURE__ */ new Map()); + const c = VMe( + e, + t, + n, + o + ), _ = GMe( + e, + t, + n, + s, + o + ); + return i ?? (i = UMe(e, t)), { + ...i, + ...c, + ..._, + clear: u, + update: m, + getPackageJsonInfoCache: () => i, + clearAllExceptPackageJsonInfoCache: g, + optionsToRedirectsKey: o + }; + function u() { + g(), i.clear(); + } + function g() { + c.clear(), _.clear(); + } + function m(h) { + c.update(h), _.update(h); + } + } + function A6(e, t, n, i, s) { + const o = i1e( + e, + t, + n, + i, + qMe, + s + ); + return o.getOrCreateCacheForModuleName = (c, _, u) => o.getOrCreateCacheForNonRelativeName(c, _, u), o; + } + function _O(e, t, n, i, s) { + return i1e( + e, + t, + n, + i, + HMe, + s + ); + } + function dW(e) { + return { moduleResolution: 2, traceResolution: e.traceResolution }; + } + function fO(e, t, n, i, s) { + return MS(e, t, dW(n), i, s); + } + function s1e(e, t, n, i) { + const s = Hn(t); + return n.getFromDirectoryCache( + e, + i, + s, + /*redirectedReference*/ + void 0 + ); + } + function MS(e, t, n, i, s, o, c) { + const _ = Xy(n, i); + o && (n = o.commandLine.options), _ && (ts(i, p.Resolving_module_0_from_1, e, t), o && ts(i, p.Using_compiler_options_of_project_reference_redirect_0, o.sourceFile.fileName)); + const u = Hn(t); + let g = s?.getFromDirectoryCache(e, c, u, o); + if (g) + _ && ts(i, p.Resolution_for_module_0_was_found_in_cache_from_location_1, e, u); + else { + let m = n.moduleResolution; + switch (m === void 0 ? (m = Pu(n), _ && ts(i, p.Module_resolution_kind_is_not_specified_using_0, SC[m])) : _ && ts(i, p.Explicitly_specified_module_resolution_kind_Colon_0, SC[m]), m) { + case 3: + g = YMe(e, t, n, i, s, o, c); + break; + case 99: + g = ZMe(e, t, n, i, s, o, c); + break; + case 2: + g = one(e, t, n, i, s, o, c ? Qy(n, c) : void 0); + break; + case 1: + g = pne(e, t, n, i, s, o); + break; + case 100: + g = ane(e, t, n, i, s, o, c ? Qy(n, c) : void 0); + break; + default: + return E.fail(`Unexpected moduleResolution: ${m}`); + } + s && !s.isReadonly && (s.getOrCreateCacheForDirectory(u, o).set(e, c, g), Dl(e) || s.getOrCreateCacheForNonRelativeName(e, c, o).set(u, g)); + } + return _ && (g.resolvedModule ? g.resolvedModule.packageId ? ts(i, p.Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2, e, g.resolvedModule.resolvedFileName, U1(g.resolvedModule.packageId)) : ts(i, p.Module_name_0_was_successfully_resolved_to_1, e, g.resolvedModule.resolvedFileName) : ts(i, p.Module_name_0_was_not_resolved, e)), g; + } + function a1e(e, t, n, i, s) { + const o = $Me(e, t, i, s); + return o ? o.value : Dl(t) ? XMe(e, t, n, i, s) : QMe(e, t, i, s); + } + function $Me(e, t, n, i) { + const { baseUrl: s, paths: o } = i.compilerOptions; + if (o && !xf(t)) { + i.traceEnabled && (s && ts(i.host, p.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, s, t), ts(i.host, p.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, t)); + const c = C5(i.compilerOptions, i.host), _ = xN(o); + return _ne( + e, + t, + c, + o, + _, + n, + /*onlyRecordFailures*/ + !1, + i + ); + } + } + function XMe(e, t, n, i, s) { + if (!s.compilerOptions.rootDirs) + return; + s.traceEnabled && ts(s.host, p.rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0, t); + const o = Hs(On(n, t)); + let c, _; + for (const u of s.compilerOptions.rootDirs) { + let g = Hs(u); + wo(g, So) || (g += So); + const m = Ui(o, g) && (_ === void 0 || _.length < g.length); + s.traceEnabled && ts(s.host, p.Checking_if_0_is_the_longest_matching_prefix_for_1_2, g, o, m), m && (_ = g, c = u); + } + if (_) { + s.traceEnabled && ts(s.host, p.Longest_matching_prefix_for_0_is_1, o, _); + const u = o.substr(_.length); + s.traceEnabled && ts(s.host, p.Loading_0_from_the_root_dir_1_candidate_location_2, u, _, o); + const g = i(e, o, !Pd(n, s.host), s); + if (g) + return g; + s.traceEnabled && ts(s.host, p.Trying_other_entries_in_rootDirs); + for (const m of s.compilerOptions.rootDirs) { + if (m === c) + continue; + const h = On(Hs(m), u); + s.traceEnabled && ts(s.host, p.Loading_0_from_the_root_dir_1_candidate_location_2, u, m, h); + const S = Hn(h), T = i(e, h, !Pd(S, s.host), s); + if (T) + return T; + } + s.traceEnabled && ts(s.host, p.Module_resolution_using_rootDirs_has_failed); + } + } + function QMe(e, t, n, i) { + const { baseUrl: s } = i.compilerOptions; + if (!s) + return; + i.traceEnabled && ts(i.host, p.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, s, t); + const o = Hs(On(s, t)); + return i.traceEnabled && ts(i.host, p.Resolving_module_name_0_relative_to_base_url_1_2, t, s, o), n(e, o, !Pd(Hn(o), i.host), i); + } + function ine(e, t, n) { + const { resolvedModule: i, failedLookupLocations: s } = KMe(e, t, n); + if (!i) + throw new Error(`Could not resolve JS module '${e}' starting at '${t}'. Looked in: ${s?.join(", ")}`); + return i.resolvedFileName; + } + var sne = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Imports = 2] = "Imports", e[e.SelfName = 4] = "SelfName", e[e.Exports = 8] = "Exports", e[e.ExportsPatternTrailers = 16] = "ExportsPatternTrailers", e[e.AllFeatures = 30] = "AllFeatures", e[e.Node16Default = 30] = "Node16Default", e[ + e.NodeNextDefault = 30 + /* AllFeatures */ + ] = "NodeNextDefault", e[e.BundlerDefault = 30] = "BundlerDefault", e[e.EsmMode = 32] = "EsmMode", e))(sne || {}); + function YMe(e, t, n, i, s, o, c) { + return o1e( + 30, + e, + t, + n, + i, + s, + o, + c + ); + } + function ZMe(e, t, n, i, s, o, c) { + return o1e( + 30, + e, + t, + n, + i, + s, + o, + c + ); + } + function o1e(e, t, n, i, s, o, c, _, u) { + const g = Hn(n), m = _ === 99 ? 32 : 0; + let h = i.noDtsResolution ? 3 : 7; + return zb(i) && (h |= 8), cA( + e | m, + t, + g, + i, + s, + o, + h, + /*isConfigLookup*/ + !1, + c, + u + ); + } + function KMe(e, t, n) { + return cA( + 0, + e, + t, + { moduleResolution: 2, allowJs: !0 }, + n, + /*cache*/ + void 0, + 2, + /*isConfigLookup*/ + !1, + /*redirectedReference*/ + void 0, + /*conditions*/ + void 0 + ); + } + function ane(e, t, n, i, s, o, c) { + const _ = Hn(t); + let u = n.noDtsResolution ? 3 : 7; + return zb(n) && (u |= 8), cA( + tne(n), + e, + _, + n, + i, + s, + u, + /*isConfigLookup*/ + !1, + o, + c + ); + } + function one(e, t, n, i, s, o, c, _) { + let u; + return _ ? u = 8 : n.noDtsResolution ? (u = 3, zb(n) && (u |= 8)) : u = zb(n) ? 15 : 7, cA(c ? 30 : 0, e, Hn(t), n, i, s, u, !!_, o, c); + } + function cne(e, t, n) { + return cA( + 30, + e, + Hn(t), + { + moduleResolution: 99 + /* NodeNext */ + }, + n, + /*cache*/ + void 0, + 8, + /*isConfigLookup*/ + !0, + /*redirectedReference*/ + void 0, + /*conditions*/ + void 0 + ); + } + function cA(e, t, n, i, s, o, c, _, u, g) { + var m, h, S, T, k; + const D = Xy(i, s), P = [], A = [], O = Pu(i); + g ?? (g = Qy( + i, + O === 100 || O === 2 ? void 0 : e & 32 ? 99 : 1 + /* CommonJS */ + )); + const F = [], R = { + compilerOptions: i, + host: s, + traceEnabled: D, + failedLookupLocations: P, + affectingLocations: A, + packageJsonInfoCache: o, + features: e, + conditions: g ?? Ge, + requestContainingDirectory: n, + reportDiagnostic: (W) => void F.push(W), + isConfigLookup: _, + candidateIsFromPackageJsonField: !1, + resolvedPackageDirectory: !1 + }; + D && i6(O) && ts(s, p.Resolving_in_0_mode_with_conditions_1, e & 32 ? "ESM" : "CJS", R.conditions.map((W) => `'${W}'`).join(", ")); + let B; + if (O === 2) { + const W = c & 5, _e = c & -6; + B = W && $(W, R) || _e && $(_e, R) || void 0; + } else + B = $(c, R); + let U; + if (R.resolvedPackageDirectory && !_ && !Dl(t)) { + const W = B?.value && c & 5 && !m1e(5, B.value.resolved.extension); + if ((m = B?.value) != null && m.isExternalLibraryImport && W && e & 8 && g?.includes("import")) { + Zy(R, p.Resolution_of_non_relative_name_failed_trying_with_modern_Node_resolution_features_disabled_to_see_if_npm_library_needs_configuration_update); + const _e = { + ...R, + features: R.features & -9, + reportDiagnostic: Ha + }, K = $(c & 5, _e); + (h = K?.value) != null && h.isExternalLibraryImport && (U = K.value.resolved.path); + } else if ((!B?.value || W) && O === 2) { + Zy(R, p.Resolution_of_non_relative_name_failed_trying_with_moduleResolution_bundler_to_see_if_project_may_need_configuration_update); + const _e = { + ...R.compilerOptions, + moduleResolution: 100 + /* Bundler */ + }, K = { + ...R, + compilerOptions: _e, + features: 30, + conditions: Qy(_e), + reportDiagnostic: Ha + }, V = $(c & 5, K); + (S = V?.value) != null && S.isExternalLibraryImport && (U = V.value.resolved.path); + } + } + return Yye( + t, + (T = B?.value) == null ? void 0 : T.resolved, + (k = B?.value) == null ? void 0 : k.isExternalLibraryImport, + P, + A, + F, + R, + o, + U + ); + function $(W, _e) { + const V = a1e(W, t, n, (ae, se, ce, fe) => mW( + ae, + se, + ce, + fe, + /*considerPackageJson*/ + !0 + ), _e); + if (V) + return Mf({ resolved: V, isExternalLibraryImport: Yy(V.path) }); + if (Dl(t)) { + const { path: ae, parts: se } = c1e(n, t), ce = mW( + W, + ae, + /*onlyRecordFailures*/ + !1, + _e, + /*considerPackageJson*/ + !0 + ); + return ce && Mf({ resolved: ce, isExternalLibraryImport: ms(se, "node_modules") }); + } else { + if (e & 2 && Ui(t, "#")) { + const se = sRe(W, t, n, _e, o, u); + if (se) + return se.value && { value: { resolved: se.value, isExternalLibraryImport: !1 } }; + } + if (e & 4) { + const se = iRe(W, t, n, _e, o, u); + if (se) + return se.value && { value: { resolved: se.value, isExternalLibraryImport: !1 } }; + } + if (t.includes(":")) { + D && ts(s, p.Skipping_module_0_that_looks_like_an_absolute_URI_target_file_types_Colon_1, t, oO(W)); + return; + } + D && ts(s, p.Loading_module_0_from_node_modules_folder_target_file_types_Colon_1, t, oO(W)); + let ae = y1e(W, t, n, _e, o, u); + return W & 4 && (ae ?? (ae = k1e(t, _e))), ae && { value: ae.value && { resolved: ae.value, isExternalLibraryImport: !0 } }; + } + } + } + function c1e(e, t) { + const n = On(e, t), i = fu(n), s = Do(i); + return { path: s === "." || s === ".." ? gl(Hs(n)) : Hs(n), parts: i }; + } + function l1e(e, t, n) { + if (!t.realpath) + return e; + const i = Hs(t.realpath(e)); + return n && ts(t, p.Resolving_real_path_for_0_result_1, e, i), i; + } + function mW(e, t, n, i, s) { + if (i.traceEnabled && ts(i.host, p.Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_types_Colon_1, t, oO(e)), !vy(t)) { + if (!n) { + const c = Hn(t); + Pd(c, i.host) || (i.traceEnabled && ts(i.host, p.Directory_0_does_not_exist_skipping_all_lookups_in_it, c), n = !0); + } + const o = I6(e, t, n, i); + if (o) { + const c = s ? lA(o.path) : void 0, _ = c ? RS( + c, + /*onlyRecordFailures*/ + !1, + i + ) : void 0; + return ik(_, o, i); + } + } + if (n || Pd(t, i.host) || (i.traceEnabled && ts(i.host, p.Directory_0_does_not_exist_skipping_all_lookups_in_it, t), n = !0), !(i.features & 32)) + return une(e, t, n, i, s); + } + var qg = "/node_modules/"; + function Yy(e) { + return e.includes(qg); + } + function lA(e, t) { + const n = Hs(e), i = n.lastIndexOf(qg); + if (i === -1) + return; + const s = i + qg.length; + let o = u1e(n, s, t); + return n.charCodeAt(s) === 64 && (o = u1e(n, o, t)), n.slice(0, o); + } + function u1e(e, t, n) { + const i = e.indexOf(So, t + 1); + return i === -1 ? n ? e.length : t : i; + } + function lne(e, t, n, i) { + return uW(I6(e, t, n, i)); + } + function I6(e, t, n, i) { + const s = _1e(e, t, n, i); + if (s) + return s; + if (!(i.features & 32)) { + const o = f1e(t, e, "", n, i); + if (o) + return o; + } + } + function _1e(e, t, n, i) { + if (!Zc(t).includes(".")) + return; + let o = Gu(t); + o === t && (o = t.substring(0, t.lastIndexOf("."))); + const c = t.substring(o.length); + return i.traceEnabled && ts(i.host, p.File_name_0_has_a_1_extension_stripping_it, t, c), f1e(o, e, c, n, i); + } + function gW(e, t, n, i, s) { + if (e & 1 && xc(t, vN) || e & 4 && xc(t, tF)) { + const o = hW(t, i, s), c = O5(t); + return o !== void 0 ? { path: t, ext: c, resolvedUsingTsExtension: n ? !wo(n, c) : void 0 } : void 0; + } + return s.isConfigLookup && e === 8 && Xo( + t, + ".json" + /* Json */ + ) ? hW(t, i, s) !== void 0 ? { path: t, ext: ".json", resolvedUsingTsExtension: void 0 } : void 0 : _1e(e, t, i, s); + } + function f1e(e, t, n, i, s) { + if (!i) { + const c = Hn(e); + c && (i = !Pd(c, s.host)); + } + switch (n) { + case ".mjs": + case ".mts": + case ".d.mts": + return t & 1 && o( + ".mts", + n === ".mts" || n === ".d.mts" + /* Dmts */ + ) || t & 4 && o( + ".d.mts", + n === ".mts" || n === ".d.mts" + /* Dmts */ + ) || t & 2 && o( + ".mjs" + /* Mjs */ + ) || void 0; + case ".cjs": + case ".cts": + case ".d.cts": + return t & 1 && o( + ".cts", + n === ".cts" || n === ".d.cts" + /* Dcts */ + ) || t & 4 && o( + ".d.cts", + n === ".cts" || n === ".d.cts" + /* Dcts */ + ) || t & 2 && o( + ".cjs" + /* Cjs */ + ) || void 0; + case ".json": + return t & 4 && o(".d.json.ts") || t & 8 && o( + ".json" + /* Json */ + ) || void 0; + case ".tsx": + case ".jsx": + return t & 1 && (o( + ".tsx", + n === ".tsx" + /* Tsx */ + ) || o( + ".ts", + n === ".tsx" + /* Tsx */ + )) || t & 4 && o( + ".d.ts", + n === ".tsx" + /* Tsx */ + ) || t & 2 && (o( + ".jsx" + /* Jsx */ + ) || o( + ".js" + /* Js */ + )) || void 0; + case ".ts": + case ".d.ts": + case ".js": + case "": + return t & 1 && (o( + ".ts", + n === ".ts" || n === ".d.ts" + /* Dts */ + ) || o( + ".tsx", + n === ".ts" || n === ".d.ts" + /* Dts */ + )) || t & 4 && o( + ".d.ts", + n === ".ts" || n === ".d.ts" + /* Dts */ + ) || t & 2 && (o( + ".js" + /* Js */ + ) || o( + ".jsx" + /* Jsx */ + )) || s.isConfigLookup && o( + ".json" + /* Json */ + ) || void 0; + default: + return t & 4 && !Il(e + n) && o(`.d${n}.ts`) || void 0; + } + function o(c, _) { + const u = hW(e + c, i, s); + return u === void 0 ? void 0 : { path: u, ext: c, resolvedUsingTsExtension: !s.candidateIsFromPackageJsonField && _ }; + } + } + function hW(e, t, n) { + var i; + if (!((i = n.compilerOptions.moduleSuffixes) != null && i.length)) + return p1e(e, t, n); + const s = Jg(e) ?? "", o = s ? TN(e, s) : e; + return lr(n.compilerOptions.moduleSuffixes, (c) => p1e(o + c + s, t, n)); + } + function p1e(e, t, n) { + var i; + if (!t) { + if (n.host.fileExists(e)) + return n.traceEnabled && ts(n.host, p.File_0_exists_use_it_as_a_name_resolution_result, e), e; + n.traceEnabled && ts(n.host, p.File_0_does_not_exist, e); + } + (i = n.failedLookupLocations) == null || i.push(e); + } + function une(e, t, n, i, s = !0) { + const o = s ? RS(t, n, i) : void 0; + return ik(o, vW(e, t, n, i, o), i); + } + function yW(e, t, n, i, s) { + if (!s && e.contents.resolvedEntrypoints !== void 0) + return e.contents.resolvedEntrypoints; + let o; + const c = 5 | (s ? 2 : 0), _ = tne(t), u = G4(i?.getPackageJsonInfoCache(), n, t); + u.conditions = Qy(t), u.requestContainingDirectory = e.packageDirectory; + const g = vW( + c, + e.packageDirectory, + /*onlyRecordFailures*/ + !1, + u, + e + ); + if (o = Er(o, g?.path), _ & 8 && e.contents.packageJsonContent.exports) { + const m = hb( + [Qy( + t, + 99 + /* ESNext */ + ), Qy( + t, + 1 + /* CommonJS */ + )], + Tf + ); + for (const h of m) { + const S = { ...u, failedLookupLocations: [], conditions: h, host: n }, T = eRe( + e, + e.contents.packageJsonContent.exports, + S, + c + ); + if (T) + for (const k of T) + o = dh(o, k.path); + } + } + return e.contents.resolvedEntrypoints = o || !1; + } + function eRe(e, t, n, i) { + let s; + if (as(t)) + for (const c of t) + o(c); + else if (typeof t == "object" && t !== null && dO(t)) + for (const c in t) + o(t[c]); + else + o(t); + return s; + function o(c) { + var _, u; + if (typeof c == "string" && Ui(c, "./")) + if (c.includes("*") && n.host.readDirectory) { + if (c.indexOf("*") !== c.lastIndexOf("*")) + return !1; + n.host.readDirectory( + e.packageDirectory, + LMe(i), + /*excludes*/ + void 0, + [ + u7(vS(c, "**/*"), ".*") + ] + ).forEach((g) => { + s = dh(s, { + path: g, + ext: ex(g), + resolvedUsingTsExtension: void 0 + }); + }); + } else { + const g = fu(c).slice(2); + if (g.includes("..") || g.includes(".") || g.includes("node_modules")) + return !1; + const m = On(e.packageDirectory, c), h = Qi(m, (u = (_ = n.host).getCurrentDirectory) == null ? void 0 : u.call(_)), S = gW( + i, + h, + c, + /*onlyRecordFailures*/ + !1, + n + ); + if (S) + return s = dh(s, S, (T, k) => T.path === k.path), !0; + } + else if (Array.isArray(c)) { + for (const g of c) + if (o(g)) + return !0; + } else if (typeof c == "object" && c !== null) + return lr(rm(c), (g) => { + if (g === "default" || ms(n.conditions, g) || uA(n.conditions, g)) + return o(c[g]), !0; + }); + } + } + function G4(e, t, n) { + return { + host: t, + compilerOptions: n, + traceEnabled: Xy(n, t), + failedLookupLocations: void 0, + affectingLocations: void 0, + packageJsonInfoCache: e, + features: 0, + conditions: Ge, + requestContainingDirectory: void 0, + reportDiagnostic: Ha, + isConfigLookup: !1, + candidateIsFromPackageJsonField: !1, + resolvedPackageDirectory: !1 + }; + } + function $4(e, t) { + return eg( + t.host, + e, + (n) => RS( + n, + /*onlyRecordFailures*/ + !1, + t + ) + ); + } + function d1e(e, t) { + return e.contents.versionPaths === void 0 && (e.contents.versionPaths = JMe(e.contents.packageJsonContent, t) || !1), e.contents.versionPaths || void 0; + } + function tRe(e, t) { + return e.contents.peerDependencies === void 0 && (e.contents.peerDependencies = rRe(e, t) || !1), e.contents.peerDependencies || void 0; + } + function rRe(e, t) { + const n = Zre(e.contents.packageJsonContent, "peerDependencies", "object", t); + if (n === void 0) return; + t.traceEnabled && ts(t.host, p.package_json_has_a_peerDependencies_field); + const i = l1e(e.packageDirectory, t.host, t.traceEnabled), s = i.substring(0, i.lastIndexOf("node_modules") + 12) + So; + let o = ""; + for (const c in n) + if (eo(n, c)) { + const _ = RS( + s + c, + /*onlyRecordFailures*/ + !1, + t + ); + if (_) { + const u = _.contents.packageJsonContent.version; + o += `+${c}@${u}`, t.traceEnabled && ts(t.host, p.Found_peerDependency_0_with_1_version, c, u); + } else + t.traceEnabled && ts(t.host, p.Failed_to_find_peerDependency_0, c); + } + return o; + } + function RS(e, t, n) { + var i, s, o, c, _, u; + const { host: g, traceEnabled: m } = n, h = On(e, "package.json"); + if (t) { + (i = n.failedLookupLocations) == null || i.push(h); + return; + } + const S = (s = n.packageJsonInfoCache) == null ? void 0 : s.getPackageJsonInfo(h); + if (S !== void 0) { + if (uO(S)) + return m && ts(g, p.File_0_exists_according_to_earlier_cached_lookups, h), (o = n.affectingLocations) == null || o.push(h), S.packageDirectory === e ? S : { packageDirectory: e, contents: S.contents }; + S.directoryExists && m && ts(g, p.File_0_does_not_exist_according_to_earlier_cached_lookups, h), (c = n.failedLookupLocations) == null || c.push(h); + return; + } + const T = Pd(e, g); + if (T && g.fileExists(h)) { + const k = e6(h, g); + m && ts(g, p.Found_package_json_at_0, h); + const D = { packageDirectory: e, contents: { packageJsonContent: k, versionPaths: void 0, resolvedEntrypoints: void 0, peerDependencies: void 0 } }; + return n.packageJsonInfoCache && !n.packageJsonInfoCache.isReadonly && n.packageJsonInfoCache.setPackageJsonInfo(h, D), (_ = n.affectingLocations) == null || _.push(h), D; + } else + T && m && ts(g, p.File_0_does_not_exist, h), n.packageJsonInfoCache && !n.packageJsonInfoCache.isReadonly && n.packageJsonInfoCache.setPackageJsonInfo(h, { packageDirectory: e, directoryExists: T }), (u = n.failedLookupLocations) == null || u.push(h); + } + function vW(e, t, n, i, s) { + const o = s && d1e(s, i); + let c; + s && Kye(s?.packageDirectory, t, i.host) && (i.isConfigLookup ? c = RMe(s.contents.packageJsonContent, s.packageDirectory, i) : c = e & 4 && MMe(s.contents.packageJsonContent, s.packageDirectory, i) || e & 7 && jMe(s.contents.packageJsonContent, s.packageDirectory, i) || void 0); + const _ = (S, T, k, D) => { + const P = gW( + S, + T, + /*packageJsonValue*/ + void 0, + k, + D + ); + if (P) + return uW(P); + const A = S === 4 ? 5 : S, O = D.features, F = D.candidateIsFromPackageJsonField; + D.candidateIsFromPackageJsonField = !0, s?.contents.packageJsonContent.type !== "module" && (D.features &= -33); + const R = mW( + A, + T, + k, + D, + /*considerPackageJson*/ + !1 + ); + return D.features = O, D.candidateIsFromPackageJsonField = F, R; + }, u = c ? !Pd(Hn(c), i.host) : void 0, g = n || !Pd(t, i.host), m = On(t, i.isConfigLookup ? "tsconfig" : "index"); + if (o && (!c || np(t, c))) { + const S = Nf( + t, + c || m, + /*ignoreCase*/ + !1 + ); + i.traceEnabled && ts(i.host, p.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, o.version, ep, S); + const T = xN(o.paths), k = _ne(e, S, t, o.paths, T, _, u || g, i); + if (k) + return Qye(k.value); + } + const h = c && Qye(_(e, c, u, i)); + if (h) return h; + if (!(i.features & 32)) + return I6(e, m, g, i); + } + function m1e(e, t) { + return e & 2 && (t === ".js" || t === ".jsx" || t === ".mjs" || t === ".cjs") || e & 1 && (t === ".ts" || t === ".tsx" || t === ".mts" || t === ".cts") || e & 4 && (t === ".d.ts" || t === ".d.mts" || t === ".d.cts") || e & 8 && t === ".json" || !1; + } + function pO(e) { + let t = e.indexOf(So); + return e[0] === "@" && (t = e.indexOf(So, t + 1)), t === -1 ? { packageName: e, rest: "" } : { packageName: e.slice(0, t), rest: e.slice(t + 1) }; + } + function dO(e) { + return Ni(rm(e), (t) => Ui(t, ".")); + } + function nRe(e) { + return !ot(rm(e), (t) => Ui(t, ".")); + } + function iRe(e, t, n, i, s, o) { + var c, _; + const u = Qi(n, (_ = (c = i.host).getCurrentDirectory) == null ? void 0 : _.call(c)), g = $4(u, i); + if (!g || !g.contents.packageJsonContent.exports || typeof g.contents.packageJsonContent.name != "string") + return; + const m = fu(t), h = fu(g.contents.packageJsonContent.name); + if (!Ni(h, (P, A) => m[A] === P)) + return; + const S = m.slice(h.length), T = wr(S) ? `.${So}${S.join(So)}` : "."; + if (Jy(i.compilerOptions) && !Yy(n)) + return bW(g, e, T, i, s, o); + const k = e & 5, D = e & -6; + return bW(g, k, T, i, s, o) || bW(g, D, T, i, s, o); + } + function bW(e, t, n, i, s, o) { + if (e.contents.packageJsonContent.exports) { + if (n === ".") { + let c; + if (typeof e.contents.packageJsonContent.exports == "string" || Array.isArray(e.contents.packageJsonContent.exports) || typeof e.contents.packageJsonContent.exports == "object" && nRe(e.contents.packageJsonContent.exports) ? c = e.contents.packageJsonContent.exports : eo(e.contents.packageJsonContent.exports, ".") && (c = e.contents.packageJsonContent.exports["."]), c) + return h1e( + t, + i, + s, + o, + n, + e, + /*isImports*/ + !1 + )( + c, + "", + /*pattern*/ + !1, + "." + ); + } else if (dO(e.contents.packageJsonContent.exports)) { + if (typeof e.contents.packageJsonContent.exports != "object") + return i.traceEnabled && ts(i.host, p.Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1, n, e.packageDirectory), Mf( + /*value*/ + void 0 + ); + const c = g1e( + t, + i, + s, + o, + n, + e.contents.packageJsonContent.exports, + e, + /*isImports*/ + !1 + ); + if (c) + return c; + } + return i.traceEnabled && ts(i.host, p.Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1, n, e.packageDirectory), Mf( + /*value*/ + void 0 + ); + } + } + function sRe(e, t, n, i, s, o) { + var c, _; + if (t === "#" || Ui(t, "#/")) + return i.traceEnabled && ts(i.host, p.Invalid_import_specifier_0_has_no_possible_resolutions, t), Mf( + /*value*/ + void 0 + ); + const u = Qi(n, (_ = (c = i.host).getCurrentDirectory) == null ? void 0 : _.call(c)), g = $4(u, i); + if (!g) + return i.traceEnabled && ts(i.host, p.Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve, u), Mf( + /*value*/ + void 0 + ); + if (!g.contents.packageJsonContent.imports) + return i.traceEnabled && ts(i.host, p.package_json_scope_0_has_no_imports_defined, g.packageDirectory), Mf( + /*value*/ + void 0 + ); + const m = g1e( + e, + i, + s, + o, + t, + g.contents.packageJsonContent.imports, + g, + /*isImports*/ + !0 + ); + return m || (i.traceEnabled && ts(i.host, p.Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1, t, g.packageDirectory), Mf( + /*value*/ + void 0 + )); + } + function SW(e, t) { + const n = e.indexOf("*"), i = t.indexOf("*"), s = n === -1 ? e.length : n + 1, o = i === -1 ? t.length : i + 1; + return s > o ? -1 : o > s || n === -1 ? 1 : i === -1 || e.length > t.length ? -1 : t.length > e.length ? 1 : 0; + } + function g1e(e, t, n, i, s, o, c, _) { + const u = h1e(e, t, n, i, s, c, _); + if (!wo(s, So) && !s.includes("*") && eo(o, s)) { + const h = o[s]; + return u( + h, + /*subpath*/ + "", + /*pattern*/ + !1, + s + ); + } + const g = X_(kn(rm(o), (h) => aRe(h) || wo(h, "/")), SW); + for (const h of g) + if (t.features & 16 && m(h, s)) { + const S = o[h], T = h.indexOf("*"), k = s.substring(h.substring(0, T).length, s.length - (h.length - 1 - T)); + return u( + S, + k, + /*pattern*/ + !0, + h + ); + } else if (wo(h, "*") && Ui(s, h.substring(0, h.length - 1))) { + const S = o[h], T = s.substring(h.length - 1); + return u( + S, + T, + /*pattern*/ + !0, + h + ); + } else if (Ui(s, h)) { + const S = o[h], T = s.substring(h.length); + return u( + S, + T, + /*pattern*/ + !1, + h + ); + } + function m(h, S) { + if (wo(h, "*")) return !1; + const T = h.indexOf("*"); + return T === -1 ? !1 : Ui(S, h.substring(0, T)) && wo(S, h.substring(T + 1)); + } + } + function aRe(e) { + const t = e.indexOf("*"); + return t !== -1 && t === e.lastIndexOf("*"); + } + function h1e(e, t, n, i, s, o, c) { + return _; + function _(u, g, m, h) { + var S, T; + if (typeof u == "string") { + if (!m && g.length > 0 && !wo(u, "/")) + return t.traceEnabled && ts(t.host, p.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, o.packageDirectory, s), Mf( + /*value*/ + void 0 + ); + if (!Ui(u, "./")) { + if (c && !Ui(u, "../") && !Ui(u, "/") && !Z_(u)) { + const $ = m ? u.replace(/\*/g, g) : u + g; + Zy(t, p.Using_0_subpath_1_with_target_2, "imports", h, $), Zy(t, p.Resolving_module_0_from_1, $, o.packageDirectory + "/"); + const W = cA( + t.features, + $, + o.packageDirectory + "/", + t.compilerOptions, + t.host, + n, + e, + /*isConfigLookup*/ + !1, + i, + t.conditions + ); + return (S = t.failedLookupLocations) == null || S.push(...W.failedLookupLocations ?? Ge), (T = t.affectingLocations) == null || T.push(...W.affectingLocations ?? Ge), Mf( + W.resolvedModule ? { + path: W.resolvedModule.resolvedFileName, + extension: W.resolvedModule.extension, + packageId: W.resolvedModule.packageId, + originalPath: W.resolvedModule.originalPath, + resolvedUsingTsExtension: W.resolvedModule.resolvedUsingTsExtension + } : void 0 + ); + } + return t.traceEnabled && ts(t.host, p.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, o.packageDirectory, s), Mf( + /*value*/ + void 0 + ); + } + const O = (xf(u) ? fu(u).slice(1) : fu(u)).slice(1); + if (O.includes("..") || O.includes(".") || O.includes("node_modules")) + return t.traceEnabled && ts(t.host, p.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, o.packageDirectory, s), Mf( + /*value*/ + void 0 + ); + const F = On(o.packageDirectory, u), R = fu(g); + if (R.includes("..") || R.includes(".") || R.includes("node_modules")) + return t.traceEnabled && ts(t.host, p.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, o.packageDirectory, s), Mf( + /*value*/ + void 0 + ); + t.traceEnabled && ts(t.host, p.Using_0_subpath_1_with_target_2, c ? "imports" : "exports", h, m ? u.replace(/\*/g, g) : u + g); + const B = k(m ? F.replace(/\*/g, g) : F + g), U = P(B, g, On(o.packageDirectory, "package.json"), c); + return U || Mf(ik(o, gW( + e, + B, + u, + /*onlyRecordFailures*/ + !1, + t + ), t)); + } else if (typeof u == "object" && u !== null) + if (Array.isArray(u)) { + if (!wr(u)) + return t.traceEnabled && ts(t.host, p.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, o.packageDirectory, s), Mf( + /*value*/ + void 0 + ); + for (const A of u) { + const O = _(A, g, m, h); + if (O) + return O; + } + } else { + Zy(t, p.Entering_conditional_exports); + for (const A of rm(u)) + if (A === "default" || t.conditions.includes(A) || uA(t.conditions, A)) { + Zy(t, p.Matched_0_condition_1, c ? "imports" : "exports", A); + const O = u[A], F = _(O, g, m, h); + if (F) + return Zy(t, p.Resolved_under_condition_0, A), Zy(t, p.Exiting_conditional_exports), F; + Zy(t, p.Failed_to_resolve_under_condition_0, A); + } else + Zy(t, p.Saw_non_matching_condition_0, A); + Zy(t, p.Exiting_conditional_exports); + return; + } + else if (u === null) + return t.traceEnabled && ts(t.host, p.package_json_scope_0_explicitly_maps_specifier_1_to_null, o.packageDirectory, s), Mf( + /*value*/ + void 0 + ); + return t.traceEnabled && ts(t.host, p.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, o.packageDirectory, s), Mf( + /*value*/ + void 0 + ); + function k(A) { + var O, F; + return A === void 0 ? A : Qi(A, (F = (O = t.host).getCurrentDirectory) == null ? void 0 : F.call(O)); + } + function D(A, O) { + return gl(On(A, O)); + } + function P(A, O, F, R) { + var B, U, $, W; + if (!t.isConfigLookup && (t.compilerOptions.declarationDir || t.compilerOptions.outDir) && !A.includes("/node_modules/") && (!t.compilerOptions.configFile || np(o.packageDirectory, k(t.compilerOptions.configFile.fileName), !TW(t)))) { + const K = xh({ useCaseSensitiveFileNames: () => TW(t) }), V = []; + if (t.compilerOptions.rootDir || t.compilerOptions.composite && t.compilerOptions.configFilePath) { + const ae = k(aw(t.compilerOptions, () => [], ((U = (B = t.host).getCurrentDirectory) == null ? void 0 : U.call(B)) || "", K)); + V.push(ae); + } else if (t.requestContainingDirectory) { + const ae = k(On(t.requestContainingDirectory, "index.ts")), se = k(aw(t.compilerOptions, () => [ae, k(F)], ((W = ($ = t.host).getCurrentDirectory) == null ? void 0 : W.call($)) || "", K)); + V.push(se); + let ce = gl(se); + for (; ce && ce.length > 1; ) { + const fe = fu(ce); + fe.pop(); + const he = B1(fe); + V.unshift(he), ce = gl(he); + } + } + V.length > 1 && t.reportDiagnostic(Yo( + R ? p.The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate : p.The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate, + O === "" ? "." : O, + // replace empty string with `.` - the reverse of the operation done when entries are built - so main entrypoint errors don't look weird + F + )); + for (const ae of V) { + const se = _e(ae); + for (const ce of se) + if (np(ce, A, !TW(t))) { + const fe = A.slice(ce.length + 1), he = On(ae, fe), q = [ + ".mjs", + ".cjs", + ".js", + ".json", + ".d.mts", + ".d.cts", + ".d.ts" + /* Dts */ + ]; + for (const be of q) + if (Xo(he, be)) { + const je = YB(he); + for (const me of je) { + if (!m1e(e, me)) continue; + const Z = HP(he, me, be, !TW(t)); + if (t.host.fileExists(Z)) + return Mf(ik(o, gW( + e, + Z, + /*packageJsonValue*/ + void 0, + /*onlyRecordFailures*/ + !1, + t + ), t)); + } + } + } + } + } + return; + function _e(K) { + var V, ae; + const se = t.compilerOptions.configFile ? ((ae = (V = t.host).getCurrentDirectory) == null ? void 0 : ae.call(V)) || "" : K, ce = []; + return t.compilerOptions.declarationDir && ce.push(k(D(se, t.compilerOptions.declarationDir))), t.compilerOptions.outDir && t.compilerOptions.outDir !== t.compilerOptions.declarationDir && ce.push(k(D(se, t.compilerOptions.outDir))), ce; + } + } + } + } + function uA(e, t) { + if (!e.includes("types") || !Ui(t, "types@")) return !1; + const n = t7.tryParse(t.substring(6)); + return n ? n.test(ep) : !1; + } + function y1e(e, t, n, i, s, o) { + return v1e( + e, + t, + n, + i, + /*typesScopeOnly*/ + !1, + s, + o + ); + } + function oRe(e, t, n) { + return v1e( + 4, + e, + t, + n, + /*typesScopeOnly*/ + !0, + /*cache*/ + void 0, + /*redirectedReference*/ + void 0 + ); + } + function v1e(e, t, n, i, s, o, c) { + const _ = i.features === 0 ? void 0 : i.features & 32 || i.conditions.includes("import") ? 99 : 1, u = e & 5, g = e & -6; + if (u) { + Zy(i, p.Searching_all_ancestor_node_modules_directories_for_preferred_extensions_Colon_0, oO(u)); + const h = m(u); + if (h) return h; + } + if (g && !s) + return Zy(i, p.Searching_all_ancestor_node_modules_directories_for_fallback_extensions_Colon_0, oO(g)), m(g); + function m(h) { + return eg( + i.host, + zl(n), + (S) => { + if (Zc(S) !== "node_modules") { + const T = x1e(o, t, _, S, c, i); + return T || Mf(b1e(h, t, S, i, s, o, c)); + } + } + ); + } + } + function eg(e, t, n) { + var i; + const s = (i = e?.getGlobalTypingsCacheLocation) == null ? void 0 : i.call(e); + return pD(t, (o) => { + const c = n(o); + if (c !== void 0) return c; + if (o === s) return !1; + }) || void 0; + } + function b1e(e, t, n, i, s, o, c) { + const _ = On(n, "node_modules"), u = Pd(_, i.host); + if (!u && i.traceEnabled && ts(i.host, p.Directory_0_does_not_exist_skipping_all_lookups_in_it, _), !s) { + const g = S1e(e, t, _, u, i, o, c); + if (g) + return g; + } + if (e & 4) { + const g = On(_, "@types"); + let m = u; + return u && !Pd(g, i.host) && (i.traceEnabled && ts(i.host, p.Directory_0_does_not_exist_skipping_all_lookups_in_it, g), m = !1), S1e(4, T1e(t, i), g, m, i, o, c); + } + } + function S1e(e, t, n, i, s, o, c) { + var _, u; + const g = Hs(On(n, t)), { packageName: m, rest: h } = pO(t), S = On(n, m); + let T, k = RS(g, !i, s); + if (h !== "" && k && (!(s.features & 8) || !eo(((_ = T = RS(S, !i, s)) == null ? void 0 : _.contents.packageJsonContent) ?? Ge, "exports"))) { + const A = I6(e, g, !i, s); + if (A) + return uW(A); + const O = vW( + e, + g, + !i, + s, + k + ); + return ik(k, O, s); + } + const D = (A, O, F, R) => { + let B = (h || !(R.features & 32)) && I6(A, O, F, R) || vW( + A, + O, + F, + R, + k + ); + return !B && !h && k && (k.contents.packageJsonContent.exports === void 0 || k.contents.packageJsonContent.exports === null) && R.features & 32 && (B = I6(A, On(O, "index.js"), F, R)), ik(k, B, R); + }; + if (h !== "" && (k = T ?? RS(S, !i, s)), k && (s.resolvedPackageDirectory = !0), k && k.contents.packageJsonContent.exports && s.features & 8) + return (u = bW(k, e, On(".", h), s, o, c)) == null ? void 0 : u.value; + const P = h !== "" && k ? d1e(k, s) : void 0; + if (P) { + s.traceEnabled && ts(s.host, p.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, P.version, ep, h); + const A = i && Pd(S, s.host), O = xN(P.paths), F = _ne(e, h, S, P.paths, O, D, !A, s); + if (F) + return F.value; + } + return D(e, g, !i, s); + } + function _ne(e, t, n, i, s, o, c, _) { + const u = LJ(s, t); + if (u) { + const g = gs(u) ? void 0 : gQ(u, t), m = gs(u) ? u : mQ(u); + return _.traceEnabled && ts(_.host, p.Module_name_0_matched_pattern_1, t, m), { value: lr(i[m], (S) => { + const T = g ? vS(S, g) : S, k = Hs(On(n, T)); + _.traceEnabled && ts(_.host, p.Trying_substitution_0_candidate_module_location_Colon_1, S, T); + const D = Jg(S); + if (D !== void 0) { + const P = hW(k, c, _); + if (P !== void 0) + return uW({ path: P, ext: D, resolvedUsingTsExtension: void 0 }); + } + return o(e, k, c || !Pd(Hn(k), _.host), _); + }) }; + } + } + var fne = "__"; + function T1e(e, t) { + const n = F6(e); + return t.traceEnabled && n !== e && ts(t.host, p.Scoped_package_detected_looking_in_0, n), n; + } + function mO(e) { + return `@types/${F6(e)}`; + } + function F6(e) { + if (Ui(e, "@")) { + const t = e.replace(So, fne); + if (t !== e) + return t.slice(1); + } + return e; + } + function X4(e) { + const t = nD(e, "@types/"); + return t !== e ? _A(t) : e; + } + function _A(e) { + return e.includes(fne) ? "@" + e.replace(fne, So) : e; + } + function x1e(e, t, n, i, s, o) { + const c = e && e.getFromNonRelativeNameCache(t, n, i, s); + if (c) + return o.traceEnabled && ts(o.host, p.Resolution_for_module_0_was_found_in_cache_from_location_1, t, i), o.resultFromCache = c, { + value: c.resolvedModule && { + path: c.resolvedModule.resolvedFileName, + originalPath: c.resolvedModule.originalPath || !0, + extension: c.resolvedModule.extension, + packageId: c.resolvedModule.packageId, + resolvedUsingTsExtension: c.resolvedModule.resolvedUsingTsExtension + } + }; + } + function pne(e, t, n, i, s, o) { + const c = Xy(n, i), _ = [], u = [], g = Hn(t), m = [], h = { + compilerOptions: n, + host: i, + traceEnabled: c, + failedLookupLocations: _, + affectingLocations: u, + packageJsonInfoCache: s, + features: 0, + conditions: [], + requestContainingDirectory: g, + reportDiagnostic: (k) => void m.push(k), + isConfigLookup: !1, + candidateIsFromPackageJsonField: !1, + resolvedPackageDirectory: !1 + }, S = T( + 5 + /* Declaration */ + ) || T(2 | (n.resolveJsonModule ? 8 : 0)); + return Yye( + e, + S && S.value, + S?.value && Yy(S.value.path), + _, + u, + m, + h, + s + ); + function T(k) { + const D = a1e(k, e, g, lne, h); + if (D) + return { value: D }; + if (Dl(e)) { + const P = Hs(On(g, e)); + return Mf(lne( + k, + P, + /*onlyRecordFailures*/ + !1, + h + )); + } else { + const P = eg( + h.host, + g, + (A) => { + const O = x1e( + s, + e, + /*mode*/ + void 0, + A, + o, + h + ); + if (O) + return O; + const F = Hs(On(A, e)); + return Mf(lne( + k, + F, + /*onlyRecordFailures*/ + !1, + h + )); + } + ); + if (P) return P; + if (k & 5) { + let A = oRe(e, g, h); + return k & 4 && (A ?? (A = k1e(e, h))), A; + } + } + } + } + function k1e(e, t) { + if (t.compilerOptions.typeRoots) + for (const n of t.compilerOptions.typeRoots) { + const i = t1e(n, e, t), s = Pd(n, t.host); + !s && t.traceEnabled && ts(t.host, p.Directory_0_does_not_exist_skipping_all_lookups_in_it, n); + const o = I6(4, i, !s, t); + if (o) { + const _ = lA(o.path), u = _ ? RS( + _, + /*onlyRecordFailures*/ + !1, + t + ) : void 0; + return Mf(ik(u, o, t)); + } + const c = une(4, i, !s, t); + if (c) return Mf(c); + } + } + function O6(e, t) { + return Cee(e) || !!t && Il(t); + } + function dne(e, t, n, i, s, o) { + const c = Xy(n, i); + c && ts(i, p.Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2, t, e, s); + const _ = [], u = [], g = [], m = { + compilerOptions: n, + host: i, + traceEnabled: c, + failedLookupLocations: _, + affectingLocations: u, + packageJsonInfoCache: o, + features: 0, + conditions: [], + requestContainingDirectory: void 0, + reportDiagnostic: (S) => void g.push(S), + isConfigLookup: !1, + candidateIsFromPackageJsonField: !1, + resolvedPackageDirectory: !1 + }, h = b1e( + 4, + e, + s, + m, + /*typesScopeOnly*/ + !1, + /*cache*/ + void 0, + /*redirectedReference*/ + void 0 + ); + return Zye( + h, + /*isExternalLibraryImport*/ + !0, + _, + u, + g, + m.resultFromCache, + /*cache*/ + void 0 + ); + } + function Mf(e) { + return e !== void 0 ? { value: e } : void 0; + } + function Zy(e, t, ...n) { + e.traceEnabled && ts(e.host, t, ...n); + } + function TW(e) { + return e.host.useCaseSensitiveFileNames ? typeof e.host.useCaseSensitiveFileNames == "boolean" ? e.host.useCaseSensitiveFileNames : e.host.useCaseSensitiveFileNames() : !0; + } + var mne = /* @__PURE__ */ ((e) => (e[e.NonInstantiated = 0] = "NonInstantiated", e[e.Instantiated = 1] = "Instantiated", e[e.ConstEnumOnly = 2] = "ConstEnumOnly", e))(mne || {}); + function Ah(e, t) { + return e.body && !e.body.parent && (za(e.body, e), ev( + e.body, + /*incremental*/ + !1 + )), e.body ? gne(e.body, t) : 1; + } + function gne(e, t = /* @__PURE__ */ new Map()) { + const n = Ma(e); + if (t.has(n)) + return t.get(n) || 0; + t.set(n, void 0); + const i = cRe(e, t); + return t.set(n, i), i; + } + function cRe(e, t) { + switch (e.kind) { + // 1. interface declarations, type alias declarations + case 265: + case 266: + return 0; + // 2. const enum declarations + case 267: + if (V1(e)) + return 2; + break; + // 3. non-exported import declarations + case 273: + case 272: + if (!Gn( + e, + 32 + /* Export */ + )) + return 0; + break; + // 4. Export alias declarations pointing at only uninstantiated modules or things uninstantiated modules contain + case 279: + const n = e; + if (!n.moduleSpecifier && n.exportClause && n.exportClause.kind === 280) { + let i = 0; + for (const s of n.exportClause.elements) { + const o = lRe(s, t); + if (o > i && (i = o), i === 1) + return i; + } + return i; + } + break; + // 5. other uninstantiated module declarations. + case 269: { + let i = 0; + return xs(e, (s) => { + const o = gne(s, t); + switch (o) { + case 0: + return; + case 2: + i = 2; + return; + case 1: + return i = 1, !0; + default: + E.assertNever(o); + } + }), i; + } + case 268: + return Ah(e, t); + case 80: + if (e.flags & 4096) + return 0; + } + return 1; + } + function lRe(e, t) { + const n = e.propertyName || e.name; + if (n.kind !== 80) + return 1; + let i = e.parent; + for (; i; ) { + if (Ns(i) || vm(i) || Di(i)) { + const s = i.statements; + let o; + for (const c of s) + if (n3(c, n)) { + c.parent || (za(c, i), ev( + c, + /*incremental*/ + !1 + )); + const _ = gne(c, t); + if ((o === void 0 || _ > o) && (o = _), o === 1) + return o; + c.kind === 272 && (o = 1); + } + if (o !== void 0) + return o; + } + i = i.parent; + } + return 1; + } + var hne = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.IsContainer = 1] = "IsContainer", e[e.IsBlockScopedContainer = 2] = "IsBlockScopedContainer", e[e.IsControlFlowContainer = 4] = "IsControlFlowContainer", e[e.IsFunctionLike = 8] = "IsFunctionLike", e[e.IsFunctionExpression = 16] = "IsFunctionExpression", e[e.HasLocals = 32] = "HasLocals", e[e.IsInterface = 64] = "IsInterface", e[e.IsObjectLiteralOrClassExpressionMethodOrAccessor = 128] = "IsObjectLiteralOrClassExpressionMethodOrAccessor", e))(hne || {}); + function tg(e, t, n) { + return E.attachFlowNodeDebugInfo({ flags: e, id: 0, node: t, antecedent: n }); + } + var uRe = /* @__PURE__ */ _Re(); + function yne(e, t) { + Ko("beforeBind"), uRe(e, t), Ko("afterBind"), rp("Bind", "beforeBind", "afterBind"); + } + function _Re() { + var e, t, n, i, s, o, c, _, u, g, m, h, S, T, k, D, P, A, O, F, R, B, U, $, W, _e = !1, K = 0, V, ae, se = tg( + 1, + /*node*/ + void 0, + /*antecedent*/ + void 0 + ), ce = tg( + 1, + /*node*/ + void 0, + /*antecedent*/ + void 0 + ), fe = M(); + return q; + function he(L, Oe, ...xt) { + return sp(xr(L) || e, L, Oe, ...xt); + } + function q(L, Oe) { + var xt, Tr; + e = L, t = Oe, n = da(t), W = be(e, Oe), ae = /* @__PURE__ */ new Set(), K = 0, V = tu.getSymbolConstructor(), E.attachFlowNodeDebugInfo(se), E.attachFlowNodeDebugInfo(ce), e.locals || ((xt = on) == null || xt.push( + on.Phase.Bind, + "bindSourceFile", + { path: e.path }, + /*separateBeginAndEnd*/ + !0 + ), kr(e), (Tr = on) == null || Tr.pop(), e.symbolCount = K, e.classifiableNames = ae, Co(), ta()), e = void 0, t = void 0, n = void 0, i = void 0, s = void 0, o = void 0, c = void 0, _ = void 0, u = void 0, m = void 0, g = !1, h = void 0, S = void 0, T = void 0, k = void 0, D = void 0, P = void 0, A = void 0, F = void 0, R = !1, B = !1, U = !1, _e = !1, $ = 0; + } + function be(L, Oe) { + return du(Oe, "alwaysStrict") && !L.isDeclarationFile ? !0 : !!L.externalModuleIndicator; + } + function je(L, Oe) { + return K++, new V(L, Oe); + } + function me(L, Oe, xt) { + L.flags |= xt, Oe.symbol = L, L.declarations = dh(L.declarations, Oe), xt & 1955 && !L.exports && (L.exports = Bs()), xt & 6240 && !L.members && (L.members = Bs()), L.constEnumOnlyModule && L.flags & 304 && (L.constEnumOnlyModule = !1), xt & 111551 && WD(L, Oe); + } + function Z(L) { + if (L.kind === 278) + return L.isExportEquals ? "export=" : "default"; + const Oe = _s(L); + if (Oe) { + if (Vu(L)) { + const xt = op(Oe); + return $m(L) ? "__global" : `"${xt}"`; + } + if (Oe.kind === 168) { + const xt = Oe.expression; + if (If(xt)) + return tc(xt.text); + if (y5(xt)) + return qs(xt.operator) + xt.operand.text; + E.fail("Only computed properties with literal names have declaration names"); + } + if (Ai(Oe)) { + const xt = Wl(L); + if (!xt) + return; + const Tr = xt.symbol; + return Z3(Tr, Oe.escapedText); + } + return Fd(Oe) ? Lx(Oe) : um(Oe) ? XD(Oe) : void 0; + } + switch (L.kind) { + case 177: + return "__constructor"; + case 185: + case 180: + case 324: + return "__call"; + case 186: + case 181: + return "__new"; + case 182: + return "__index"; + case 279: + return "__export"; + case 308: + return "export="; + case 227: + if (Ac(L) === 2) + return "export="; + E.fail("Unknown binary declaration kind"); + break; + case 318: + return vx(L) ? "__new" : "__call"; + case 170: + return E.assert(L.parent.kind === 318, "Impossible parameter parent kind", () => `parent is: ${E.formatSyntaxKind(L.parent.kind)}, expected JSDocFunctionType`), "arg" + L.parent.parameters.indexOf(L); + } + } + function pe(L) { + return wl(L) ? co(L.name) : Si(E.checkDefined(Z(L))); + } + function Te(L, Oe, xt, Tr, $i, As, Zi) { + E.assert(Zi || !Th(xt)); + const ys = Gn( + xt, + 2048 + /* Default */ + ) || Nu(xt) && Gm(xt.name), zo = Zi ? "__computed" : ys && Oe ? "default" : Z(xt); + let na; + if (zo === void 0) + na = je( + 0, + "__missing" + /* Missing */ + ); + else if (na = L.get(zo), Tr & 2885600 && ae.add(zo), !na) + L.set(zo, na = je(0, zo)), As && (na.isReplaceableByMethod = !0); + else { + if (As && !na.isReplaceableByMethod) + return na; + if (na.flags & $i) { + if (na.isReplaceableByMethod) + L.set(zo, na = je(0, zo)); + else if (!(Tr & 3 && na.flags & 67108864)) { + wl(xt) && za(xt.name, xt); + let Ll = na.flags & 2 ? p.Cannot_redeclare_block_scoped_variable_0 : p.Duplicate_identifier_0, df = !0; + (na.flags & 384 || Tr & 384) && (Ll = p.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations, df = !1); + let Uf = !1; + wr(na.declarations) && (ys || na.declarations && na.declarations.length && xt.kind === 278 && !xt.isExportEquals) && (Ll = p.A_module_cannot_have_multiple_default_exports, df = !1, Uf = !0); + const yp = []; + Wp(xt) && lc(xt.type) && Gn( + xt, + 32 + /* Export */ + ) && na.flags & 2887656 && yp.push(he(xt, p.Did_you_mean_0, `export type { ${Si(xt.name.escapedText)} }`)); + const jh = _s(xt) || xt; + lr(na.declarations, (__, sg) => { + const zd = _s(__) || __, $p = df ? he(zd, Ll, pe(__)) : he(zd, Ll); + e.bindDiagnostics.push( + Uf ? zs($p, he(jh, sg === 0 ? p.Another_export_default_is_here : p.and_here)) : $p + ), Uf && yp.push(he(zd, p.The_first_export_default_is_here)); + }); + const M0 = df ? he(jh, Ll, pe(xt)) : he(jh, Ll); + e.bindDiagnostics.push(zs(M0, ...yp)), na = je(0, zo); + } + } + } + return me(na, xt, Tr), na.parent ? E.assert(na.parent === Oe, "Existing symbol parent should match new one") : na.parent = Oe, na; + } + function Fe(L, Oe, xt) { + const Tr = !!(J1(L) & 32) || Ye(L); + if (Oe & 2097152) + return L.kind === 282 || L.kind === 272 && Tr ? Te(s.symbol.exports, s.symbol, L, Oe, xt) : (E.assertNode(s, qm), Te( + s.locals, + /*parent*/ + void 0, + L, + Oe, + xt + )); + if (jp(L) && E.assert(an(L)), !Vu(L) && (Tr || s.flags & 128)) { + if (!qm(s) || !s.locals || Gn( + L, + 2048 + /* Default */ + ) && !Z(L)) + return Te(s.symbol.exports, s.symbol, L, Oe, xt); + const $i = Oe & 111551 ? 1048576 : 0, As = Te( + s.locals, + /*parent*/ + void 0, + L, + $i, + xt + ); + return As.exportSymbol = Te(s.symbol.exports, s.symbol, L, Oe, xt), L.localSymbol = As, As; + } else + return E.assertNode(s, qm), Te( + s.locals, + /*parent*/ + void 0, + L, + Oe, + xt + ); + } + function Ye(L) { + if (L.parent && jc(L) && (L = L.parent), !jp(L)) return !1; + if (!WN(L) && L.fullName) return !0; + const Oe = _s(L); + return Oe ? !!(oN(Oe.parent) && hp(Oe.parent) || Pl(Oe.parent) && J1(Oe.parent) & 32) : !1; + } + function ne(L, Oe) { + const xt = s, Tr = o, $i = c, As = B; + if (L.kind === 220 && L.body.kind !== 242 && (B = !0), Oe & 1 ? (L.kind !== 220 && (o = s), s = c = L, Oe & 32 && (s.locals = Bs(), cr(s))) : Oe & 2 && (c = L, Oe & 32 && (c.locals = void 0)), Oe & 4) { + const Zi = h, ys = S, zo = T, na = k, Ll = A, df = F, Uf = R, yp = Oe & 16 && !Gn( + L, + 1024 + /* Async */ + ) && !L.asteriskToken && !!q1(L) || L.kind === 176; + yp || (h = tg( + 2, + /*node*/ + void 0, + /*antecedent*/ + void 0 + ), Oe & 144 && (h.node = L)), k = yp || L.kind === 177 || an(L) && (L.kind === 263 || L.kind === 219) ? Wt() : void 0, A = void 0, S = void 0, T = void 0, F = void 0, R = !1, Ee(L), L.flags &= -5633, !(h.flags & 1) && Oe & 8 && Mp(L.body) && (L.flags |= 512, R && (L.flags |= 1024), L.endFlowNode = h), L.kind === 308 && (L.flags |= $, L.endFlowNode = h), k && (Dt(k, h), h = _i(k), (L.kind === 177 || L.kind === 176 || an(L) && (L.kind === 263 || L.kind === 219)) && (L.returnFlowNode = h)), yp || (h = Zi), S = ys, T = zo, k = na, A = Ll, F = df, R = Uf; + } else Oe & 64 ? (g = !1, Ee(L), E.assertNotNode(L, Me), L.flags = g ? L.flags | 256 : L.flags & -257) : Ee(L); + B = As, s = xt, o = Tr, c = $i; + } + function Se(L) { + ie(L, (Oe) => Oe.kind === 263 ? kr(Oe) : void 0), ie(L, (Oe) => Oe.kind !== 263 ? kr(Oe) : void 0); + } + function ie(L, Oe = kr) { + L !== void 0 && lr(L, Oe); + } + function Ne(L) { + xs(L, kr, ie); + } + function Ee(L) { + const Oe = _e; + if (_e = !1, wi(L)) { + HC(L) && L.flowNode && (L.flowNode = void 0), Ne(L), Li(L), _e = Oe; + return; + } + switch (L.kind >= 244 && L.kind <= 260 && (!t.allowUnreachableCode || L.kind === 254) && (L.flowNode = h), L.kind) { + case 248: + Ks(L); + break; + case 247: + yr(L); + break; + case 249: + bs(L); + break; + case 250: + case 251: + Xe(L); + break; + case 246: + Et(L); + break; + case 254: + case 258: + re(L); + break; + case 253: + case 252: + Ae(L); + break; + case 259: + $e(L); + break; + case 256: + Ke(L); + break; + case 270: + Tt(L); + break; + case 297: + Le(L); + break; + case 245: + mt(L); + break; + case 257: + Ct(L); + break; + case 225: + Pe(L); + break; + case 226: + yt(L); + break; + case 227: + if (y0(L)) { + _e = Oe, ue(L); + return; + } + fe(L); + break; + case 221: + ye(L); + break; + case 228: + Q(L); + break; + case 261: + Mt(L); + break; + case 212: + case 213: + nr(L); + break; + case 214: + kt(L); + break; + case 236: + _r(L); + break; + case 347: + case 339: + case 341: + Zr(L); + break; + case 352: + Pr(L); + break; + // In source files and blocks, bind functions first to match hoisting that occurs at runtime + case 308: { + Se(L.statements), kr(L.endOfFileToken); + break; + } + case 242: + case 269: + Se(L.statements); + break; + case 209: + ke(L); + break; + case 170: + at(L); + break; + case 211: + case 210: + case 304: + case 231: + _e = Oe; + // falls through + default: + Ne(L); + break; + } + Li(L), _e = Oe; + } + function Ce(L) { + switch (L.kind) { + case 80: + case 110: + return !0; + case 212: + case 213: + return St(L); + case 214: + return Bt(L); + case 218: + if (Kb(L)) + return !1; + // fallthrough + case 236: + return Ce(L.expression); + case 227: + return Nr(L); + case 225: + return L.operator === 54 && Ce(L.operand); + case 222: + return Ce(L.expression); + } + return !1; + } + function Ve(L) { + switch (L.kind) { + case 80: + case 110: + case 108: + case 237: + return !0; + case 212: + case 218: + case 236: + return Ve(L.expression); + case 213: + return (If(L.argumentExpression) || to(L.argumentExpression)) && Ve(L.expression); + case 227: + return L.operatorToken.kind === 28 && Ve(L.right) || kh(L.operatorToken.kind) && S_(L.left); + } + return !1; + } + function St(L) { + return Ve(L) || Eu(L) && St(L.expression); + } + function Bt(L) { + if (L.arguments) { + for (const Oe of L.arguments) + if (St(Oe)) + return !0; + } + return !!(L.expression.kind === 212 && St(L.expression.expression)); + } + function tr(L, Oe) { + return p6(L) && st(L.expression) && ja(Oe); + } + function Nr(L) { + switch (L.operatorToken.kind) { + case 64: + case 76: + case 77: + case 78: + return St(L.left); + case 35: + case 36: + case 37: + case 38: + const Oe = Ba(L.left), xt = Ba(L.right); + return st(Oe) || st(xt) || tr(xt, Oe) || tr(Oe, xt) || DD(xt) && Ce(Oe) || DD(Oe) && Ce(xt); + case 104: + return st(L.left); + case 103: + return Ce(L.right); + case 28: + return Ce(L.right); + } + return !1; + } + function st(L) { + switch (L.kind) { + case 218: + return st(L.expression); + case 227: + switch (L.operatorToken.kind) { + case 64: + return st(L.left); + case 28: + return st(L.right); + } + } + return St(L); + } + function Wt() { + return tg( + 4, + /*node*/ + void 0, + /*antecedent*/ + void 0 + ); + } + function Jr() { + return tg( + 8, + /*node*/ + void 0, + /*antecedent*/ + void 0 + ); + } + function ui(L, Oe, xt) { + return tg(1024, { target: L, antecedents: Oe }, xt); + } + function Ji(L) { + L.flags |= L.flags & 2048 ? 4096 : 2048; + } + function Dt(L, Oe) { + !(Oe.flags & 1) && !ms(L.antecedent, Oe) && ((L.antecedent || (L.antecedent = [])).push(Oe), Ji(Oe)); + } + function Mn(L, Oe, xt) { + return Oe.flags & 1 ? Oe : xt ? (xt.kind === 112 && L & 64 || xt.kind === 97 && L & 32) && !x7(xt) && !jj(xt.parent) ? se : Ce(xt) ? (Ji(Oe), tg(L, xt, Oe)) : Oe : L & 32 ? Oe : se; + } + function ai(L, Oe, xt, Tr) { + return Ji(L), tg(128, { switchStatement: Oe, clauseStart: xt, clauseEnd: Tr }, L); + } + function fi(L, Oe, xt) { + Ji(Oe), U = !0; + const Tr = tg(L, xt, Oe); + return A && Dt(A, Tr), Tr; + } + function pn(L, Oe) { + return Ji(L), U = !0, tg(512, Oe, L); + } + function _i(L) { + const Oe = L.antecedent; + return Oe ? Oe.length === 1 ? Oe[0] : L : se; + } + function Je(L) { + const Oe = L.parent; + switch (Oe.kind) { + case 246: + case 248: + case 247: + return Oe.expression === L; + case 249: + case 228: + return Oe.condition === L; + } + return !1; + } + function ft(L) { + for (; ; ) + if (L.kind === 218) + L = L.expression; + else if (L.kind === 225 && L.operator === 54) + L = L.operand; + else + return sN(L); + } + function er(L) { + return sJ(Ba(L)); + } + function qr(L) { + for (; o_(L.parent) || iv(L.parent) && L.parent.operator === 54; ) + L = L.parent; + return !Je(L) && !ft(L.parent) && !(Eu(L.parent) && L.parent.expression === L); + } + function Jn(L, Oe, xt, Tr) { + const $i = D, As = P; + D = xt, P = Tr, L(Oe), D = $i, P = As; + } + function Un(L, Oe, xt) { + Jn(kr, L, Oe, xt), (!L || !er(L) && !ft(L) && !(Eu(L) && TD(L))) && (Dt(Oe, Mn(32, h, L)), Dt(xt, Mn(64, h, L))); + } + function ki(L, Oe, xt) { + const Tr = S, $i = T; + S = Oe, T = xt, kr(L), S = Tr, T = $i; + } + function Ds(L, Oe) { + let xt = F; + for (; xt && L.parent.kind === 257; ) + xt.continueTarget = Oe, xt = xt.next, L = L.parent; + return Oe; + } + function Ks(L) { + const Oe = Ds(L, Jr()), xt = Wt(), Tr = Wt(); + Dt(Oe, h), h = Oe, Un(L.expression, xt, Tr), h = _i(xt), ki(L.statement, Tr, Oe), Dt(Oe, h), h = _i(Tr); + } + function yr(L) { + const Oe = Jr(), xt = Ds(L, Wt()), Tr = Wt(); + Dt(Oe, h), h = Oe, ki(L.statement, Tr, xt), Dt(xt, h), h = _i(xt), Un(L.expression, Oe, Tr), h = _i(Tr); + } + function bs(L) { + const Oe = Ds(L, Jr()), xt = Wt(), Tr = Wt(), $i = Wt(); + kr(L.initializer), Dt(Oe, h), h = Oe, Un(L.condition, xt, $i), h = _i(xt), ki(L.statement, $i, Tr), Dt(Tr, h), h = _i(Tr), kr(L.incrementor), Dt(Oe, h), h = _i($i); + } + function Xe(L) { + const Oe = Ds(L, Jr()), xt = Wt(); + kr(L.expression), Dt(Oe, h), h = Oe, L.kind === 251 && kr(L.awaitModifier), Dt(xt, h), kr(L.initializer), L.initializer.kind !== 262 && Lt(L.initializer), ki(L.statement, xt, Oe), Dt(Oe, h), h = _i(xt); + } + function Et(L) { + const Oe = Wt(), xt = Wt(), Tr = Wt(); + Un(L.expression, Oe, xt), h = _i(Oe), kr(L.thenStatement), Dt(Tr, h), h = _i(xt), kr(L.elseStatement), Dt(Tr, h), h = _i(Tr); + } + function re(L) { + const Oe = B; + B = !0, kr(L.expression), B = Oe, L.kind === 254 && (R = !0, k && Dt(k, h)), h = se, U = !0; + } + function it(L) { + for (let Oe = F; Oe; Oe = Oe.next) + if (Oe.name === L) + return Oe; + } + function Y(L, Oe, xt) { + const Tr = L.kind === 253 ? Oe : xt; + Tr && (Dt(Tr, h), h = se, U = !0); + } + function Ae(L) { + if (kr(L.label), L.label) { + const Oe = it(L.label.escapedText); + Oe && (Oe.referenced = !0, Y(L, Oe.breakTarget, Oe.continueTarget)); + } else + Y(L, S, T); + } + function $e(L) { + const Oe = k, xt = A, Tr = Wt(), $i = Wt(); + let As = Wt(); + if (L.finallyBlock && (k = $i), Dt(As, h), A = As, kr(L.tryBlock), Dt(Tr, h), L.catchClause && (h = _i(As), As = Wt(), Dt(As, h), A = As, kr(L.catchClause), Dt(Tr, h)), k = Oe, A = xt, L.finallyBlock) { + const Zi = Wt(); + Zi.antecedent = Bi(Bi(Tr.antecedent, As.antecedent), $i.antecedent), h = Zi, kr(L.finallyBlock), h.flags & 1 ? h = se : (k && $i.antecedent && Dt(k, ui(Zi, $i.antecedent, h)), A && As.antecedent && Dt(A, ui(Zi, As.antecedent, h)), h = Tr.antecedent ? ui(Zi, Tr.antecedent, h) : se); + } else + h = _i(Tr); + } + function Ke(L) { + const Oe = Wt(); + kr(L.expression); + const xt = S, Tr = O; + S = Oe, O = h, kr(L.caseBlock), Dt(Oe, h); + const $i = lr( + L.caseBlock.clauses, + (As) => As.kind === 298 + /* DefaultClause */ + ); + L.possiblyExhaustive = !$i && !Oe.antecedent, $i || Dt(Oe, ai(O, L, 0, 0)), S = xt, O = Tr, h = _i(Oe); + } + function Tt(L) { + const Oe = L.clauses, xt = L.parent.expression.kind === 112 || Ce(L.parent.expression); + let Tr = se; + for (let $i = 0; $i < Oe.length; $i++) { + const As = $i; + for (; !Oe[$i].statements.length && $i + 1 < Oe.length; ) + Tr === se && (h = O), kr(Oe[$i]), $i++; + const Zi = Wt(); + Dt(Zi, xt ? ai(O, L.parent, As, $i + 1) : O), Dt(Zi, Tr), h = _i(Zi); + const ys = Oe[$i]; + kr(ys), Tr = h, !(h.flags & 1) && $i !== Oe.length - 1 && t.noFallthroughCasesInSwitch && (ys.fallthroughFlowNode = h); + } + } + function Le(L) { + const Oe = h; + h = O, kr(L.expression), h = Oe, ie(L.statements); + } + function mt(L) { + kr(L.expression), pt(L.expression); + } + function pt(L) { + if (L.kind === 214) { + const Oe = L; + Oe.expression.kind !== 108 && aN(Oe.expression) && (h = pn(h, Oe)); + } + } + function Ct(L) { + const Oe = Wt(); + F = { + next: F, + name: L.label.escapedText, + breakTarget: Oe, + continueTarget: void 0, + referenced: !1 + }, kr(L.label), kr(L.statement), !F.referenced && !t.allowUnusedLabels && Hr(wee(t), L.label, p.Unused_label), F = F.next, Dt(Oe, h), h = _i(Oe); + } + function qe(L) { + L.kind === 227 && L.operatorToken.kind === 64 ? Lt(L.left) : Lt(L); + } + function Lt(L) { + if (Ve(L)) + h = fi(16, h, L); + else if (L.kind === 210) + for (const Oe of L.elements) + Oe.kind === 231 ? Lt(Oe.expression) : qe(Oe); + else if (L.kind === 211) + for (const Oe of L.properties) + Oe.kind === 304 ? qe(Oe.initializer) : Oe.kind === 305 ? Lt(Oe.name) : Oe.kind === 306 && Lt(Oe.expression); + } + function rn(L, Oe, xt) { + const Tr = Wt(); + L.operatorToken.kind === 56 || L.operatorToken.kind === 77 ? Un(L.left, Tr, xt) : Un(L.left, Oe, Tr), h = _i(Tr), kr(L.operatorToken), t4(L.operatorToken.kind) ? (Jn(kr, L.right, Oe, xt), Lt(L.left), Dt(Oe, Mn(32, h, L)), Dt(xt, Mn(64, h, L))) : Un(L.right, Oe, xt); + } + function Pe(L) { + if (L.operator === 54) { + const Oe = D; + D = P, P = Oe, Ne(L), P = D, D = Oe; + } else + Ne(L), (L.operator === 46 || L.operator === 47) && Lt(L.operand); + } + function yt(L) { + Ne(L), (L.operator === 46 || L.operator === 47) && Lt(L.operand); + } + function ue(L) { + _e ? (_e = !1, kr(L.operatorToken), kr(L.right), _e = !0, kr(L.left)) : (_e = !0, kr(L.left), _e = !1, kr(L.operatorToken), kr(L.right)), Lt(L.left); + } + function M() { + return WF( + L, + Oe, + xt, + Tr, + $i, + /*foldState*/ + void 0 + ); + function L(Zi, ys) { + if (ys) { + ys.stackIndex++, za(Zi, i); + const na = W; + ra(Zi); + const Ll = i; + i = Zi, ys.skip = !1, ys.inStrictModeStack[ys.stackIndex] = na, ys.parentStack[ys.stackIndex] = Ll; + } else + ys = { + stackIndex: 0, + skip: !1, + inStrictModeStack: [void 0], + parentStack: [void 0] + }; + const zo = Zi.operatorToken.kind; + if (A5(zo) || t4(zo)) { + if (qr(Zi)) { + const na = Wt(), Ll = h, df = U; + U = !1, rn(Zi, na, na), h = U ? _i(na) : Ll, U || (U = df); + } else + rn(Zi, D, P); + ys.skip = !0; + } + return ys; + } + function Oe(Zi, ys, zo) { + if (!ys.skip) { + const na = As(Zi); + return zo.operatorToken.kind === 28 && pt(Zi), na; + } + } + function xt(Zi, ys, zo) { + ys.skip || kr(Zi); + } + function Tr(Zi, ys, zo) { + if (!ys.skip) { + const na = As(Zi); + return zo.operatorToken.kind === 28 && pt(Zi), na; + } + } + function $i(Zi, ys) { + if (!ys.skip) { + const Ll = Zi.operatorToken.kind; + if (kh(Ll) && !Ly(Zi) && (Lt(Zi.left), Ll === 64 && Zi.left.kind === 213)) { + const df = Zi.left; + st(df.expression) && (h = fi(256, h, Zi)); + } + } + const zo = ys.inStrictModeStack[ys.stackIndex], na = ys.parentStack[ys.stackIndex]; + zo !== void 0 && (W = zo), na !== void 0 && (i = na), ys.skip = !1, ys.stackIndex--; + } + function As(Zi) { + if (Zi && _n(Zi) && !y0(Zi)) + return Zi; + kr(Zi); + } + } + function ye(L) { + Ne(L), L.expression.kind === 212 && Lt(L.expression); + } + function Q(L) { + const Oe = Wt(), xt = Wt(), Tr = Wt(), $i = h, As = U; + U = !1, Un(L.condition, Oe, xt), h = _i(Oe), B && (L.flowNodeWhenTrue = h), kr(L.questionToken), kr(L.whenTrue), Dt(Tr, h), h = _i(xt), B && (L.flowNodeWhenFalse = h), kr(L.colonToken), kr(L.whenFalse), Dt(Tr, h), h = U ? _i(Tr) : $i, U || (U = As); + } + function dt(L) { + const Oe = vl(L) ? void 0 : L.name; + if (ws(Oe)) + for (const xt of Oe.elements) + dt(xt); + else + h = fi(16, h, L); + } + function Mt(L) { + Ne(L), (L.initializer || nS(L.parent.parent)) && dt(L); + } + function ke(L) { + kr(L.dotDotDotToken), kr(L.propertyName), wt(L.initializer), kr(L.name); + } + function at(L) { + ie(L.modifiers), kr(L.dotDotDotToken), kr(L.questionToken), kr(L.type), wt(L.initializer), kr(L.name); + } + function wt(L) { + if (!L) + return; + const Oe = h; + if (kr(L), Oe === se || Oe === h) + return; + const xt = Wt(); + Dt(xt, Oe), Dt(xt, h), h = _i(xt); + } + function Zr(L) { + kr(L.tagName), L.kind !== 341 && L.fullName && (za(L.fullName, L), ev( + L.fullName, + /*incremental*/ + !1 + )), typeof L.comment != "string" && ie(L.comment); + } + function Rr(L) { + Ne(L); + const Oe = $1(L); + Oe && Oe.kind !== 175 && me( + Oe.symbol, + Oe, + 32 + /* Class */ + ); + } + function Pr(L) { + kr(L.tagName), kr(L.moduleSpecifier), kr(L.attributes), typeof L.comment != "string" && ie(L.comment); + } + function rt(L, Oe, xt) { + Jn(kr, L, Oe, xt), (!Eu(L) || TD(L)) && (Dt(Oe, Mn(32, h, L)), Dt(xt, Mn(64, h, L))); + } + function vt(L) { + switch (L.kind) { + case 212: + kr(L.questionDotToken), kr(L.name); + break; + case 213: + kr(L.questionDotToken), kr(L.argumentExpression); + break; + case 214: + kr(L.questionDotToken), ie(L.typeArguments), ie(L.arguments); + break; + } + } + function Nt(L, Oe, xt) { + const Tr = SD(L) ? Wt() : void 0; + rt(L.expression, Tr || Oe, xt), Tr && (h = _i(Tr)), Jn(vt, L, Oe, xt), TD(L) && (Dt(Oe, Mn(32, h, L)), Dt(xt, Mn(64, h, L))); + } + function Jt(L) { + if (qr(L)) { + const Oe = Wt(), xt = h, Tr = U; + Nt(L, Oe, Oe), h = U ? _i(Oe) : xt, U || (U = Tr); + } else + Nt(L, D, P); + } + function _r(L) { + Eu(L) ? Jt(L) : Ne(L); + } + function nr(L) { + Eu(L) ? Jt(L) : Ne(L); + } + function kt(L) { + if (Eu(L)) + Jt(L); + else { + const Oe = Ba(L.expression); + Oe.kind === 219 || Oe.kind === 220 ? (ie(L.typeArguments), ie(L.arguments), kr(L.expression)) : (Ne(L), L.expression.kind === 108 && (h = pn(h, L))); + } + if (L.expression.kind === 212) { + const Oe = L.expression; + Me(Oe.name) && st(Oe.expression) && zB(Oe.name) && (h = fi(256, h, L)); + } + } + function cr(L) { + _ && (_.nextContainer = L), _ = L; + } + function fr(L, Oe, xt) { + switch (s.kind) { + // Modules, source files, and classes need specialized handling for how their + // members are declared (for example, a member of a class will go into a specific + // symbol table depending on if it is static or not). We defer to specialized + // handlers to take care of declaring these child members. + case 268: + return Fe(L, Oe, xt); + case 308: + return Xt(L, Oe, xt); + case 232: + case 264: + return vr(L, Oe, xt); + case 267: + return Te(s.symbol.exports, s.symbol, L, Oe, xt); + case 188: + case 323: + case 211: + case 265: + case 293: + return Te(s.symbol.members, s.symbol, L, Oe, xt); + case 185: + case 186: + case 180: + case 181: + case 324: + case 182: + case 175: + case 174: + case 177: + case 178: + case 179: + case 263: + case 219: + case 220: + case 318: + case 176: + case 266: + case 201: + return s.locals && E.assertNode(s, qm), Te( + s.locals, + /*parent*/ + void 0, + L, + Oe, + xt + ); + } + } + function vr(L, Oe, xt) { + return Js(L) ? Te(s.symbol.exports, s.symbol, L, Oe, xt) : Te(s.symbol.members, s.symbol, L, Oe, xt); + } + function Xt(L, Oe, xt) { + return fl(e) ? Fe(L, Oe, xt) : Te( + e.locals, + /*parent*/ + void 0, + L, + Oe, + xt + ); + } + function oi(L) { + const Oe = Di(L) ? L : Bn(L.body, vm); + return !!Oe && Oe.statements.some((xt) => Bc(xt) || Mo(xt)); + } + function Fs(L) { + L.flags & 33554432 && !oi(L) ? L.flags |= 128 : L.flags &= -129; + } + function Rs(L) { + if (Fs(L), Vu(L)) + if (Gn( + L, + 32 + /* Export */ + ) && Kt(L, p.export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible), _B(L)) + ds(L); + else { + let Oe; + if (L.name.kind === 11) { + const { text: Tr } = L.name; + Oe = Ix(Tr), Oe === void 0 && Kt(L.name, p.Pattern_0_can_have_at_most_one_Asterisk_character, Tr); + } + const xt = fr( + L, + 512, + 110735 + /* ValueModuleExcludes */ + ); + e.patternAmbientModules = Er(e.patternAmbientModules, Oe && !gs(Oe) ? { pattern: Oe, symbol: xt } : void 0); + } + else { + const Oe = ds(L); + if (Oe !== 0) { + const { symbol: xt } = L; + xt.constEnumOnlyModule = !(xt.flags & 304) && Oe === 2 && xt.constEnumOnlyModule !== !1; + } + } + } + function ds(L) { + const Oe = Ah(L), xt = Oe !== 0; + return fr( + L, + xt ? 512 : 1024, + xt ? 110735 : 0 + /* NamespaceModuleExcludes */ + ), Oe; + } + function pc(L) { + const Oe = je(131072, Z(L)); + me( + Oe, + L, + 131072 + /* Signature */ + ); + const xt = je( + 2048, + "__type" + /* Type */ + ); + me( + xt, + L, + 2048 + /* TypeLiteral */ + ), xt.members = Bs(), xt.members.set(Oe.escapedName, Oe); + } + function Zo(L) { + return hs( + L, + 4096, + "__object" + /* Object */ + ); + } + function so(L) { + return hs( + L, + 4096, + "__jsxAttributes" + /* JSXAttributes */ + ); + } + function zi(L, Oe, xt) { + return fr(L, Oe, xt); + } + function hs(L, Oe, xt) { + const Tr = je(Oe, xt); + return Oe & 106508 && (Tr.parent = s.symbol), me(Tr, L, Oe), Tr; + } + function Gc(L, Oe, xt) { + switch (c.kind) { + case 268: + Fe(L, Oe, xt); + break; + case 308: + if (tf(s)) { + Fe(L, Oe, xt); + break; + } + // falls through + default: + E.assertNode(c, qm), c.locals || (c.locals = Bs(), cr(c)), Te( + c.locals, + /*parent*/ + void 0, + L, + Oe, + xt + ); + } + } + function Co() { + if (!u) + return; + const L = s, Oe = _, xt = c, Tr = i, $i = h; + for (const As of u) { + const Zi = As.parent.parent; + s = G7(Zi) || e, c = Dd(Zi) || e, h = tg( + 2, + /*node*/ + void 0, + /*antecedent*/ + void 0 + ), i = As, kr(As.typeExpression); + const ys = _s(As); + if ((WN(As) || !As.fullName) && ys && oN(ys.parent)) { + const zo = hp(ys.parent); + if (zo) { + pf( + e.symbol, + ys.parent, + zo, + !!dr(ys, (Ll) => wn(Ll) && Ll.name.escapedText === "prototype"), + /*containerIsClass*/ + !1 + ); + const na = s; + switch (z3(ys.parent)) { + case 1: + case 2: + tf(e) ? s = e : s = void 0; + break; + case 4: + s = ys.parent.expression; + break; + case 3: + s = ys.parent.expression.name; + break; + case 5: + s = t2(e, ys.parent.expression) ? e : wn(ys.parent.expression) ? ys.parent.expression.name : ys.parent.expression; + break; + case 0: + return E.fail("Shouldn't have detected typedef or enum on non-assignment declaration"); + } + s && Fe( + As, + 524288, + 788968 + /* TypeAliasExcludes */ + ), s = na; + } + } else WN(As) || !As.fullName || As.fullName.kind === 80 ? (i = As.parent, Gc( + As, + 524288, + 788968 + /* TypeAliasExcludes */ + )) : kr(As.fullName); + } + s = L, _ = Oe, c = xt, i = Tr, h = $i; + } + function ta() { + if (m === void 0) + return; + const L = s, Oe = _, xt = c, Tr = i, $i = h; + for (const As of m) { + const Zi = Fb(As), ys = Zi ? G7(Zi) : void 0, zo = Zi ? Dd(Zi) : void 0; + s = ys || e, c = zo || e, h = tg( + 2, + /*node*/ + void 0, + /*antecedent*/ + void 0 + ), i = As, kr(As.importClause); + } + s = L, _ = Oe, c = xt, i = Tr, h = $i; + } + function Ec(L) { + if (!e.parseDiagnostics.length && !(L.flags & 33554432) && !(L.flags & 16777216) && !jK(L)) { + const Oe = Z2(L); + if (Oe === void 0) + return; + W && Oe >= 119 && Oe <= 127 ? e.bindDiagnostics.push(he(L, zf(L), co(L))) : Oe === 135 ? fl(e) && n5(L) ? e.bindDiagnostics.push(he(L, p.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module, co(L))) : L.flags & 65536 && e.bindDiagnostics.push(he(L, p.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here, co(L))) : Oe === 127 && L.flags & 16384 && e.bindDiagnostics.push(he(L, p.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here, co(L))); + } + } + function zf(L) { + return Wl(L) ? p.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode : e.externalModuleIndicator ? p.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode : p.Identifier_expected_0_is_a_reserved_word_in_strict_mode; + } + function cs(L) { + L.escapedText === "#constructor" && (e.parseDiagnostics.length || e.bindDiagnostics.push(he(L, p.constructor_is_a_reserved_word, co(L)))); + } + function Ws(L) { + W && S_(L.left) && kh(L.operatorToken.kind) && Za(L, L.left); + } + function Fa(L) { + W && L.variableDeclaration && Za(L, L.variableDeclaration.name); + } + function va(L) { + if (W && L.expression.kind === 80) { + const Oe = aS(e, L.expression); + e.bindDiagnostics.push(ll(e, Oe.start, Oe.length, p.delete_cannot_be_called_on_an_identifier_in_strict_mode)); + } + } + function zt(L) { + return Me(L) && (L.escapedText === "eval" || L.escapedText === "arguments"); + } + function Za(L, Oe) { + if (Oe && Oe.kind === 80) { + const xt = Oe; + if (zt(xt)) { + const Tr = aS(e, Oe); + e.bindDiagnostics.push(ll(e, Tr.start, Tr.length, yc(L), An(xt))); + } + } + } + function yc(L) { + return Wl(L) ? p.Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of_0_For_more_information_see_https_Colon_Slash_Slashdeveloper_mozilla_org_Slashen_US_Slashdocs_SlashWeb_SlashJavaScript_SlashReference_SlashStrict_mode : e.externalModuleIndicator ? p.Invalid_use_of_0_Modules_are_automatically_in_strict_mode : p.Invalid_use_of_0_in_strict_mode; + } + function Fc(L) { + W && !(L.flags & 33554432) && Za(L, L.name); + } + function Hl(L) { + return Wl(L) ? p.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES5_Class_definitions_are_automatically_in_strict_mode : e.externalModuleIndicator ? p.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES5_Modules_are_automatically_in_strict_mode : p.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES5; + } + function _o(L) { + if (n < 2 && c.kind !== 308 && c.kind !== 268 && !IC(c)) { + const Oe = aS(e, L); + e.bindDiagnostics.push(ll(e, Oe.start, Oe.length, Hl(L))); + } + } + function ge(L) { + W && Za(L, L.operand); + } + function H(L) { + W && (L.operator === 46 || L.operator === 47) && Za(L, L.operand); + } + function tt(L) { + W && Kt(L, p.with_statements_are_not_allowed_in_strict_mode); + } + function Ft(L) { + W && da(t) >= 2 && (OZ(L.statement) || Ic(L.statement)) && Kt(L.label, p.A_label_is_not_allowed_here); + } + function Kt(L, Oe, ...xt) { + const Tr = om(e, L.pos); + e.bindDiagnostics.push(ll(e, Tr.start, Tr.length, Oe, ...xt)); + } + function Hr(L, Oe, xt) { + Vn(L, Oe, Oe, xt); + } + function Vn(L, Oe, xt, Tr) { + ln(L, { pos: Ay(Oe, e), end: xt.end }, Tr); + } + function ln(L, Oe, xt) { + const Tr = ll(e, Oe.pos, Oe.end - Oe.pos, xt); + L ? e.bindDiagnostics.push(Tr) : e.bindSuggestionDiagnostics = Er(e.bindSuggestionDiagnostics, { + ...Tr, + category: 2 + /* Suggestion */ + }); + } + function kr(L) { + if (!L) + return; + za(L, i), on && (L.tracingPath = e.path); + const Oe = W; + if (ra(L), L.kind > 166) { + const xt = i; + i = L; + const Tr = xW(L); + Tr === 0 ? Ee(L) : ne(L, Tr), i = xt; + } else { + const xt = i; + L.kind === 1 && (i = L), Li(L), i = xt; + } + W = Oe; + } + function Li(L) { + if (kf(L)) + if (an(L)) + for (const Oe of L.jsDoc) + kr(Oe); + else + for (const Oe of L.jsDoc) + za(Oe, L), ev( + Oe, + /*incremental*/ + !1 + ); + } + function Yi(L) { + if (!W) + for (const Oe of L) { + if (!cm(Oe)) + return; + if (no(Oe)) { + W = !0; + return; + } + } + } + function no(L) { + const Oe = Db(e, L.expression); + return Oe === '"use strict"' || Oe === "'use strict'"; + } + function ra(L) { + switch (L.kind) { + /* Strict mode checks */ + case 80: + if (L.flags & 4096) { + let Zi = L.parent; + for (; Zi && !jp(Zi); ) + Zi = Zi.parent; + Gc( + Zi, + 524288, + 788968 + /* TypeAliasExcludes */ + ); + break; + } + // falls through + case 110: + return h && (ut(L) || i.kind === 305) && (L.flowNode = h), Ec(L); + case 167: + h && o5(L) && (L.flowNode = h); + break; + case 237: + case 108: + L.flowNode = h; + break; + case 81: + return cs(L); + case 212: + case 213: + const Oe = L; + h && Ve(Oe) && (Oe.flowNode = h), PK(Oe) && il(Oe), an(Oe) && e.commonJsModuleIndicator && Lg(Oe) && !gO(c, "module") && Te( + e.locals, + /*parent*/ + void 0, + Oe.expression, + 134217729, + 111550 + /* FunctionScopedVariableExcludes */ + ); + break; + case 227: + switch (Ac(L)) { + case 1: + Ot(L); + break; + case 2: + Mr(L); + break; + case 3: + vc(L.left, L); + break; + case 6: + Po(L); + break; + case 4: + Da(L); + break; + case 5: + const Zi = L.left.expression; + if (an(L) && Me(Zi)) { + const ys = gO(c, Zi.escapedText); + if (i5(ys?.valueDeclaration)) { + Da(L); + break; + } + } + Gl(L); + break; + case 0: + break; + default: + E.fail("Unknown binary expression special property assignment kind"); + } + return Ws(L); + case 300: + return Fa(L); + case 221: + return va(L); + case 226: + return ge(L); + case 225: + return H(L); + case 255: + return tt(L); + case 257: + return Ft(L); + case 198: + g = !0; + return; + case 183: + break; + // Binding the children will handle everything + case 169: + return jn(L); + case 170: + return et(L); + case 261: + return ee(L); + case 209: + return L.flowNode = h, ee(L); + case 173: + case 172: + return Eo(L); + case 304: + case 305: + return Sr( + L, + 4, + 0 + /* PropertyExcludes */ + ); + case 307: + return Sr( + L, + 8, + 900095 + /* EnumMemberExcludes */ + ); + case 180: + case 181: + case 182: + return fr( + L, + 131072, + 0 + /* None */ + ); + case 175: + case 174: + return Sr( + L, + 8192 | (L.questionToken ? 16777216 : 0), + Rp(L) ? 0 : 103359 + /* MethodExcludes */ + ); + case 263: + return Ut(L); + case 177: + return fr( + L, + 16384, + /*symbolExcludes:*/ + 0 + /* None */ + ); + case 178: + return Sr( + L, + 32768, + 46015 + /* GetAccessorExcludes */ + ); + case 179: + return Sr( + L, + 65536, + 78783 + /* SetAccessorExcludes */ + ); + case 185: + case 318: + case 324: + case 186: + return pc(L); + case 188: + case 323: + case 201: + return $c(L); + case 333: + return Rr(L); + case 211: + return Zo(L); + case 219: + case 220: + return Gt(L); + case 214: + switch (Ac(L)) { + case 7: + return Df(L); + case 8: + return Ie(L); + case 9: + return sc(L); + case 0: + break; + // Nothing to do + default: + return E.fail("Unknown call expression assignment declaration kind"); + } + an(L) && Jd(L); + break; + // Members of classes, interfaces, and modules + case 232: + case 264: + return W = !0, Wf(L); + case 265: + return Gc( + L, + 64, + 788872 + /* InterfaceExcludes */ + ); + case 266: + return Gc( + L, + 524288, + 788968 + /* TypeAliasExcludes */ + ); + case 267: + return Nm(L); + case 268: + return Rs(L); + // Jsx-attributes + case 293: + return so(L); + case 292: + return zi( + L, + 4, + 0 + /* PropertyExcludes */ + ); + // Imports and exports + case 272: + case 275: + case 277: + case 282: + return fr( + L, + 2097152, + 2097152 + /* AliasExcludes */ + ); + case 271: + return Bd(L); + case 274: + return Ef(L); + case 279: + return au(L); + case 278: + return ic(L); + case 308: + return Yi(L.statements), Jc(); + case 242: + if (!IC(L.parent)) + return; + // falls through + case 269: + return Yi(L.statements); + case 342: + if (L.parent.kind === 324) + return et(L); + if (L.parent.kind !== 323) + break; + // falls through + case 349: + const $i = L, As = $i.isBracketed || $i.typeExpression && $i.typeExpression.type.kind === 317 ? 16777220 : 4; + return fr( + $i, + As, + 0 + /* PropertyExcludes */ + ); + case 347: + case 339: + case 341: + return (u || (u = [])).push(L); + case 340: + return kr(L.typeExpression); + case 352: + return (m || (m = [])).push(L); + } + } + function Eo(L) { + const Oe = b_(L), xt = Oe ? 98304 : 4, Tr = Oe ? 13247 : 0; + return Sr(L, xt | (L.questionToken ? 16777216 : 0), Tr); + } + function $c(L) { + return hs( + L, + 2048, + "__type" + /* Type */ + ); + } + function Jc() { + if (Fs(e), fl(e)) + vo(); + else if (ap(e)) { + vo(); + const L = e.symbol; + Te( + e.symbol.exports, + e.symbol, + e, + 4, + -1 + /* All */ + ), e.symbol = L; + } + } + function vo() { + hs(e, 512, `"${Gu(e.fileName)}"`); + } + function ic(L) { + if (!s.symbol || !s.symbol.exports) + hs(L, 111551, Z(L)); + else { + const Oe = Q3(L) ? 2097152 : 4, xt = Te( + s.symbol.exports, + s.symbol, + L, + Oe, + -1 + /* All */ + ); + L.isExportEquals && WD(xt, L); + } + } + function Bd(L) { + ot(L.modifiers) && e.bindDiagnostics.push(he(L, p.Modifiers_cannot_appear_here)); + const Oe = Di(L.parent) ? fl(L.parent) ? L.parent.isDeclarationFile ? void 0 : p.Global_module_exports_may_only_appear_in_declaration_files : p.Global_module_exports_may_only_appear_in_module_files : p.Global_module_exports_may_only_appear_at_top_level; + Oe ? e.bindDiagnostics.push(he(L, Oe)) : (e.symbol.globalExports = e.symbol.globalExports || Bs(), Te( + e.symbol.globalExports, + e.symbol, + L, + 2097152, + 2097152 + /* AliasExcludes */ + )); + } + function au(L) { + !s.symbol || !s.symbol.exports ? hs(L, 8388608, Z(L)) : L.exportClause ? Km(L.exportClause) && (za(L.exportClause, L), Te( + s.symbol.exports, + s.symbol, + L.exportClause, + 2097152, + 2097152 + /* AliasExcludes */ + )) : Te( + s.symbol.exports, + s.symbol, + L, + 8388608, + 0 + /* None */ + ); + } + function Ef(L) { + L.name && fr( + L, + 2097152, + 2097152 + /* AliasExcludes */ + ); + } + function P_(L) { + return e.externalModuleIndicator && e.externalModuleIndicator !== !0 ? !1 : (e.commonJsModuleIndicator || (e.commonJsModuleIndicator = L, e.externalModuleIndicator || vo()), !0); + } + function Ie(L) { + if (!P_(L)) + return; + const Oe = Sl( + L.arguments[0], + /*parent*/ + void 0, + (xt, Tr) => (Tr && me( + Tr, + xt, + 67110400 + /* Assignment */ + ), Tr) + ); + Oe && Te( + Oe.exports, + Oe, + L, + 1048580, + 0 + /* None */ + ); + } + function Ot(L) { + if (!P_(L)) + return; + const Oe = Sl( + L.left.expression, + /*parent*/ + void 0, + (xt, Tr) => (Tr && me( + Tr, + xt, + 67110400 + /* Assignment */ + ), Tr) + ); + if (Oe) { + const Tr = m5(L.right) && (lS(L.left.expression) || Lg(L.left.expression)) ? 2097152 : 1048580; + za(L.left, L), Te( + Oe.exports, + Oe, + L.left, + Tr, + 0 + /* None */ + ); + } + } + function Mr(L) { + if (!P_(L)) + return; + const Oe = B3(L.right); + if (lJ(Oe) || s === e && t2(e, Oe)) + return; + if (_a(Oe) && Ni(Oe.properties, gu)) { + lr(Oe.properties, Gi); + return; + } + const xt = Q3(L) ? 2097152 : 1049092, Tr = Te( + e.symbol.exports, + e.symbol, + L, + xt | 67108864, + 0 + /* None */ + ); + WD(Tr, L); + } + function Gi(L) { + Te( + e.symbol.exports, + e.symbol, + L, + 69206016, + 0 + /* None */ + ); + } + function Da(L) { + if (E.assert(an(L)), _n(L) && wn(L.left) && Ai(L.left.name) || wn(L) && Ai(L.name)) + return; + const xt = qu( + L, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + switch (xt.kind) { + case 263: + case 219: + let Tr = xt.symbol; + if (_n(xt.parent) && xt.parent.operatorToken.kind === 64) { + const Zi = xt.parent.left; + Ib(Zi) && jy(Zi.expression) && (Tr = N_(Zi.expression.expression, o)); + } + Tr && Tr.valueDeclaration && (Tr.members = Tr.members || Bs(), Th(L) ? wa(L, Tr, Tr.members) : Te( + Tr.members, + Tr, + L, + 67108868, + 0 + /* Property */ + ), me( + Tr, + Tr.valueDeclaration, + 32 + /* Class */ + )); + break; + case 177: + case 173: + case 175: + case 178: + case 179: + case 176: + const $i = xt.parent, As = Js(xt) ? $i.symbol.exports : $i.symbol.members; + Th(L) ? wa(L, $i.symbol, As) : Te( + As, + $i.symbol, + L, + 67108868, + 0, + /*isReplaceableByMethod*/ + !0 + ); + break; + case 308: + if (Th(L)) + break; + xt.commonJsModuleIndicator ? Te( + xt.symbol.exports, + xt.symbol, + L, + 1048580, + 0 + /* None */ + ) : fr( + L, + 1, + 111550 + /* FunctionScopedVariableExcludes */ + ); + break; + // Namespaces are not allowed in javascript files, so do nothing here + case 268: + break; + default: + E.failBadSyntaxKind(xt); + } + } + function wa(L, Oe, xt) { + Te( + xt, + Oe, + L, + 4, + 0, + /*isReplaceableByMethod*/ + !0, + /*isComputedName*/ + !0 + ), ma(L, Oe); + } + function ma(L, Oe) { + Oe && (Oe.assignmentDeclarationMembers || (Oe.assignmentDeclarationMembers = /* @__PURE__ */ new Map())).set(Ma(L), L); + } + function il(L) { + L.expression.kind === 110 ? Da(L) : Ib(L) && L.parent.parent.kind === 308 && (jy(L.expression) ? vc(L, L.parent) : Ol(L)); + } + function Po(L) { + za(L.left, L), za(L.right, L), ig( + L.left.expression, + L.left, + /*isPrototypeProperty*/ + !1, + /*containerIsClass*/ + !0 + ); + } + function sc(L) { + const Oe = N_(L.arguments[0].expression); + Oe && Oe.valueDeclaration && me( + Oe, + Oe.valueDeclaration, + 32 + /* Class */ + ), Qu( + L, + Oe, + /*isPrototypeProperty*/ + !0 + ); + } + function vc(L, Oe) { + const xt = L.expression, Tr = xt.expression; + za(Tr, xt), za(xt, L), za(L, Oe), ig( + Tr, + L, + /*isPrototypeProperty*/ + !0, + /*containerIsClass*/ + !0 + ); + } + function Df(L) { + let Oe = N_(L.arguments[0]); + const xt = L.parent.parent.kind === 308; + Oe = pf( + Oe, + L.arguments[0], + xt, + /*isPrototypeProperty*/ + !1, + /*containerIsClass*/ + !1 + ), Qu( + L, + Oe, + /*isPrototypeProperty*/ + !1 + ); + } + function Gl(L) { + var Oe; + const xt = N_(L.left.expression, c) || N_(L.left.expression, s); + if (!an(L) && !NK(xt)) + return; + const Tr = r6(L.left); + if (!(Me(Tr) && ((Oe = gO(s, Tr.escapedText)) == null ? void 0 : Oe.flags) & 2097152)) + if (za(L.left, L), za(L.right, L), Me(L.left.expression) && s === e && t2(e, L.left.expression)) + Ot(L); + else if (Th(L)) { + hs( + L, + 67108868, + "__computed" + /* Computed */ + ); + const $i = pf( + xt, + L.left.expression, + hp(L.left), + /*isPrototypeProperty*/ + !1, + /*containerIsClass*/ + !1 + ); + ma(L, $i); + } else + Ol(Us(L.left, _S)); + } + function Ol(L) { + E.assert(!Me(L)), za(L.expression, L), ig( + L.expression, + L, + /*isPrototypeProperty*/ + !1, + /*containerIsClass*/ + !1 + ); + } + function pf(L, Oe, xt, Tr, $i) { + return L?.flags & 2097152 || (xt && !Tr && (L = Sl(Oe, L, (ys, zo, na) => { + if (zo) + return me(zo, ys, 67110400), zo; + { + const Ll = na ? na.exports : e.jsGlobalAugmentations || (e.jsGlobalAugmentations = Bs()); + return Te(Ll, na, ys, 67110400, 110735); + } + })), $i && L && L.valueDeclaration && me( + L, + L.valueDeclaration, + 32 + /* Class */ + )), L; + } + function Qu(L, Oe, xt) { + if (!Oe || !Gg(Oe)) + return; + const Tr = xt ? Oe.members || (Oe.members = Bs()) : Oe.exports || (Oe.exports = Bs()); + let $i = 0, As = 0; + io(mx(L)) ? ($i = 8192, As = 103359) : Ps(L) && uS(L) && (ot(L.arguments[2].properties, (Zi) => { + const ys = _s(Zi); + return !!ys && Me(ys) && An(ys) === "set"; + }) && ($i |= 65540, As |= 78783), ot(L.arguments[2].properties, (Zi) => { + const ys = _s(Zi); + return !!ys && Me(ys) && An(ys) === "get"; + }) && ($i |= 32772, As |= 46015)), $i === 0 && ($i = 4, As = 0), Te( + Tr, + Oe, + L, + $i | 67108864, + As & -67108865 + /* Assignment */ + ); + } + function hp(L) { + return _n(L.parent) ? $g(L.parent).parent.kind === 308 : L.parent.parent.kind === 308; + } + function ig(L, Oe, xt, Tr) { + let $i = N_(L, c) || N_(L, s); + const As = hp(Oe); + $i = pf($i, Oe.expression, As, xt, Tr), Qu(Oe, $i, xt); + } + function Gg(L) { + if (L.flags & 1072) + return !0; + const Oe = L.valueDeclaration; + if (Oe && Ps(Oe)) + return !!mx(Oe); + let xt = Oe ? ei(Oe) ? Oe.initializer : _n(Oe) ? Oe.right : wn(Oe) && _n(Oe.parent) ? Oe.parent.right : void 0 : void 0; + if (xt = xt && B3(xt), xt) { + const Tr = jy(ei(Oe) ? Oe.name : _n(Oe) ? Oe.left : Oe); + return !!G1(_n(xt) && (xt.operatorToken.kind === 57 || xt.operatorToken.kind === 61) ? xt.right : xt, Tr); + } + return !1; + } + function $g(L) { + for (; _n(L.parent); ) + L = L.parent; + return L.parent; + } + function N_(L, Oe = s) { + if (Me(L)) + return gO(Oe, L.escapedText); + { + const xt = N_(L.expression); + return xt && xt.exports && xt.exports.get(Sh(L)); + } + } + function Sl(L, Oe, xt) { + if (t2(e, L)) + return e.symbol; + if (Me(L)) + return xt(L, N_(L), Oe); + { + const Tr = Sl(L.expression, Oe, xt), $i = J3(L); + return Ai($i) && E.fail("unexpected PrivateIdentifier"), xt($i, Tr && Tr.exports && Tr.exports.get(Sh(L)), Tr); + } + } + function Jd(L) { + !e.commonJsModuleIndicator && x_( + L, + /*requireStringLiteralLikeArgument*/ + !1 + ) && P_(L); + } + function Wf(L) { + if (L.kind === 264) + Gc( + L, + 32, + 899503 + /* ClassExcludes */ + ); + else { + const $i = L.name ? L.name.escapedText : "__class"; + hs(L, 32, $i), L.name && ae.add(L.name.escapedText); + } + const { symbol: Oe } = L, xt = je(4194308, "prototype"), Tr = Oe.exports.get(xt.escapedName); + Tr && (L.name && za(L.name, L), e.bindDiagnostics.push(he(Tr.declarations[0], p.Duplicate_identifier_0, cc(xt)))), Oe.exports.set(xt.escapedName, xt), xt.parent = Oe; + } + function Nm(L) { + return V1(L) ? Gc( + L, + 128, + 899967 + /* ConstEnumExcludes */ + ) : Gc( + L, + 256, + 899327 + /* RegularEnumExcludes */ + ); + } + function ee(L) { + if (W && Za(L, L.name), !ws(L.name)) { + const Oe = L.kind === 261 ? L : L.parent.parent; + an(L) && Ab(Oe) && !z1(L) && !(J1(L) & 32) ? fr( + L, + 2097152, + 2097152 + /* AliasExcludes */ + ) : cB(L) ? Gc( + L, + 2, + 111551 + /* BlockScopedVariableExcludes */ + ) : Y1(L) ? fr( + L, + 1, + 111551 + /* ParameterExcludes */ + ) : fr( + L, + 1, + 111550 + /* FunctionScopedVariableExcludes */ + ); + } + } + function et(L) { + if (!(L.kind === 342 && s.kind !== 324) && (W && !(L.flags & 33554432) && Za(L, L.name), ws(L.name) ? hs(L, 1, "__" + L.parent.parameters.indexOf(L)) : fr( + L, + 1, + 111551 + /* ParameterExcludes */ + ), K_(L, L.parent))) { + const Oe = L.parent.parent; + Te( + Oe.symbol.members, + Oe.symbol, + L, + 4 | (L.questionToken ? 16777216 : 0), + 0 + /* PropertyExcludes */ + ); + } + } + function Ut(L) { + !e.isDeclarationFile && !(L.flags & 33554432) && $D(L) && ($ |= 4096), Fc(L), W ? (_o(L), Gc( + L, + 16, + 110991 + /* FunctionExcludes */ + )) : fr( + L, + 16, + 110991 + /* FunctionExcludes */ + ); + } + function Gt(L) { + !e.isDeclarationFile && !(L.flags & 33554432) && $D(L) && ($ |= 4096), h && (L.flowNode = h), Fc(L); + const Oe = L.name ? L.name.escapedText : "__function"; + return hs(L, 16, Oe); + } + function Sr(L, Oe, xt) { + return !e.isDeclarationFile && !(L.flags & 33554432) && $D(L) && ($ |= 4096), h && K7(L) && (L.flowNode = h), Th(L) ? hs( + L, + Oe, + "__computed" + /* Computed */ + ) : fr(L, Oe, xt); + } + function zr(L) { + const Oe = dr(L, (xt) => xt.parent && Gb(xt.parent) && xt.parent.extendsType === xt); + return Oe && Oe.parent; + } + function jn(L) { + if (Up(L.parent)) { + const Oe = d5(L.parent); + Oe ? (E.assertNode(Oe, qm), Oe.locals ?? (Oe.locals = Bs()), Te( + Oe.locals, + /*parent*/ + void 0, + L, + 262144, + 526824 + /* TypeParameterExcludes */ + )) : fr( + L, + 262144, + 526824 + /* TypeParameterExcludes */ + ); + } else if (L.parent.kind === 196) { + const Oe = zr(L.parent); + Oe ? (E.assertNode(Oe, qm), Oe.locals ?? (Oe.locals = Bs()), Te( + Oe.locals, + /*parent*/ + void 0, + L, + 262144, + 526824 + /* TypeParameterExcludes */ + )) : hs(L, 262144, Z(L)); + } else + fr( + L, + 262144, + 526824 + /* TypeParameterExcludes */ + ); + } + function ni(L) { + const Oe = Ah(L); + return Oe === 1 || Oe === 2 && By(t); + } + function wi(L) { + if (!(h.flags & 1)) + return !1; + if (h === se && // report error on all statements except empty ones + (m3(L) && L.kind !== 243 || // report error on class declarations + L.kind === 264 || // report errors on enums with preserved emit + C1e(L, t) || // report error on instantiated modules + L.kind === 268 && ni(L)) && (h = ce, !t.allowUnreachableCode)) { + const xt = Dee(t) && !(L.flags & 33554432) && (!Ic(L) || !!(yh(L.declarationList) & 7) || L.declarationList.declarations.some((Tr) => !!Tr.initializer)); + fRe(L, t, (Tr, $i) => Vn(xt, Tr, $i, p.Unreachable_code_detected)); + } + return !0; + } + } + function C1e(e, t) { + return e.kind === 267 && (!V1(e) || By(t)); + } + function fRe(e, t, n) { + if (Ti(e) && i(e) && Ns(e.parent)) { + const { statements: o } = e.parent, c = MJ(o, e); + wR(c, i, (_, u) => n(c[_], c[u - 1])); + } else + n(e, e); + function i(o) { + return !Cc(o) && !s(o) && // `var x;` may declare a variable used above + !(Ic(o) && !(yh(o) & 7) && o.declarationList.declarations.some((c) => !c.initializer)); + } + function s(o) { + switch (o.kind) { + case 265: + case 266: + return !0; + case 268: + return Ah(o) !== 1; + case 267: + return !C1e(o, t); + default: + return !1; + } + } + } + function t2(e, t) { + let n = 0; + const i = JP(); + for (i.enqueue(t); !i.isEmpty() && n < 100; ) { + if (n++, t = i.dequeue(), lS(t) || Lg(t)) + return !0; + if (Me(t)) { + const s = gO(e, t.escapedText); + if (s && s.valueDeclaration && ei(s.valueDeclaration) && s.valueDeclaration.initializer) { + const o = s.valueDeclaration.initializer; + i.enqueue(o), Nl( + o, + /*excludeCompoundAssignment*/ + !0 + ) && (i.enqueue(o.left), i.enqueue(o.right)); + } + } + } + return !1; + } + function xW(e) { + switch (e.kind) { + case 232: + case 264: + case 267: + case 211: + case 188: + case 323: + case 293: + return 1; + case 265: + return 65; + case 268: + case 266: + case 201: + case 182: + return 33; + case 308: + return 37; + case 178: + case 179: + case 175: + if (K7(e)) + return 173; + // falls through + case 177: + case 263: + case 174: + case 180: + case 324: + case 318: + case 185: + case 181: + case 186: + case 176: + return 45; + case 352: + return 37; + case 219: + case 220: + return 61; + case 269: + return 4; + case 173: + return e.initializer ? 4 : 0; + case 300: + case 249: + case 250: + case 251: + case 270: + return 34; + case 242: + return Es(e.parent) || kc(e.parent) ? 0 : 34; + } + return 0; + } + function gO(e, t) { + var n, i, s, o; + const c = (i = (n = Bn(e, qm)) == null ? void 0 : n.locals) == null ? void 0 : i.get(t); + if (c) + return c.exportSymbol ?? c; + if (Di(e) && e.jsGlobalAugmentations && e.jsGlobalAugmentations.has(t)) + return e.jsGlobalAugmentations.get(t); + if (Ed(e)) + return (o = (s = e.symbol) == null ? void 0 : s.exports) == null ? void 0 : o.get(t); + } + function vne(e, t, n, i, s, o, c, _, u, g) { + return m; + function m(h = () => !0) { + const S = [], T = []; + return { + walkType: (_e) => { + try { + return k(_e), { visitedTypes: XT(S), visitedSymbols: XT(T) }; + } finally { + Ap(S), Ap(T); + } + }, + walkSymbol: (_e) => { + try { + return W(_e), { visitedTypes: XT(S), visitedSymbols: XT(T) }; + } finally { + Ap(S), Ap(T); + } + } + }; + function k(_e) { + if (!(!_e || S[_e.id] || (S[_e.id] = _e, W(_e.symbol)))) { + if (_e.flags & 524288) { + const V = _e, ae = V.objectFlags; + ae & 4 && D(_e), ae & 32 && R(_e), ae & 3 && U(_e), ae & 24 && $(V); + } + _e.flags & 262144 && P(_e), _e.flags & 3145728 && A(_e), _e.flags & 4194304 && O(_e), _e.flags & 8388608 && F(_e); + } + } + function D(_e) { + k(_e.target), lr(g(_e), k); + } + function P(_e) { + k(_(_e)); + } + function A(_e) { + lr(_e.types, k); + } + function O(_e) { + k(_e.type); + } + function F(_e) { + k(_e.objectType), k(_e.indexType), k(_e.constraint); + } + function R(_e) { + k(_e.typeParameter), k(_e.constraintType), k(_e.templateType), k(_e.modifiersType); + } + function B(_e) { + const K = t(_e); + K && k(K.type), lr(_e.typeParameters, k); + for (const V of _e.parameters) + W(V); + k(e(_e)), k(n(_e)); + } + function U(_e) { + $(_e), lr(_e.typeParameters, k), lr(i(_e), k), k(_e.thisType); + } + function $(_e) { + const K = s(_e); + for (const V of K.indexInfos) + k(V.keyType), k(V.type); + for (const V of K.callSignatures) + B(V); + for (const V of K.constructSignatures) + B(V); + for (const V of K.properties) + W(V); + } + function W(_e) { + if (!_e) + return !1; + const K = Xs(_e); + if (T[K]) + return !1; + if (T[K] = _e, !h(_e)) + return !0; + const V = o(_e); + return k(V), _e.exports && _e.exports.forEach(W), lr(_e.declarations, (ae) => { + if (ae.type && ae.type.kind === 187) { + const se = ae.type, ce = c(u(se.exprName)); + W(ce); + } + }), !1; + } + } + } + var Ih = {}; + Na(Ih, { + RelativePreference: () => E1e, + countPathComponents: () => vO, + forEachFileNameOfModule: () => I1e, + getLocalModuleSpecifierBetweenFileNames: () => yRe, + getModuleSpecifier: () => mRe, + getModuleSpecifierPreferences: () => fA, + getModuleSpecifiers: () => P1e, + getModuleSpecifiersWithCacheInfo: () => N1e, + getNodeModulesPackageName: () => gRe, + tryGetJSExtensionForFile: () => CW, + tryGetModuleSpecifiersFromCache: () => hRe, + tryGetRealFileNameForNonJsDeclarationFileName: () => R1e, + updateModuleSpecifier: () => dRe + }); + var pRe = nm((e) => { + try { + let t = e.indexOf("/"); + if (t !== 0) + return new RegExp(e); + const n = e.lastIndexOf("/"); + if (t === n) + return new RegExp(e); + for (; (t = e.indexOf("/", t + 1)) !== n; ) + if (e[t - 1] !== "\\") + return new RegExp(e); + const i = e.substring(n + 1).replace(/[^iu]/g, ""); + return e = e.substring(1, n), new RegExp(e, i); + } catch { + return; + } + }), E1e = /* @__PURE__ */ ((e) => (e[e.Relative = 0] = "Relative", e[e.NonRelative = 1] = "NonRelative", e[e.Shortest = 2] = "Shortest", e[e.ExternalNonRelative = 3] = "ExternalNonRelative", e))(E1e || {}); + function fA({ importModuleSpecifierPreference: e, importModuleSpecifierEnding: t, autoImportSpecifierExcludeRegexes: n }, i, s, o, c) { + const _ = u(); + return { + excludeRegexes: n, + relativePreference: c !== void 0 ? Dl(c) ? 0 : 1 : e === "relative" ? 0 : e === "non-relative" ? 1 : e === "project-relative" ? 3 : 2, + getAllowedEndingsInPreferredOrder: (g) => { + const m = EW(o, i, s), h = g !== m ? u(g) : _, S = Pu(s); + if ((g ?? m) === 99 && 3 <= S && S <= 99) + return O6(s, o.fileName) ? [ + 3, + 2 + /* JsExtension */ + ] : [ + 2 + /* JsExtension */ + ]; + if (Pu(s) === 1) + return h === 2 ? [ + 2, + 1 + /* Index */ + ] : [ + 1, + 2 + /* JsExtension */ + ]; + const T = O6(s, o.fileName); + switch (h) { + case 2: + return T ? [ + 2, + 3, + 0, + 1 + /* Index */ + ] : [ + 2, + 0, + 1 + /* Index */ + ]; + case 3: + return [ + 3, + 0, + 2, + 1 + /* Index */ + ]; + case 1: + return T ? [ + 1, + 0, + 3, + 2 + /* JsExtension */ + ] : [ + 1, + 0, + 2 + /* JsExtension */ + ]; + case 0: + return T ? [ + 0, + 1, + 3, + 2 + /* JsExtension */ + ] : [ + 0, + 1, + 2 + /* JsExtension */ + ]; + default: + E.assertNever(h); + } + } + }; + function u(g) { + if (c !== void 0) { + if (Bg(c)) return 2; + if (wo(c, "/index")) return 1; + } + return Bee( + t, + g ?? EW(o, i, s), + s, + Og(o) ? o : void 0 + ); + } + } + function dRe(e, t, n, i, s, o, c = {}) { + const _ = D1e(e, t, n, i, s, fA({}, s, e, t, o), {}, c); + if (_ !== o) + return _; + } + function mRe(e, t, n, i, s, o = {}) { + return D1e(e, t, n, i, s, fA({}, s, e, t), {}, o); + } + function gRe(e, t, n, i, s, o = {}) { + const c = yO(t.fileName, i), _ = F1e(c, n, i, s, e, o); + return Lc(_, (u) => Tne( + u, + c, + t, + i, + e, + s, + /*packageNameOnly*/ + !0, + o.overrideImportMode + )); + } + function D1e(e, t, n, i, s, o, c, _ = {}) { + const u = yO(n, s), g = F1e(u, i, s, c, e, _); + return Lc(g, (m) => Tne( + m, + u, + t, + s, + e, + c, + /*packageNameOnly*/ + void 0, + _.overrideImportMode + )) || bne(i, u, e, s, _.overrideImportMode || EW(t, s, e), o); + } + function hRe(e, t, n, i, s = {}) { + const o = w1e( + e, + t, + n, + i, + s + ); + return o[1] && { kind: o[0], moduleSpecifiers: o[1], computedWithoutCache: !1 }; + } + function w1e(e, t, n, i, s = {}) { + var o; + const c = y3(e); + if (!c) + return Ge; + const _ = (o = n.getModuleSpecifierCache) == null ? void 0 : o.call(n), u = _?.get(t.path, c.path, i, s); + return [u?.kind, u?.moduleSpecifiers, c, u?.modulePaths, _]; + } + function P1e(e, t, n, i, s, o, c = {}) { + return N1e( + e, + t, + n, + i, + s, + o, + c, + /*forAutoImport*/ + !1 + ).moduleSpecifiers; + } + function N1e(e, t, n, i, s, o, c = {}, _) { + let u = !1; + const g = xRe(e, t); + if (g) + return { + kind: "ambient", + moduleSpecifiers: _ && hO(g, o.autoImportSpecifierExcludeRegexes) ? Ge : [g], + computedWithoutCache: u + }; + let [m, h, S, T, k] = w1e( + e, + i, + s, + o, + c + ); + if (h) return { kind: m, moduleSpecifiers: h, computedWithoutCache: u }; + if (!S) return { kind: void 0, moduleSpecifiers: Ge, computedWithoutCache: u }; + u = !0, T || (T = O1e(yO(i.fileName, s), S.originalFileName, s, n, c)); + const D = vRe( + T, + n, + i, + s, + o, + c, + _ + ); + return k?.set(i.path, S.path, o, c, D.kind, T, D.moduleSpecifiers), D; + } + function yRe(e, t, n, i, s, o = {}) { + const c = yO(e.fileName, i), _ = o.overrideImportMode ?? e.impliedNodeFormat; + return bne( + t, + c, + n, + i, + _, + fA(s, i, n, e) + ); + } + function vRe(e, t, n, i, s, o = {}, c) { + const _ = yO(n.fileName, i), u = fA(s, i, t, n), g = Og(n) && lr(e, (D) => lr( + i.getFileIncludeReasons().get(oo(D.path, i.getCurrentDirectory(), _.getCanonicalFileName)), + (P) => { + if (P.kind !== 3 || P.file !== n.path) return; + const A = i.getModeForResolutionAtIndex(n, P.index), O = o.overrideImportMode ?? i.getDefaultResolutionModeForFile(n); + if (A !== O && A !== void 0 && O !== void 0) + return; + const F = PA(n, P.index).text; + return u.relativePreference !== 1 || !xf(F) ? F : void 0; + } + )); + if (g) + return { kind: void 0, moduleSpecifiers: [g], computedWithoutCache: !0 }; + const m = ot(e, (D) => D.isInNodeModules); + let h, S, T, k; + for (const D of e) { + const P = D.isInNodeModules ? Tne( + D, + _, + n, + i, + t, + s, + /*packageNameOnly*/ + void 0, + o.overrideImportMode + ) : void 0; + if (P && !(c && hO(P, u.excludeRegexes)) && (h = Er(h, P), D.isRedirect)) + return { kind: "node_modules", moduleSpecifiers: h, computedWithoutCache: !0 }; + const A = bne( + D.path, + _, + t, + i, + o.overrideImportMode || n.impliedNodeFormat, + u, + /*pathsOnly*/ + D.isRedirect || !!P + ); + !A || c && hO(A, u.excludeRegexes) || (D.isRedirect ? T = Er(T, A) : vj(A) ? Yy(A) ? k = Er(k, A) : S = Er(S, A) : (c || !m || D.isInNodeModules) && (k = Er(k, A))); + } + return S?.length ? { kind: "paths", moduleSpecifiers: S, computedWithoutCache: !0 } : T?.length ? { kind: "redirect", moduleSpecifiers: T, computedWithoutCache: !0 } : h?.length ? { kind: "node_modules", moduleSpecifiers: h, computedWithoutCache: !0 } : { kind: "relative", moduleSpecifiers: k ?? Ge, computedWithoutCache: !0 }; + } + function hO(e, t) { + return ot(t, (n) => { + var i; + return !!((i = pRe(n)) != null && i.test(e)); + }); + } + function yO(e, t) { + e = Qi(e, t.getCurrentDirectory()); + const n = Zl(t.useCaseSensitiveFileNames ? t.useCaseSensitiveFileNames() : !0), i = Hn(e); + return { + getCanonicalFileName: n, + importingSourceFileName: e, + sourceDirectory: i, + canonicalSourceDirectory: n(i) + }; + } + function bne(e, t, n, i, s, { getAllowedEndingsInPreferredOrder: o, relativePreference: c, excludeRegexes: _ }, u) { + const { baseUrl: g, paths: m, rootDirs: h } = n; + if (u && !m) + return; + const { sourceDirectory: S, canonicalSourceDirectory: T, getCanonicalFileName: k } = t, D = o(s), P = h && ERe(h, e, S, k, D, n) || pA(X2(Nf(S, e, k)), D, n); + if (!g && !m && !mN(n) || c === 0) + return u ? void 0 : P; + const A = Qi(C5(n, i) || g, i.getCurrentDirectory()), O = xne(e, A, k); + if (!O) + return u ? void 0 : P; + const F = u ? void 0 : CRe( + e, + S, + n, + i, + s, + wRe(D) + ), R = u || F === void 0 ? m && L1e(O, m, D, A, k, i, n) : void 0; + if (u) + return R; + const B = F ?? (R === void 0 && g !== void 0 ? pA(O, D, n) : R); + if (!B) + return P; + const U = hO(P, _), $ = hO(B, _); + if (!U && $) + return P; + if (U && !$ || c === 1 && !xf(B)) + return B; + if (c === 3 && !xf(B)) { + const W = n.configFilePath ? oo(Hn(n.configFilePath), i.getCurrentDirectory(), t.getCanonicalFileName) : t.getCanonicalFileName(i.getCurrentDirectory()), _e = oo(e, W, k), K = Ui(T, W), V = Ui(_e, W); + if (K && !V || !K && V) + return B; + const ae = Sne(i, Hn(_e)), se = Sne(i, S), ce = !mS(i); + return bRe(ae, se, ce) ? P : B; + } + return j1e(B) || vO(P) < vO(B) ? P : B; + } + function bRe(e, t, n) { + return e === t ? !0 : e === void 0 || t === void 0 ? !1 : gh(e, t, n) === 0; + } + function vO(e) { + let t = 0; + for (let n = Ui(e, "./") ? 2 : 0; n < e.length; n++) + e.charCodeAt(n) === 47 && t++; + return t; + } + function A1e(e, t) { + return j1(t.isRedirect, e.isRedirect) || SN(e.path, t.path); + } + function Sne(e, t) { + return e.getNearestAncestorDirectoryWithPackageJson ? e.getNearestAncestorDirectoryWithPackageJson(t) : eg( + e, + t, + (n) => e.fileExists(On(n, "package.json")) ? n : void 0 + ); + } + function I1e(e, t, n, i, s) { + var o, c; + const _ = xh(n), u = n.getCurrentDirectory(), g = n.isSourceOfProjectReferenceRedirect(t) ? (o = n.getRedirectFromSourceFile(t)) == null ? void 0 : o.outputDts : void 0, m = oo(t, u, _), h = n.redirectTargetsMap.get(m) || Ge, T = [...g ? [g] : Ge, t, ...h].map((O) => Qi(O, u)); + let k = !Ni(T, y4); + if (!i) { + const O = lr(T, (F) => !(k && y4(F)) && s(F, g === F)); + if (O) return O; + } + const D = (c = n.getSymlinkCache) == null ? void 0 : c.call(n).getSymlinkedDirectoriesByRealpath(), P = Qi(t, u); + return D && eg( + n, + Hn(P), + (O) => { + const F = D.get(gl(oo(O, u, _))); + if (F) + return Tj(e, O, _) ? !1 : lr(T, (R) => { + if (!Tj(R, O, _)) + return; + const B = Nf(O, R, _); + for (const U of F) { + const $ = by(U, B), W = s($, R === g); + if (k = !0, W) return W; + } + }); + } + ) || (i ? lr(T, (O) => k && y4(O) ? void 0 : s(O, O === g)) : void 0); + } + function F1e(e, t, n, i, s, o = {}) { + var c; + const _ = oo(e.importingSourceFileName, n.getCurrentDirectory(), xh(n)), u = oo(t, n.getCurrentDirectory(), xh(n)), g = (c = n.getModuleSpecifierCache) == null ? void 0 : c.call(n); + if (g) { + const h = g.get(_, u, i, o); + if (h?.modulePaths) return h.modulePaths; + } + const m = O1e(e, t, n, s, o); + return g && g.setModulePaths(_, u, i, o, m), m; + } + var SRe = ["dependencies", "peerDependencies", "optionalDependencies"]; + function TRe(e) { + let t; + for (const n of SRe) { + const i = e[n]; + i && typeof i == "object" && (t = Bi(t, rm(i))); + } + return t; + } + function O1e(e, t, n, i, s) { + var o, c; + const _ = (o = n.getModuleResolutionCache) == null ? void 0 : o.call(n), u = (c = n.getSymlinkCache) == null ? void 0 : c.call(n); + if (_ && u && n.readFile && !Yy(e.importingSourceFileName)) { + E.type(n); + const h = G4(_.getPackageJsonInfoCache(), n, {}), S = $4(Hn(e.importingSourceFileName), h); + if (S) { + const T = TRe(S.contents.packageJsonContent); + for (const k of T || Ge) { + const D = MS( + k, + On(S.packageDirectory, "package.json"), + i, + n, + _, + /*redirectedReference*/ + void 0, + s.overrideImportMode + ); + u.setSymlinksFromResolution(D.resolvedModule); + } + } + } + const g = /* @__PURE__ */ new Map(); + I1e( + e.importingSourceFileName, + t, + n, + /*preferSymlinks*/ + !0, + (h, S) => { + const T = Yy(h); + g.set(h, { path: e.getCanonicalFileName(h), isRedirect: S, isInNodeModules: T }); + } + ); + const m = []; + for (let h = e.canonicalSourceDirectory; g.size !== 0; ) { + const S = gl(h); + let T; + g.forEach(({ path: D, isRedirect: P, isInNodeModules: A }, O) => { + Ui(D, S) && ((T || (T = [])).push({ path: O, isRedirect: P, isInNodeModules: A }), g.delete(O)); + }), T && (T.length > 1 && T.sort(A1e), m.push(...T)); + const k = Hn(h); + if (k === h) break; + h = k; + } + if (g.size) { + const h = is( + g.entries(), + ([S, { isRedirect: T, isInNodeModules: k }]) => ({ path: S, isRedirect: T, isInNodeModules: k }) + ); + h.length > 1 && h.sort(A1e), m.push(...h); + } + return m; + } + function xRe(e, t) { + var n; + const i = (n = e.declarations) == null ? void 0 : n.find( + (c) => uB(c) && (!Pb(c) || !Dl(op(c.name))) + ); + if (i) + return i.name.text; + const o = Fi(e.declarations, (c) => { + var _, u, g, m; + if (!jc(c)) return; + const h = D(c); + if (!((_ = h?.parent) != null && _.parent && vm(h.parent) && Vu(h.parent.parent) && Di(h.parent.parent.parent))) return; + const S = (m = (g = (u = h.parent.parent.symbol.exports) == null ? void 0 : u.get("export=")) == null ? void 0 : g.valueDeclaration) == null ? void 0 : m.expression; + if (!S) return; + const T = t.getSymbolAtLocation(S); + if (!T) return; + if ((T?.flags & 2097152 ? t.getAliasedSymbol(T) : T) === c.symbol) return h.parent.parent; + function D(P) { + for (; P.flags & 8; ) + P = P.parent; + return P; + } + })[0]; + if (o) + return o.name.text; + } + function L1e(e, t, n, i, s, o, c) { + for (const u in t) + for (const g of t[u]) { + const m = Hs(g), h = xne(m, i, s) ?? m, S = h.indexOf("*"), T = n.map((k) => ({ + ending: k, + value: pA(e, [k], c) + })); + if (Jg(h) && T.push({ ending: void 0, value: e }), S !== -1) { + const k = h.substring(0, S), D = h.substring(S + 1); + for (const { ending: P, value: A } of T) + if (A.length >= k.length + D.length && Ui(A, k) && wo(A, D) && _({ ending: P, value: A })) { + const O = A.substring(k.length, A.length - D.length); + if (!xf(O)) + return vS(u, O); + } + } else if (ot(T, (k) => k.ending !== 0 && h === k.value) || ot(T, (k) => k.ending === 0 && h === k.value && _(k))) + return u; + } + function _({ ending: u, value: g }) { + return u !== 0 || g === pA(e, [u], c, o); + } + } + function bO(e, t, n, i, s, o, c, _, u, g) { + if (typeof o == "string") { + const m = !mS(t), h = () => t.getCommonSourceDirectory(), S = u && eU(n, e, m, h), T = u && KW(n, e, m, h), k = Qi( + On(i, o), + /*currentDirectory*/ + void 0 + ), D = yS(n) ? Gu(n) + CW(n, e) : void 0, P = g && Ree(n); + switch (_) { + case 0: + if (D && gh(D, k, m) === 0 || gh(n, k, m) === 0 || S && gh(S, k, m) === 0 || T && gh(T, k, m) === 0) + return { moduleFileToTry: s }; + break; + case 1: + if (P && np(n, k, m)) { + const R = Nf( + k, + n, + /*ignoreCase*/ + !1 + ); + return { moduleFileToTry: Qi( + On(On(s, o), R), + /*currentDirectory*/ + void 0 + ) }; + } + if (D && np(k, D, m)) { + const R = Nf( + k, + D, + /*ignoreCase*/ + !1 + ); + return { moduleFileToTry: Qi( + On(On(s, o), R), + /*currentDirectory*/ + void 0 + ) }; + } + if (!P && np(k, n, m)) { + const R = Nf( + k, + n, + /*ignoreCase*/ + !1 + ); + return { moduleFileToTry: Qi( + On(On(s, o), R), + /*currentDirectory*/ + void 0 + ) }; + } + if (S && np(k, S, m)) { + const R = Nf( + k, + S, + /*ignoreCase*/ + !1 + ); + return { moduleFileToTry: On(s, R) }; + } + if (T && np(k, T, m)) { + const R = u7(Nf( + k, + T, + /*ignoreCase*/ + !1 + ), kW(T, e)); + return { moduleFileToTry: On(s, R) }; + } + break; + case 2: + const A = k.indexOf("*"), O = k.slice(0, A), F = k.slice(A + 1); + if (P && Ui(n, O, m) && wo(n, F, m)) { + const R = n.slice(O.length, n.length - F.length); + return { moduleFileToTry: vS(s, R) }; + } + if (D && Ui(D, O, m) && wo(D, F, m)) { + const R = D.slice(O.length, D.length - F.length); + return { moduleFileToTry: vS(s, R) }; + } + if (!P && Ui(n, O, m) && wo(n, F, m)) { + const R = n.slice(O.length, n.length - F.length); + return { moduleFileToTry: vS(s, R) }; + } + if (S && Ui(S, O, m) && wo(S, F, m)) { + const R = S.slice(O.length, S.length - F.length); + return { moduleFileToTry: vS(s, R) }; + } + if (T && Ui(T, O, m) && wo(T, F, m)) { + const R = T.slice(O.length, T.length - F.length), B = vS(s, R), U = CW(T, e); + return U ? { moduleFileToTry: u7(B, U) } : void 0; + } + break; + } + } else { + if (Array.isArray(o)) + return lr(o, (m) => bO(e, t, n, i, s, m, c, _, u, g)); + if (typeof o == "object" && o !== null) { + for (const m of rm(o)) + if (m === "default" || c.indexOf(m) >= 0 || uA(c, m)) { + const h = o[m], S = bO(e, t, n, i, s, h, c, _, u, g); + if (S) + return S; + } + } + } + } + function kRe(e, t, n, i, s, o, c) { + return typeof o == "object" && o !== null && !Array.isArray(o) && dO(o) ? lr(rm(o), (_) => { + const u = Qi( + On(s, _), + /*currentDirectory*/ + void 0 + ), g = wo(_, "/") ? 1 : _.includes("*") ? 2 : 0; + return bO( + e, + t, + n, + i, + u, + o[_], + c, + g, + /*isImports*/ + !1, + /*preferTsExtension*/ + !1 + ); + }) : bO( + e, + t, + n, + i, + s, + o, + c, + 0, + /*isImports*/ + !1, + /*preferTsExtension*/ + !1 + ); + } + function CRe(e, t, n, i, s, o) { + var c, _, u; + if (!i.readFile || !mN(n)) + return; + const g = Sne(i, t); + if (!g) + return; + const m = On(g, "package.json"), h = (_ = (c = i.getPackageJsonInfoCache) == null ? void 0 : c.call(i)) == null ? void 0 : _.getPackageJsonInfo(m); + if (rne(h) || !i.fileExists(m)) + return; + const S = h?.contents.packageJsonContent || lN(i.readFile(m)), T = S?.imports; + if (!T) + return; + const k = Qy(n, s); + return (u = lr(rm(T), (D) => { + if (!Ui(D, "#") || D === "#" || Ui(D, "#/")) return; + const P = wo(D, "/") ? 1 : D.includes("*") ? 2 : 0; + return bO( + n, + i, + e, + g, + D, + T[D], + k, + P, + /*isImports*/ + !0, + o + ); + })) == null ? void 0 : u.moduleFileToTry; + } + function ERe(e, t, n, i, s, o) { + const c = M1e(t, e, i); + if (c === void 0) + return; + const _ = M1e(n, e, i), u = ka(_, (m) => hr(c, (h) => X2(Nf(m, h, i)))), g = JR(u, SN); + if (g) + return pA(g, s, o); + } + function Tne({ path: e, isRedirect: t }, { getCanonicalFileName: n, canonicalSourceDirectory: i }, s, o, c, _, u, g) { + if (!o.fileExists || !o.readFile) + return; + const m = oF(e); + if (!m) + return; + const S = fA(_, o, c, s).getAllowedEndingsInPreferredOrder(); + let T = e, k = !1; + if (!u) { + let R = m.packageRootIndex, B; + for (; ; ) { + const { moduleFileToTry: U, packageRootPath: $, blockedByExports: W, verbatimFromExports: _e } = F(R); + if (Pu(c) !== 1) { + if (W) + return; + if (_e) + return U; + } + if ($) { + T = $, k = !0; + break; + } + if (B || (B = U), R = e.indexOf(So, R + 1), R === -1) { + T = pA(B, S, c, o); + break; + } + } + } + if (t && !k) + return; + const D = o.getGlobalTypingsCacheLocation && o.getGlobalTypingsCacheLocation(), P = n(T.substring(0, m.topLevelNodeModulesIndex)); + if (!(Ui(i, P) || D && Ui(n(D), P))) + return; + const A = T.substring(m.topLevelPackageNameIndex + 1), O = X4(A); + return Pu(c) === 1 && O === A ? void 0 : O; + function F(R) { + var B, U; + const $ = e.substring(0, R), W = On($, "package.json"); + let _e = e, K = !1; + const V = (U = (B = o.getPackageJsonInfoCache) == null ? void 0 : B.call(o)) == null ? void 0 : U.getPackageJsonInfo(W); + if (uO(V) || V === void 0 && o.fileExists(W)) { + const ae = V?.contents.packageJsonContent || lN(o.readFile(W)), se = g || EW(s, o, c); + if (dN(c)) { + const he = $.substring(m.topLevelPackageNameIndex + 1), q = X4(he), be = Qy(c, se), je = ae?.exports ? kRe( + c, + o, + e, + $, + q, + ae.exports, + be + ) : void 0; + if (je) + return { ...je, verbatimFromExports: !0 }; + if (ae?.exports) + return { moduleFileToTry: e, blockedByExports: !0 }; + } + const ce = ae?.typesVersions ? cO(ae.typesVersions) : void 0; + if (ce) { + const he = e.slice($.length + 1), q = L1e( + he, + ce.paths, + S, + $, + n, + o, + c + ); + q === void 0 ? K = !0 : _e = On($, q); + } + const fe = ae?.typings || ae?.types || ae?.main || "index.js"; + if (gs(fe) && !(K && LJ(xN(ce.paths), fe))) { + const he = oo(fe, $, n), q = n(_e); + if (Gu(he) === Gu(q)) + return { packageRootPath: $, moduleFileToTry: _e }; + if (ae?.type !== "module" && !xc(q, rF) && Ui(q, he) && Hn(q) === _0(he) && Gu(Zc(q)) === "index") + return { packageRootPath: $, moduleFileToTry: _e }; + } + } else { + const ae = n(_e.substring(m.packageRootIndex + 1)); + if (ae === "index.d.ts" || ae === "index.js" || ae === "index.ts" || ae === "index.tsx") + return { moduleFileToTry: _e, packageRootPath: $ }; + } + return { moduleFileToTry: _e }; + } + } + function DRe(e, t) { + if (!e.fileExists) return; + const n = Ip(_4({ allowJs: !0 }, [{ extension: "node", isMixedContent: !1 }, { + extension: "json", + isMixedContent: !1, + scriptKind: 6 + /* JSON */ + }])); + for (const i of n) { + const s = t + i; + if (e.fileExists(s)) + return s; + } + } + function M1e(e, t, n) { + return Fi(t, (i) => { + const s = xne(e, i, n); + return s !== void 0 && j1e(s) ? void 0 : s; + }); + } + function pA(e, t, n, i) { + if (xc(e, [ + ".json", + ".mjs", + ".cjs" + /* Cjs */ + ])) + return e; + const s = Gu(e); + if (e === s) + return e; + const o = t.indexOf( + 2 + /* JsExtension */ + ), c = t.indexOf( + 3 + /* TsExtension */ + ); + if (xc(e, [ + ".mts", + ".cts" + /* Cts */ + ]) && c !== -1 && c < o) + return e; + if (xc(e, [ + ".d.mts", + ".mts", + ".d.cts", + ".cts" + /* Cts */ + ])) + return s + kW(e, n); + if (!xc(e, [ + ".d.ts" + /* Dts */ + ]) && xc(e, [ + ".ts" + /* Ts */ + ]) && e.includes(".d.")) + return R1e(e); + switch (t[0]) { + case 0: + const _ = bC(s, "/index"); + return i && _ !== s && DRe(i, _) ? s : _; + case 1: + return s; + case 2: + return s + kW(e, n); + case 3: + if (Il(e)) { + const u = t.findIndex( + (g) => g === 0 || g === 1 + /* Index */ + ); + return u !== -1 && u < o ? s : s + kW(e, n); + } + return e; + default: + return E.assertNever(t[0]); + } + } + function R1e(e) { + const t = Zc(e); + if (!wo( + e, + ".ts" + /* Ts */ + ) || !t.includes(".d.") || xc(t, [ + ".d.ts" + /* Dts */ + ])) return; + const n = TN( + e, + ".ts" + /* Ts */ + ), i = n.substring(n.lastIndexOf(".")); + return n.substring(0, n.indexOf(".d.")) + i; + } + function kW(e, t) { + return CW(e, t) ?? E.fail(`Extension ${p4(e)} is unsupported:: FileName:: ${e}`); + } + function CW(e, t) { + const n = Jg(e); + switch (n) { + case ".ts": + case ".d.ts": + return ".js"; + case ".tsx": + return t.jsx === 1 ? ".jsx" : ".js"; + case ".js": + case ".jsx": + case ".json": + return n; + case ".d.mts": + case ".mts": + case ".mjs": + return ".mjs"; + case ".d.cts": + case ".cts": + case ".cjs": + return ".cjs"; + default: + return; + } + } + function xne(e, t, n) { + const i = rx( + t, + e, + t, + n, + /*isAbsolutePathAnUrl*/ + !1 + ); + return Z_(i) ? void 0 : i; + } + function j1e(e) { + return Ui(e, ".."); + } + function EW(e, t, n) { + return Og(e) ? t.getDefaultResolutionModeForFile(e) : zO(e, n); + } + function wRe(e) { + const t = e.indexOf( + 3 + /* TsExtension */ + ); + return t > -1 && t < e.indexOf( + 2 + /* JsExtension */ + ); + } + var kne = /^".+"$/, DW = "(anonymous)", B1e = 1, J1e = 1, z1e = 1, W1e = 1, wW = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.TypeofEQString = 1] = "TypeofEQString", e[e.TypeofEQNumber = 2] = "TypeofEQNumber", e[e.TypeofEQBigInt = 4] = "TypeofEQBigInt", e[e.TypeofEQBoolean = 8] = "TypeofEQBoolean", e[e.TypeofEQSymbol = 16] = "TypeofEQSymbol", e[e.TypeofEQObject = 32] = "TypeofEQObject", e[e.TypeofEQFunction = 64] = "TypeofEQFunction", e[e.TypeofEQHostObject = 128] = "TypeofEQHostObject", e[e.TypeofNEString = 256] = "TypeofNEString", e[e.TypeofNENumber = 512] = "TypeofNENumber", e[e.TypeofNEBigInt = 1024] = "TypeofNEBigInt", e[e.TypeofNEBoolean = 2048] = "TypeofNEBoolean", e[e.TypeofNESymbol = 4096] = "TypeofNESymbol", e[e.TypeofNEObject = 8192] = "TypeofNEObject", e[e.TypeofNEFunction = 16384] = "TypeofNEFunction", e[e.TypeofNEHostObject = 32768] = "TypeofNEHostObject", e[e.EQUndefined = 65536] = "EQUndefined", e[e.EQNull = 131072] = "EQNull", e[e.EQUndefinedOrNull = 262144] = "EQUndefinedOrNull", e[e.NEUndefined = 524288] = "NEUndefined", e[e.NENull = 1048576] = "NENull", e[e.NEUndefinedOrNull = 2097152] = "NEUndefinedOrNull", e[e.Truthy = 4194304] = "Truthy", e[e.Falsy = 8388608] = "Falsy", e[e.IsUndefined = 16777216] = "IsUndefined", e[e.IsNull = 33554432] = "IsNull", e[e.IsUndefinedOrNull = 50331648] = "IsUndefinedOrNull", e[e.All = 134217727] = "All", e[e.BaseStringStrictFacts = 3735041] = "BaseStringStrictFacts", e[e.BaseStringFacts = 12582401] = "BaseStringFacts", e[e.StringStrictFacts = 16317953] = "StringStrictFacts", e[e.StringFacts = 16776705] = "StringFacts", e[e.EmptyStringStrictFacts = 12123649] = "EmptyStringStrictFacts", e[ + e.EmptyStringFacts = 12582401 + /* BaseStringFacts */ + ] = "EmptyStringFacts", e[e.NonEmptyStringStrictFacts = 7929345] = "NonEmptyStringStrictFacts", e[e.NonEmptyStringFacts = 16776705] = "NonEmptyStringFacts", e[e.BaseNumberStrictFacts = 3734786] = "BaseNumberStrictFacts", e[e.BaseNumberFacts = 12582146] = "BaseNumberFacts", e[e.NumberStrictFacts = 16317698] = "NumberStrictFacts", e[e.NumberFacts = 16776450] = "NumberFacts", e[e.ZeroNumberStrictFacts = 12123394] = "ZeroNumberStrictFacts", e[ + e.ZeroNumberFacts = 12582146 + /* BaseNumberFacts */ + ] = "ZeroNumberFacts", e[e.NonZeroNumberStrictFacts = 7929090] = "NonZeroNumberStrictFacts", e[e.NonZeroNumberFacts = 16776450] = "NonZeroNumberFacts", e[e.BaseBigIntStrictFacts = 3734276] = "BaseBigIntStrictFacts", e[e.BaseBigIntFacts = 12581636] = "BaseBigIntFacts", e[e.BigIntStrictFacts = 16317188] = "BigIntStrictFacts", e[e.BigIntFacts = 16775940] = "BigIntFacts", e[e.ZeroBigIntStrictFacts = 12122884] = "ZeroBigIntStrictFacts", e[ + e.ZeroBigIntFacts = 12581636 + /* BaseBigIntFacts */ + ] = "ZeroBigIntFacts", e[e.NonZeroBigIntStrictFacts = 7928580] = "NonZeroBigIntStrictFacts", e[e.NonZeroBigIntFacts = 16775940] = "NonZeroBigIntFacts", e[e.BaseBooleanStrictFacts = 3733256] = "BaseBooleanStrictFacts", e[e.BaseBooleanFacts = 12580616] = "BaseBooleanFacts", e[e.BooleanStrictFacts = 16316168] = "BooleanStrictFacts", e[e.BooleanFacts = 16774920] = "BooleanFacts", e[e.FalseStrictFacts = 12121864] = "FalseStrictFacts", e[ + e.FalseFacts = 12580616 + /* BaseBooleanFacts */ + ] = "FalseFacts", e[e.TrueStrictFacts = 7927560] = "TrueStrictFacts", e[e.TrueFacts = 16774920] = "TrueFacts", e[e.SymbolStrictFacts = 7925520] = "SymbolStrictFacts", e[e.SymbolFacts = 16772880] = "SymbolFacts", e[e.ObjectStrictFacts = 7888800] = "ObjectStrictFacts", e[e.ObjectFacts = 16736160] = "ObjectFacts", e[e.FunctionStrictFacts = 7880640] = "FunctionStrictFacts", e[e.FunctionFacts = 16728e3] = "FunctionFacts", e[e.VoidFacts = 9830144] = "VoidFacts", e[e.UndefinedFacts = 26607360] = "UndefinedFacts", e[e.NullFacts = 42917664] = "NullFacts", e[e.EmptyObjectStrictFacts = 83427327] = "EmptyObjectStrictFacts", e[e.EmptyObjectFacts = 83886079] = "EmptyObjectFacts", e[e.UnknownFacts = 83886079] = "UnknownFacts", e[e.AllTypeofNE = 556800] = "AllTypeofNE", e[e.OrFactsMask = 8256] = "OrFactsMask", e[e.AndFactsMask = 134209471] = "AndFactsMask", e))(wW || {}), Cne = new Map(Object.entries({ + string: 256, + number: 512, + bigint: 1024, + boolean: 2048, + symbol: 4096, + undefined: 524288, + object: 8192, + function: 16384 + /* TypeofNEFunction */ + })), PW = /* @__PURE__ */ ((e) => (e[e.Normal = 0] = "Normal", e[e.Contextual = 1] = "Contextual", e[e.Inferential = 2] = "Inferential", e[e.SkipContextSensitive = 4] = "SkipContextSensitive", e[e.SkipGenericFunctions = 8] = "SkipGenericFunctions", e[e.IsForSignatureHelp = 16] = "IsForSignatureHelp", e[e.RestBindingElement = 32] = "RestBindingElement", e[e.TypeOnly = 64] = "TypeOnly", e))(PW || {}), NW = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.BivariantCallback = 1] = "BivariantCallback", e[e.StrictCallback = 2] = "StrictCallback", e[e.IgnoreReturnTypes = 4] = "IgnoreReturnTypes", e[e.StrictArity = 8] = "StrictArity", e[e.StrictTopSignature = 16] = "StrictTopSignature", e[e.Callback = 3] = "Callback", e))(NW || {}), PRe = ZI(V1e, ARe), AW = new Map(Object.entries({ + Uppercase: 0, + Lowercase: 1, + Capitalize: 2, + Uncapitalize: 3, + NoInfer: 4 + /* NoInfer */ + })), U1e = class { + }; + function NRe() { + this.flags = 0; + } + function Ma(e) { + return e.id || (e.id = J1e, J1e++), e.id; + } + function Xs(e) { + return e.id || (e.id = B1e, B1e++), e.id; + } + function IW(e, t) { + const n = Ah(e); + return n === 1 || t && n === 2; + } + function Ene(e) { + var t = [], n = (r) => { + t.push(r); + }, i, s, o = tu.getSymbolConstructor(), c = tu.getTypeConstructor(), _ = tu.getSignatureConstructor(), u = 0, g = 0, m = 0, h = 0, S = 0, T = 0, k, D, P = !1, A = Bs(), O = [ + 1 + /* Covariant */ + ], F = e.getCompilerOptions(), R = da(F), B = Hu(F), U = !!F.experimentalDecorators, $ = gN(F), W = kJ(F), _e = Ax(F), K = du(F, "strictNullChecks"), V = du(F, "strictFunctionTypes"), ae = du(F, "strictBindCallApply"), se = du(F, "strictPropertyInitialization"), ce = du(F, "strictBuiltinIteratorReturn"), fe = du(F, "noImplicitAny"), he = du(F, "noImplicitThis"), q = du(F, "useUnknownInCatchVariables"), be = F.exactOptionalPropertyTypes, je = !!F.noUncheckedSideEffectImports, me = dct(), Z = Z_t(), pe = GL(), Te = Nse(F, pe.syntacticBuilderResolver), Fe = rte({ + evaluateElementAccessExpression: Wut, + evaluateEntityNameExpression: U7e + }), Ye = Bs(), ne = ga(4, "undefined"); + ne.declarations = []; + var Se = ga( + 1536, + "globalThis", + 8 + /* Readonly */ + ); + Se.exports = Ye, Se.declarations = [], Ye.set(Se.escapedName, Se); + var ie = ga(4, "arguments"), Ne = ga(4, "require"), Ee = F.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules", Ce = !F.verbatimModuleSyntax, Ve, St, Bt = 0, tr, Nr = 0, st = GJ({ + compilerOptions: F, + requireSymbol: Ne, + argumentsSymbol: ie, + globals: Ye, + getSymbolOfDeclaration: yn, + error: ze, + getRequiresScopeChangeCache: S2, + setRequiresScopeChangeCache: yE, + lookup: Xl, + onPropertyWithInvalidInitializer: Gw, + onFailedToResolveSymbol: bn, + onSuccessfullyResolvedSymbol: Ku + }), Wt = GJ({ + compilerOptions: F, + requireSymbol: Ne, + argumentsSymbol: ie, + globals: Ye, + getSymbolOfDeclaration: yn, + error: ze, + getRequiresScopeChangeCache: S2, + setRequiresScopeChangeCache: yE, + lookup: Lat + }); + const Jr = { + getNodeCount: () => Wu(e.getSourceFiles(), (r, a) => r + a.nodeCount, 0), + getIdentifierCount: () => Wu(e.getSourceFiles(), (r, a) => r + a.identifierCount, 0), + getSymbolCount: () => Wu(e.getSourceFiles(), (r, a) => r + a.symbolCount, g), + getTypeCount: () => u, + getInstantiationCount: () => m, + getRelationCacheSizes: () => ({ + assignable: yu.size, + identity: vu.size, + subtype: cg.size, + strictSubtype: Ro.size + }), + isUndefinedSymbol: (r) => r === ne, + isArgumentsSymbol: (r) => r === ie, + isUnknownSymbol: (r) => r === Y, + getMergedSymbol: Oa, + symbolIsValue: ur, + getDiagnostics: Y7e, + getGlobalDiagnostics: p_t, + getRecursionIdentity: E$, + getUnmatchedProperties: ede, + getTypeOfSymbolAtLocation: (r, a) => { + const l = vs(a); + return l ? Hit(r, l) : qe; + }, + getTypeOfSymbol: Yr, + getSymbolsOfParameterPropertyDeclaration: (r, a) => { + const l = vs(r, Ii); + return l === void 0 ? E.fail("Cannot get symbols of a synthetic parameter that cannot be resolved to a parse-tree node.") : (E.assert(K_(l, l.parent)), sT(l, tc(a))); + }, + getDeclaredTypeOfSymbol: bo, + getPropertiesOfType: $a, + getPropertyOfType: (r, a) => Ys(r, tc(a)), + getPrivateIdentifierPropertyOfType: (r, a, l) => { + const f = vs(l); + if (!f) + return; + const d = tc(a), y = zM(d, f); + return y ? cX(r, y) : void 0; + }, + getTypeOfPropertyOfType: (r, a) => rr(r, tc(a)), + getIndexInfoOfType: (r, a) => ah(r, a === 0 ? at : wt), + getIndexInfosOfType: Su, + getIndexInfosOfIndexSymbol: r$, + getSignaturesOfType: Is, + getIndexTypeOfType: (r, a) => eb(r, a === 0 ? at : wt), + getIndexType: (r) => jm(r), + getBaseTypes: bd, + getBaseTypeOfLiteralType: r0, + getWidenedType: Sf, + getWidenedLiteralType: ob, + fillMissingTypeArguments: ty, + getTypeFromTypeNode: (r) => { + const a = vs(r, li); + return a ? Ci(a) : qe; + }, + getParameterType: Kd, + getParameterIdentifierInfoAtPosition: Pot, + getPromisedTypeOfPromise: LI, + getAwaitedType: (r) => _C(r), + getReturnTypeOfSignature: Wa, + isNullableType: JM, + getNullableType: xM, + getNonNullableType: n0, + getNonOptionalType: N$, + getTypeArguments: Ao, + typeToTypeNode: pe.typeToTypeNode, + typePredicateToTypePredicateNode: pe.typePredicateToTypePredicateNode, + indexInfoToIndexSignatureDeclaration: pe.indexInfoToIndexSignatureDeclaration, + signatureToSignatureDeclaration: pe.signatureToSignatureDeclaration, + symbolToEntityName: pe.symbolToEntityName, + symbolToExpression: pe.symbolToExpression, + symbolToNode: pe.symbolToNode, + symbolToTypeParameterDeclarations: pe.symbolToTypeParameterDeclarations, + symbolToParameterDeclaration: pe.symbolToParameterDeclaration, + typeParameterToDeclaration: pe.typeParameterToDeclaration, + getSymbolsInScope: (r, a) => { + const l = vs(r); + return l ? d_t(l, a) : []; + }, + getSymbolAtLocation: (r) => { + const a = vs(r); + return a ? Pp( + a, + /*ignoreErrors*/ + !0 + ) : void 0; + }, + getIndexInfosAtLocation: (r) => { + const a = vs(r); + return a ? T_t(a) : void 0; + }, + getShorthandAssignmentValueSymbol: (r) => { + const a = vs(r); + return a ? x_t(a) : void 0; + }, + getExportSpecifierLocalTargetSymbol: (r) => { + const a = vs(r, Nu); + return a ? k_t(a) : void 0; + }, + getExportSymbolOfSymbol(r) { + return Oa(r.exportSymbol || r); + }, + getTypeAtLocation: (r) => { + const a = vs(r); + return a ? pC(a) : qe; + }, + getTypeOfAssignmentPattern: (r) => { + const a = vs(r, wD); + return a && jX(a) || qe; + }, + getPropertySymbolOfDestructuringAssignment: (r) => { + const a = vs(r, Me); + return a ? C_t(a) : void 0; + }, + signatureToString: (r, a, l, f) => b1(r, vs(a), l, f), + typeToString: (r, a, l) => Wr(r, vs(a), l), + symbolToString: (r, a, l, f) => Wi(r, vs(a), l, f), + typePredicateToString: (r, a, l) => _g(r, vs(a), l), + writeSignature: (r, a, l, f, d, y, x, I) => b1(r, vs(a), l, f, d, y, x, I), + writeType: (r, a, l, f, d, y, x) => Wr(r, vs(a), l, f, d, y, x), + writeSymbol: (r, a, l, f, d) => Wi(r, vs(a), l, f, d), + writeTypePredicate: (r, a, l, f) => _g(r, vs(a), l, f), + getAugmentedPropertiesOfType: Ume, + getRootSymbols: s5e, + getSymbolOfExpando: dX, + getContextualType: (r, a) => { + const l = vs(r, ut); + if (l) + return a & 4 ? Mn(l, () => g_(l, a)) : g_(l, a); + }, + getContextualTypeForObjectLiteralElement: (r) => { + const a = vs(r, vh); + return a ? Nde( + a, + /*contextFlags*/ + void 0 + ) : void 0; + }, + getContextualTypeForArgumentAtIndex: (r, a) => { + const l = vs(r, Cb); + return l && Dde(l, a); + }, + getContextualTypeForJsxAttribute: (r) => { + const a = vs(r, A7); + return a && b8e( + a, + /*contextFlags*/ + void 0 + ); + }, + isContextSensitive: Qf, + getTypeOfPropertyOfContextualType: lb, + getFullyQualifiedName: q0, + getResolvedSignature: (r, a, l) => ai( + r, + a, + l, + 0 + /* Normal */ + ), + getCandidateSignaturesForStringLiteralCompletions: Ji, + getResolvedSignatureForSignatureHelp: (r, a, l) => Dt(r, () => ai( + r, + a, + l, + 16 + /* IsForSignatureHelp */ + )), + getExpandedParameters: n3e, + hasEffectiveRestParameter: vg, + containsArgumentsReference: Hfe, + getConstantValue: (r) => { + const a = vs(r, _5e); + return a ? zX(a) : void 0; + }, + isValidPropertyAccess: (r, a) => { + const l = vs(r, DZ); + return !!l && jat(l, tc(a)); + }, + isValidPropertyAccessForCompletions: (r, a, l) => { + const f = vs(r, wn); + return !!f && Y8e(f, a, l); + }, + getSignatureFromDeclaration: (r) => { + const a = vs(r, Es); + return a ? Xf(a) : void 0; + }, + isImplementationOfOverload: (r) => { + const a = vs(r, Es); + return a ? l5e(a) : void 0; + }, + getImmediateAliasedSymbol: tX, + getAliasedSymbol: Rl, + getEmitResolver: Hw, + requiresAddingImplicitUndefined: pR, + getExportsOfModule: Wk, + getExportsAndPropertiesOfModule: xE, + forEachExportAndPropertyOfModule: Uk, + getSymbolWalker: vne( + utt, + kp, + Wa, + bd, + $d, + Yr, + ju, + m_, + i_, + Ao + ), + getAmbientModules: Jft, + getJsxIntrinsicTagNamesAt: yat, + isOptionalParameter: (r) => { + const a = vs(r, Ii); + return a ? K8(a) : !1; + }, + tryGetMemberInModuleExports: (r, a) => dT(tc(r), a), + tryGetMemberInModuleExportsAndProperties: (r, a) => Vk(tc(r), a), + tryFindAmbientModule: (r) => x3e( + r, + /*withAugmentations*/ + !0 + ), + getApparentType: e_, + getUnionType: Xn, + isTypeAssignableTo: Ms, + createAnonymousType: Ho, + createSignature: Mm, + createSymbol: ga, + createIndexInfo: oh, + getAnyType: () => Le, + getStringType: () => at, + getStringLiteralType: H_, + getNumberType: () => wt, + getNumberLiteralType: Xd, + getBigIntType: () => Zr, + getBigIntLiteralType: _M, + getUnknownType: () => yt, + createPromiseType: QM, + createArrayType: Tu, + getElementTypeOfArrayType: TM, + getBooleanType: () => Nt, + getFalseType: (r) => r ? Rr : Pr, + getTrueType: (r) => r ? rt : vt, + getVoidType: () => _r, + getUndefinedType: () => ue, + getNullType: () => Mt, + getESSymbolType: () => Jt, + getNeverType: () => nr, + getNonPrimitiveType: () => vr, + getOptionalType: () => dt, + getPromiseType: () => sM( + /*reportErrors*/ + !1 + ), + getPromiseLikeType: () => G3e( + /*reportErrors*/ + !1 + ), + getAnyAsyncIterableType: () => { + const r = aM( + /*reportErrors*/ + !1 + ); + if (r !== zt) + return Qh(r, [Le, Le, Le]); + }, + isSymbolAccessible: v1, + isArrayType: Ep, + isTupleType: Sa, + isArrayLikeType: iy, + isEmptyAnonymousObjectType: yg, + isTypeInvalidDueToUnionDiscriminant: qet, + getExactOptionalProperties: bnt, + getAllPossiblePropertiesOfTypes: Het, + getSuggestedSymbolForNonexistentProperty: Ude, + getSuggestedSymbolForNonexistentJSXAttribute: G8e, + getSuggestedSymbolForNonexistentSymbol: (r, a, l) => X8e(r, tc(a), l), + getSuggestedSymbolForNonexistentModule: Vde, + getSuggestedSymbolForNonexistentClassMember: H8e, + getBaseConstraintOfType: ou, + getDefaultFromTypeParameter: (r) => r && r.flags & 262144 ? A2(r) : void 0, + resolveName(r, a, l, f) { + return st( + a, + tc(r), + l, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1, + f + ); + }, + getJsxNamespace: (r) => Si(pd(r)), + getJsxFragmentFactory: (r) => { + const a = $me(r); + return a && Si(i_(a).escapedText); + }, + getAccessibleSymbolChain: $0, + getTypePredicateOfSignature: kp, + resolveExternalModuleName: (r) => { + const a = vs(r, ut); + return a && Mu( + a, + a, + /*ignoreErrors*/ + !0 + ); + }, + resolveExternalModuleSymbol: q_, + tryGetThisTypeAt: (r, a, l) => { + const f = vs(r); + return f && xde(f, a, l); + }, + getTypeArgumentConstraint: (r) => { + const a = vs(r, li); + return a && Qct(a); + }, + getSuggestionDiagnostics: (r, a) => { + const l = vs(r, Di) || E.fail("Could not determine parsed source file."); + if (a6(l, F, e)) + return Ge; + let f; + try { + return i = a, zme(l), E.assert(!!(xn(l).flags & 1)), f = In(f, rT.getDiagnostics(l.fileName)), m7e(Q7e(l), (d, y, x) => { + !fx(d) && !X7e(y, !!(d.flags & 33554432)) && (f || (f = [])).push({ + ...x, + category: 2 + /* Suggestion */ + }); + }), f || Ge; + } finally { + i = void 0; + } + }, + runWithCancellationToken: (r, a) => { + try { + return i = r, a(Jr); + } finally { + i = void 0; + } + }, + getLocalTypeParametersOfClassOrInterfaceOrTypeAlias: ia, + isDeclarationVisible: fg, + isPropertyAccessible: Hde, + getTypeOnlyAliasDeclaration: Vd, + getMemberOverrideModifierStatus: Aut, + isTypeParameterPossiblyReferenced: dM, + typeHasCallOrConstructSignatures: BX, + getSymbolFlags: O_, + getTypeArgumentsForResolvedSignature: ui, + isLibType: EE + }; + function ui(r) { + if (r.mapper !== void 0) + return e0((r.target || r).typeParameters, r.mapper); + } + function Ji(r, a) { + const l = /* @__PURE__ */ new Set(), f = []; + Mn(a, () => ai( + r, + f, + /*argumentCount*/ + void 0, + 0 + /* Normal */ + )); + for (const d of f) + l.add(d); + f.length = 0, Dt(a, () => ai( + r, + f, + /*argumentCount*/ + void 0, + 0 + /* Normal */ + )); + for (const d of f) + l.add(d); + return is(l); + } + function Dt(r, a) { + if (r = dr(r, Gj), r) { + const l = [], f = []; + for (; r; ) { + const y = xn(r); + if (l.push([y, y.resolvedSignature]), y.resolvedSignature = void 0, zy(r)) { + const x = Pn(yn(r)), I = x.type; + f.push([x, I]), x.type = void 0; + } + r = dr(r.parent, Gj); + } + const d = a(); + for (const [y, x] of l) + y.resolvedSignature = x; + for (const [y, x] of f) + y.type = x; + return d; + } + return a(); + } + function Mn(r, a) { + const l = dr(r, Cb); + if (l) { + let d = r; + do + xn(d).skipDirectInference = !0, d = d.parent; + while (d && d !== l); + } + P = !0; + const f = Dt(r, a); + if (P = !1, l) { + let d = r; + do + xn(d).skipDirectInference = void 0, d = d.parent; + while (d && d !== l); + } + return f; + } + function ai(r, a, l, f) { + const d = vs(r, Cb); + Ve = l; + const y = d ? qE(d, a, f) : void 0; + return Ve = void 0, y; + } + var fi = /* @__PURE__ */ new Map(), pn = /* @__PURE__ */ new Map(), _i = /* @__PURE__ */ new Map(), Je = /* @__PURE__ */ new Map(), ft = /* @__PURE__ */ new Map(), er = /* @__PURE__ */ new Map(), qr = /* @__PURE__ */ new Map(), Jn = /* @__PURE__ */ new Map(), Un = /* @__PURE__ */ new Map(), ki = /* @__PURE__ */ new Map(), Ds = /* @__PURE__ */ new Map(), Ks = /* @__PURE__ */ new Map(), yr = /* @__PURE__ */ new Map(), bs = /* @__PURE__ */ new Map(), Xe = /* @__PURE__ */ new Map(), Et = [], re = /* @__PURE__ */ new Map(), it = /* @__PURE__ */ new Set(), Y = ga(4, "unknown"), Ae = ga( + 0, + "__resolving__" + /* Resolving */ + ), $e = /* @__PURE__ */ new Map(), Ke = /* @__PURE__ */ new Map(), Tt = /* @__PURE__ */ new Set(), Le = mi(1, "any"), mt = mi(1, "any", 262144, "auto"), pt = mi( + 1, + "any", + /*objectFlags*/ + void 0, + "wildcard" + ), Ct = mi( + 1, + "any", + /*objectFlags*/ + void 0, + "blocked string" + ), qe = mi(1, "error"), Lt = mi(1, "unresolved"), rn = mi(1, "any", 65536, "non-inferrable"), Pe = mi(1, "intrinsic"), yt = mi(2, "unknown"), ue = mi(32768, "undefined"), M = K ? ue : mi(32768, "undefined", 65536, "widening"), ye = mi( + 32768, + "undefined", + /*objectFlags*/ + void 0, + "missing" + ), Q = be ? ye : ue, dt = mi( + 32768, + "undefined", + /*objectFlags*/ + void 0, + "optional" + ), Mt = mi(65536, "null"), ke = K ? Mt : mi(65536, "null", 65536, "widening"), at = mi(4, "string"), wt = mi(8, "number"), Zr = mi(64, "bigint"), Rr = mi( + 512, + "false", + /*objectFlags*/ + void 0, + "fresh" + ), Pr = mi(512, "false"), rt = mi( + 512, + "true", + /*objectFlags*/ + void 0, + "fresh" + ), vt = mi(512, "true"); + rt.regularType = vt, rt.freshType = rt, vt.regularType = vt, vt.freshType = rt, Rr.regularType = Pr, Rr.freshType = Rr, Pr.regularType = Pr, Pr.freshType = Rr; + var Nt = Xn([Pr, vt]), Jt = mi(4096, "symbol"), _r = mi(16384, "void"), nr = mi(131072, "never"), kt = mi(131072, "never", 262144, "silent"), cr = mi( + 131072, + "never", + /*objectFlags*/ + void 0, + "implicit" + ), fr = mi( + 131072, + "never", + /*objectFlags*/ + void 0, + "unreachable" + ), vr = mi(67108864, "object"), Xt = Xn([at, wt]), oi = Xn([at, wt, Jt]), Fs = Xn([wt, Zr]), Rs = Xn([at, wt, Nt, Zr, Mt, ue]), ds = wT(["", ""], [wt]), pc = pM((r) => r.flags & 262144 ? Hrt(r) : r, () => "(restrictive mapper)"), Zo = pM((r) => r.flags & 262144 ? pt : r, () => "(permissive mapper)"), so = mi( + 131072, + "never", + /*objectFlags*/ + void 0, + "unique literal" + ), zi = pM((r) => r.flags & 262144 ? so : r, () => "(unique literal mapper)"), hs, Gc = pM((r) => (hs && (r === _o || r === ge || r === H) && hs( + /*onlyUnreliable*/ + !0 + ), r), () => "(unmeasurable reporter)"), Co = pM((r) => (hs && (r === _o || r === ge || r === H) && hs( + /*onlyUnreliable*/ + !1 + ), r), () => "(unreliable reporter)"), ta = Ho( + /*symbol*/ + void 0, + A, + Ge, + Ge, + Ge + ), Ec = Ho( + /*symbol*/ + void 0, + A, + Ge, + Ge, + Ge + ); + Ec.objectFlags |= 2048; + var zf = Ho( + /*symbol*/ + void 0, + A, + Ge, + Ge, + Ge + ); + zf.objectFlags |= 141440; + var cs = ga( + 2048, + "__type" + /* Type */ + ); + cs.members = Bs(); + var Ws = Ho(cs, A, Ge, Ge, Ge), Fa = Ho( + /*symbol*/ + void 0, + A, + Ge, + Ge, + Ge + ), va = K ? Xn([ue, Mt, Fa]) : yt, zt = Ho( + /*symbol*/ + void 0, + A, + Ge, + Ge, + Ge + ); + zt.instantiations = /* @__PURE__ */ new Map(); + var Za = Ho( + /*symbol*/ + void 0, + A, + Ge, + Ge, + Ge + ); + Za.objectFlags |= 262144; + var yc = Ho( + /*symbol*/ + void 0, + A, + Ge, + Ge, + Ge + ), Fc = Ho( + /*symbol*/ + void 0, + A, + Ge, + Ge, + Ge + ), Hl = Ho( + /*symbol*/ + void 0, + A, + Ge, + Ge, + Ge + ), _o = p_(), ge = p_(); + ge.constraint = _o; + var H = p_(), tt = p_(), Ft = p_(); + Ft.constraint = tt; + var Kt = eI(1, "<>", 0, Le), Hr = Mm( + /*declaration*/ + void 0, + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + Ge, + Le, + /*resolvedTypePredicate*/ + void 0, + 0, + 0 + /* None */ + ), Vn = Mm( + /*declaration*/ + void 0, + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + Ge, + qe, + /*resolvedTypePredicate*/ + void 0, + 0, + 0 + /* None */ + ), ln = Mm( + /*declaration*/ + void 0, + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + Ge, + Le, + /*resolvedTypePredicate*/ + void 0, + 0, + 0 + /* None */ + ), kr = Mm( + /*declaration*/ + void 0, + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + Ge, + kt, + /*resolvedTypePredicate*/ + void 0, + 0, + 0 + /* None */ + ), Li = oh( + wt, + at, + /*isReadonly*/ + !0 + ), Yi = oh( + at, + Le, + /*isReadonly*/ + !1 + ), no = /* @__PURE__ */ new Map(), ra = { + get yieldType() { + return E.fail("Not supported"); + }, + get returnType() { + return E.fail("Not supported"); + }, + get nextType() { + return E.fail("Not supported"); + } + }, Eo = I1(Le, Le, Le), $c = I1(kt, kt, kt), Jc = { + iterableCacheKey: "iterationTypesOfAsyncIterable", + iteratorCacheKey: "iterationTypesOfAsyncIterator", + iteratorSymbolName: "asyncIterator", + getGlobalIteratorType: Ctt, + getGlobalIterableType: aM, + getGlobalIterableIteratorType: $3e, + getGlobalIteratorObjectType: Dtt, + getGlobalGeneratorType: wtt, + getGlobalBuiltinIteratorTypes: Ett, + resolveIterationType: (r, a) => _C(r, a, p.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member), + mustHaveANextMethodDiagnostic: p.An_async_iterator_must_have_a_next_method, + mustBeAMethodDiagnostic: p.The_0_property_of_an_async_iterator_must_be_a_method, + mustHaveAValueDiagnostic: p.The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property + }, vo = { + iterableCacheKey: "iterationTypesOfIterable", + iteratorCacheKey: "iterationTypesOfIterator", + iteratorSymbolName: "iterator", + getGlobalIteratorType: Ptt, + getGlobalIterableType: u$, + getGlobalIterableIteratorType: X3e, + getGlobalIteratorObjectType: Att, + getGlobalGeneratorType: Itt, + getGlobalBuiltinIteratorTypes: Ntt, + resolveIterationType: (r, a) => r, + mustHaveANextMethodDiagnostic: p.An_iterator_must_have_a_next_method, + mustBeAMethodDiagnostic: p.The_0_property_of_an_iterator_must_be_a_method, + mustHaveAValueDiagnostic: p.The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property + }, ic, Bd = /* @__PURE__ */ new Map(), au = /* @__PURE__ */ new Map(), Ef, P_, Ie, Ot, Mr, Gi, Da, wa, ma, il, Po, sc, vc, Df, Gl, Ol, pf, Qu, hp, ig, Gg, $g, N_, Sl, Jd, Wf, Nm, ee, et, Ut, Gt, Sr, zr, jn, ni, wi, L, Oe, xt, Tr, $i, As, Zi, ys, zo, na, Ll, df, Uf, yp, jh, M0, __, sg, zd, $p, s1, Be, nt, Rt, pr, Or = /* @__PURE__ */ new Map(), dn = 0, Ir = 0, Vr = 0, hi = !1, rs = 0, Zn, ns, Pi, Wo = [], A_ = [], Xp = [], $l = 0, Qp = [], mf = [], wv = [], Am = 0, ag = [], Pv = [], og = 0, pE = H_(""), Vw = Xd(0), dE = _M({ negative: !1, base10Value: "0" }), Xg = [], Nv = [], YS = [], R0 = 0, ZS = !1, Dk = 0, qw = 10, KS = [], wk = [], Av = [], mE = [], eT = [], Pk = [], g2 = [], a1 = [], Nk = [], Ak = [], h2 = [], o1 = [], j0 = [], Bh = [], Jh = [], zh = [], c1 = [], Iv = [], tT = [], Fv = 0, Aa = ZD(), rT = ZD(), gE = bu(), Wh, Uh, cg = /* @__PURE__ */ new Map(), Ro = /* @__PURE__ */ new Map(), yu = /* @__PURE__ */ new Map(), I_ = /* @__PURE__ */ new Map(), vu = /* @__PURE__ */ new Map(), Ov = /* @__PURE__ */ new Map(), Yu = [ + [".mts", ".mjs"], + [".ts", ".js"], + [".cts", ".cjs"], + [".mjs", ".mjs"], + [".js", ".js"], + [".cjs", ".cjs"], + [".tsx", F.jsx === 1 ? ".jsx" : ".js"], + [".jsx", ".jsx"], + [".json", ".json"] + ]; + return K_t(), Jr; + function lg(r) { + return !wn(r) || !Me(r.name) || !wn(r.expression) && !Me(r.expression) ? !1 : Me(r.expression) ? An(r.expression) === "Symbol" && ju(r.expression) === (ME( + "Symbol", + 1160127, + /*diagnostic*/ + void 0 + ) || Y) : Me(r.expression.expression) ? An(r.expression.name) === "Symbol" && An(r.expression.expression) === "globalThis" && ju(r.expression.expression) === Se : !1; + } + function f_(r) { + return r ? Xe.get(r) : void 0; + } + function Yp(r, a) { + return r && Xe.set(r, a), a; + } + function pd(r) { + if (r) { + const a = xr(r); + if (a) + if (ud(r)) { + if (a.localJsxFragmentNamespace) + return a.localJsxFragmentNamespace; + const l = a.pragmas.get("jsxfrag"); + if (l) { + const d = as(l) ? l[0] : l; + if (a.localJsxFragmentFactory = tk(d.arguments.factory, R), Qe(a.localJsxFragmentFactory, Mv, r_), a.localJsxFragmentFactory) + return a.localJsxFragmentNamespace = i_(a.localJsxFragmentFactory).escapedText; + } + const f = $me(r); + if (f) + return a.localJsxFragmentFactory = f, a.localJsxFragmentNamespace = i_(f).escapedText; + } else { + const l = Lv(a); + if (l) + return a.localJsxNamespace = l; + } + } + return Wh || (Wh = "React", F.jsxFactory ? (Uh = tk(F.jsxFactory, R), Qe(Uh, Mv), Uh && (Wh = i_(Uh).escapedText)) : F.reactNamespace && (Wh = tc(F.reactNamespace))), Uh || (Uh = N.createQualifiedName(N.createIdentifier(Si(Wh)), "createElement")), Wh; + } + function Lv(r) { + if (r.localJsxNamespace) + return r.localJsxNamespace; + const a = r.pragmas.get("jsx"); + if (a) { + const l = as(a) ? a[0] : a; + if (r.localJsxFactory = tk(l.arguments.factory, R), Qe(r.localJsxFactory, Mv, r_), r.localJsxFactory) + return r.localJsxNamespace = i_(r.localJsxFactory).escapedText; + } + } + function Mv(r) { + return Ad(r, -1, -1), br( + r, + Mv, + /*context*/ + void 0 + ); + } + function Hw(r, a, l) { + return l || Y7e(r, a), Z; + } + function hE(r, a, ...l) { + const f = r ? sn(r, a, ...l) : Yo(a, ...l), d = Aa.lookup(f); + return d || (Aa.add(f), f); + } + function B0(r, a, l, ...f) { + const d = ze(a, l, ...f); + return d.skippedOn = r, d; + } + function y2(r, a, ...l) { + return r ? sn(r, a, ...l) : Yo(a, ...l); + } + function ze(r, a, ...l) { + const f = y2(r, a, ...l); + return Aa.add(f), f; + } + function nT(r) { + const l = xr(r).fileName; + return xc(l, [ + ".cts", + ".cjs" + /* Cjs */ + ]) ? p.ECMAScript_imports_and_exports_cannot_be_written_in_a_CommonJS_file_under_verbatimModuleSyntax : p.ECMAScript_imports_and_exports_cannot_be_written_in_a_CommonJS_file_under_verbatimModuleSyntax_Adjust_the_type_field_in_the_nearest_package_json_to_make_this_file_an_ECMAScript_module_or_adjust_your_verbatimModuleSyntax_module_and_moduleResolution_settings_in_TypeScript; + } + function Qg(r, a) { + r ? Aa.add(a) : rT.add({ + ...a, + category: 2 + /* Suggestion */ + }); + } + function dd(r, a, l, ...f) { + if (a.pos < 0 || a.end < 0) { + if (!r) + return; + const d = xr(a); + Qg(r, "message" in l ? ll(d, 0, 0, l, ...f) : yB(d, l)); + return; + } + Qg(r, "message" in l ? sn(a, l, ...f) : Fg(xr(a), a, l)); + } + function J0(r, a, l, ...f) { + const d = ze(r, l, ...f); + if (a) { + const y = sn(r, p.Did_you_forget_to_use_await); + zs(d, y); + } + return d; + } + function l1(r, a) { + const l = Array.isArray(r) ? lr(r, Oj) : Oj(r); + return l && zs( + a, + sn(l, p.The_declaration_was_marked_as_deprecated_here) + ), rT.add(a), a; + } + function Zu(r) { + const a = Tl(r); + return a && wr(r.declarations) > 1 ? a.flags & 64 ? ot(r.declarations, Wd) : Ni(r.declarations, Wd) : !!r.valueDeclaration && Wd(r.valueDeclaration) || wr(r.declarations) && Ni(r.declarations, Wd); + } + function Wd(r) { + return !!(U2(r) & 536870912); + } + function Zp(r, a, l) { + const f = sn(r, p._0_is_deprecated, l); + return l1(a, f); + } + function Rv(r, a, l, f) { + const d = l ? sn(r, p.The_signature_0_of_1_is_deprecated, f, l) : sn(r, p._0_is_deprecated, f); + return l1(a, d); + } + function ga(r, a, l) { + g++; + const f = new o(r | 33554432, a); + return f.links = new U1e(), f.links.checkFlags = l || 0, f; + } + function Vf(r, a) { + const l = ga(1, r); + return l.links.type = a, l; + } + function z0(r, a) { + const l = ga(4, r); + return l.links.type = a, l; + } + function iT(r) { + let a = 0; + return r & 2 && (a |= 111551), r & 1 && (a |= 111550), r & 4 && (a |= 0), r & 8 && (a |= 900095), r & 16 && (a |= 110991), r & 32 && (a |= 899503), r & 64 && (a |= 788872), r & 256 && (a |= 899327), r & 128 && (a |= 899967), r & 512 && (a |= 110735), r & 8192 && (a |= 103359), r & 32768 && (a |= 46015), r & 65536 && (a |= 78783), r & 262144 && (a |= 526824), r & 524288 && (a |= 788968), r & 2097152 && (a |= 2097152), a; + } + function Vh(r, a) { + a.mergeId || (a.mergeId = z1e, z1e++), KS[a.mergeId] = r; + } + function v2(r) { + const a = ga(r.flags, r.escapedName); + return a.declarations = r.declarations ? r.declarations.slice() : [], a.parent = r.parent, r.valueDeclaration && (a.valueDeclaration = r.valueDeclaration), r.constEnumOnlyModule && (a.constEnumOnlyModule = !0), r.members && (a.members = new Map(r.members)), r.exports && (a.exports = new Map(r.exports)), Vh(a, r), a; + } + function vp(r, a, l = !1) { + if (!(r.flags & iT(a.flags)) || (a.flags | r.flags) & 67108864) { + if (a === r) + return r; + if (!(r.flags & 33554432)) { + const y = zc(r); + if (y === Y) + return a; + if (!(y.flags & iT(a.flags)) || (a.flags | y.flags) & 67108864) + r = v2(y); + else + return f(r, a), a; + } + a.flags & 512 && r.flags & 512 && r.constEnumOnlyModule && !a.constEnumOnlyModule && (r.constEnumOnlyModule = !1), r.flags |= a.flags, a.valueDeclaration && WD(r, a.valueDeclaration), In(r.declarations, a.declarations), a.members && (r.members || (r.members = Bs()), Im(r.members, a.members, l)), a.exports && (r.exports || (r.exports = Bs()), Im(r.exports, a.exports, l, r)), l || Vh(r, a); + } else r.flags & 1024 ? r !== Se && ze( + a.declarations && _s(a.declarations[0]), + p.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity, + Wi(r) + ) : f(r, a); + return r; + function f(y, x) { + const I = !!(y.flags & 384 || x.flags & 384), J = !!(y.flags & 2 || x.flags & 2), z = I ? p.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations : J ? p.Cannot_redeclare_block_scoped_variable_0 : p.Duplicate_identifier_0, G = x.declarations && xr(x.declarations[0]), ve = y.declarations && xr(y.declarations[0]), de = AD(G, F.checkJs), We = AD(ve, F.checkJs), lt = Wi(x); + if (G && ve && ic && !I && G !== ve) { + const gt = gh(G.path, ve.path) === -1 ? G : ve, jt = gt === G ? ve : G, ar = eD(ic, `${gt.path}|${jt.path}`, () => ({ firstFile: gt, secondFile: jt, conflictingSymbols: /* @__PURE__ */ new Map() })), jr = eD(ar.conflictingSymbols, lt, () => ({ isBlockScoped: J, firstFileLocations: [], secondFileLocations: [] })); + de || d(jr.firstFileLocations, x), We || d(jr.secondFileLocations, y); + } else + de || Yg(x, z, lt, y), We || Yg(y, z, lt, x); + } + function d(y, x) { + if (x.declarations) + for (const I of x.declarations) + tp(y, I); + } + } + function Yg(r, a, l, f) { + lr(r.declarations, (d) => { + jv(d, a, l, f.declarations); + }); + } + function jv(r, a, l, f) { + const d = (G1( + r, + /*isPrototypeAssignment*/ + !1 + ) ? EB(r) : _s(r)) || r, y = hE(d, a, l); + for (const x of f || Ge) { + const I = (G1( + x, + /*isPrototypeAssignment*/ + !1 + ) ? EB(x) : _s(x)) || x; + if (I === d) continue; + y.relatedInformation = y.relatedInformation || []; + const J = sn(I, p._0_was_also_declared_here, l), z = sn(I, p.and_here); + wr(y.relatedInformation) >= 5 || ot( + y.relatedInformation, + (G) => c4(G, z) === 0 || c4(G, J) === 0 + /* EqualTo */ + ) || zs(y, wr(y.relatedInformation) ? z : J); + } + } + function W0(r, a) { + if (!r?.size) return a; + if (!a?.size) return r; + const l = Bs(); + return Im(l, r), Im(l, a), l; + } + function Im(r, a, l = !1, f) { + a.forEach((d, y) => { + const x = r.get(y), I = x ? vp(x, d, l) : Oa(d); + f && x && (I.parent = f), r.set(y, I); + }); + } + function b2(r) { + var a, l, f; + const d = r.parent; + if (((a = d.symbol.declarations) == null ? void 0 : a[0]) !== d) { + E.assert(d.symbol.declarations.length > 1); + return; + } + if ($m(d)) + Im(Ye, d.symbol.exports); + else { + const y = r.parent.parent.flags & 33554432 ? void 0 : p.Invalid_module_name_in_augmentation_module_0_cannot_be_found; + let x = V_( + r, + r, + y, + /*ignoreErrors*/ + !1, + /*isForAugmentation*/ + !0 + ); + if (!x) + return; + if (x = q_(x), x.flags & 1920) + if (ot(P_, (I) => x === I.symbol)) { + const I = vp( + d.symbol, + x, + /*unidirectional*/ + !0 + ); + Ie || (Ie = /* @__PURE__ */ new Map()), Ie.set(r.text, I); + } else { + if ((l = x.exports) != null && l.get( + "__export" + /* ExportStar */ + ) && ((f = d.symbol.exports) != null && f.size)) { + const I = Afe( + x, + "resolvedExports" + /* resolvedExports */ + ); + for (const [J, z] of is(d.symbol.exports.entries())) + I.has(J) && !x.exports.has(J) && vp(I.get(J), z); + } + vp(x, d.symbol); + } + else + ze(r, p.Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity, r.text); + } + } + function Bv() { + const r = ne.escapedName, a = Ye.get(r); + a ? lr(a.declarations, (l) => { + Fx(l) || Aa.add(sn(l, p.Declaration_name_conflicts_with_built_in_global_identifier_0, Si(r))); + }) : Ye.set(r, ne); + } + function Pn(r) { + if (r.flags & 33554432) return r.links; + const a = Xs(r); + return wk[a] ?? (wk[a] = new U1e()); + } + function xn(r) { + const a = Ma(r); + return Av[a] || (Av[a] = new NRe()); + } + function Xl(r, a, l) { + if (l) { + const f = Oa(r.get(a)); + if (f && (f.flags & l || f.flags & 2097152 && O_(f) & l)) + return f; + } + } + function sT(r, a) { + const l = r.parent, f = r.parent.parent, d = Xl( + l.locals, + a, + 111551 + /* Value */ + ), y = Xl( + dg(f.symbol), + a, + 111551 + /* Value */ + ); + return d && y ? [d, y] : E.fail("There should exist two symbols, one as property declaration and one as parameter declaration"); + } + function qh(r, a) { + const l = xr(r), f = xr(a), d = Dd(r); + if (l !== f) { + if (B && (l.externalModuleIndicator || f.externalModuleIndicator) || !F.outFile || Tx(a) || r.flags & 33554432 || x(a, r)) + return !0; + const z = e.getSourceFiles(); + return z.indexOf(l) <= z.indexOf(f); + } + if (a.flags & 16777216 || Tx(a) || ode(a)) + return !0; + if (r.pos <= a.pos && !(os(r) && A3(a.parent) && !r.initializer && !r.exclamationToken)) { + if (r.kind === 209) { + const z = Q1( + a, + 209 + /* BindingElement */ + ); + return z ? dr(z, ya) !== dr(r, ya) || r.pos < z.pos : qh(Q1( + r, + 261 + /* VariableDeclaration */ + ), a); + } else { + if (r.kind === 261) + return !y(r, a); + if ($n(r)) { + const z = dr(a, (G) => G === r ? "quit" : Gs(G) ? G.parent.parent === r : !U && ul(G) && (G.parent === r || rc(G.parent) && G.parent.parent === r || a3(G.parent) && G.parent.parent === r || os(G.parent) && G.parent.parent === r || Ii(G.parent) && G.parent.parent.parent === r)); + return z ? !U && ul(z) ? !!dr(a, (G) => G === z ? "quit" : Es(G) && !q1(G)) : !1 : !0; + } else { + if (os(r)) + return !J( + r, + a, + /*stopAtAnyPropertyDeclaration*/ + !1 + ); + if (K_(r, r.parent)) + return !(W && Wl(r) === Wl(a) && x(a, r)); + } + } + return !0; + } + if (a.parent.kind === 282 || a.parent.kind === 278 && a.parent.isExportEquals || a.kind === 278 && a.isExportEquals) + return !0; + if (x(a, r)) + return W && Wl(r) && (os(r) || K_(r, r.parent)) ? !J( + r, + a, + /*stopAtAnyPropertyDeclaration*/ + !0 + ) : !0; + return !1; + function y(z, G) { + switch (z.parent.parent.kind) { + case 244: + case 249: + case 251: + if (md(G, z, d)) + return !0; + break; + } + const ve = z.parent.parent; + return nS(ve) && md(G, ve.expression, d); + } + function x(z, G) { + return I(z, G); + } + function I(z, G) { + return !!dr(z, (ve) => { + if (ve === d) + return "quit"; + if (Es(ve)) + return !q1(ve); + if (kc(ve)) + return G.pos < z.pos; + const de = Bn(ve.parent, os); + if (de && de.initializer === ve) { + if (Js(ve.parent)) { + if (G.kind === 175) + return !0; + if (os(G) && Wl(z) === Wl(G)) { + const gt = G.name; + if (Me(gt) || Ai(gt)) { + const jt = Yr(yn(G)), ar = kn(G.parent.members, kc); + if (Rut(gt, jt, ar, G.parent.pos, ve.pos)) + return !0; + } + } + } else if (!(G.kind === 173 && !Js(G)) || Wl(z) !== Wl(G)) + return !0; + } + const We = Bn(ve.parent, ul); + if (We && We.expression === ve) { + if (Ii(We.parent)) + return I(We.parent.parent.parent, G) ? !0 : "quit"; + if (rc(We.parent)) + return I(We.parent.parent, G) ? !0 : "quit"; + } + return !1; + }); + } + function J(z, G, ve) { + return G.end > z.end ? !1 : dr(G, (We) => { + if (We === z) + return "quit"; + switch (We.kind) { + case 220: + return !0; + case 173: + return ve && (os(z) && We.parent === z.parent || K_(z, z.parent) && We.parent === z.parent.parent) ? "quit" : !0; + case 242: + switch (We.parent.kind) { + case 178: + case 175: + case 179: + return !0; + default: + return !1; + } + default: + return !1; + } + }) === void 0; + } + } + function S2(r) { + return xn(r).declarationRequiresScopeChange; + } + function yE(r, a) { + xn(r).declarationRequiresScopeChange = a; + } + function Gw(r, a, l, f) { + return W ? !1 : (r && !f && aT(r, a, a) || ze( + r, + r && l.type && KP(l.type, r.pos) ? p.Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor : p.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, + co(l.name), + U_(a) + ), !0); + } + function bn(r, a, l, f) { + const d = gs(a) ? a : a.escapedText; + n(() => { + if (!r || r.parent.kind !== 325 && !aT(r, d, a) && !u1(r) && !vE(r, d, l) && !ug(r, d) && !f1(r, d, l) && !Ud(r, d, l) && !Ik(r, d, l)) { + let y, x; + if (a && (x = Fat(a), x && ze(r, f, U_(a), x)), !x && Dk < qw && (y = X8e(r, d, l), y?.valueDeclaration && Vu(y.valueDeclaration) && $m(y.valueDeclaration) && (y = void 0), y)) { + const J = Wi(y), z = zde( + r, + y, + /*excludeClasses*/ + !1 + ), G = l === 1920 || a && typeof a != "string" && lo(a) ? p.Cannot_find_namespace_0_Did_you_mean_1 : z ? p.Could_not_find_name_0_Did_you_mean_1 : p.Cannot_find_name_0_Did_you_mean_1, ve = y2(r, G, U_(a), J); + ve.canonicalHead = uK(f, U_(a)), Qg(!z, ve), y.valueDeclaration && zs( + ve, + sn(y.valueDeclaration, p._0_is_declared_here, J) + ); + } + !y && !x && a && ze(r, f, U_(a)), Dk++; + } + }); + } + function Ku(r, a, l, f, d, y) { + n(() => { + var x; + const I = a.escapedName, J = f && Di(f) && tf(f); + if (r && (l & 2 || (l & 32 || l & 384) && (l & 111551) === 111551)) { + const z = _t(a); + (z.flags & 2 || z.flags & 32 || z.flags & 384) && qf(z, r); + } + if (J && (l & 111551) === 111551 && !(r.flags & 16777216)) { + const z = Oa(a); + wr(z.declarations) && Ni(z.declarations, (G) => zN(G) || Di(G) && !!G.symbol.globalExports) && dd(!F.allowUmdGlobalAccess, r, p._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, Si(I)); + } + if (d && !y && (l & 111551) === 111551) { + const z = Oa(XG(a)), G = _m(d); + z === yn(d) ? ze(r, p.Parameter_0_cannot_reference_itself, co(d.name)) : z.valueDeclaration && z.valueDeclaration.pos > d.pos && G.parent.locals && Xl(G.parent.locals, z.escapedName, l) === z && ze(r, p.Parameter_0_cannot_reference_identifier_1_declared_after_it, co(d.name), co(r)); + } + if (r && l & 111551 && a.flags & 2097152 && !(a.flags & 111551) && !K1(r)) { + const z = Vd( + a, + 111551 + /* Value */ + ); + if (z) { + const G = z.kind === 282 || z.kind === 279 || z.kind === 281 ? p._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type : p._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type, ve = Si(I); + fs( + ze(r, G, ve), + z, + ve + ); + } + } + if (F.isolatedModules && a && J && (l & 111551) === 111551) { + const G = Xl(Ye, I, l) === a && Di(f) && f.locals && Xl( + f.locals, + I, + -111552 + /* Value */ + ); + if (G) { + const ve = (x = G.declarations) == null ? void 0 : x.find( + (de) => de.kind === 277 || de.kind === 274 || de.kind === 275 || de.kind === 272 + /* ImportEqualsDeclaration */ + ); + ve && !NC(ve) && ze(ve, p.Import_0_conflicts_with_global_value_used_in_this_file_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled, Si(I)); + } + } + }); + } + function fs(r, a, l) { + return a ? zs( + r, + sn( + a, + a.kind === 282 || a.kind === 279 || a.kind === 281 ? p._0_was_exported_here : p._0_was_imported_here, + l + ) + ) : r; + } + function U_(r) { + return gs(r) ? Si(r) : co(r); + } + function aT(r, a, l) { + if (!Me(r) || r.escapedText !== a || Z7e(r) || Tx(r)) + return !1; + const f = qu( + r, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + let d = f; + for (; d; ) { + if ($n(d.parent)) { + const y = yn(d.parent); + if (!y) + break; + const x = Yr(y); + if (Ys(x, a)) + return ze(r, p.Cannot_find_name_0_Did_you_mean_the_static_member_1_0, U_(l), Wi(y)), !0; + if (d === f && !Js(d)) { + const I = bo(y).thisType; + if (Ys(I, a)) + return ze(r, p.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0, U_(l)), !0; + } + } + d = d.parent; + } + return !1; + } + function u1(r) { + const a = fn(r); + return a && dc( + a, + 64, + /*ignoreErrors*/ + !0 + ) ? (ze(r, p.Cannot_extend_an_interface_0_Did_you_mean_implements, Qo(a)), !0) : !1; + } + function fn(r) { + switch (r.kind) { + case 80: + case 212: + return r.parent ? fn(r.parent) : void 0; + case 234: + if (to(r.expression)) + return r.expression; + // falls through + default: + return; + } + } + function vE(r, a, l) { + const f = 1920 | (an(r) ? 111551 : 0); + if (l === f) { + const d = zc(st( + r, + a, + 788968 & ~f, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + )), y = r.parent; + if (d) { + if (s_(y)) { + E.assert(y.left === r, "Should only be resolving left side of qualified name as a namespace"); + const x = y.right.escapedText; + if (Ys(bo(d), x)) + return ze( + y, + p.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1, + Si(a), + Si(x) + ), !0; + } + return ze(r, p._0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here, Si(a)), !0; + } + } + return !1; + } + function Ik(r, a, l) { + if (l & 788584) { + const f = zc(st( + r, + a, + 111127, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + )); + if (f && !(f.flags & 1920)) + return ze(r, p._0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0, Si(a)), !0; + } + return !1; + } + function Lu(r) { + return r === "any" || r === "string" || r === "number" || r === "boolean" || r === "never" || r === "unknown"; + } + function ug(r, a) { + return Lu(a) && r.parent.kind === 282 ? (ze(r, p.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, a), !0) : !1; + } + function Ud(r, a, l) { + if (l & 111551) { + if (Lu(a)) { + const y = r.parent.parent; + if (y && y.parent && cf(y)) { + const x = y.token; + y.parent.kind === 265 && x === 96 ? ze(r, p.An_interface_cannot_extend_a_primitive_type_like_0_It_can_only_extend_other_named_object_types, Si(a)) : $n(y.parent) && x === 96 ? ze(r, p.A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values, Si(a)) : $n(y.parent) && x === 119 && ze(r, p.A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types, Si(a)); + } else + ze(r, p._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, Si(a)); + return !0; + } + const f = zc(st( + r, + a, + 788544, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + )), d = f && O_(f); + if (f && d !== void 0 && !(d & 111551)) { + const y = Si(a); + return oT(a) ? ze(r, p._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later, y) : _1(r, f) ? ze(r, p._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0, y, y === "K" ? "P" : "K") : ze(r, p._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, y), !0; + } + } + return !1; + } + function _1(r, a) { + const l = dr(r.parent, (f) => Gs(f) || $u(f) ? !1 : a_(f) || "quit"); + if (l && l.members.length === 1) { + const f = bo(a); + return !!(f.flags & 1048576) && AI( + f, + 384, + /*strict*/ + !0 + ); + } + return !1; + } + function oT(r) { + switch (r) { + case "Promise": + case "Symbol": + case "Map": + case "WeakMap": + case "Set": + case "WeakSet": + return !0; + } + return !1; + } + function f1(r, a, l) { + if (l & 111127) { + if (zc(st( + r, + a, + 1024, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + ))) + return ze( + r, + p.Cannot_use_namespace_0_as_a_value, + Si(a) + ), !0; + } else if (l & 788544 && zc(st( + r, + a, + 1536, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + ))) + return ze(r, p.Cannot_use_namespace_0_as_a_type, Si(a)), !0; + return !1; + } + function qf(r, a) { + var l; + if (E.assert(!!(r.flags & 2 || r.flags & 32 || r.flags & 384)), r.flags & 67108881 && r.flags & 32) + return; + const f = (l = r.declarations) == null ? void 0 : l.find( + (d) => cB(d) || $n(d) || d.kind === 267 + /* EnumDeclaration */ + ); + if (f === void 0) return E.fail("checkResolvedBlockScopedVariable could not find block-scoped declaration"); + if (!(f.flags & 33554432) && !qh(f, a)) { + let d; + const y = co(_s(f)); + r.flags & 2 ? d = ze(a, p.Block_scoped_variable_0_used_before_its_declaration, y) : r.flags & 32 ? d = ze(a, p.Class_0_used_before_its_declaration, y) : r.flags & 256 ? d = ze(a, p.Enum_0_used_before_its_declaration, y) : (E.assert(!!(r.flags & 128)), zp(F) && (d = ze(a, p.Enum_0_used_before_its_declaration, y))), d && zs(d, sn(f, p._0_is_declared_here, y)); + } + } + function md(r, a, l) { + return !!a && !!dr(r, (f) => f === a || (f === l || Es(f) && (!q1(f) || Mc(f) & 3) ? "quit" : !1)); + } + function bp(r) { + switch (r.kind) { + case 272: + return r; + case 274: + return r.parent; + case 275: + return r.parent.parent; + case 277: + return r.parent.parent.parent; + default: + return; + } + } + function F_(r) { + return r.declarations && gb(r.declarations, U0); + } + function U0(r) { + return r.kind === 272 || r.kind === 271 || r.kind === 274 && !!r.name || r.kind === 275 || r.kind === 281 || r.kind === 277 || r.kind === 282 || r.kind === 278 && Q3(r) || _n(r) && Ac(r) === 2 && Q3(r) || To(r) && _n(r.parent) && r.parent.left === r && r.parent.operatorToken.kind === 64 && Jv(r.parent.right) || r.kind === 305 || r.kind === 304 && Jv(r.initializer) || r.kind === 261 && Ab(r) || r.kind === 209 && Ab(r.parent.parent); + } + function Jv(r) { + return m5(r) || yo(r) && zm(r); + } + function Fk(r, a) { + const l = Mk(r); + if (l) { + const d = r6(l.expression).arguments[0]; + return Me(l.name) ? zc(Ys(k3e(d), l.name.escapedText)) : void 0; + } + if (ei(r) || r.moduleReference.kind === 284) { + const d = Mu( + r, + CB(r) || jD(r) + ), y = q_(d); + if (y && 102 <= B && B <= 199) { + const x = T2(y, "module.exports", r, a); + if (x) + return x; + } + return Sp( + r, + d, + y, + /*overwriteEmpty*/ + !1 + ), y; + } + const f = h1(r.moduleReference, a); + return zv(r, f), f; + } + function zv(r, a) { + if (Sp( + r, + /*immediateTarget*/ + void 0, + a, + /*overwriteEmpty*/ + !1 + ) && !r.isTypeOnly) { + const l = Vd(yn(r)), f = l.kind === 282 || l.kind === 279, d = f ? p.An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type : p.An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type, y = f ? p._0_was_exported_here : p._0_was_imported_here, x = l.kind === 279 ? "*" : Iy(l.name); + zs(ze(r.moduleReference, d), sn(l, y, x)); + } + } + function p1(r, a, l, f) { + const d = r.exports.get( + "export=" + /* ExportEquals */ + ), y = d ? Ys( + Yr(d), + a, + /*skipObjectFunctionPropertyAugment*/ + !0 + ) : r.exports.get(a), x = zc(y, f); + return Sp( + l, + y, + x, + /*overwriteEmpty*/ + !1 + ), x; + } + function Ok(r) { + return Mo(r) && !r.isExportEquals || Gn( + r, + 2048 + /* Default */ + ) || Nu(r) || Km(r); + } + function Hh(r) { + return ja(r) ? e.getEmitSyntaxForUsageLocation(xr(r), r) : void 0; + } + function Fm(r, a) { + return r === 99 && a === 1; + } + function d1(r, a) { + if (100 <= B && B <= 199 && Hh(r) === 99) { + a ?? (a = Mu( + r, + r, + /*ignoreErrors*/ + !0 + )); + const f = a && y3(a); + return f && (ap(f) || qF(f.fileName) === ".d.json.ts"); + } + return !1; + } + function Wv(r, a, l, f) { + const d = r && Hh(f); + if (r && d !== void 0) { + const y = e.getImpliedNodeFormatForEmit(r); + if (d === 99 && y === 1 && 100 <= B && B <= 199) + return !0; + if (d === 99 && y === 99) + return !1; + } + if (!_e) + return !1; + if (!r || r.isDeclarationFile) { + const y = p1( + a, + "default", + /*sourceNode*/ + void 0, + /*dontResolveAlias*/ + !0 + ); + return !(y && ot(y.declarations, Ok) || p1( + a, + tc("__esModule"), + /*sourceNode*/ + void 0, + l + )); + } + return n_(r) ? typeof r.externalModuleIndicator != "object" && !p1( + a, + tc("__esModule"), + /*sourceNode*/ + void 0, + l + ) : hd(a); + } + function V0(r, a) { + const l = Mu(r, r.parent.moduleSpecifier); + if (l) + return m1(l, r, a); + } + function m1(r, a, l) { + var f; + const d = (f = r.declarations) == null ? void 0 : f.find(Di), y = gd(a); + let x, I; + if (S3(r)) + x = r; + else if (d && y && 102 <= B && B <= 199 && Hh(y) === 1 && e.getImpliedNodeFormatForEmit(d) === 99 && (I = p1(r, "module.exports", a, l))) { + if (!mm(F)) { + ze(a.name, p.Module_0_can_only_be_default_imported_using_the_1_flag, Wi(r), "esModuleInterop"); + return; + } + return Sp( + a, + I, + /*finalTarget*/ + void 0, + /*overwriteEmpty*/ + !1 + ), I; + } else + x = p1(r, "default", a, l); + if (!y) + return x; + const J = d1(y, r), z = Wv(d, r, l, y); + if (!x && !z && !J) + if (hd(r) && !_e) { + const G = B >= 5 ? "allowSyntheticDefaultImports" : "esModuleInterop", de = r.exports.get( + "export=" + /* ExportEquals */ + ).valueDeclaration, We = ze(a.name, p.Module_0_can_only_be_default_imported_using_the_1_flag, Wi(r), G); + de && zs( + We, + sn( + de, + p.This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag, + G + ) + ); + } else ld(a) ? Gh(r, a) : cT(r, r, a, Cy(a) && a.propertyName || a.name); + else if (z || J) { + const G = q_(r, l) || zc(r, l); + return Sp( + a, + r, + G, + /*overwriteEmpty*/ + !1 + ), G; + } + return Sp( + a, + x, + /*finalTarget*/ + void 0, + /*overwriteEmpty*/ + !1 + ), x; + } + function gd(r) { + switch (r.kind) { + case 274: + return r.parent.moduleSpecifier; + case 272: + return wh(r.moduleReference) ? r.moduleReference.expression : void 0; + case 275: + return r.parent.parent.moduleSpecifier; + case 277: + return r.parent.parent.parent.moduleSpecifier; + case 282: + return r.parent.parent.moduleSpecifier; + default: + return E.assertNever(r); + } + } + function Gh(r, a) { + var l, f, d; + if ((l = r.exports) != null && l.has(a.symbol.escapedName)) + ze( + a.name, + p.Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead, + Wi(r), + Wi(a.symbol) + ); + else { + const y = ze(a.name, p.Module_0_has_no_default_export, Wi(r)), x = (f = r.exports) == null ? void 0 : f.get( + "__export" + /* ExportStar */ + ); + if (x) { + const I = (d = x.declarations) == null ? void 0 : d.find( + (J) => { + var z, G; + return !!(Bc(J) && J.moduleSpecifier && ((G = (z = Mu(J, J.moduleSpecifier)) == null ? void 0 : z.exports) != null && G.has( + "default" + /* Default */ + ))); + } + ); + I && zs(y, sn(I, p.export_Asterisk_does_not_re_export_a_default)); + } + } + } + function Zg(r, a) { + const l = r.parent.parent.moduleSpecifier, f = Mu(r, l), d = th( + f, + l, + a, + /*suppressInteropError*/ + !1 + ); + return Sp( + r, + f, + d, + /*overwriteEmpty*/ + !1 + ), d; + } + function g1(r, a) { + const l = r.parent.moduleSpecifier, f = l && Mu(r, l), d = l && th( + f, + l, + a, + /*suppressInteropError*/ + !1 + ); + return Sp( + r, + f, + d, + /*overwriteEmpty*/ + !1 + ), d; + } + function Ml(r, a) { + if (r === Y && a === Y) + return Y; + if (r.flags & 790504) + return r; + const l = ga(r.flags | a.flags, r.escapedName); + return E.assert(r.declarations || a.declarations), l.declarations = hb(Bi(r.declarations, a.declarations), gy), l.parent = r.parent || a.parent, r.valueDeclaration && (l.valueDeclaration = r.valueDeclaration), a.members && (l.members = new Map(a.members)), r.exports && (l.exports = new Map(r.exports)), l; + } + function T2(r, a, l, f) { + var d; + if (r.flags & 1536) { + const y = gf(r).get(a), x = zc(y, f), I = (d = Pn(r).typeOnlyExportStarMap) == null ? void 0 : d.get(a); + return Sp( + l, + y, + x, + /*overwriteEmpty*/ + !1, + I, + a + ), x; + } + } + function Kg(r, a) { + if (r.flags & 3) { + const l = r.valueDeclaration.type; + if (l) + return zc(Ys(Ci(l), a)); + } + } + function Uv(r, a, l = !1) { + var f; + const d = CB(r) || r.moduleSpecifier, y = Mu(r, d), x = !wn(a) && a.propertyName || a.name; + if (!Me(x) && x.kind !== 11) + return; + const I = wb(x), z = th( + y, + d, + /*dontResolveAlias*/ + !1, + I === "default" && _e + ); + if (z && (I || x.kind === 11)) { + if (S3(y)) + return y; + let G; + y && y.exports && y.exports.get( + "export=" + /* ExportEquals */ + ) ? G = Ys( + Yr(z), + I, + /*skipObjectFunctionPropertyAugment*/ + !0 + ) : G = Kg(z, I), G = zc(G, l); + let ve = T2(z, I, a, l); + if (ve === void 0 && I === "default") { + const We = (f = y.declarations) == null ? void 0 : f.find(Di); + (d1(d, y) || Wv(We, y, l, d)) && (ve = q_(y, l) || zc(y, l)); + } + const de = ve && G && ve !== G ? Ml(G, ve) : ve || G; + return Cy(a) && d1(d, y) && I !== "default" ? ze(x, p.Named_imports_from_a_JSON_file_into_an_ECMAScript_module_are_not_allowed_when_module_is_set_to_0, TC[B]) : de || cT(y, z, r, x), de; + } + } + function cT(r, a, l, f) { + var d; + const y = q0(r, l), x = co(f), I = Me(f) ? Vde(f, a) : void 0; + if (I !== void 0) { + const J = Wi(I), z = ze(f, p._0_has_no_exported_member_named_1_Did_you_mean_2, y, x, J); + I.valueDeclaration && zs(z, sn(I.valueDeclaration, p._0_is_declared_here, J)); + } else + (d = r.exports) != null && d.has( + "default" + /* Default */ + ) ? ze( + f, + p.Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead, + y, + x + ) : eh(l, f, x, r, y); + } + function eh(r, a, l, f, d) { + var y, x; + const I = (x = (y = Bn(f.valueDeclaration, qm)) == null ? void 0 : y.locals) == null ? void 0 : x.get(wb(a)), J = f.exports; + if (I) { + const z = J?.get( + "export=" + /* ExportEquals */ + ); + if (z) + le(z, I) ? bE(r, a, l, d) : ze(a, p.Module_0_has_no_exported_member_1, d, l); + else { + const G = J ? Nn(qfe(J), (de) => !!le(de, I)) : void 0, ve = G ? ze(a, p.Module_0_declares_1_locally_but_it_is_exported_as_2, d, l, Wi(G)) : ze(a, p.Module_0_declares_1_locally_but_it_is_not_exported, d, l); + I.declarations && zs(ve, ...hr(I.declarations, (de, We) => sn(de, We === 0 ? p._0_is_declared_here : p.and_here, l))); + } + } else + ze(a, p.Module_0_has_no_exported_member_1, d, l); + } + function bE(r, a, l, f) { + if (B >= 5) { + const d = mm(F) ? p._0_can_only_be_imported_by_using_a_default_import : p._0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import; + ze(a, d, l); + } else if (an(r)) { + const d = mm(F) ? p._0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import : p._0_can_only_be_imported_by_using_a_require_call_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import; + ze(a, d, l); + } else { + const d = mm(F) ? p._0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import : p._0_can_only_be_imported_by_using_import_1_require_2_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import; + ze(a, d, l, l, f); + } + } + function Lk(r, a) { + if (Xu(r) && Gm(r.propertyName || r.name)) { + const x = gd(r), I = x && Mu(r, x); + if (I) + return m1(I, r, a); + } + const l = ya(r) ? _m(r) : r.parent.parent.parent, f = Mk(l), d = Uv(l, f || r, a), y = r.propertyName || r.name; + return f && d && Me(y) ? zc(Ys(Yr(d), y.escapedText), a) : (Sp( + r, + /*immediateTarget*/ + void 0, + d, + /*overwriteEmpty*/ + !1 + ), d); + } + function Mk(r) { + if (ei(r) && r.initializer && wn(r.initializer)) + return r.initializer; + } + function $w(r, a) { + if (Ed(r.parent)) { + const l = q_(r.parent.symbol, a); + return Sp( + r, + /*immediateTarget*/ + void 0, + l, + /*overwriteEmpty*/ + !1 + ), l; + } + } + function Rk(r, a, l) { + const f = r.propertyName || r.name; + if (Gm(f)) { + const y = gd(r), x = y && Mu(r, y); + if (x) + return m1(x, r, !!l); + } + const d = r.parent.parent.moduleSpecifier ? Uv(r.parent.parent, r, l) : f.kind === 11 ? void 0 : ( + // Skip for invalid syntax like this: export { "x" } + dc( + f, + a, + /*ignoreErrors*/ + !1, + l + ) + ); + return Sp( + r, + /*immediateTarget*/ + void 0, + d, + /*overwriteEmpty*/ + !1 + ), d; + } + function Vv(r, a) { + const l = Mo(r) ? r.expression : r.right, f = $h(l, a); + return Sp( + r, + /*immediateTarget*/ + void 0, + f, + /*overwriteEmpty*/ + !1 + ), f; + } + function $h(r, a) { + if (Rc(r)) + return mc(r).symbol; + if (!r_(r) && !to(r)) + return; + const l = dc( + r, + 901119, + /*ignoreErrors*/ + !0, + a + ); + return l || (mc(r), xn(r).resolvedSymbol); + } + function SE(r, a) { + if (_n(r.parent) && r.parent.left === r && r.parent.operatorToken.kind === 64) + return $h(r.parent.right, a); + } + function qv(r, a = !1) { + switch (r.kind) { + case 272: + case 261: + return Fk(r, a); + case 274: + return V0(r, a); + case 275: + return Zg(r, a); + case 281: + return g1(r, a); + case 277: + case 209: + return Lk(r, a); + case 282: + return Rk(r, 901119, a); + case 278: + case 227: + return Vv(r, a); + case 271: + return $w(r, a); + case 305: + return dc( + r.name, + 901119, + /*ignoreErrors*/ + !0, + a + ); + case 304: + return $h(r.initializer, a); + case 213: + case 212: + return SE(r, a); + default: + return E.fail(); + } + } + function lT(r, a = 901119) { + return r ? (r.flags & (2097152 | a)) === 2097152 || !!(r.flags & 2097152 && r.flags & 67108864) : !1; + } + function zc(r, a) { + return !a && lT(r) ? Rl(r) : r; + } + function Rl(r) { + E.assert((r.flags & 2097152) !== 0, "Should only get Alias here."); + const a = Pn(r); + if (a.aliasTarget) + a.aliasTarget === Ae && (a.aliasTarget = Y); + else { + a.aliasTarget = Ae; + const l = F_(r); + if (!l) return E.fail(); + const f = qv(l); + a.aliasTarget === Ae ? a.aliasTarget = f || Y : ze(l, p.Circular_definition_of_import_alias_0, Wi(r)); + } + return a.aliasTarget; + } + function jk(r) { + if (Pn(r).aliasTarget !== Ae) + return Rl(r); + } + function O_(r, a, l) { + const f = a && Vd(r), d = f && Bc(f), y = f && (d ? Mu( + f.moduleSpecifier, + f.moduleSpecifier, + /*ignoreErrors*/ + !0 + ) : Rl(f.symbol)), x = d && y ? Om(y) : void 0; + let I = l ? 0 : r.flags, J; + for (; r.flags & 2097152; ) { + const z = _t(Rl(r)); + if (!d && z === y || x?.get(z.escapedName) === z) + break; + if (z === Y) + return -1; + if (z === r || J?.has(z)) + break; + z.flags & 2097152 && (J ? J.add(z) : J = /* @__PURE__ */ new Set([r, z])), I |= z.flags, r = z; + } + return I; + } + function Sp(r, a, l, f, d, y) { + if (!r || wn(r)) return !1; + const x = yn(r); + if (p0(r)) { + const J = Pn(x); + return J.typeOnlyDeclaration = r, !0; + } + if (d) { + const J = Pn(x); + return J.typeOnlyDeclaration = d, x.escapedName !== y && (J.typeOnlyExportStarName = y), !0; + } + const I = Pn(x); + return x2(I, a, f) || x2(I, l, f); + } + function x2(r, a, l) { + var f; + if (a && (r.typeOnlyDeclaration === void 0 || l && r.typeOnlyDeclaration === !1)) { + const d = ((f = a.exports) == null ? void 0 : f.get( + "export=" + /* ExportEquals */ + )) ?? a, y = d.declarations && Nn(d.declarations, p0); + r.typeOnlyDeclaration = y ?? Pn(d).typeOnlyDeclaration ?? !1; + } + return !!r.typeOnlyDeclaration; + } + function Vd(r, a) { + var l; + if (!(r.flags & 2097152)) + return; + const f = Pn(r); + if (f.typeOnlyDeclaration === void 0) { + f.typeOnlyDeclaration = !1; + const d = zc(r); + Sp( + (l = r.declarations) == null ? void 0 : l[0], + F_(r) && tX(r), + d, + /*overwriteEmpty*/ + !0 + ); + } + if (a === void 0) + return f.typeOnlyDeclaration || void 0; + if (f.typeOnlyDeclaration) { + const d = f.typeOnlyDeclaration.kind === 279 ? zc(Om(f.typeOnlyDeclaration.symbol.parent).get(f.typeOnlyExportStarName || r.escapedName)) : Rl(f.typeOnlyDeclaration.symbol); + return O_(d) & a ? f.typeOnlyDeclaration : void 0; + } + } + function h1(r, a) { + return r.kind === 80 && r4(r) && (r = r.parent), r.kind === 80 || r.parent.kind === 167 ? dc( + r, + 1920, + /*ignoreErrors*/ + !1, + a + ) : (E.assert( + r.parent.kind === 272 + /* ImportEqualsDeclaration */ + ), dc( + r, + 901119, + /*ignoreErrors*/ + !1, + a + )); + } + function q0(r, a) { + return r.parent ? q0(r.parent, a) + "." + Wi(r) : Wi( + r, + a, + /*meaning*/ + void 0, + 36 + /* AllowAnyNodeKind */ + ); + } + function Bk(r) { + for (; s_(r.parent); ) + r = r.parent; + return r; + } + function Xw(r) { + let a = i_(r), l = st( + a, + a, + 111551, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !0 + ); + if (l) { + for (; s_(a.parent); ) { + const f = Yr(l); + if (l = Ys(f, a.parent.right.escapedText), !l) + return; + a = a.parent; + } + return l; + } + } + function dc(r, a, l, f, d) { + if (lc(r)) + return; + const y = 1920 | (an(r) ? a & 111551 : 0); + let x; + if (r.kind === 80) { + const I = a === y || lo(r) ? p.Cannot_find_namespace_0 : kAe(i_(r)), J = an(r) && !lo(r) ? TE(r, a) : void 0; + if (x = Oa(st( + d || r, + r, + a, + l || J ? void 0 : I, + /*isUse*/ + !0, + /*excludeGlobals*/ + !1 + )), !x) + return Oa(J); + } else if (r.kind === 167 || r.kind === 212) { + const I = r.kind === 167 ? r.left : r.expression, J = r.kind === 167 ? r.right : r.name; + let z = dc( + I, + y, + l, + /*dontResolveAlias*/ + !1, + d + ); + if (!z || lc(J)) + return; + if (z === Y) + return z; + if (z.valueDeclaration && an(z.valueDeclaration) && Pu(F) !== 100 && ei(z.valueDeclaration) && z.valueDeclaration.initializer && bIe(z.valueDeclaration.initializer)) { + const G = z.valueDeclaration.initializer.arguments[0], ve = Mu(G, G); + if (ve) { + const de = q_(ve); + de && (z = de); + } + } + if (x = Oa(Xl(gf(z), J.escapedText, a)), !x && z.flags & 2097152 && (x = Oa(Xl(gf(Rl(z)), J.escapedText, a))), !x) { + if (!l) { + const G = q0(z), ve = co(J), de = Vde(J, z); + if (de) { + ze(J, p._0_has_no_exported_member_named_1_Did_you_mean_2, G, ve, Wi(de)); + return; + } + const We = s_(r) && Bk(r); + if (Ot && a & 788968 && We && !p6(We.parent) && Xw(We)) { + ze( + We, + p._0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0, + ef(We) + ); + return; + } + if (a & 1920 && s_(r.parent)) { + const gt = Oa(Xl( + gf(z), + J.escapedText, + 788968 + /* Type */ + )); + if (gt) { + ze( + r.parent.right, + p.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1, + Wi(gt), + Si(r.parent.right.escapedText) + ); + return; + } + } + ze(J, p.Namespace_0_has_no_exported_member_1, G, ve); + } + return; + } + } else + E.assertNever(r, "Unknown entity name kind."); + return !lo(r) && r_(r) && (x.flags & 2097152 || r.parent.kind === 278) && Sp( + LB(r), + x, + /*finalTarget*/ + void 0, + /*overwriteEmpty*/ + !0 + ), x.flags & a || f ? x : Rl(x); + } + function TE(r, a) { + if (o$(r.parent)) { + const l = uT(r.parent); + if (l) + return st( + l, + r, + a, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !0 + ); + } + } + function uT(r) { + if (dr(r, (d) => FC(d) || d.flags & 16777216 ? jp(d) : "quit")) + return; + const l = Fb(r); + if (l && Al(l) && W3(l.expression)) { + const d = yn(l.expression.left); + if (d) + return k2(d); + } + if (l && yo(l) && W3(l.parent) && Al(l.parent.parent)) { + const d = yn(l.parent.left); + if (d) + return k2(d); + } + if (l && (Rp(l) || rl(l)) && _n(l.parent.parent) && Ac(l.parent.parent) === 6) { + const d = yn(l.parent.parent.left); + if (d) + return k2(d); + } + const f = X1(r); + if (f && Es(f)) { + const d = yn(f); + return d && d.valueDeclaration; + } + } + function k2(r) { + const a = r.parent.valueDeclaration; + return a ? (JD(a) ? mx(a) : iS(a) ? zD(a) : void 0) || a : void 0; + } + function Jk(r) { + const a = r.valueDeclaration; + if (!a || !an(a) || r.flags & 524288 || G1( + a, + /*isPrototypeAssignment*/ + !1 + )) + return; + const l = ei(a) ? zD(a) : mx(a); + if (l) { + const f = Hf(l); + if (f) + return eme(f, r); + } + } + function Mu(r, a, l) { + const d = Pu(F) === 1 ? p.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option : p.Cannot_find_module_0_or_its_corresponding_type_declarations; + return V_(r, a, l ? void 0 : d, l); + } + function V_(r, a, l, f = !1, d = !1) { + return ja(a) ? _T(r, a.text, l, f ? void 0 : a, d) : void 0; + } + function _T(r, a, l, f, d = !1) { + var y, x, I, J, z, G, ve, de, We, lt, gt, jt; + if (f && Ui(a, "@types/")) { + const bi = p.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1, ks = nD(a, "@types/"); + ze(f, bi, ks, a); + } + const ar = x3e( + a, + /*withAugmentations*/ + !0 + ); + if (ar) + return ar; + const jr = xr(r), Kr = ja(r) ? r : ((y = jc(r) ? r : r.parent && jc(r.parent) && r.parent.name === r ? r.parent : void 0) == null ? void 0 : y.name) || ((x = bh(r) ? r : void 0) == null ? void 0 : x.argument.literal) || (ei(r) && r.initializer && x_( + r.initializer, + /*requireStringLiteralLikeArgument*/ + !0 + ) ? r.initializer.arguments[0] : void 0) || ((I = dr(r, T_)) == null ? void 0 : I.arguments[0]) || ((J = dr(r, Q_(qo, xm, Bc))) == null ? void 0 : J.moduleSpecifier) || ((z = dr(r, H1)) == null ? void 0 : z.moduleReference.expression), or = Kr && ja(Kr) ? e.getModeForUsageLocation(jr, Kr) : e.getDefaultResolutionModeForFile(jr), ir = Pu(F), nn = (G = e.getResolvedModule(jr, a, or)) == null ? void 0 : G.resolvedModule, Qn = f && nn && TU(F, nn, jr), Ri = nn && (!Qn || Qn === p.Module_0_was_resolved_to_1_but_jsx_is_not_set) && e.getSourceFile(nn.resolvedFileName); + if (Ri) { + if (Qn && ze(f, Qn, a, nn.resolvedFileName), nn.resolvedUsingTsExtension && Il(a)) { + const bi = ((ve = dr(r, qo)) == null ? void 0 : ve.importClause) || dr(r, Q_(_l, Bc)); + (f && bi && !bi.isTypeOnly || dr(r, T_)) && ze( + f, + p.A_declaration_file_cannot_be_imported_without_import_type_Did_you_mean_to_import_an_implementation_file_0_instead, + zn(E.checkDefined(O5(a))) + ); + } else if (nn.resolvedUsingTsExtension && !O6(F, jr.fileName)) { + const bi = ((de = dr(r, qo)) == null ? void 0 : de.importClause) || dr(r, Q_(_l, Bc)); + if (f && !(bi?.isTypeOnly || dr(r, ym))) { + const ks = E.checkDefined(O5(a)); + ze(f, p.An_import_path_can_only_end_with_a_0_extension_when_allowImportingTsExtensions_is_enabled, ks); + } + } else if (F.rewriteRelativeImportExtensions && !(r.flags & 33554432) && !Il(a) && !bh(r) && !TZ(r)) { + const bi = V3(a, F); + if (!nn.resolvedUsingTsExtension && bi) + ze( + f, + p.This_relative_import_path_is_unsafe_to_rewrite_because_it_looks_like_a_file_name_but_actually_resolves_to_0, + kC(Qi(jr.fileName, e.getCurrentDirectory()), nn.resolvedFileName, xh(e)) + ); + else if (nn.resolvedUsingTsExtension && !bi && Mb(Ri, e)) + ze( + f, + p.This_import_uses_a_0_extension_to_resolve_to_an_input_TypeScript_file_but_will_not_be_rewritten_during_emit_because_it_is_not_a_relative_path, + ex(a) + ); + else if (nn.resolvedUsingTsExtension && bi) { + const ks = (We = e.getRedirectFromSourceFile(Ri.path)) == null ? void 0 : We.resolvedRef; + if (ks) { + const Ua = !e.useCaseSensitiveFileNames(), Vi = e.getCommonSourceDirectory(), jo = JS(ks.commandLine, Ua), Sc = Nf(Vi, jo, Ua), Bu = Nf(F.outDir || Vi, ks.commandLine.options.outDir || jo, Ua); + Sc !== Bu && ze( + f, + p.This_import_path_is_unsafe_to_rewrite_because_it_resolves_to_another_project_and_the_relative_path_between_the_projects_output_files_is_not_the_same_as_the_relative_path_between_its_input_files + ); + } + } + } + if (Ri.symbol) { + if (f && nn.isExternalLibraryImport && !f4(nn.extension) && Hv( + /*isError*/ + !1, + f, + jr, + or, + nn, + a + ), f && (B === 100 || B === 101)) { + const bi = jr.impliedNodeFormat === 1 && !dr(r, T_) || !!dr(r, _l), ks = dr(r, (Ua) => ym(Ua) || Bc(Ua) || qo(Ua) || xm(Ua)); + if (bi && Ri.impliedNodeFormat === 99 && !ete(ks)) + if (dr(r, _l)) + ze(f, p.Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_with_require_Use_an_ECMAScript_import_instead, a); + else { + let Ua; + const Vi = Jg(jr.fileName); + (Vi === ".ts" || Vi === ".js" || Vi === ".tsx" || Vi === ".jsx") && (Ua = rB(jr)); + const jo = ks?.kind === 273 && ((lt = ks.importClause) != null && lt.isTypeOnly) ? p.Type_only_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute : ks?.kind === 206 ? p.Type_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute : p.The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_referenced_file_is_an_ECMAScript_module_and_cannot_be_imported_with_require_Consider_writing_a_dynamic_import_0_call_instead; + Aa.add(Fg( + xr(f), + f, + Ts(Ua, jo, a) + )); + } + } + return Oa(Ri.symbol); + } + f && l && !$J(f) && ze(f, p.File_0_is_not_a_module, Ri.fileName); + return; + } + if (P_) { + const bi = VR(P_, (ks) => ks.pattern, a); + if (bi) { + const ks = Ie && Ie.get(a); + return Oa(ks || bi.symbol); + } + } + if (!f) + return; + if (nn && !f4(nn.extension) && Qn === void 0 || Qn === p.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type) { + if (d) { + const bi = p.Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented; + ze(f, bi, a, nn.resolvedFileName); + } else + Hv( + /*isError*/ + fe && !!l, + f, + jr, + or, + nn, + a + ); + return; + } + if (l) { + if (nn) { + const bi = e.getRedirectFromSourceFile(nn.resolvedFileName); + if (bi?.outputDts) { + ze(f, p.Output_file_0_has_not_been_built_from_source_file_1, bi.outputDts, nn.resolvedFileName); + return; + } + } + if (Qn) + ze(f, Qn, a, nn.resolvedFileName); + else { + const bi = xf(a) && !xC(a), ks = ir === 3 || ir === 99; + if (!zb(F) && Xo( + a, + ".json" + /* Json */ + ) && ir !== 1 && V5(F)) + ze(f, p.Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension, a); + else if (or === 99 && ks && bi) { + const Ua = Qi(a, Hn(jr.path)), Vi = (gt = Yu.find(([jo, Sc]) => e.fileExists(Ua + jo))) == null ? void 0 : gt[1]; + Vi ? ze(f, p.Relative_import_paths_need_explicit_file_extensions_in_ECMAScript_imports_when_moduleResolution_is_node16_or_nodenext_Did_you_mean_0, a + Vi) : ze(f, p.Relative_import_paths_need_explicit_file_extensions_in_ECMAScript_imports_when_moduleResolution_is_node16_or_nodenext_Consider_adding_an_extension_to_the_import_path); + } else if ((jt = e.getResolvedModule(jr, a, or)) != null && jt.alternateResult) { + const Ua = J7(jr, e, a, or, a); + dd( + /*isError*/ + !0, + f, + Ts(Ua, l, a) + ); + } else + ze(f, l, a); + } + } + return; + function zn(bi) { + const ks = TN(a, bi); + if (hN(B) || or === 99) { + const Ua = Il(a) && O6(F); + return ks + (bi === ".mts" || bi === ".d.mts" ? Ua ? ".mts" : ".mjs" : bi === ".cts" || bi === ".d.mts" ? Ua ? ".cts" : ".cjs" : Ua ? ".ts" : ".js"); + } + return ks; + } + } + function Hv(r, a, l, f, { packageId: d, resolvedFileName: y }, x) { + if ($J(a)) + return; + let I; + !Dl(x) && d && (I = J7(l, e, x, f, d.name)), dd( + r, + a, + Ts( + I, + p.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type, + x, + y + ) + ); + } + function q_(r, a) { + if (r?.exports) { + const l = zc(r.exports.get( + "export=" + /* ExportEquals */ + ), a), f = fT(Oa(l), Oa(r)); + return Oa(f) || r; + } + } + function fT(r, a) { + if (!r || r === Y || r === a || a.exports.size === 1 || r.flags & 2097152) + return r; + const l = Pn(r); + if (l.cjsExportMerged) + return l.cjsExportMerged; + const f = r.flags & 33554432 ? r : v2(r); + return f.flags = f.flags | 512, f.exports === void 0 && (f.exports = Bs()), a.exports.forEach((d, y) => { + y !== "export=" && f.exports.set(y, f.exports.has(y) ? vp(f.exports.get(y), d) : d); + }), f === r && (Pn(f).resolvedExports = void 0, Pn(f).resolvedMembers = void 0), Pn(f).cjsExportMerged = f, l.cjsExportMerged = f; + } + function th(r, a, l, f) { + var d; + const y = q_(r, l); + if (!l && y) { + if (!f && !(y.flags & 1539) && !Oo( + y, + 308 + /* SourceFile */ + )) { + const J = B >= 5 ? "allowSyntheticDefaultImports" : "esModuleInterop"; + return ze(a, p.This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export, J), y; + } + const x = a.parent, I = qo(x) && qC(x); + if (I || T_(x)) { + const J = T_(x) ? x.arguments[0] : x.moduleSpecifier, z = Yr(y), G = yIe(z, y, r, J); + if (G) + return pT(y, G, x); + const ve = (d = r?.declarations) == null ? void 0 : d.find(Di), de = Hh(J); + let We; + if (I && ve && 102 <= B && B <= 199 && de === 1 && e.getImpliedNodeFormatForEmit(ve) === 99 && (We = p1(y, "module.exports", I, l))) + return !f && !(y.flags & 1539) && ze(a, p.This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export, "esModuleInterop"), mm(F) && zk(z) ? pT(We, z, x) : We; + const lt = ve && Fm(de, e.getImpliedNodeFormatForEmit(ve)); + if ((mm(F) || lt) && (zk(z) || Ys( + z, + "default", + /*skipObjectFunctionPropertyAugment*/ + !0 + ) || lt)) { + const gt = z.flags & 3670016 ? vIe(z, y, r, J) : tme(y, y.parent); + return pT(y, gt, x); + } + } + } + return y; + } + function zk(r) { + return ot(rM( + r, + 0 + /* Call */ + )) || ot(rM( + r, + 1 + /* Construct */ + )); + } + function pT(r, a, l) { + const f = ga(r.flags, r.escapedName); + f.declarations = r.declarations ? r.declarations.slice() : [], f.parent = r.parent, f.links.target = r, f.links.originatingImport = l, r.valueDeclaration && (f.valueDeclaration = r.valueDeclaration), r.constEnumOnlyModule && (f.constEnumOnlyModule = !0), r.members && (f.members = new Map(r.members)), r.exports && (f.exports = new Map(r.exports)); + const d = $d(a); + return f.links.type = Ho(f, d.members, Ge, Ge, d.indexInfos), f; + } + function hd(r) { + return r.exports.get( + "export=" + /* ExportEquals */ + ) !== void 0; + } + function Wk(r) { + return qfe(Om(r)); + } + function xE(r) { + const a = Wk(r), l = q_(r); + if (l !== r) { + const f = Yr(l); + H0(f) && In(a, $a(f)); + } + return a; + } + function Uk(r, a) { + Om(r).forEach((d, y) => { + Xv(y) || a(d, y); + }); + const f = q_(r); + if (f !== r) { + const d = Yr(f); + H0(d) && Vet(d, (y, x) => { + a(y, x); + }); + } + } + function dT(r, a) { + const l = Om(a); + if (l) + return l.get(r); + } + function Vk(r, a) { + const l = dT(r, a); + if (l) + return l; + const f = q_(a); + if (f === a) + return; + const d = Yr(f); + return H0(d) ? Ys(d, r) : void 0; + } + function H0(r) { + return !(r.flags & 402784252 || Dn(r) & 1 || // `isArrayOrTupleLikeType` is too expensive to use in this auto-imports hot path + Ep(r) || Sa(r)); + } + function gf(r) { + return r.flags & 6256 ? Afe( + r, + "resolvedExports" + /* resolvedExports */ + ) : r.flags & 1536 ? Om(r) : r.exports || A; + } + function Om(r) { + const a = Pn(r); + if (!a.resolvedExports) { + const { exports: l, typeOnlyExportStarMap: f } = gT(r); + a.resolvedExports = l, a.typeOnlyExportStarMap = f; + } + return a.resolvedExports; + } + function mT(r, a, l, f) { + a && a.forEach((d, y) => { + if (y === "default") return; + const x = r.get(y); + if (!x) + r.set(y, d), l && f && l.set(y, { + specifierText: Qo(f.moduleSpecifier) + }); + else if (l && f && x && zc(x) !== zc(d)) { + const I = l.get(y); + I.exportsWithDuplicate ? I.exportsWithDuplicate.push(f) : I.exportsWithDuplicate = [f]; + } + }); + } + function gT(r) { + const a = []; + let l; + const f = /* @__PURE__ */ new Set(); + r = q_(r); + const d = y(r) || A; + return l && f.forEach((x) => l.delete(x)), { + exports: d, + typeOnlyExportStarMap: l + }; + function y(x, I, J) { + if (!J && x?.exports && x.exports.forEach((ve, de) => f.add(de)), !(x && x.exports && tp(a, x))) + return; + const z = new Map(x.exports), G = x.exports.get( + "__export" + /* ExportStar */ + ); + if (G) { + const ve = Bs(), de = /* @__PURE__ */ new Map(); + if (G.declarations) + for (const We of G.declarations) { + const lt = Mu(We, We.moduleSpecifier), gt = y(lt, We, J || We.isTypeOnly); + mT( + ve, + gt, + de, + We + ); + } + de.forEach(({ exportsWithDuplicate: We }, lt) => { + if (!(lt === "export=" || !(We && We.length) || z.has(lt))) + for (const gt of We) + Aa.add(sn( + gt, + p.Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity, + de.get(lt).specifierText, + Si(lt) + )); + }), mT(z, ve); + } + return I?.isTypeOnly && (l ?? (l = /* @__PURE__ */ new Map()), z.forEach( + (ve, de) => l.set( + de, + I + ) + )), z; + } + } + function Oa(r) { + let a; + return r && r.mergeId && (a = KS[r.mergeId]) ? a : r; + } + function yn(r) { + return Oa(r.symbol && XG(r.symbol)); + } + function Hf(r) { + return Ed(r) ? yn(r) : void 0; + } + function Tl(r) { + return Oa(r.parent && XG(r.parent)); + } + function Gv(r) { + var a, l; + return (((a = r.valueDeclaration) == null ? void 0 : a.kind) === 220 || ((l = r.valueDeclaration) == null ? void 0 : l.kind) === 219) && Hf(r.valueDeclaration.parent) || r; + } + function hT(r, a) { + const l = xr(a), f = Ma(l), d = Pn(r); + let y; + if (d.extendedContainersByFile && (y = d.extendedContainersByFile.get(f))) + return y; + if (l && l.imports) { + for (const I of l.imports) { + if (lo(I)) continue; + const J = Mu( + a, + I, + /*ignoreErrors*/ + !0 + ); + !J || !C(J, r) || (y = Er(y, J)); + } + if (wr(y)) + return (d.extendedContainersByFile || (d.extendedContainersByFile = /* @__PURE__ */ new Map())).set(f, y), y; + } + if (d.extendedContainers) + return d.extendedContainers; + const x = e.getSourceFiles(); + for (const I of x) { + if (!fl(I)) continue; + const J = yn(I); + C(J, r) && (y = Er(y, J)); + } + return d.extendedContainers = y || Ge; + } + function C2(r, a, l) { + const f = Tl(r); + if (f && !(r.flags & 262144)) + return J(f); + const d = Fi(r.declarations, (G) => { + if (!Vu(G) && G.parent) { + if (D2(G.parent)) + return yn(G.parent); + if (vm(G.parent) && G.parent.parent && q_(yn(G.parent.parent)) === r) + return yn(G.parent.parent); + } + if (Rc(G) && _n(G.parent) && G.parent.operatorToken.kind === 64 && To(G.parent.left) && to(G.parent.left.expression)) + return Lg(G.parent.left) || lS(G.parent.left.expression) ? yn(xr(G)) : (mc(G.parent.left.expression), xn(G.parent.left.expression).resolvedSymbol); + }); + if (!wr(d)) + return; + const y = Fi(d, (G) => C(G, r) ? G : void 0); + let x = [], I = []; + for (const G of y) { + const [ve, ...de] = J(G); + x = Er(x, ve), I = In(I, de); + } + return Bi(x, I); + function J(G) { + const ve = Fi(G.declarations, z), de = a && hT(r, a), We = $v(G, l); + if (a && G.flags & yd(l) && $0( + G, + a, + 1920, + /*useOnlyExternalAliasing*/ + !1 + )) + return Er(Bi(Bi([G], ve), de), We); + const lt = !(G.flags & yd(l)) && G.flags & 788968 && bo(G).flags & 524288 && l === 111551 ? G0(a, (jt) => hl(jt, (ar) => { + if (ar.flags & yd(l) && Yr(ar) === bo(G)) + return ar; + })) : void 0; + let gt = lt ? [lt, ...ve, G] : [...ve, G]; + return gt = Er(gt, We), gt = In(gt, de), gt; + } + function z(G) { + return f && yT(G, f); + } + } + function $v(r, a) { + const l = !!wr(r.declarations) && Ca(r.declarations); + if (a & 111551 && l && l.parent && ei(l.parent) && (_a(l) && l === l.parent.initializer || a_(l) && l === l.parent.type)) + return yn(l.parent); + } + function yT(r, a) { + const l = bT(r), f = l && l.exports && l.exports.get( + "export=" + /* ExportEquals */ + ); + return f && le(f, a) ? l : void 0; + } + function C(r, a) { + if (r === Tl(a)) + return a; + const l = r.exports && r.exports.get( + "export=" + /* ExportEquals */ + ); + if (l && le(l, a)) + return r; + const f = gf(r), d = f.get(a.escapedName); + return d && le(d, a) ? d : hl(f, (y) => { + if (le(y, a)) + return y; + }); + } + function le(r, a) { + if (Oa(zc(Oa(r))) === Oa(zc(Oa(a)))) + return r; + } + function _t(r) { + return Oa(r && (r.flags & 1048576) !== 0 && r.exportSymbol || r); + } + function ur(r, a) { + return !!(r.flags & 111551 || r.flags & 2097152 && O_(r, !a) & 111551); + } + function ti(r) { + var a; + const l = new c(Jr, r); + return u++, l.id = u, (a = on) == null || a.recordType(l), l; + } + function gi(r, a) { + const l = ti(r); + return l.symbol = a, l; + } + function Ki(r) { + return new c(Jr, r); + } + function mi(r, a, l = 0, f) { + ba(a, f); + const d = ti(r); + return d.intrinsicName = a, d.debugIntrinsicName = f, d.objectFlags = l | 524288 | 2097152 | 33554432 | 16777216, d; + } + function ba(r, a) { + const l = `${r},${a ?? ""}`; + Tt.has(l) && E.fail(`Duplicate intrinsic type name ${r}${a ? ` (${a})` : ""}; you may need to pass a name to createIntrinsicType.`), Tt.add(l); + } + function Wc(r, a) { + const l = gi(524288, a); + return l.objectFlags = r, l.members = void 0, l.properties = void 0, l.callSignatures = void 0, l.constructSignatures = void 0, l.indexInfos = void 0, l; + } + function bu() { + return Xn(is(Cne.keys(), H_)); + } + function p_(r) { + return gi(262144, r); + } + function Xv(r) { + return r.charCodeAt(0) === 95 && r.charCodeAt(1) === 95 && r.charCodeAt(2) !== 95 && r.charCodeAt(2) !== 64 && r.charCodeAt(2) !== 35; + } + function d_(r) { + let a; + return r.forEach((l, f) => { + y1(l, f) && (a || (a = [])).push(l); + }), a || Ge; + } + function y1(r, a) { + return !Xv(a) && ur(r); + } + function qk(r) { + const a = d_(r), l = t$(r); + return l ? Bi(a, [l]) : a; + } + function Kp(r, a, l, f, d) { + const y = r; + return y.members = a, y.properties = Ge, y.callSignatures = l, y.constructSignatures = f, y.indexInfos = d, a !== A && (y.properties = d_(a)), y; + } + function Ho(r, a, l, f, d) { + return Kp(Wc(16, r), a, l, f, d); + } + function vT(r) { + if (r.constructSignatures.length === 0) return r; + if (r.objectTypeWithoutAbstractConstructSignatures) return r.objectTypeWithoutAbstractConstructSignatures; + const a = kn(r.constructSignatures, (f) => !(f.flags & 4)); + if (r.constructSignatures === a) return r; + const l = Ho( + r.symbol, + r.members, + r.callSignatures, + ot(a) ? a : Ge, + r.indexInfos + ); + return r.objectTypeWithoutAbstractConstructSignatures = l, l.objectTypeWithoutAbstractConstructSignatures = l, l; + } + function G0(r, a) { + let l; + for (let f = r; f; f = f.parent) { + if (qm(f) && f.locals && !m0(f) && (l = a( + f.locals, + /*ignoreQualification*/ + void 0, + /*isLocalNameLookup*/ + !0, + f + ))) + return l; + switch (f.kind) { + case 308: + if (!tf(f)) + break; + // falls through + case 268: + const d = yn(f); + if (l = a( + d?.exports || A, + /*ignoreQualification*/ + void 0, + /*isLocalNameLookup*/ + !0, + f + )) + return l; + break; + case 264: + case 232: + case 265: + let y; + if ((yn(f).members || A).forEach((x, I) => { + x.flags & 788968 && (y || (y = Bs())).set(I, x); + }), y && (l = a( + y, + /*ignoreQualification*/ + void 0, + /*isLocalNameLookup*/ + !1, + f + ))) + return l; + break; + } + } + return a( + Ye, + /*ignoreQualification*/ + void 0, + /*isLocalNameLookup*/ + !0 + ); + } + function yd(r) { + return r === 111551 ? 111551 : 1920; + } + function $0(r, a, l, f, d = /* @__PURE__ */ new Map()) { + if (!(r && !qL(r))) + return; + const y = Pn(r), x = y.accessibleChainCache || (y.accessibleChainCache = /* @__PURE__ */ new Map()), I = G0(a, (ar, jr, Kr, or) => or), J = `${f ? 0 : 1}|${I ? Ma(I) : 0}|${l}`; + if (x.has(J)) + return x.get(J); + const z = Xs(r); + let G = d.get(z); + G || d.set(z, G = []); + const ve = G0(a, de); + return x.set(J, ve), ve; + function de(ar, jr, Kr) { + if (!tp(G, ar)) + return; + const or = gt(ar, jr, Kr); + return G.pop(), or; + } + function We(ar, jr) { + return !E2(ar, a, jr) || // If symbol needs qualification, make sure that parent is accessible, if it is then this symbol is accessible too + !!$0(ar.parent, a, yd(jr), f, d); + } + function lt(ar, jr, Kr) { + return (r === (jr || ar) || Oa(r) === Oa(jr || ar)) && // if the symbolFromSymbolTable is not external module (it could be if it was determined as ambient external module and would be in globals table) + // and if symbolFromSymbolTable or alias resolution matches the symbol, + // check the symbol can be qualified, it is only then this symbol is accessible + !ot(ar.declarations, D2) && (Kr || We(Oa(ar), l)); + } + function gt(ar, jr, Kr) { + return lt( + ar.get(r.escapedName), + /*resolvedAliasSymbol*/ + void 0, + jr + ) ? [r] : hl(ar, (ir) => { + if (ir.flags & 2097152 && ir.escapedName !== "export=" && ir.escapedName !== "default" && !(j5(ir) && a && fl(xr(a))) && (!f || ot(ir.declarations, H1)) && (!Kr || !ot(ir.declarations, CK)) && (jr || !Oo( + ir, + 282 + /* ExportSpecifier */ + ))) { + const nn = Rl(ir), Qn = jt(ir, nn, jr); + if (Qn) + return Qn; + } + if (ir.escapedName === r.escapedName && ir.exportSymbol && lt( + Oa(ir.exportSymbol), + /*resolvedAliasSymbol*/ + void 0, + jr + )) + return [r]; + }) || (ar === Ye ? jt(Se, Se, jr) : void 0); + } + function jt(ar, jr, Kr) { + if (lt(ar, jr, Kr)) + return [ar]; + const or = gf(jr), ir = or && de( + or, + /*ignoreQualification*/ + !0 + ); + if (ir && We(ar, yd(l))) + return [ar].concat(ir); + } + } + function E2(r, a, l) { + let f = !1; + return G0(a, (d) => { + let y = Oa(d.get(r.escapedName)); + if (!y) + return !1; + if (y === r) + return !0; + const x = y.flags & 2097152 && !Oo( + y, + 282 + /* ExportSpecifier */ + ); + return y = x ? Rl(y) : y, (x ? O_(y) : y.flags) & l ? (f = !0, !0) : !1; + }), f; + } + function qL(r) { + if (r.declarations && r.declarations.length) { + for (const a of r.declarations) + switch (a.kind) { + case 173: + case 175: + case 178: + case 179: + continue; + default: + return !1; + } + return !0; + } + return !1; + } + function Qw(r, a) { + return Gk( + r, + a, + 788968, + /*shouldComputeAliasesToMakeVisible*/ + !1, + /*allowModules*/ + !0 + ).accessibility === 0; + } + function Hk(r, a) { + return Gk( + r, + a, + 111551, + /*shouldComputeAliasesToMakeVisible*/ + !1, + /*allowModules*/ + !0 + ).accessibility === 0; + } + function Yw(r, a, l) { + return Gk( + r, + a, + l, + /*shouldComputeAliasesToMakeVisible*/ + !1, + /*allowModules*/ + !1 + ).accessibility === 0; + } + function U8(r, a, l, f, d, y) { + if (!wr(r)) return; + let x, I = !1; + for (const J of r) { + const z = $0( + J, + a, + f, + /*useOnlyExternalAliasing*/ + !1 + ); + if (z) { + x = J; + const de = ST(z[0], d); + if (de) + return de; + } + if (y && ot(J.declarations, D2)) { + if (d) { + I = !0; + continue; + } + return { + accessibility: 0 + /* Accessible */ + }; + } + const G = C2(J, a, f), ve = U8(G, a, l, l === J ? yd(f) : f, d, y); + if (ve) + return ve; + } + if (I) + return { + accessibility: 0 + /* Accessible */ + }; + if (x) + return { + accessibility: 1, + errorSymbolName: Wi(l, a, f), + errorModuleName: x !== l ? Wi( + x, + a, + 1920 + /* Namespace */ + ) : void 0 + }; + } + function v1(r, a, l, f) { + return Gk( + r, + a, + l, + f, + /*allowModules*/ + !0 + ); + } + function Gk(r, a, l, f, d) { + if (r && a) { + const y = U8([r], a, r, l, f, d); + if (y) + return y; + const x = lr(r.declarations, bT); + if (x) { + const I = bT(a); + if (x !== I) + return { + accessibility: 2, + errorSymbolName: Wi(r, a, l), + errorModuleName: Wi(x), + errorNode: an(a) ? a : void 0 + }; + } + return { + accessibility: 1, + errorSymbolName: Wi(r, a, l) + }; + } + return { + accessibility: 0 + /* Accessible */ + }; + } + function bT(r) { + const a = dr(r, HL); + return a && yn(a); + } + function HL(r) { + return Vu(r) || r.kind === 308 && tf(r); + } + function D2(r) { + return q7(r) || r.kind === 308 && tf(r); + } + function ST(r, a) { + let l; + if (!Ni(kn( + r.declarations, + (y) => y.kind !== 80 + /* Identifier */ + ), f)) + return; + return { accessibility: 0, aliasesToMakeVisible: l }; + function f(y) { + var x, I; + if (!fg(y)) { + const J = bp(y); + if (J && !Gn( + J, + 32 + /* Export */ + ) && // import clause without export + fg(J.parent)) + return d(y, J); + if (ei(y) && Ic(y.parent.parent) && !Gn( + y.parent.parent, + 32 + /* Export */ + ) && // unexported variable statement + fg(y.parent.parent.parent)) + return d(y, y.parent.parent); + if (H7(y) && !Gn( + y, + 32 + /* Export */ + ) && fg(y.parent)) + return d(y, y); + if (ya(y)) { + if (r.flags & 2097152 && an(y) && ((x = y.parent) != null && x.parent) && ei(y.parent.parent) && ((I = y.parent.parent.parent) != null && I.parent) && Ic(y.parent.parent.parent.parent) && !Gn( + y.parent.parent.parent.parent, + 32 + /* Export */ + ) && y.parent.parent.parent.parent.parent && fg(y.parent.parent.parent.parent.parent)) + return d(y, y.parent.parent.parent.parent); + if (r.flags & 2) { + const z = Y2(y); + if (z.kind === 170) + return !1; + const G = z.parent.parent; + return G.kind !== 244 ? !1 : Gn( + G, + 32 + /* Export */ + ) ? !0 : fg(G.parent) ? d(y, G) : !1; + } + } + return !1; + } + return !0; + } + function d(y, x) { + return a && (xn(y).isVisible = !0, l = dh(l, x)), !0; + } + } + function Zw(r) { + let a; + return r.parent.kind === 187 || r.parent.kind === 234 && !lm(r.parent) || r.parent.kind === 168 || r.parent.kind === 183 && r.parent.parameterName === r ? a = 1160127 : r.kind === 167 || r.kind === 212 || r.parent.kind === 272 || r.parent.kind === 167 && r.parent.left === r || r.parent.kind === 212 && r.parent.expression === r || r.parent.kind === 213 && r.parent.expression === r ? a = 1920 : a = 788968, a; + } + function $k(r, a, l = !0) { + const f = Zw(r), d = i_(r), y = st( + a, + d.escapedText, + f, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + ); + return y && y.flags & 262144 && f & 788968 ? { + accessibility: 0 + /* Accessible */ + } : !y && Ry(d) && v1( + yn(qu( + d, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + )), + d, + f, + /*shouldComputeAliasesToMakeVisible*/ + !1 + ).accessibility === 0 ? { + accessibility: 0 + /* Accessible */ + } : y ? ST(y, l) || { + accessibility: 1, + errorSymbolName: Qo(d), + errorNode: d + } : { + accessibility: 3, + errorSymbolName: Qo(d), + errorNode: d + }; + } + function Wi(r, a, l, f = 4, d) { + let y = 70221824, x = 0; + f & 2 && (y |= 128), f & 1 && (y |= 512), f & 8 && (y |= 16384), f & 32 && (x |= 4), f & 16 && (x |= 1); + const I = f & 4 ? pe.symbolToNode : pe.symbolToEntityName; + return d ? J(d).getText() : LC(J); + function J(z) { + const G = I(r, l, a, y, x), ve = a?.kind === 308 ? Sie() : i2(), de = a && xr(a); + return ve.writeNode( + 4, + G, + /*sourceFile*/ + de, + z + ), z; + } + } + function b1(r, a, l = 0, f, d, y, x, I) { + return d ? J(d).getText() : LC(J); + function J(z) { + let G; + l & 262144 ? G = f === 1 ? 186 : 185 : G = f === 1 ? 181 : 180; + const ve = pe.signatureToSignatureDeclaration( + r, + G, + a, + w2(l) | 70221824 | 512, + /*internalFlags*/ + void 0, + /*tracker*/ + void 0, + y, + x, + I + ), de = sU(), We = a && xr(a); + return de.writeNode( + 4, + ve, + /*sourceFile*/ + We, + $B(z) + ), z; + } + } + function Wr(r, a, l = 1064960, f = nN(""), d, y, x) { + const I = !d && F.noErrorTruncation || l & 1, J = pe.typeToTypeNode( + r, + a, + w2(l) | 70221824 | (I ? 1 : 0), + /*internalFlags*/ + void 0, + /*tracker*/ + void 0, + d, + y, + x + ); + if (J === void 0) return E.fail("should always get typenode"); + const z = r !== Lt ? i2() : bie(), G = a && xr(a); + z.writeNode( + 4, + J, + /*sourceFile*/ + G, + f + ); + const ve = f.getText(), de = d || (I ? eB * 2 : ND * 2); + return de && ve && ve.length >= de ? ve.substr(0, de - 3) + "..." : ve; + } + function Kw(r, a) { + let l = CE(r.symbol) ? Wr(r, r.symbol.valueDeclaration) : Wr(r), f = CE(a.symbol) ? Wr(a, a.symbol.valueDeclaration) : Wr(a); + return l === f && (l = kE(r), f = kE(a)), [l, f]; + } + function kE(r) { + return Wr( + r, + /*enclosingDeclaration*/ + void 0, + 64 + /* UseFullyQualifiedType */ + ); + } + function CE(r) { + return r && !!r.valueDeclaration && ut(r.valueDeclaration) && !Qf(r.valueDeclaration); + } + function w2(r = 0) { + return r & 848330095; + } + function V8(r) { + return !!r.symbol && !!(r.symbol.flags & 32) && (r === xp(r.symbol) || !!(r.flags & 524288) && !!(Dn(r) & 16777216)); + } + function TT(r) { + return Ci(r); + } + function GL() { + return { + syntacticBuilderResolver: { + evaluateEntityNameExpression: U7e, + isExpandoFunctionDeclaration: u5e, + hasLateBindableName: PE, + shouldRemoveDeclaration(we, te) { + return !(we.internalFlags & 8 && to(te.name.expression) && Td(te.name).flags & 1); + }, + createRecoveryBoundary(we) { + return bi(we); + }, + isDefinitelyReferenceToGlobalSymbolObject: lg, + getAllAccessorDeclarations: Hme, + requiresAddingImplicitUndefined(we, te, Ht) { + var Zt; + switch (we.kind) { + case 173: + case 172: + case 349: + te ?? (te = yn(we)); + const xe = Yr(te); + return !!(te.flags & 4 && te.flags & 16777216 && Ox(we) && ((Zt = te.links) != null && Zt.mappedType) && gnt(xe)); + case 170: + case 342: + return pR(we, Ht); + default: + E.assertNever(we); + } + }, + isOptionalParameter: K8, + isUndefinedIdentifierExpression(we) { + return Pp(we) === ne; + }, + isEntityNameVisible(we, te, Ht) { + return $k(te, we.enclosingDeclaration, Ht); + }, + serializeExistingTypeNode(we, te, Ht) { + return M_(we, te, !!Ht); + }, + serializeReturnTypeForSignature(we, te, Ht) { + const Zt = we, xe = Xf(te); + Ht ?? (Ht = yn(te)); + const Re = Zt.enclosingSymbolTypes.get(Xs(Ht)) ?? Mi(Wa(xe), Zt.mapper); + return ua(Zt, xe, Re); + }, + serializeTypeOfExpression(we, te) { + const Ht = we, Zt = Mi(Sf(r5e(te)), Ht.mapper); + return jt(Zt, Ht); + }, + serializeTypeOfDeclaration(we, te, Ht) { + var Zt; + const xe = we; + Ht ?? (Ht = yn(te)); + let Re = (Zt = xe.enclosingSymbolTypes) == null ? void 0 : Zt.get(Xs(Ht)); + return Re === void 0 && (Re = Ht.flags & 98304 && te.kind === 179 ? Mi(Z0(Ht), xe.mapper) : Ht && !(Ht.flags & 133120) ? Mi(ob(Yr(Ht)), xe.mapper) : qe), te && (Ii(te) || Lf(te)) && pR(te, xe.enclosingDeclaration) && (Re = P1(Re)), Qr(Ht, xe, Re); + }, + serializeNameOfParameter(we, te) { + return xi(yn(te), te, we); + }, + serializeEntityName(we, te) { + const Ht = we, Zt = Pp( + te, + /*ignoreErrors*/ + !0 + ); + if (Zt && Hk(Zt, Ht.enclosingDeclaration)) + return Np( + Zt, + Ht, + 1160127 + /* ExportValue */ + ); + }, + serializeTypeName(we, te, Ht, Zt) { + return kl(we, te, Ht, Zt); + }, + getJsDocPropertyOverride(we, te, Ht) { + const Zt = we, xe = Me(Ht.name) ? Ht.name : Ht.name.right, Re = rr(a(Zt, te), xe.escapedText); + return Re && Ht.typeExpression && a(Zt, Ht.typeExpression.type) !== Re ? jt(Re, Zt) : void 0; + }, + enterNewScope(we, te) { + if (Es(te) || w0(te)) { + const Ht = Xf(te); + return ks(we, te, Ht.parameters, Ht.typeParameters); + } else { + const Ht = Gb(te) ? vpe(te) : [Zv(yn(te.typeParameter))]; + return ks( + we, + te, + /*expandedParams*/ + void 0, + Ht + ); + } + }, + markNodeReuse(we, te, Ht) { + return l(we, te, Ht); + }, + trackExistingEntityName(we, te) { + return mo(te, we); + }, + trackComputedName(we, te) { + en(te, we.enclosingDeclaration, we); + }, + getModuleSpecifierOverride(we, te, Ht) { + const Zt = we; + if (Zt.bundled || Zt.enclosingFile !== xr(Ht)) { + let xe = Ht.text; + const Re = xe, Ze = xn(te).resolvedSymbol, Pt = te.isTypeOf ? 111551 : 788968, $t = Ze && v1( + Ze, + Zt.enclosingDeclaration, + Pt, + /*shouldComputeAliasesToMakeVisible*/ + !1 + ).accessibility === 0 && us( + Ze, + Zt, + Pt, + /*yieldModuleSymbol*/ + !0 + )[0]; + if ($t && lx($t)) + xe = Oc($t, Zt); + else { + const At = Xme(te); + At && (xe = Oc(At.symbol, Zt)); + } + if (xe.includes("/node_modules/") && (Zt.encounteredError = !0, Zt.tracker.reportLikelyUnsafeImportRequiredError && Zt.tracker.reportLikelyUnsafeImportRequiredError(xe)), xe !== Re) + return xe; + } + }, + canReuseTypeNode(we, te) { + return Ju(we, te); + }, + canReuseTypeNodeAnnotation(we, te, Ht, Zt, xe) { + var Re; + const Ze = we; + if (Ze.enclosingDeclaration === void 0) return !1; + Zt ?? (Zt = yn(te)); + let Pt = (Re = Ze.enclosingSymbolTypes) == null ? void 0 : Re.get(Xs(Zt)); + Pt === void 0 && (Zt.flags & 98304 ? Pt = te.kind === 179 ? Z0(Zt) : iP(Zt) : pS(te) ? Pt = Wa(Xf(te)) : Pt = Yr(Zt)); + let $t = TT(Ht); + return Gr($t) ? !0 : (xe && $t && ($t = Ru($t, !Ii(te))), !!$t && Kn(te, Pt, $t) && gr(Ht, Pt)); + } + }, + typeToTypeNode: (we, te, Ht, Zt, xe, Re, Ze, Pt) => z(te, Ht, Zt, xe, Re, Ze, ($t) => jt(we, $t), Pt), + typePredicateToTypePredicateNode: (we, te, Ht, Zt, xe) => z( + te, + Ht, + Zt, + xe, + /*maximumLength*/ + void 0, + /*verbosityLevel*/ + void 0, + (Re) => Bu(we, Re) + ), + serializeTypeForDeclaration: (we, te, Ht, Zt, xe, Re) => z( + Ht, + Zt, + xe, + Re, + /*maximumLength*/ + void 0, + /*verbosityLevel*/ + void 0, + (Ze) => Te.serializeTypeOfDeclaration(we, te, Ze) + ), + serializeReturnTypeForSignature: (we, te, Ht, Zt, xe) => z( + te, + Ht, + Zt, + xe, + /*maximumLength*/ + void 0, + /*verbosityLevel*/ + void 0, + (Re) => Te.serializeReturnTypeForSignature(we, yn(we), Re) + ), + serializeTypeForExpression: (we, te, Ht, Zt, xe) => z( + te, + Ht, + Zt, + xe, + /*maximumLength*/ + void 0, + /*verbosityLevel*/ + void 0, + (Re) => Te.serializeTypeOfExpression(we, Re) + ), + indexInfoToIndexSignatureDeclaration: (we, te, Ht, Zt, xe) => z( + te, + Ht, + Zt, + xe, + /*maximumLength*/ + void 0, + /*verbosityLevel*/ + void 0, + (Re) => Ri( + we, + Re, + /*typeNode*/ + void 0 + ) + ), + signatureToSignatureDeclaration: (we, te, Ht, Zt, xe, Re, Ze, Pt, $t) => z(Ht, Zt, xe, Re, Ze, Pt, (At) => zn(we, te, At), $t), + symbolToEntityName: (we, te, Ht, Zt, xe, Re) => z( + Ht, + Zt, + xe, + Re, + /*maximumLength*/ + void 0, + /*verbosityLevel*/ + void 0, + (Ze) => wc( + we, + Ze, + te, + /*expectsIdentifier*/ + !1 + ) + ), + symbolToExpression: (we, te, Ht, Zt, xe, Re) => z( + Ht, + Zt, + xe, + Re, + /*maximumLength*/ + void 0, + /*verbosityLevel*/ + void 0, + (Ze) => Np(we, Ze, te) + ), + symbolToTypeParameterDeclarations: (we, te, Ht, Zt, xe) => z( + te, + Ht, + Zt, + xe, + /*maximumLength*/ + void 0, + /*verbosityLevel*/ + void 0, + (Re) => Io(we, Re) + ), + symbolToParameterDeclaration: (we, te, Ht, Zt, xe) => z( + te, + Ht, + Zt, + xe, + /*maximumLength*/ + void 0, + /*verbosityLevel*/ + void 0, + (Re) => Br(we, Re) + ), + typeParameterToDeclaration: (we, te, Ht, Zt, xe, Re, Ze, Pt) => z(te, Ht, Zt, xe, Re, Ze, ($t) => Sc(we, $t), Pt), + symbolTableToDeclarationStatements: (we, te, Ht, Zt, xe) => z( + te, + Ht, + Zt, + xe, + /*maximumLength*/ + void 0, + /*verbosityLevel*/ + void 0, + (Re) => fb(we, Re) + ), + symbolToNode: (we, te, Ht, Zt, xe, Re) => z( + Ht, + Zt, + xe, + Re, + /*maximumLength*/ + void 0, + /*verbosityLevel*/ + void 0, + (Ze) => f(we, Ze, te) + ), + symbolToDeclarations: d + }; + function a(we, te, Ht) { + const Zt = TT(te); + if (!we.mapper) return Zt; + const xe = Mi(Zt, we.mapper); + return Ht && xe !== Zt ? void 0 : xe; + } + function l(we, te, Ht) { + if ((!lo(te) || !(te.flags & 16) || !we.enclosingFile || we.enclosingFile !== xr(Vo(te))) && (te = N.cloneNode(te)), te === Ht || !Ht) + return te; + let Zt = te.original; + for (; Zt && Zt !== Ht; ) + Zt = Zt.original; + return Zt || Cn(te, Ht), we.enclosingFile && we.enclosingFile === xr(Vo(Ht)) ? ct(te, Ht) : te; + } + function f(we, te, Ht) { + if (te.internalFlags & 1) { + if (we.valueDeclaration) { + const xe = _s(we.valueDeclaration); + if (xe && Gs(xe)) return xe; + } + const Zt = Pn(we).nameType; + if (Zt && Zt.flags & 9216) + return te.enclosingDeclaration = Zt.symbol.valueDeclaration, N.createComputedPropertyName(Np(Zt.symbol, te, Ht)); + } + return Np(we, te, Ht); + } + function d(we, te, Ht, Zt, xe, Re) { + const Ze = z( + /*enclosingDeclaration*/ + void 0, + Ht, + /*internalFlags*/ + void 0, + /*tracker*/ + void 0, + Zt, + xe, + (Pt) => J(we, Pt), + Re + ); + return Fi(Ze, (Pt) => { + switch (Pt.kind) { + case 264: + return y(Pt, we); + case 267: + return x(Pt, ov, we); + case 265: + return I(Pt, we, te); + case 268: + return x(Pt, jc, we); + default: + return; + } + }); + } + function y(we, te) { + const Ht = kn(te.declarations, $n), Zt = Ht && Ht.length > 0 ? Ht[0] : we, xe = pu(Zt) & -161; + return Rc(Zt) && (we = N.updateClassDeclaration( + we, + we.modifiers, + /*name*/ + void 0, + we.typeParameters, + we.heritageClauses, + we.members + )), N.replaceModifiers(we, xe); + } + function x(we, te, Ht) { + const Zt = kn(Ht.declarations, te), xe = Zt && Zt.length > 0 ? Zt[0] : we, Re = pu(xe) & -161; + return N.replaceModifiers(we, Re); + } + function I(we, te, Ht) { + if (Ht & 64) + return x(we, Vl, te); + } + function J(we, te) { + const Ht = bo(we); + te.typeStack.push(Ht.id), te.typeStack.push(-1); + const Zt = Bs([we]), xe = fb(Zt, te); + return te.typeStack.pop(), te.typeStack.pop(), xe; + } + function z(we, te, Ht, Zt, xe, Re, Ze, Pt) { + const $t = Zt?.trackSymbol ? Zt.moduleResolverHost : (Ht || 0) & 4 ? IRe(e) : void 0; + te = te || 0; + const At = xe || (te & 1 ? eB : ND), Yt = { + enclosingDeclaration: we, + enclosingFile: we && xr(we), + flags: te, + internalFlags: Ht || 0, + tracker: void 0, + maxTruncationLength: At, + maxExpansionDepth: Re ?? -1, + encounteredError: !1, + suppressReportInferenceFallback: !1, + reportedDiagnostic: !1, + visitedTypes: void 0, + symbolDepth: void 0, + inferTypeParameters: void 0, + approximateLength: 0, + trackedSymbols: void 0, + bundled: !!F.outFile && !!we && tf(xr(we)), + truncating: !1, + usedSymbolNames: void 0, + remappedSymbolNames: void 0, + remappedSymbolReferences: void 0, + reverseMappedStack: void 0, + mustCreateTypeParameterSymbolList: !0, + typeParameterSymbolList: void 0, + mustCreateTypeParametersNamesLookups: !0, + typeParameterNames: void 0, + typeParameterNamesByText: void 0, + typeParameterNamesByTextNextNameCount: void 0, + enclosingSymbolTypes: /* @__PURE__ */ new Map(), + mapper: void 0, + depth: 0, + typeStack: [], + out: { + canIncreaseExpansionDepth: !1, + truncated: !1 + } + }; + Yt.tracker = new Dne(Yt, Zt, $t); + const Lr = Ze(Yt); + return Yt.truncating && Yt.flags & 1 && Yt.tracker.reportTruncationError(), Pt && (Pt.canIncreaseExpansionDepth = Yt.out.canIncreaseExpansionDepth, Pt.truncated = Yt.out.truncated), Yt.encounteredError ? void 0 : Lr; + } + function G(we, te, Ht) { + const Zt = Xs(te), xe = we.enclosingSymbolTypes.get(Zt); + return we.enclosingSymbolTypes.set(Zt, Ht), Re; + function Re() { + xe ? we.enclosingSymbolTypes.set(Zt, xe) : we.enclosingSymbolTypes.delete(Zt); + } + } + function ve(we) { + const te = we.flags, Ht = we.internalFlags, Zt = we.depth; + return xe; + function xe() { + we.flags = te, we.internalFlags = Ht, we.depth = Zt; + } + } + function de(we) { + return we.maxExpansionDepth >= 0 && We(we); + } + function We(we) { + return we.truncating ? we.truncating : we.truncating = we.approximateLength > we.maxTruncationLength; + } + function lt(we, te) { + for (let Ht = 0; Ht < te.typeStack.length - 1; Ht++) + if (te.typeStack[Ht] === we.id) + return !1; + return te.depth < te.maxExpansionDepth || te.depth === te.maxExpansionDepth && !te.out.canIncreaseExpansionDepth; + } + function gt(we, te, Ht = !1) { + if (!Ht && EE(we)) + return !1; + for (let xe = 0; xe < te.typeStack.length - 1; xe++) + if (te.typeStack[xe] === we.id) + return !1; + const Zt = te.depth < te.maxExpansionDepth; + return Zt || (te.out.canIncreaseExpansionDepth = !0), Zt; + } + function jt(we, te) { + const Ht = ve(te); + we && te.typeStack.push(we.id); + const Zt = ar(we, te); + return we && te.typeStack.pop(), Ht(), Zt; + } + function ar(we, te) { + var Ht, Zt; + i && i.throwIfCancellationRequested && i.throwIfCancellationRequested(); + const xe = te.flags & 8388608; + te.flags &= -8388609; + let Re = !1; + if (!we) { + if (!(te.flags & 262144)) { + te.encounteredError = !0; + return; + } + return te.approximateLength += 3, N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ); + } + if (te.flags & 536870912 || (we = td(we)), we.flags & 1) + return we.aliasSymbol ? N.createTypeReferenceNode(Uc(we.aliasSymbol), nn(we.aliasTypeArguments, te)) : we === Lt ? Uy(N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ), 3, "unresolved") : (te.approximateLength += 3, N.createKeywordTypeNode( + we === Pe ? 141 : 133 + /* AnyKeyword */ + )); + if (we.flags & 2) + return N.createKeywordTypeNode( + 159 + /* UnknownKeyword */ + ); + if (we.flags & 4) + return te.approximateLength += 6, N.createKeywordTypeNode( + 154 + /* StringKeyword */ + ); + if (we.flags & 8) + return te.approximateLength += 6, N.createKeywordTypeNode( + 150 + /* NumberKeyword */ + ); + if (we.flags & 64) + return te.approximateLength += 6, N.createKeywordTypeNode( + 163 + /* BigIntKeyword */ + ); + if (we.flags & 16 && !we.aliasSymbol) + return te.approximateLength += 7, N.createKeywordTypeNode( + 136 + /* BooleanKeyword */ + ); + if (we.flags & 1056) { + if (we.symbol.flags & 8) { + const sr = Tl(we.symbol), Fn = Xa( + sr, + te, + 788968 + /* Type */ + ); + if (bo(sr) === we) + return Fn; + const ps = cc(we.symbol); + return R_( + ps, + 1 + /* ES5 */ + ) ? Ur( + Fn, + N.createTypeReferenceNode( + ps, + /*typeArguments*/ + void 0 + ) + ) : ym(Fn) ? (Fn.isTypeOf = !0, N.createIndexedAccessTypeNode(Fn, N.createLiteralTypeNode(N.createStringLiteral(ps)))) : of(Fn) ? N.createIndexedAccessTypeNode(N.createTypeQueryNode(Fn.typeName), N.createLiteralTypeNode(N.createStringLiteral(ps))) : E.fail("Unhandled type node kind returned from `symbolToTypeNode`."); + } + if (gt(we, te)) + Re = !0; + else + return Xa( + we.symbol, + te, + 788968 + /* Type */ + ); + } + if (we.flags & 128) + return te.approximateLength += we.value.length + 2, N.createLiteralTypeNode(un( + N.createStringLiteral(we.value, !!(te.flags & 268435456)), + 16777216 + /* NoAsciiEscaping */ + )); + if (we.flags & 256) { + const sr = we.value; + return te.approximateLength += ("" + sr).length, N.createLiteralTypeNode(sr < 0 ? N.createPrefixUnaryExpression(41, N.createNumericLiteral(-sr)) : N.createNumericLiteral(sr)); + } + if (we.flags & 2048) + return te.approximateLength += Ub(we.value).length + 1, N.createLiteralTypeNode(N.createBigIntLiteral(we.value)); + if (we.flags & 512) + return te.approximateLength += we.intrinsicName.length, N.createLiteralTypeNode(we.intrinsicName === "true" ? N.createTrue() : N.createFalse()); + if (we.flags & 8192) { + if (!(te.flags & 1048576)) { + if (Hk(we.symbol, te.enclosingDeclaration)) + return te.approximateLength += 6, Xa( + we.symbol, + te, + 111551 + /* Value */ + ); + te.tracker.reportInaccessibleUniqueSymbolError && te.tracker.reportInaccessibleUniqueSymbolError(); + } + return te.approximateLength += 13, N.createTypeOperatorNode(158, N.createKeywordTypeNode( + 155 + /* SymbolKeyword */ + )); + } + if (we.flags & 16384) + return te.approximateLength += 4, N.createKeywordTypeNode( + 116 + /* VoidKeyword */ + ); + if (we.flags & 32768) + return te.approximateLength += 9, N.createKeywordTypeNode( + 157 + /* UndefinedKeyword */ + ); + if (we.flags & 65536) + return te.approximateLength += 4, N.createLiteralTypeNode(N.createNull()); + if (we.flags & 131072) + return te.approximateLength += 5, N.createKeywordTypeNode( + 146 + /* NeverKeyword */ + ); + if (we.flags & 4096) + return te.approximateLength += 6, N.createKeywordTypeNode( + 155 + /* SymbolKeyword */ + ); + if (we.flags & 67108864) + return te.approximateLength += 6, N.createKeywordTypeNode( + 151 + /* ObjectKeyword */ + ); + if (b4(we)) + return te.flags & 4194304 && (!te.encounteredError && !(te.flags & 32768) && (te.encounteredError = !0), (Zt = (Ht = te.tracker).reportInaccessibleThisError) == null || Zt.call(Ht)), te.approximateLength += 4, N.createThisTypeNode(); + if (!xe && we.aliasSymbol && (te.flags & 16384 || Qw(we.aliasSymbol, te.enclosingDeclaration))) { + if (!gt( + we, + te, + /*isAlias*/ + !0 + )) { + const sr = nn(we.aliasTypeArguments, te); + return Xv(we.aliasSymbol.escapedName) && !(we.aliasSymbol.flags & 32) ? N.createTypeReferenceNode(N.createIdentifier(""), sr) : wr(sr) === 1 && we.aliasSymbol === wa.symbol ? N.createArrayTypeNode(sr[0]) : Xa(we.aliasSymbol, te, 788968, sr); + } + te.depth += 1; + } + const Ze = Dn(we); + if (Ze & 4) + return E.assert(!!(we.flags & 524288)), gt(we, te) ? (te.depth += 1, $r( + we, + /*forceClassExpansion*/ + !0, + /*forceExpansion*/ + !0 + )) : we.node ? Sn(we, Yn) : Yn(we); + if (we.flags & 262144 || Ze & 3) { + if (we.flags & 262144 && ms(te.inferTypeParameters, we)) { + te.approximateLength += cc(we.symbol).length + 6; + let Fn; + const ps = m_(we); + if (ps) { + const Xi = P3e( + we, + /*omitTypeReferences*/ + !0 + ); + Xi && lh(ps, Xi) || (te.approximateLength += 9, Fn = ps && jt(ps, te)); + } + return N.createInferTypeNode(Vi(we, te, Fn)); + } + if (te.flags & 4 && we.flags & 262144) { + const Fn = $o(we, te); + return te.approximateLength += An(Fn).length, N.createTypeReferenceNode( + N.createIdentifier(An(Fn)), + /*typeArguments*/ + void 0 + ); + } + if (Ze & 3 && gt(we, te)) + return te.depth += 1, $r( + we, + /*forceClassExpansion*/ + !0, + /*forceExpansion*/ + !0 + ); + if (we.symbol) + return Xa( + we.symbol, + te, + 788968 + /* Type */ + ); + const sr = (we === tt || we === Ft) && D && D.symbol ? (we === Ft ? "sub-" : "super-") + cc(D.symbol) : "?"; + return N.createTypeReferenceNode( + N.createIdentifier(sr), + /*typeArguments*/ + void 0 + ); + } + if (we.flags & 1048576 && we.origin && (we = we.origin), we.flags & 3145728) { + const sr = we.flags & 1048576 ? q8(we.types, Re) : we.types; + if (wr(sr) === 1) + return jt(sr[0], te); + const Fn = nn( + sr, + te, + /*isBareList*/ + !0 + ); + if (Fn && Fn.length > 0) + return we.flags & 1048576 ? N.createUnionTypeNode(Fn) : N.createIntersectionTypeNode(Fn); + !te.encounteredError && !(te.flags & 262144) && (te.encounteredError = !0); + return; + } + if (Ze & 48) + return E.assert(!!(we.flags & 524288)), $r(we); + if (we.flags & 4194304) { + const sr = we.type; + te.approximateLength += 6; + const Fn = jt(sr, te); + return N.createTypeOperatorNode(143, Fn); + } + if (we.flags & 134217728) { + const sr = we.texts, Fn = we.types, ps = N.createTemplateHead(sr[0]), Xi = N.createNodeArray( + hr(Fn, (xa, Va) => N.createTemplateLiteralTypeSpan( + jt(xa, te), + (Va < Fn.length - 1 ? N.createTemplateMiddle : N.createTemplateTail)(sr[Va + 1]) + )) + ); + return te.approximateLength += 2, N.createTemplateLiteralType(ps, Xi); + } + if (we.flags & 268435456) { + const sr = jt(we.type, te); + return Xa(we.symbol, te, 788968, [sr]); + } + if (we.flags & 8388608) { + const sr = jt(we.objectType, te), Fn = jt(we.indexType, te); + return te.approximateLength += 2, N.createIndexedAccessTypeNode(sr, Fn); + } + if (we.flags & 16777216) + return Sn(we, (sr) => Pt(sr)); + if (we.flags & 33554432) { + const sr = jt(we.baseType, te), Fn = LE(we) && epe( + "NoInfer", + /*reportErrors*/ + !1 + ); + return Fn ? Xa(Fn, te, 788968, [sr]) : sr; + } + return E.fail("Should be unreachable."); + function Pt(sr) { + const Fn = jt(sr.checkType, te); + if (te.approximateLength += 15, te.flags & 4 && sr.root.isDistributive && !(sr.checkType.flags & 262144)) { + const ss = p_(ga(262144, "T")), sl = $o(ss, te), al = N.createTypeReferenceNode(sl); + te.approximateLength += 37; + const uu = IT(sr.root.checkType, ss, sr.mapper), zu = te.inferTypeParameters; + te.inferTypeParameters = sr.root.inferTypeParameters; + const h_ = jt(Mi(sr.root.extendsType, uu), te); + te.inferTypeParameters = zu; + const c0 = $t(Mi(a(te, sr.root.node.trueType), uu)), db = $t(Mi(a(te, sr.root.node.falseType), uu)); + return N.createConditionalTypeNode( + Fn, + N.createInferTypeNode(N.createTypeParameterDeclaration( + /*modifiers*/ + void 0, + N.cloneNode(al.typeName) + )), + N.createConditionalTypeNode( + N.createTypeReferenceNode(N.cloneNode(sl)), + jt(sr.checkType, te), + N.createConditionalTypeNode(al, h_, c0, db), + N.createKeywordTypeNode( + 146 + /* NeverKeyword */ + ) + ), + N.createKeywordTypeNode( + 146 + /* NeverKeyword */ + ) + ); + } + const ps = te.inferTypeParameters; + te.inferTypeParameters = sr.root.inferTypeParameters; + const Xi = jt(sr.extendsType, te); + te.inferTypeParameters = ps; + const xa = $t(E1(sr)), Va = $t(D1(sr)); + return N.createConditionalTypeNode(Fn, Xi, xa, Va); + } + function $t(sr) { + var Fn, ps, Xi; + return sr.flags & 1048576 ? (Fn = te.visitedTypes) != null && Fn.has(jl(sr)) ? (te.flags & 131072 || (te.encounteredError = !0, (Xi = (ps = te.tracker) == null ? void 0 : ps.reportCyclicStructureError) == null || Xi.call(ps)), jr(te)) : Sn(sr, (xa) => jt(xa, te)) : jt(sr, te); + } + function At(sr) { + return !!oI(sr); + } + function Yt(sr) { + return !!sr.target && At(sr.target) && !At(sr); + } + function Lr(sr) { + var Fn; + E.assert(!!(sr.flags & 524288)); + const ps = sr.declaration.readonlyToken ? N.createToken(sr.declaration.readonlyToken.kind) : void 0, Xi = sr.declaration.questionToken ? N.createToken(sr.declaration.questionToken.kind) : void 0; + let xa, Va, ss = sh(sr); + const sl = Sd(sr), al = !AE(sr) && !(Kv(sr).flags & 2) && te.flags & 4 && !($f(sr).flags & 262144 && ((Fn = m_($f(sr))) == null ? void 0 : Fn.flags) & 4194304); + if (AE(sr)) { + if (Yt(sr) && te.flags & 4) { + const O1 = p_(ga(262144, "T")), gC = $o(O1, te), OP = sr.target; + Va = N.createTypeReferenceNode(gC), ss = Mi( + sh(OP), + FNe([Sd(OP), Kv(OP)], [sl, O1]) + ); + } + xa = N.createTypeOperatorNode(143, Va || jt(Kv(sr), te)); + } else if (al) { + const O1 = p_(ga(262144, "T")), gC = $o(O1, te); + Va = N.createTypeReferenceNode(gC), xa = Va; + } else + xa = jt($f(sr), te); + const uu = Vi(sl, te, xa), zu = ks( + te, + sr.declaration, + /*expandedParams*/ + void 0, + [Zv(yn(sr.declaration.typeParameter))] + ), h_ = sr.declaration.nameType ? jt(K0(sr), te) : void 0, c0 = jt(i0(ss, !!(mg(sr) & 4)), te); + zu(); + const db = N.createMappedTypeNode( + ps, + uu, + h_, + Xi, + c0, + /*members*/ + void 0 + ); + te.approximateLength += 10; + const V2 = un( + db, + 1 + /* SingleLine */ + ); + if (Yt(sr) && te.flags & 4) { + const O1 = Mi(m_(a(te, sr.declaration.typeParameter.constraint.type)) || yt, sr.mapper); + return N.createConditionalTypeNode( + jt(Kv(sr), te), + N.createInferTypeNode(N.createTypeParameterDeclaration( + /*modifiers*/ + void 0, + N.cloneNode(Va.typeName), + O1.flags & 2 ? void 0 : jt(O1, te) + )), + V2, + N.createKeywordTypeNode( + 146 + /* NeverKeyword */ + ) + ); + } else if (al) + return N.createConditionalTypeNode( + jt($f(sr), te), + N.createInferTypeNode(N.createTypeParameterDeclaration( + /*modifiers*/ + void 0, + N.cloneNode(Va.typeName), + N.createTypeOperatorNode(143, jt(Kv(sr), te)) + )), + V2, + N.createKeywordTypeNode( + 146 + /* NeverKeyword */ + ) + ); + return V2; + } + function $r(sr, Fn = !1, ps = !1) { + var Xi, xa; + const Va = sr.id, ss = sr.symbol; + if (ss) { + if (!!(Dn(sr) & 8388608)) { + const h_ = sr.node; + if (Hb(h_) && a(te, h_) === sr) { + const c0 = Te.tryReuseExistingTypeNode(te, h_); + if (c0) + return c0; + } + return (Xi = te.visitedTypes) != null && Xi.has(Va) ? jr(te) : Sn(sr, qn); + } + const uu = V8(sr) ? 788968 : 111551; + if (zm(ss.valueDeclaration)) + return Xa(ss, te, uu); + if (!ps && (ss.flags & 32 && !Fn && !$8(ss) && !(ss.valueDeclaration && $n(ss.valueDeclaration) && te.flags & 2048 && (!tl(ss.valueDeclaration) || v1( + ss, + te.enclosingDeclaration, + uu, + /*shouldComputeAliasesToMakeVisible*/ + !1 + ).accessibility !== 0)) || ss.flags & 896 || sl())) + if (gt(sr, te)) + te.depth += 1; + else + return Xa(ss, te, uu); + if ((xa = te.visitedTypes) != null && xa.has(Va)) { + const zu = $L(sr); + return zu ? Xa( + zu, + te, + 788968 + /* Type */ + ) : jr(te); + } else + return Sn(sr, qn); + } else + return qn(sr); + function sl() { + var al; + const uu = !!(ss.flags & 8192) && // typeof static method + ot(ss.declarations, (h_) => Js(h_) && !QPe(_s(h_))), zu = !!(ss.flags & 16) && (ss.parent || // is exported function symbol + lr( + ss.declarations, + (h_) => h_.parent.kind === 308 || h_.parent.kind === 269 + /* ModuleBlock */ + )); + if (uu || zu) + return (!!(te.flags & 4096) || ((al = te.visitedTypes) == null ? void 0 : al.has(Va))) && // it is type of the symbol uses itself recursively + (!(te.flags & 8) || Hk(ss, te.enclosingDeclaration)); + } + } + function Sn(sr, Fn) { + var ps, Xi, xa; + const Va = sr.id, ss = Dn(sr) & 16 && sr.symbol && sr.symbol.flags & 32, sl = Dn(sr) & 4 && sr.node ? "N" + Ma(sr.node) : sr.flags & 16777216 ? "N" + Ma(sr.root.node) : sr.symbol ? (ss ? "+" : "") + Xs(sr.symbol) : void 0; + te.visitedTypes || (te.visitedTypes = /* @__PURE__ */ new Set()), sl && !te.symbolDepth && (te.symbolDepth = /* @__PURE__ */ new Map()); + const al = te.maxExpansionDepth >= 0 ? void 0 : te.enclosingDeclaration && xn(te.enclosingDeclaration), uu = `${jl(sr)}|${te.flags}|${te.internalFlags}`; + al && (al.serializedTypes || (al.serializedTypes = /* @__PURE__ */ new Map())); + const zu = (ps = al?.serializedTypes) == null ? void 0 : ps.get(uu); + if (zu) + return (Xi = zu.trackedSymbols) == null || Xi.forEach( + ([bg, XE, gR]) => te.tracker.trackSymbol( + bg, + XE, + gR + ) + ), zu.truncating && (te.truncating = !0), te.approximateLength += zu.addedLength, gC(zu.node); + let h_; + if (sl) { + if (h_ = te.symbolDepth.get(sl) || 0, h_ > 10) + return jr(te); + te.symbolDepth.set(sl, h_ + 1); + } + te.visitedTypes.add(Va); + const c0 = te.trackedSymbols; + te.trackedSymbols = void 0; + const db = te.approximateLength, V2 = Fn(sr), O1 = te.approximateLength - db; + return !te.reportedDiagnostic && !te.encounteredError && ((xa = al?.serializedTypes) == null || xa.set(uu, { + node: V2, + truncating: te.truncating, + addedLength: O1, + trackedSymbols: te.trackedSymbols + })), te.visitedTypes.delete(Va), sl && te.symbolDepth.set(sl, h_), te.trackedSymbols = c0, V2; + function gC(bg) { + return !lo(bg) && vs(bg) === bg ? bg : l(te, N.cloneNode(br( + bg, + gC, + /*context*/ + void 0, + OP, + gC + )), bg); + } + function OP(bg, XE, gR, tge, rge) { + return bg && bg.length === 0 ? ct(N.createNodeArray( + /*elements*/ + void 0, + bg.hasTrailingComma + ), bg) : Ar(bg, XE, gR, tge, rge); + } + } + function qn(sr) { + if (L_(sr) || sr.containsError) + return Lr(sr); + const Fn = $d(sr); + if (!Fn.properties.length && !Fn.indexInfos.length) { + if (!Fn.callSignatures.length && !Fn.constructSignatures.length) + return te.approximateLength += 2, un( + N.createTypeLiteralNode( + /*members*/ + void 0 + ), + 1 + /* SingleLine */ + ); + if (Fn.callSignatures.length === 1 && !Fn.constructSignatures.length) { + const ss = Fn.callSignatures[0]; + return zn(ss, 185, te); + } + if (Fn.constructSignatures.length === 1 && !Fn.callSignatures.length) { + const ss = Fn.constructSignatures[0]; + return zn(ss, 186, te); + } + } + const ps = kn(Fn.constructSignatures, (ss) => !!(ss.flags & 4)); + if (ot(ps)) { + const ss = hr(ps, ET); + return Fn.callSignatures.length + (Fn.constructSignatures.length - ps.length) + Fn.indexInfos.length + // exclude `prototype` when writing a class expression as a type literal, as per + // the logic in `createTypeNodesFromResolvedType`. + (te.flags & 2048 ? l0(Fn.properties, (al) => !(al.flags & 4194304)) : wr(Fn.properties)) && ss.push(vT(Fn)), jt(sa(ss), te); + } + const Xi = ve(te); + te.flags |= 4194304; + const xa = Pa(Fn); + Xi(); + const Va = N.createTypeLiteralNode(xa); + return te.approximateLength += 2, un( + Va, + te.flags & 1024 ? 0 : 1 + /* SingleLine */ + ), Va; + } + function Yn(sr) { + let Fn = Ao(sr); + if (sr.target === wa || sr.target === ma) { + if (te.flags & 2) { + const xa = jt(Fn[0], te); + return N.createTypeReferenceNode(sr.target === wa ? "Array" : "ReadonlyArray", [xa]); + } + const ps = jt(Fn[0], te), Xi = N.createArrayTypeNode(ps); + return sr.target === wa ? Xi : N.createTypeOperatorNode(148, Xi); + } else if (sr.target.objectFlags & 8) { + if (Fn = Qc(Fn, (ps, Xi) => i0(ps, !!(sr.target.elementFlags[Xi] & 2))), Fn.length > 0) { + const ps = ry(sr), Xi = nn(Fn.slice(0, ps), te); + if (Xi) { + const { labeledElementDeclarations: xa } = sr.target; + for (let ss = 0; ss < Xi.length; ss++) { + const sl = sr.target.elementFlags[ss], al = xa?.[ss]; + al ? Xi[ss] = N.createNamedTupleMember( + sl & 12 ? N.createToken( + 26 + /* DotDotDotToken */ + ) : void 0, + N.createIdentifier(Si(ame(al))), + sl & 2 ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, + sl & 4 ? N.createArrayTypeNode(Xi[ss]) : Xi[ss] + ) : Xi[ss] = sl & 12 ? N.createRestTypeNode(sl & 4 ? N.createArrayTypeNode(Xi[ss]) : Xi[ss]) : sl & 2 ? N.createOptionalTypeNode(Xi[ss]) : Xi[ss]; + } + const Va = un( + N.createTupleTypeNode(Xi), + 1 + /* SingleLine */ + ); + return sr.target.readonly ? N.createTypeOperatorNode(148, Va) : Va; + } + } + if (te.encounteredError || te.flags & 524288) { + const ps = un( + N.createTupleTypeNode([]), + 1 + /* SingleLine */ + ); + return sr.target.readonly ? N.createTypeOperatorNode(148, ps) : ps; + } + te.encounteredError = !0; + return; + } else { + if (te.flags & 2048 && sr.symbol.valueDeclaration && $n(sr.symbol.valueDeclaration) && !Hk(sr.symbol, te.enclosingDeclaration)) + return $r(sr); + { + const ps = sr.target.outerTypeParameters; + let Xi = 0, xa; + if (ps) { + const al = ps.length; + for (; Xi < al; ) { + const uu = Xi, zu = N3e(ps[Xi]); + do + Xi++; + while (Xi < al && N3e(ps[Xi]) === zu); + if (!AR(ps, Fn, uu, Xi)) { + const h_ = nn(Fn.slice(uu, Xi), te), c0 = ve(te); + te.flags |= 16; + const db = Xa(zu, te, 788968, h_); + c0(), xa = xa ? Ur(xa, db) : db; + } + } + } + let Va; + if (Fn.length > 0) { + let al = 0; + if (sr.target.typeParameters && (al = Math.min(sr.target.typeParameters.length, Fn.length), (hf(sr, u$( + /*reportErrors*/ + !1 + )) || hf(sr, X3e( + /*reportErrors*/ + !1 + )) || hf(sr, aM( + /*reportErrors*/ + !1 + )) || hf(sr, $3e( + /*reportErrors*/ + !1 + ))) && (!sr.node || !of(sr.node) || !sr.node.typeArguments || sr.node.typeArguments.length < al))) + for (; al > 0; ) { + const uu = Fn[al - 1], zu = sr.target.typeParameters[al - 1], h_ = A2(zu); + if (!h_ || !lh(uu, h_)) + break; + al--; + } + Va = nn(Fn.slice(Xi, al), te); + } + const ss = ve(te); + te.flags |= 16; + const sl = Xa(sr.symbol, te, 788968, Va); + return ss(), xa ? Ur(xa, sl) : sl; + } + } + } + function Ur(sr, Fn) { + if (ym(sr)) { + let ps = sr.typeArguments, Xi = sr.qualifier; + Xi && (Me(Xi) ? ps !== SS(Xi) && (Xi = k0(N.cloneNode(Xi), ps)) : ps !== SS(Xi.right) && (Xi = N.updateQualifiedName(Xi, Xi.left, k0(N.cloneNode(Xi.right), ps)))), ps = Fn.typeArguments; + const xa = ci(Fn); + for (const Va of xa) + Xi = Xi ? N.createQualifiedName(Xi, Va) : Va; + return N.updateImportTypeNode( + sr, + sr.argument, + sr.attributes, + Xi, + ps, + sr.isTypeOf + ); + } else { + let ps = sr.typeArguments, Xi = sr.typeName; + Me(Xi) ? ps !== SS(Xi) && (Xi = k0(N.cloneNode(Xi), ps)) : ps !== SS(Xi.right) && (Xi = N.updateQualifiedName(Xi, Xi.left, k0(N.cloneNode(Xi.right), ps))), ps = Fn.typeArguments; + const xa = ci(Fn); + for (const Va of xa) + Xi = N.createQualifiedName(Xi, Va); + return N.updateTypeReferenceNode( + sr, + Xi, + ps + ); + } + } + function ci(sr) { + let Fn = sr.typeName; + const ps = []; + for (; !Me(Fn); ) + ps.unshift(Fn.right), Fn = Fn.left; + return ps.unshift(Fn), ps; + } + function qi(sr, Fn, ps) { + if (sr.components && Ni(sr.components, (xa) => { + var Va; + return !!(xa.name && Gs(xa.name) && to(xa.name.expression) && Fn.enclosingDeclaration && ((Va = $k( + xa.name.expression, + Fn.enclosingDeclaration, + /*shouldComputeAliasToMakeVisible*/ + !1 + )) == null ? void 0 : Va.accessibility) === 0); + })) { + const xa = kn(sr.components, (Va) => !PE(Va)); + return hr(xa, (Va) => (en(Va.name.expression, Fn.enclosingDeclaration, Fn), l( + Fn, + N.createPropertySignature( + sr.isReadonly ? [N.createModifier( + 148 + /* ReadonlyKeyword */ + )] : void 0, + Va.name, + ($u(Va) || os(Va) || cd(Va) || rc(Va) || Pg(Va) || am(Va)) && Va.questionToken ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, + ps || jt(Yr(Va.symbol), Fn) + ), + Va + ))); + } + return [Ri(sr, Fn, ps)]; + } + function Pa(sr) { + if (We(te)) + return te.out.truncated = !0, te.flags & 1 ? [C4(N.createNotEmittedTypeElement(), 3, "elided")] : [N.createPropertySignature( + /*modifiers*/ + void 0, + "...", + /*questionToken*/ + void 0, + /*type*/ + void 0 + )]; + te.typeStack.push(-1); + const Fn = []; + for (const xa of sr.callSignatures) + Fn.push(zn(xa, 180, te)); + for (const xa of sr.constructSignatures) + xa.flags & 4 || Fn.push(zn(xa, 181, te)); + for (const xa of sr.indexInfos) + Fn.push(...qi(xa, te, sr.objectFlags & 1024 ? jr(te) : void 0)); + const ps = sr.properties; + if (!ps) + return te.typeStack.pop(), Fn; + let Xi = 0; + for (const xa of ps) + if (!(pb(te) && xa.flags & 4194304)) { + if (Xi++, te.flags & 2048) { + if (xa.flags & 4194304) + continue; + up(xa) & 6 && te.tracker.reportPrivateInBaseOfClassExpression && te.tracker.reportPrivateInBaseOfClassExpression(Si(xa.escapedName)); + } + if (We(te) && Xi + 2 < ps.length - 1) { + if (te.out.truncated = !0, te.flags & 1) { + const Va = Fn.pop(); + Fn.push(C4(Va, 3, `... ${ps.length - Xi} more elided ...`)); + } else + Fn.push(N.createPropertySignature( + /*modifiers*/ + void 0, + `... ${ps.length - Xi} more ...`, + /*questionToken*/ + void 0, + /*type*/ + void 0 + )); + or(ps[ps.length - 1], te, Fn); + break; + } + or(xa, te, Fn); + } + return te.typeStack.pop(), Fn.length ? Fn : void 0; + } + } + function jr(we) { + return we.approximateLength += 3, we.flags & 1 ? Uy(N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ), 3, "elided") : N.createTypeReferenceNode( + N.createIdentifier("..."), + /*typeArguments*/ + void 0 + ); + } + function Kr(we, te) { + var Ht; + return !!(uc(we) & 8192) && (ms(te.reverseMappedStack, we) || ((Ht = te.reverseMappedStack) == null ? void 0 : Ht[0]) && !(Dn(pa(te.reverseMappedStack).links.propertyType) & 16) || xe()); + function xe() { + var Re; + if ((((Re = te.reverseMappedStack) == null ? void 0 : Re.length) ?? 0) < 3) + return !1; + for (let Ze = 0; Ze < 3; Ze++) + if (te.reverseMappedStack[te.reverseMappedStack.length - 1 - Ze].links.mappedType.symbol !== we.links.mappedType.symbol) + return !1; + return !0; + } + } + function or(we, te, Ht) { + var Zt; + const xe = !!(uc(we) & 8192), Re = Kr(we, te) ? Le : Hd(we), Ze = te.enclosingDeclaration; + if (te.enclosingDeclaration = void 0, te.tracker.canTrackSymbol && X8(we.escapedName)) + if (we.declarations) { + const Sn = Ca(we.declarations); + if (PE(Sn)) + if (_n(Sn)) { + const qn = _s(Sn); + qn && uo(qn) && oN(qn.argumentExpression) && en(qn.argumentExpression, Ze, te); + } else + en(Sn.name.expression, Ze, te); + } else + te.tracker.reportNonSerializableProperty(Wi(we)); + te.enclosingDeclaration = we.valueDeclaration || ((Zt = we.declarations) == null ? void 0 : Zt[0]) || Ze; + const Pt = FP(we, te); + if (te.enclosingDeclaration = Ze, te.approximateLength += cc(we).length + 1, we.flags & 98304) { + const Sn = Z0(we); + if (!Gr(Re) && !Gr(Sn)) { + const qn = Pn(we).mapper, Yn = Oo( + we, + 173 + /* PropertyDeclaration */ + ); + if (Re !== Sn || we.parent.flags & 32 && !Yn) { + const Ur = Oo( + we, + 178 + /* GetAccessor */ + ); + if (Ur) { + const qi = Xf(Ur); + Ht.push( + ir( + te, + zn(qn ? FT(qi, qn) : qi, 178, te, { name: Pt }), + Ur + ) + ); + } + const ci = Oo( + we, + 179 + /* SetAccessor */ + ); + if (ci) { + const qi = Xf(ci); + Ht.push( + ir( + te, + zn(qn ? FT(qi, qn) : qi, 179, te, { name: Pt }), + ci + ) + ); + } + return; + } + if (we.parent.flags & 32 && Yn && Nn(Yn.modifiers, dz)) { + const Ur = Mm( + /*declaration*/ + void 0, + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + Ge, + Re, + /*resolvedTypePredicate*/ + void 0, + 0, + 0 + /* None */ + ); + Ht.push( + ir( + te, + zn(Ur, 178, te, { name: Pt }), + Yn + ) + ); + const ci = ga(1, "arg"); + ci.links.type = Sn; + const qi = Mm( + /*declaration*/ + void 0, + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + [ci], + _r, + /*resolvedTypePredicate*/ + void 0, + 0, + 0 + /* None */ + ); + Ht.push( + zn(qi, 179, te, { name: Pt }) + ); + return; + } + } + } + const $t = we.flags & 16777216 ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0; + if (we.flags & 8208 && !ey(Re).length && !tm(we)) { + const Sn = Is( + Xc(Re, (qn) => !(qn.flags & 32768)), + 0 + /* Call */ + ); + for (const qn of Sn) { + const Yn = zn(qn, 174, te, { name: Pt, questionToken: $t }); + Ht.push($r(Yn, qn.declaration || we.valueDeclaration)); + } + if (Sn.length || !$t) + return; + } + let At; + Kr(we, te) ? At = jr(te) : (xe && (te.reverseMappedStack || (te.reverseMappedStack = []), te.reverseMappedStack.push(we)), At = Re ? Tn( + te, + /*declaration*/ + void 0, + Re, + we + ) : N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ), xe && te.reverseMappedStack.pop()); + const Yt = tm(we) ? [N.createToken( + 148 + /* ReadonlyKeyword */ + )] : void 0; + Yt && (te.approximateLength += 9); + const Lr = N.createPropertySignature( + Yt, + Pt, + $t, + At + ); + Ht.push($r(Lr, we.valueDeclaration)); + function $r(Sn, qn) { + var Yn; + const Ur = (Yn = we.declarations) == null ? void 0 : Yn.find( + (ci) => ci.kind === 349 + /* JSDocPropertyTag */ + ); + if (Ur) { + const ci = s3(Ur.comment); + ci && tv(Sn, [{ kind: 3, text: `* + * ` + ci.replace(/\n/g, ` + * `) + ` + `, pos: -1, end: -1, hasTrailingNewLine: !0 }]); + } else qn && ir(te, Sn, qn); + return Sn; + } + } + function ir(we, te, Ht) { + return we.enclosingFile && we.enclosingFile === xr(Ht) ? el(te, Ht) : te; + } + function nn(we, te, Ht) { + if (ot(we)) { + if (We(te)) + if (te.out.truncated = !0, Ht) { + if (we.length > 2) + return [ + jt(we[0], te), + te.flags & 1 ? Uy(N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ), 3, `... ${we.length - 2} more elided ...`) : N.createTypeReferenceNode( + `... ${we.length - 2} more ...`, + /*typeArguments*/ + void 0 + ), + jt(we[we.length - 1], te) + ]; + } else return [ + te.flags & 1 ? Uy(N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ), 3, "elided") : N.createTypeReferenceNode( + "...", + /*typeArguments*/ + void 0 + ) + ]; + const xe = !(te.flags & 64) ? Fp() : void 0, Re = []; + let Ze = 0; + for (const Pt of we) { + if (Ze++, We(te) && Ze + 2 < we.length - 1) { + te.out.truncated = !0, Re.push( + te.flags & 1 ? Uy(N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ), 3, `... ${we.length - Ze} more elided ...`) : N.createTypeReferenceNode( + `... ${we.length - Ze} more ...`, + /*typeArguments*/ + void 0 + ) + ); + const At = jt(we[we.length - 1], te); + At && Re.push(At); + break; + } + te.approximateLength += 2; + const $t = jt(Pt, te); + $t && (Re.push($t), xe && qee($t) && xe.add($t.typeName.escapedText, [Pt, Re.length - 1])); + } + if (xe) { + const Pt = ve(te); + te.flags |= 64, xe.forEach(($t) => { + if (!Hee($t, ([At], [Yt]) => Qn(At, Yt))) + for (const [At, Yt] of $t) + Re[Yt] = jt(At, te); + }), Pt(); + } + return Re; + } + } + function Qn(we, te) { + return we === te || !!we.symbol && we.symbol === te.symbol || !!we.aliasSymbol && we.aliasSymbol === te.aliasSymbol; + } + function Ri(we, te, Ht) { + const Zt = aK(we) || "x", xe = jt(we.keyType, te), Re = N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + Zt, + /*questionToken*/ + void 0, + xe, + /*initializer*/ + void 0 + ); + return Ht || (Ht = jt(we.type || Le, te)), !we.type && !(te.flags & 2097152) && (te.encounteredError = !0), te.approximateLength += Zt.length + 4, N.createIndexSignature( + we.isReadonly ? [N.createToken( + 148 + /* ReadonlyKeyword */ + )] : void 0, + [Re], + Ht + ); + } + function zn(we, te, Ht, Zt) { + var xe; + let Re, Ze; + const Pt = n3e( + we, + /*skipUnionExpanding*/ + !0 + )[0], $t = ks(Ht, we.declaration, Pt, we.typeParameters, we.parameters, we.mapper); + Ht.approximateLength += 3, Ht.flags & 32 && we.target && we.mapper && we.target.typeParameters ? Ze = we.target.typeParameters.map((Yn) => jt(Mi(Yn, we.mapper), Ht)) : Re = we.typeParameters && we.typeParameters.map((Yn) => Sc(Yn, Ht)); + const At = ve(Ht); + Ht.flags &= -257; + const Yt = (ot(Pt, (Yn) => Yn !== Pt[Pt.length - 1] && !!(uc(Yn) & 32768)) ? we.parameters : Pt).map((Yn) => Br( + Yn, + Ht, + te === 177 + /* Constructor */ + )), Lr = Ht.flags & 33554432 ? void 0 : Ua(we, Ht); + Lr && Yt.unshift(Lr), At(); + const $r = aa(Ht, we); + let Sn = Zt?.modifiers; + if (te === 186 && we.flags & 4) { + const Yn = pm(Sn); + Sn = N.createModifiersFromModifierFlags( + Yn | 64 + /* Abstract */ + ); + } + const qn = te === 180 ? N.createCallSignature(Re, Yt, $r) : te === 181 ? N.createConstructSignature(Re, Yt, $r) : te === 174 ? N.createMethodSignature(Sn, Zt?.name ?? N.createIdentifier(""), Zt?.questionToken, Re, Yt, $r) : te === 175 ? N.createMethodDeclaration( + Sn, + /*asteriskToken*/ + void 0, + Zt?.name ?? N.createIdentifier(""), + /*questionToken*/ + void 0, + Re, + Yt, + $r, + /*body*/ + void 0 + ) : te === 177 ? N.createConstructorDeclaration( + Sn, + Yt, + /*body*/ + void 0 + ) : te === 178 ? N.createGetAccessorDeclaration( + Sn, + Zt?.name ?? N.createIdentifier(""), + Yt, + $r, + /*body*/ + void 0 + ) : te === 179 ? N.createSetAccessorDeclaration( + Sn, + Zt?.name ?? N.createIdentifier(""), + Yt, + /*body*/ + void 0 + ) : te === 182 ? N.createIndexSignature(Sn, Yt, $r) : te === 318 ? N.createJSDocFunctionType(Yt, $r) : te === 185 ? N.createFunctionTypeNode(Re, Yt, $r ?? N.createTypeReferenceNode(N.createIdentifier(""))) : te === 186 ? N.createConstructorTypeNode(Sn, Re, Yt, $r ?? N.createTypeReferenceNode(N.createIdentifier(""))) : te === 263 ? N.createFunctionDeclaration( + Sn, + /*asteriskToken*/ + void 0, + Zt?.name ? Us(Zt.name, Me) : N.createIdentifier(""), + Re, + Yt, + $r, + /*body*/ + void 0 + ) : te === 219 ? N.createFunctionExpression( + Sn, + /*asteriskToken*/ + void 0, + Zt?.name ? Us(Zt.name, Me) : N.createIdentifier(""), + Re, + Yt, + $r, + N.createBlock([]) + ) : te === 220 ? N.createArrowFunction( + Sn, + Re, + Yt, + $r, + /*equalsGreaterThanToken*/ + void 0, + N.createBlock([]) + ) : E.assertNever(te); + if (Ze && (qn.typeArguments = N.createNodeArray(Ze)), ((xe = we.declaration) == null ? void 0 : xe.kind) === 324 && we.declaration.parent.kind === 340) { + const Yn = Qo( + we.declaration.parent.parent, + /*includeTrivia*/ + !0 + ).slice(2, -2).split(/\r\n|\n|\r/).map((Ur) => Ur.replace(/^\s+/, " ")).join(` +`); + Uy( + qn, + 3, + Yn, + /*hasTrailingNewLine*/ + !0 + ); + } + return $t?.(), qn; + } + function bi(we) { + i && i.throwIfCancellationRequested && i.throwIfCancellationRequested(); + let te, Ht, Zt = !1; + const xe = we.tracker, Re = we.trackedSymbols; + we.trackedSymbols = void 0; + const Ze = we.encounteredError; + return we.tracker = new Dne(we, { + ...xe.inner, + reportCyclicStructureError() { + Pt(() => xe.reportCyclicStructureError()); + }, + reportInaccessibleThisError() { + Pt(() => xe.reportInaccessibleThisError()); + }, + reportInaccessibleUniqueSymbolError() { + Pt(() => xe.reportInaccessibleUniqueSymbolError()); + }, + reportLikelyUnsafeImportRequiredError(Yt) { + Pt(() => xe.reportLikelyUnsafeImportRequiredError(Yt)); + }, + reportNonSerializableProperty(Yt) { + Pt(() => xe.reportNonSerializableProperty(Yt)); + }, + reportPrivateInBaseOfClassExpression(Yt) { + Pt(() => xe.reportPrivateInBaseOfClassExpression(Yt)); + }, + trackSymbol(Yt, Lr, $r) { + return (te ?? (te = [])).push([Yt, Lr, $r]), !1; + }, + moduleResolverHost: we.tracker.moduleResolverHost + }, we.tracker.moduleResolverHost), { + startRecoveryScope: $t, + finalizeBoundary: At, + markError: Pt, + hadError: () => Zt + }; + function Pt(Yt) { + Zt = !0, Yt && (Ht ?? (Ht = [])).push(Yt); + } + function $t() { + const Yt = te?.length ?? 0, Lr = Ht?.length ?? 0; + return () => { + Zt = !1, te && (te.length = Yt), Ht && (Ht.length = Lr); + }; + } + function At() { + return we.tracker = xe, we.trackedSymbols = Re, we.encounteredError = Ze, Ht?.forEach((Yt) => Yt()), Zt ? !1 : (te?.forEach( + ([Yt, Lr, $r]) => we.tracker.trackSymbol( + Yt, + Lr, + $r + ) + ), !0); + } + } + function ks(we, te, Ht, Zt, xe, Re) { + const Ze = qI(we); + let Pt, $t; + const At = we.enclosingDeclaration, Yt = we.mapper; + if (Re && (we.mapper = Re), we.enclosingDeclaration && te) { + let Lr = function($r, Sn) { + E.assert(we.enclosingDeclaration); + let qn; + xn(we.enclosingDeclaration).fakeScopeForSignatureDeclaration === $r ? qn = we.enclosingDeclaration : we.enclosingDeclaration.parent && xn(we.enclosingDeclaration.parent).fakeScopeForSignatureDeclaration === $r && (qn = we.enclosingDeclaration.parent), E.assertOptionalNode(qn, Ns); + const Yn = qn?.locals ?? Bs(); + let Ur, ci; + if (Sn((qi, Pa) => { + if (qn) { + const sr = Yn.get(qi); + sr ? ci = Er(ci, { name: qi, oldSymbol: sr }) : Ur = Er(Ur, qi); + } + Yn.set(qi, Pa); + }), qn) + return function() { + lr(Ur, (Pa) => Yn.delete(Pa)), lr(ci, (Pa) => Yn.set(Pa.name, Pa.oldSymbol)); + }; + { + const qi = N.createBlock(Ge); + xn(qi).fakeScopeForSignatureDeclaration = $r, qi.locals = Yn, za(qi, we.enclosingDeclaration), we.enclosingDeclaration = qi; + } + }; + Pt = ot(Ht) ? Lr( + "params", + ($r) => { + if (Ht) + for (let Sn = 0; Sn < Ht.length; Sn++) { + const qn = Ht[Sn], Yn = xe?.[Sn]; + xe && Yn !== qn ? ($r(qn.escapedName, Y), Yn && $r(Yn.escapedName, Y)) : lr(qn.declarations, (Ur) => { + if (Ii(Ur) && ws(Ur.name)) + return ci(Ur.name), !0; + return; + function ci(Pa) { + lr(Pa.elements, (sr) => { + switch (sr.kind) { + case 233: + return; + case 209: + return qi(sr); + default: + return E.assertNever(sr); + } + }); + } + function qi(Pa) { + if (ws(Pa.name)) + return ci(Pa.name); + const sr = yn(Pa); + $r(sr.escapedName, sr); + } + }) || $r(qn.escapedName, qn); + } + } + ) : void 0, we.flags & 4 && ot(Zt) && ($t = Lr( + "typeParams", + ($r) => { + for (const Sn of Zt ?? Ge) { + const qn = $o(Sn, we).escapedText; + $r(qn, Sn.symbol); + } + } + )); + } + return () => { + Pt?.(), $t?.(), Ze(), we.enclosingDeclaration = At, we.mapper = Yt; + }; + } + function Ua(we, te) { + if (we.thisParameter) + return Br(we.thisParameter, te); + if (we.declaration && an(we.declaration)) { + const Ht = v7(we.declaration); + if (Ht && Ht.typeExpression) + return N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "this", + /*questionToken*/ + void 0, + jt(a(te, Ht.typeExpression), te) + ); + } + } + function Vi(we, te, Ht) { + const Zt = ve(te); + te.flags &= -513; + const xe = N.createModifiersFromModifierFlags(Bpe(we)), Re = $o(we, te), Ze = A2(we), Pt = Ze && jt(Ze, te); + return Zt(), N.createTypeParameterDeclaration(xe, Re, Ht, Pt); + } + function jo(we, te, Ht) { + return !lt(we, Ht) && te && a(Ht, te) === we && Te.tryReuseExistingTypeNode(Ht, te) || jt(we, Ht); + } + function Sc(we, te, Ht = m_(we)) { + const Zt = Ht && jo(Ht, i$(we), te); + return Vi(we, te, Zt); + } + function Bu(we, te) { + const Ht = we.kind === 2 || we.kind === 3 ? N.createToken( + 131 + /* AssertsKeyword */ + ) : void 0, Zt = we.kind === 1 || we.kind === 3 ? un( + N.createIdentifier(we.parameterName), + 16777216 + /* NoAsciiEscaping */ + ) : N.createThisTypeNode(), xe = we.type && jt(we.type, te); + return N.createTypePredicateNode(Ht, Zt, xe); + } + function Dr(we) { + const te = Oo( + we, + 170 + /* Parameter */ + ); + if (te) + return te; + if (!Ng(we)) + return Oo( + we, + 342 + /* JSDocParameterTag */ + ); + } + function Br(we, te, Ht) { + const Zt = Dr(we), xe = Yr(we), Re = Tn(te, Zt, xe, we), Ze = !(te.flags & 8192) && Ht && Zt && Vp(Zt) ? hr(Tb(Zt), N.cloneNode) : void 0, $t = Zt && Hm(Zt) || uc(we) & 32768 ? N.createToken( + 26 + /* DotDotDotToken */ + ) : void 0, At = xi(we, Zt, te), Lr = Zt && K8(Zt) || uc(we) & 16384 ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, $r = N.createParameterDeclaration( + Ze, + $t, + At, + Lr, + Re, + /*initializer*/ + void 0 + ); + return te.approximateLength += cc(we).length + 3, $r; + } + function xi(we, te, Ht) { + return te && te.name ? te.name.kind === 80 ? un( + N.cloneNode(te.name), + 16777216 + /* NoAsciiEscaping */ + ) : te.name.kind === 167 ? un( + N.cloneNode(te.name.right), + 16777216 + /* NoAsciiEscaping */ + ) : Zt(te.name) : cc(we); + function Zt(xe) { + return Re(xe); + function Re(Ze) { + Ht.tracker.canTrackSymbol && Gs(Ze) && Nfe(Ze) && en(Ze.expression, Ht.enclosingDeclaration, Ht); + let Pt = br( + Ze, + Re, + /*context*/ + void 0, + /*nodesVisitor*/ + void 0, + Re + ); + return ya(Pt) && (Pt = N.updateBindingElement( + Pt, + Pt.dotDotDotToken, + Pt.propertyName, + Pt.name, + /*initializer*/ + void 0 + )), lo(Pt) || (Pt = N.cloneNode(Pt)), un( + Pt, + 16777217 + /* NoAsciiEscaping */ + ); + } + } + } + function en(we, te, Ht) { + if (!Ht.tracker.canTrackSymbol) return; + const Zt = i_(we), xe = st( + te, + Zt.escapedText, + 1160127, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !0 + ); + if (xe) + Ht.tracker.trackSymbol( + xe, + te, + 111551 + /* Value */ + ); + else { + const Re = st( + Zt, + Zt.escapedText, + 1160127, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !0 + ); + Re && Ht.tracker.trackSymbol( + Re, + te, + 111551 + /* Value */ + ); + } + } + function us(we, te, Ht, Zt) { + return te.tracker.trackSymbol(we, te.enclosingDeclaration, Ht), Ga(we, te, Ht, Zt); + } + function Ga(we, te, Ht, Zt) { + let xe; + return !(we.flags & 262144) && (te.enclosingDeclaration || te.flags & 64) && !(te.internalFlags & 4) ? (xe = E.checkDefined(Ze( + we, + Ht, + /*endOfChain*/ + !0 + )), E.assert(xe && xe.length > 0)) : xe = [we], xe; + function Ze(Pt, $t, At) { + let Yt = $0(Pt, te.enclosingDeclaration, $t, !!(te.flags & 128)), Lr; + if (!Yt || E2(Yt[0], te.enclosingDeclaration, Yt.length === 1 ? $t : yd($t))) { + const Sn = C2(Yt ? Yt[0] : Pt, te.enclosingDeclaration, $t); + if (wr(Sn)) { + Lr = Sn.map( + (Ur) => ot(Ur.declarations, D2) ? Oc(Ur, te) : void 0 + ); + const qn = Sn.map((Ur, ci) => ci); + qn.sort($r); + const Yn = qn.map((Ur) => Sn[Ur]); + for (const Ur of Yn) { + const ci = Ze( + Ur, + yd($t), + /*endOfChain*/ + !1 + ); + if (ci) { + if (Ur.exports && Ur.exports.get( + "export=" + /* ExportEquals */ + ) && le(Ur.exports.get( + "export=" + /* ExportEquals */ + ), Pt)) { + Yt = ci; + break; + } + Yt = ci.concat(Yt || [C(Ur, Pt) || Pt]); + break; + } + } + } + } + if (Yt) + return Yt; + if ( + // If this is the last part of outputting the symbol, always output. The cases apply only to parent symbols. + At || // If a parent symbol is an anonymous type, don't write it. + !(Pt.flags & 6144) + ) + return !At && !Zt && lr(Pt.declarations, D2) ? void 0 : [Pt]; + function $r(Sn, qn) { + const Yn = Lr[Sn], Ur = Lr[qn]; + if (Yn && Ur) { + const ci = xf(Ur); + return xf(Yn) === ci ? vO(Yn) - vO(Ur) : ci ? -1 : 1; + } + return 0; + } + } + } + function Io(we, te) { + let Ht; + return $E(we).flags & 524384 && (Ht = N.createNodeArray(hr(ia(we), (xe) => Sc(xe, te)))), Ht; + } + function Jl(we, te, Ht) { + var Zt; + E.assert(we && 0 <= te && te < we.length); + const xe = we[te], Re = Xs(xe); + if ((Zt = Ht.typeParameterSymbolList) != null && Zt.has(Re)) + return; + Ht.mustCreateTypeParameterSymbolList && (Ht.mustCreateTypeParameterSymbolList = !1, Ht.typeParameterSymbolList = new Set(Ht.typeParameterSymbolList)), Ht.typeParameterSymbolList.add(Re); + let Ze; + if (Ht.flags & 512 && te < we.length - 1) { + const Pt = xe, $t = we[te + 1]; + if (uc($t) & 1) { + const At = po( + Pt.flags & 2097152 ? Rl(Pt) : Pt + ); + Ze = nn(hr(At, (Yt) => ny(Yt, $t.links.mapper)), Ht); + } else + Ze = Io(xe, Ht); + } + return Ze; + } + function Ta(we) { + return $b(we.objectType) ? Ta(we.objectType) : we; + } + function Oc(we, te, Ht) { + let Zt = Oo( + we, + 308 + /* SourceFile */ + ); + if (!Zt) { + const Lr = Lc(we.declarations, ($r) => yT($r, we)); + Lr && (Zt = Oo( + Lr, + 308 + /* SourceFile */ + )); + } + if (Zt && Zt.moduleName !== void 0) + return Zt.moduleName; + if (!Zt && kne.test(we.escapedName)) + return we.escapedName.substring(1, we.escapedName.length - 1); + if (!te.enclosingFile || !te.tracker.moduleResolverHost) + return kne.test(we.escapedName) ? we.escapedName.substring(1, we.escapedName.length - 1) : xr(fB(we)).fileName; + const xe = Vo(te.enclosingDeclaration), Re = AK(xe) ? gx(xe) : void 0, Ze = te.enclosingFile, Pt = Ht || Re && e.getModeForUsageLocation(Ze, Re) || Ze && e.getDefaultResolutionModeForFile(Ze), $t = H4(Ze.path, Pt), At = Pn(we); + let Yt = At.specifierCache && At.specifierCache.get($t); + if (!Yt) { + const Lr = !!F.outFile, { moduleResolverHost: $r } = te.tracker, Sn = Lr ? { ...F, baseUrl: $r.getCommonSourceDirectory() } : F; + Yt = Ca(P1e( + we, + Jr, + Sn, + Ze, + $r, + { + importModuleSpecifierPreference: Lr ? "non-relative" : "project-relative", + importModuleSpecifierEnding: Lr ? "minimal" : Pt === 99 ? "js" : void 0 + }, + { overrideImportMode: Ht } + )), At.specifierCache ?? (At.specifierCache = /* @__PURE__ */ new Map()), At.specifierCache.set($t, Yt); + } + return Yt; + } + function Uc(we) { + const te = N.createIdentifier(Si(we.escapedName)); + return we.parent ? N.createQualifiedName(Uc(we.parent), te) : te; + } + function Xa(we, te, Ht, Zt) { + const xe = us(we, te, Ht, !(te.flags & 16384)), Re = Ht === 111551; + if (ot(xe[0].declarations, D2)) { + const $t = xe.length > 1 ? Pt(xe, xe.length - 1, 1) : void 0, At = Zt || Jl(xe, 0, te), Yt = xr(Vo(te.enclosingDeclaration)), Lr = y3(xe[0]); + let $r, Sn; + if ((Pu(F) === 3 || Pu(F) === 99) && Lr?.impliedNodeFormat === 99 && Lr.impliedNodeFormat !== Yt?.impliedNodeFormat && ($r = Oc( + xe[0], + te, + 99 + /* ESNext */ + ), Sn = N.createImportAttributes( + N.createNodeArray([ + N.createImportAttribute( + N.createStringLiteral("resolution-mode"), + N.createStringLiteral("import") + ) + ]) + )), $r || ($r = Oc(xe[0], te)), !(te.flags & 67108864) && Pu(F) !== 1 && $r.includes("/node_modules/")) { + const Yn = $r; + if (Pu(F) === 3 || Pu(F) === 99) { + const Ur = Yt?.impliedNodeFormat === 99 ? 1 : 99; + $r = Oc(xe[0], te, Ur), $r.includes("/node_modules/") ? $r = Yn : Sn = N.createImportAttributes( + N.createNodeArray([ + N.createImportAttribute( + N.createStringLiteral("resolution-mode"), + N.createStringLiteral(Ur === 99 ? "import" : "require") + ) + ]) + ); + } + Sn || (te.encounteredError = !0, te.tracker.reportLikelyUnsafeImportRequiredError && te.tracker.reportLikelyUnsafeImportRequiredError(Yn)); + } + const qn = N.createLiteralTypeNode(N.createStringLiteral($r)); + if (te.approximateLength += $r.length + 10, !$t || r_($t)) { + if ($t) { + const Yn = Me($t) ? $t : $t.right; + k0( + Yn, + /*typeArguments*/ + void 0 + ); + } + return N.createImportTypeNode(qn, Sn, $t, At, Re); + } else { + const Yn = Ta($t), Ur = Yn.objectType.typeName; + return N.createIndexedAccessTypeNode(N.createImportTypeNode(qn, Sn, Ur, At, Re), Yn.indexType); + } + } + const Ze = Pt(xe, xe.length - 1, 0); + if ($b(Ze)) + return Ze; + if (Re) + return N.createTypeQueryNode(Ze); + { + const $t = Me(Ze) ? Ze : Ze.right, At = SS($t); + return k0( + $t, + /*typeArguments*/ + void 0 + ), N.createTypeReferenceNode(Ze, At); + } + function Pt($t, At, Yt) { + const Lr = At === $t.length - 1 ? Zt : Jl($t, At, te), $r = $t[At], Sn = $t[At - 1]; + let qn; + if (At === 0) + te.flags |= 16777216, qn = Yv($r, te), te.approximateLength += (qn ? qn.length : 0) + 1, te.flags ^= 16777216; + else if (Sn && gf(Sn)) { + const Ur = gf(Sn); + hl(Ur, (ci, qi) => { + if (le(ci, $r) && !X8(qi) && qi !== "export=") + return qn = Si(qi), !0; + }); + } + if (qn === void 0) { + const Ur = Lc($r.declarations, _s); + if (Ur && Gs(Ur) && r_(Ur.expression)) { + const ci = Pt($t, At - 1, Yt); + return r_(ci) ? N.createIndexedAccessTypeNode(N.createParenthesizedType(N.createTypeQueryNode(ci)), N.createTypeQueryNode(Ur.expression)) : ci; + } + qn = Yv($r, te); + } + if (te.approximateLength += qn.length + 1, !(te.flags & 16) && Sn && dg(Sn) && dg(Sn).get($r.escapedName) && le(dg(Sn).get($r.escapedName), $r)) { + const Ur = Pt($t, At - 1, Yt); + return $b(Ur) ? N.createIndexedAccessTypeNode(Ur, N.createLiteralTypeNode(N.createStringLiteral(qn))) : N.createIndexedAccessTypeNode(N.createTypeReferenceNode(Ur, Lr), N.createLiteralTypeNode(N.createStringLiteral(qn))); + } + const Yn = un( + N.createIdentifier(qn), + 16777216 + /* NoAsciiEscaping */ + ); + if (Lr && k0(Yn, N.createNodeArray(Lr)), Yn.symbol = $r, At > Yt) { + const Ur = Pt($t, At - 1, Yt); + return r_(Ur) ? N.createQualifiedName(Ur, Yn) : E.fail("Impossible construct - an export of an indexed access cannot be reachable"); + } + return Yn; + } + } + function Yf(we, te, Ht) { + const Zt = st( + te.enclosingDeclaration, + we, + 788968, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + ); + return Zt && Zt.flags & 262144 ? Zt !== Ht.symbol : !1; + } + function $o(we, te) { + var Ht, Zt, xe, Re; + if (te.flags & 4 && te.typeParameterNames) { + const $t = te.typeParameterNames.get(jl(we)); + if ($t) + return $t; + } + let Ze = wc( + we.symbol, + te, + 788968, + /*expectsIdentifier*/ + !0 + ); + if (!(Ze.kind & 80)) + return N.createIdentifier("(Missing type parameter)"); + const Pt = (Zt = (Ht = we.symbol) == null ? void 0 : Ht.declarations) == null ? void 0 : Zt[0]; + if (Pt && Lo(Pt) && (Ze = l(te, Ze, Pt.name)), te.flags & 4) { + const $t = Ze.escapedText; + let At = ((xe = te.typeParameterNamesByTextNextNameCount) == null ? void 0 : xe.get($t)) || 0, Yt = $t; + for (; (Re = te.typeParameterNamesByText) != null && Re.has(Yt) || Yf(Yt, te, we); ) + At++, Yt = `${$t}_${At}`; + if (Yt !== $t) { + const Lr = SS(Ze); + Ze = N.createIdentifier(Yt), k0(Ze, Lr); + } + te.mustCreateTypeParametersNamesLookups && (te.mustCreateTypeParametersNamesLookups = !1, te.typeParameterNames = new Map(te.typeParameterNames), te.typeParameterNamesByTextNextNameCount = new Map(te.typeParameterNamesByTextNextNameCount), te.typeParameterNamesByText = new Set(te.typeParameterNamesByText)), te.typeParameterNamesByTextNextNameCount.set($t, At), te.typeParameterNames.set(jl(we), Ze), te.typeParameterNamesByText.add(Yt); + } + return Ze; + } + function wc(we, te, Ht, Zt) { + const xe = us(we, te, Ht); + return Zt && xe.length !== 1 && !te.encounteredError && !(te.flags & 65536) && (te.encounteredError = !0), Re(xe, xe.length - 1); + function Re(Ze, Pt) { + const $t = Jl(Ze, Pt, te), At = Ze[Pt]; + Pt === 0 && (te.flags |= 16777216); + const Yt = Yv(At, te); + Pt === 0 && (te.flags ^= 16777216); + const Lr = un( + N.createIdentifier(Yt), + 16777216 + /* NoAsciiEscaping */ + ); + return $t && k0(Lr, N.createNodeArray($t)), Lr.symbol = At, Pt > 0 ? N.createQualifiedName(Re(Ze, Pt - 1), Lr) : Lr; + } + } + function Np(we, te, Ht) { + const Zt = us(we, te, Ht); + return xe(Zt, Zt.length - 1); + function xe(Re, Ze) { + const Pt = Jl(Re, Ze, te), $t = Re[Ze]; + Ze === 0 && (te.flags |= 16777216); + let At = Yv($t, te); + Ze === 0 && (te.flags ^= 16777216); + let Yt = At.charCodeAt(0); + if (R3(Yt) && ot($t.declarations, D2)) { + const Lr = Oc($t, te); + return te.approximateLength += 2 + Lr.length, N.createStringLiteral(Lr); + } + if (Ze === 0 || WJ(At, R)) { + const Lr = un( + N.createIdentifier(At), + 16777216 + /* NoAsciiEscaping */ + ); + return Pt && k0(Lr, N.createNodeArray(Pt)), Lr.symbol = $t, te.approximateLength += 1 + At.length, Ze > 0 ? N.createPropertyAccessExpression(xe(Re, Ze - 1), Lr) : Lr; + } else { + Yt === 91 && (At = At.substring(1, At.length - 1), Yt = At.charCodeAt(0)); + let Lr; + if (R3(Yt) && !($t.flags & 8)) { + const $r = Bp(At).replace(/\\./g, (Sn) => Sn.substring(1)); + te.approximateLength += $r.length + 2, Lr = N.createStringLiteral( + $r, + Yt === 39 + /* singleQuote */ + ); + } else "" + +At === At && (te.approximateLength += At.length, Lr = N.createNumericLiteral(+At)); + if (!Lr) { + const $r = un( + N.createIdentifier(At), + 16777216 + /* NoAsciiEscaping */ + ); + Pt && k0($r, N.createNodeArray(Pt)), $r.symbol = $t, te.approximateLength += At.length, Lr = $r; + } + return te.approximateLength += 2, N.createElementAccessExpression(xe(Re, Ze - 1), Lr); + } + } + } + function IP(we) { + const te = _s(we); + return te ? Gs(te) ? !!(Hi(te.expression).flags & 402653316) : uo(te) ? !!(Hi(te.argumentExpression).flags & 402653316) : ca(te) : !1; + } + function VI(we) { + const te = _s(we); + return !!(te && ca(te) && (te.singleQuote || !lo(te) && Ui(Qo( + te, + /*includeTrivia*/ + !1 + ), "'"))); + } + function FP(we, te) { + const Ht = GX(we); + if (Ht) + if (!!te.tracker.reportPrivateInBaseOfClassExpression && te.flags & 2048) { + let At = Si(we.escapedName); + return At = At.replace(/__#\d+@#/g, "__#private@#"), kN( + At, + da(F), + /*singleQuote*/ + !1, + /*stringNamed*/ + !0, + !!(we.flags & 8192) + ); + } else + return Ht; + const Zt = !!wr(we.declarations) && Ni(we.declarations, IP), xe = !!wr(we.declarations) && Ni(we.declarations, VI), Re = !!(we.flags & 8192), Ze = Pf(we, te, xe, Zt, Re); + if (Ze) + return Ze; + const Pt = Si(we.escapedName); + return kN(Pt, da(F), xe, Zt, Re); + } + function Pf(we, te, Ht, Zt, xe) { + const Re = Pn(we).nameType; + if (Re) { + if (Re.flags & 384) { + const Ze = "" + Re.value; + return !R_(Ze, da(F)) && (Zt || !zg(Ze)) ? N.createStringLiteral(Ze, !!Ht) : zg(Ze) && Ui(Ze, "-") ? N.createComputedPropertyName(N.createPrefixUnaryExpression(41, N.createNumericLiteral(-Ze))) : kN(Ze, da(F), Ht, Zt, xe); + } + if (Re.flags & 8192) + return N.createComputedPropertyName(Np( + Re.symbol, + te, + 111551 + /* Value */ + )); + } + } + function qI(we) { + const te = we.mustCreateTypeParameterSymbolList, Ht = we.mustCreateTypeParametersNamesLookups; + we.mustCreateTypeParameterSymbolList = !0, we.mustCreateTypeParametersNamesLookups = !0; + const Zt = we.typeParameterNames, xe = we.typeParameterNamesByText, Re = we.typeParameterNamesByTextNextNameCount, Ze = we.typeParameterSymbolList; + return () => { + we.typeParameterNames = Zt, we.typeParameterNamesByText = xe, we.typeParameterNamesByTextNextNameCount = Re, we.typeParameterSymbolList = Ze, we.mustCreateTypeParameterSymbolList = te, we.mustCreateTypeParametersNamesLookups = Ht; + }; + } + function It(we, te) { + return we.declarations && Nn(we.declarations, (Ht) => !!f5e(Ht) && (!te || !!dr(Ht, (Zt) => Zt === te))); + } + function gr(we, te) { + if (!(Dn(te) & 4) || !of(we)) return !0; + c$(we); + const Ht = xn(we).resolvedSymbol, Zt = Ht && bo(Ht); + return !Zt || Zt !== te.target ? !0 : wr(we.typeArguments) >= gg(te.target.typeParameters); + } + function Fr(we) { + for (; xn(we).fakeScopeForSignatureDeclaration; ) + we = we.parent; + return we; + } + function Qr(we, te, Ht) { + return Ht.flags & 8192 && Ht.symbol === we && (!te.enclosingDeclaration || ot(we.declarations, (xe) => xr(xe) === te.enclosingFile)) && (te.flags |= 1048576), jt(Ht, te); + } + function Tn(we, te, Ht, Zt) { + var xe; + let Re; + const Ze = te && (Ii(te) || Lf(te)) && pR(te, we.enclosingDeclaration), Pt = te ?? Zt.valueDeclaration ?? It(Zt) ?? ((xe = Zt.declarations) == null ? void 0 : xe[0]); + if (!lt(Ht, we) && Pt) { + const $t = G(we, Zt, Ht); + Dy(Pt) ? Re = Te.serializeTypeOfAccessor(Pt, Zt, we) : fF(Pt) && !lo(Pt) && !(Dn(Ht) & 196608) && (Re = Te.serializeTypeOfDeclaration(Pt, Zt, we)), $t(); + } + return Re || (Ze && (Ht = P1(Ht)), Re = Qr(Zt, we, Ht)), Re ?? N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ); + } + function Kn(we, te, Ht) { + return Ht === te ? !0 : we && (($u(we) || os(we)) && we.questionToken || Ii(we) && YG(we)) ? Dp( + te, + 524288 + /* NEUndefined */ + ) === Ht : !1; + } + function aa(we, te) { + const Ht = we.flags & 256, Zt = ve(we); + Ht && (we.flags &= -257); + let xe; + const Re = Wa(te); + if (!(Ht && gn(Re))) { + if (te.declaration && !lo(te.declaration) && !lt(Re, we)) { + const Ze = yn(te.declaration), Pt = G(we, Ze, Re); + xe = Te.serializeReturnTypeForSignature(te.declaration, Ze, we), Pt(); + } + xe || (xe = ua(we, te, Re)); + } + return !xe && !Ht && (xe = N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + )), Zt(), xe; + } + function ua(we, te, Ht) { + const Zt = we.suppressReportInferenceFallback; + we.suppressReportInferenceFallback = !0; + const xe = kp(te), Re = xe ? Bu(we.mapper ? MNe(xe, we.mapper) : xe, we) : jt(Ht, we); + return we.suppressReportInferenceFallback = Zt, Re; + } + function mo(we, te, Ht = te.enclosingDeclaration) { + let Zt = !1; + const xe = i_(we); + if (an(we) && (lS(xe) || Lg(xe.parent) || s_(xe.parent) && DB(xe.parent.left) && lS(xe.parent.right))) + return Zt = !0, { introducesError: Zt, node: we }; + const Re = Zw(we); + let Ze; + if (Ry(xe)) + return Ze = yn(qu( + xe, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + )), v1( + Ze, + xe, + Re, + /*shouldComputeAliasesToMakeVisible*/ + !1 + ).accessibility !== 0 && (Zt = !0, te.tracker.reportInaccessibleThisError()), { introducesError: Zt, node: Pt(we) }; + if (Ze = dc( + xe, + Re, + /*ignoreErrors*/ + !0, + /*dontResolveAlias*/ + !0 + ), te.enclosingDeclaration && !(Ze && Ze.flags & 262144)) { + Ze = _t(Ze); + const $t = dc( + xe, + Re, + /*ignoreErrors*/ + !0, + /*dontResolveAlias*/ + !0, + te.enclosingDeclaration + ); + if ( + // Check for unusable parameters symbols + $t === Y || // If the symbol is not found, but was not found in the original scope either we probably have an error, don't reuse the node + $t === void 0 && Ze !== void 0 || // If the symbol is found both in declaration scope and in current scope then it should point to the same reference + $t && Ze && !le(_t($t), Ze) + ) + return $t !== Y && te.tracker.reportInferenceFallback(we), Zt = !0, { introducesError: Zt, node: we, sym: Ze }; + Ze = $t; + } + if (Ze) + return Ze.flags & 1 && Ze.valueDeclaration && (Y1(Ze.valueDeclaration) || Lf(Ze.valueDeclaration)) ? { introducesError: Zt, node: Pt(we) } : (!(Ze.flags & 262144) && // Type parameters are visible in the current context if they are are resolvable + !Qm(we) && v1( + Ze, + Ht, + Re, + /*shouldComputeAliasesToMakeVisible*/ + !1 + ).accessibility !== 0 ? (te.tracker.reportInferenceFallback(we), Zt = !0) : te.tracker.trackSymbol(Ze, Ht, Re), { introducesError: Zt, node: Pt(we) }); + return { introducesError: Zt, node: we }; + function Pt($t) { + if ($t === xe) { + const Yt = bo(Ze), Lr = Ze.flags & 262144 ? $o(Yt, te) : N.cloneNode($t); + return Lr.symbol = Ze, l(te, un( + Lr, + 16777216 + /* NoAsciiEscaping */ + ), $t); + } + const At = br( + $t, + (Yt) => Pt(Yt), + /*context*/ + void 0 + ); + return l(te, At, $t); + } + } + function kl(we, te, Ht, Zt) { + const xe = Ht ? 111551 : 788968, Re = dc( + te, + xe, + /*ignoreErrors*/ + !0 + ); + if (!Re) return; + const Ze = Re.flags & 2097152 ? Rl(Re) : Re; + if (v1( + Re, + we.enclosingDeclaration, + xe, + /*shouldComputeAliasesToMakeVisible*/ + !1 + ).accessibility === 0) + return Xa(Ze, we, xe, Zt); + } + function Ju(we, te) { + const Ht = a( + we, + te, + /*noMappedTypes*/ + !0 + ); + if (!Ht) + return !1; + if (an(te) && bh(te)) { + DNe(te); + const Zt = xn(te).resolvedSymbol; + return !Zt || !// The import type resolved using jsdoc fallback logic + (!te.isTypeOf && !(Zt.flags & 788968) || // The import type had type arguments autofilled by js fallback logic + !(wr(te.typeArguments) >= gg(ia(Zt)))); + } + if (of(te)) { + if (nd(te)) return !1; + const Zt = xn(te).resolvedSymbol; + if (!Zt) return !1; + if (Zt.flags & 262144) { + const xe = bo(Zt); + return !(we.mapper && ny(xe, we.mapper) !== xe); + } + if (BD(te)) + return gr(te, Ht) && !j3e(te) && !!(Zt.flags & 788968); + } + if (rv(te) && te.operator === 158 && te.type.kind === 155) { + const Zt = we.enclosingDeclaration && Fr(we.enclosingDeclaration); + return !!dr(te, (xe) => xe === Zt); + } + return !0; + } + function M_(we, te, Ht) { + const Zt = a(we, te); + if (Ht && !wp(Zt, (xe) => !!(xe.flags & 32768)) && Ju(we, te)) { + const xe = Te.tryReuseExistingTypeNode(we, te); + if (xe) + return N.createUnionTypeNode([xe, N.createKeywordTypeNode( + 157 + /* UndefinedKeyword */ + )]); + } + return jt(Zt, we); + } + function fb(we, te) { + var Ht; + const Zt = w5e( + N.createPropertyDeclaration, + 175, + /*useAccessors*/ + !0 + ), xe = w5e( + (ht, Xr, ri, si) => N.createPropertySignature(ht, Xr, ri, si), + 174, + /*useAccessors*/ + !1 + ), Re = te.enclosingDeclaration; + let Ze = []; + const Pt = /* @__PURE__ */ new Set(), $t = [], At = te; + te = { + ...At, + usedSymbolNames: new Set(At.usedSymbolNames), + remappedSymbolNames: /* @__PURE__ */ new Map(), + remappedSymbolReferences: new Map((Ht = At.remappedSymbolReferences) == null ? void 0 : Ht.entries()), + tracker: void 0 + }; + const Yt = { + ...At.tracker.inner, + trackSymbol: (ht, Xr, ri) => { + var si, mn; + if ((si = te.remappedSymbolNames) != null && si.has(Xs(ht))) return !1; + if (v1( + ht, + Xr, + ri, + /*shouldComputeAliasesToMakeVisible*/ + !1 + ).accessibility === 0) { + const fa = Ga(ht, te, ri); + if (!(ht.flags & 4)) { + const Cs = fa[0], di = xr(At.enclosingDeclaration); + ot(Cs.declarations, ($s) => xr($s) === di) && xa(Cs); + } + } else if ((mn = At.tracker.inner) != null && mn.trackSymbol) + return At.tracker.inner.trackSymbol(ht, Xr, ri); + return !1; + } + }; + te.tracker = new Dne(te, Yt, At.tracker.moduleResolverHost), hl(we, (ht, Xr) => { + const ri = Si(Xr); + Sg(ht, ri); + }); + let Lr = !te.bundled; + const $r = we.get( + "export=" + /* ExportEquals */ + ); + return $r && we.size > 1 && $r.flags & 2098688 && (we = Bs(), we.set("export=", $r)), Fn(we), qi(Ze); + function Sn(ht) { + return !!ht && ht.kind === 80; + } + function qn(ht) { + return Ic(ht) ? kn(hr(ht.declarationList.declarations, _s), Sn) : kn([_s(ht)], Sn); + } + function Yn(ht) { + const Xr = Nn(ht, Mo), ri = oc(ht, jc); + let si = ri !== -1 ? ht[ri] : void 0; + if (si && Xr && Xr.isExportEquals && Me(Xr.expression) && Me(si.name) && An(si.name) === An(Xr.expression) && si.body && vm(si.body)) { + const mn = kn(ht, (Cs) => !!(pu(Cs) & 32)), ea = si.name; + let fa = si.body; + if (wr(mn) && (si = N.updateModuleDeclaration( + si, + si.modifiers, + si.name, + fa = N.updateModuleBlock( + fa, + N.createNodeArray([ + ...si.body.statements, + N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createNamedExports(hr(ka(mn, (Cs) => qn(Cs)), (Cs) => N.createExportSpecifier( + /*isTypeOnly*/ + !1, + /*propertyName*/ + void 0, + Cs + ))), + /*moduleSpecifier*/ + void 0 + ) + ]) + ) + ), ht = [...ht.slice(0, ri), si, ...ht.slice(ri + 1)]), !Nn(ht, (Cs) => Cs !== si && n3(Cs, ea))) { + Ze = []; + const Cs = !ot(fa.statements, (di) => Gn( + di, + 32 + /* Export */ + ) || Mo(di) || Bc(di)); + lr(fa.statements, (di) => { + ss( + di, + Cs ? 32 : 0 + /* None */ + ); + }), ht = [...kn(ht, (di) => di !== si && di !== Xr), ...Ze]; + } + } + return ht; + } + function Ur(ht) { + const Xr = kn(ht, (si) => Bc(si) && !si.moduleSpecifier && !!si.exportClause && mp(si.exportClause)); + wr(Xr) > 1 && (ht = [ + ...kn(ht, (mn) => !Bc(mn) || !!mn.moduleSpecifier || !mn.exportClause), + N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createNamedExports(ka(Xr, (mn) => Us(mn.exportClause, mp).elements)), + /*moduleSpecifier*/ + void 0 + ) + ]); + const ri = kn(ht, (si) => Bc(si) && !!si.moduleSpecifier && !!si.exportClause && mp(si.exportClause)); + if (wr(ri) > 1) { + const si = yC(ri, (mn) => ca(mn.moduleSpecifier) ? ">" + mn.moduleSpecifier.text : ">"); + if (si.length !== ri.length) + for (const mn of si) + mn.length > 1 && (ht = [ + ...kn(ht, (ea) => !mn.includes(ea)), + N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createNamedExports(ka(mn, (ea) => Us(ea.exportClause, mp).elements)), + mn[0].moduleSpecifier + ) + ]); + } + return ht; + } + function ci(ht) { + const Xr = oc(ht, (ri) => Bc(ri) && !ri.moduleSpecifier && !ri.attributes && !!ri.exportClause && mp(ri.exportClause)); + if (Xr >= 0) { + const ri = ht[Xr], si = Fi(ri.exportClause.elements, (mn) => { + if (!mn.propertyName && mn.name.kind !== 11) { + const ea = mn.name, fa = $I(ht), Cs = kn(fa, (di) => n3(ht[di], ea)); + if (wr(Cs) && Ni(Cs, (di) => CN(ht[di]))) { + for (const di of Cs) + ht[di] = Pa(ht[di]); + return; + } + } + return mn; + }); + wr(si) ? ht[Xr] = N.updateExportDeclaration( + ri, + ri.modifiers, + ri.isTypeOnly, + N.updateNamedExports( + ri.exportClause, + si + ), + ri.moduleSpecifier, + ri.attributes + ) : yy(ht, Xr); + } + return ht; + } + function qi(ht) { + return ht = Yn(ht), ht = Ur(ht), ht = ci(ht), Re && (Di(Re) && tf(Re) || jc(Re)) && (!ot(ht, p3) || !NZ(ht) && ot(ht, P7)) && ht.push(UN(N)), ht; + } + function Pa(ht) { + const Xr = (pu(ht) | 32) & -129; + return N.replaceModifiers(ht, Xr); + } + function sr(ht) { + const Xr = pu(ht) & -33; + return N.replaceModifiers(ht, Xr); + } + function Fn(ht, Xr, ri) { + Xr || $t.push(/* @__PURE__ */ new Map()); + let si = 0; + const mn = Array.from(ht.values()); + for (const ea of mn) { + if (si++, de(te) && si + 2 < ht.size - 1) { + te.out.truncated = !0, Ze.push(gC(`... (${ht.size - si} more ...)`)), ps( + mn[mn.length - 1], + /*isPrivate*/ + !1, + !!ri + ); + break; + } + ps( + ea, + /*isPrivate*/ + !1, + !!ri + ); + } + Xr || ($t[$t.length - 1].forEach((ea) => { + ps( + ea, + /*isPrivate*/ + !0, + !!ri + ); + }), $t.pop()); + } + function ps(ht, Xr, ri) { + $a(Yr(ht)); + const si = Oa(ht); + if (Pt.has(Xs(si))) + return; + if (Pt.add(Xs(si)), !Xr || wr(ht.declarations) && ot(ht.declarations, (ea) => !!dr(ea, (fa) => fa === Re))) { + const ea = qI(te); + te.tracker.pushErrorFallbackNode(Nn(ht.declarations, (fa) => xr(fa) === te.enclosingFile)), Xi(ht, Xr, ri), te.tracker.popErrorFallbackNode(), ea(); + } + } + function Xi(ht, Xr, ri, si = ht.escapedName) { + var mn, ea, fa, Cs, di, $s, ol; + const Uo = Si(si), ku = si === "default"; + if (Xr && !(te.flags & 131072) && Sx(Uo) && !ku) { + te.encounteredError = !0; + return; + } + let Tc = ku && !!(ht.flags & -113 || ht.flags & 16 && wr($a(Yr(ht)))) && !(ht.flags & 2097152), Fo = !Tc && !Xr && Sx(Uo) && !ku; + (Tc || Fo) && (Xr = !0); + const ac = (Xr ? 0 : 32) | (ku && !Tc ? 2048 : 0), gc = ht.flags & 1536 && ht.flags & 7 && si !== "export=", Zf = gc && nge(Yr(ht), ht); + if ((ht.flags & 8208 || Zf) && O1(Yr(ht), ht, Sg(ht, Uo), ac), ht.flags & 524288 && sl(ht, Uo, ac), ht.flags & 98311 && si !== "export=" && !(ht.flags & 4194304) && !(ht.flags & 32) && !(ht.flags & 8192) && !Zf) + if (ri) + hR(ht) && (Fo = !1, Tc = !1); + else { + const Vc = Yr(ht), y_ = Sg(ht, Uo); + if (Vc.symbol && Vc.symbol !== ht && Vc.symbol.flags & 16 && ot(Vc.symbol.declarations, zy) && ((mn = Vc.symbol.members) != null && mn.size || (ea = Vc.symbol.exports) != null && ea.size)) + te.remappedSymbolReferences || (te.remappedSymbolReferences = /* @__PURE__ */ new Map()), te.remappedSymbolReferences.set(Xs(Vc.symbol), ht), Xi(Vc.symbol, Xr, ri, si), te.remappedSymbolReferences.delete(Xs(Vc.symbol)); + else if (!(ht.flags & 16) && nge(Vc, ht)) + O1(Vc, ht, y_, ac); + else { + const cy = ht.flags & 2 ? oC(ht) ? 2 : 1 : (fa = ht.parent) != null && fa.valueDeclaration && Di((Cs = ht.parent) == null ? void 0 : Cs.valueDeclaration) ? 2 : void 0, Kf = Tc || !(ht.flags & 4) ? y_ : vR(y_, ht); + let ph = ht.declarations && Nn(ht.declarations, (M1) => ei(M1)); + ph && Ul(ph.parent) && ph.parent.declarations.length === 1 && (ph = ph.parent.parent); + const L1 = (di = ht.declarations) == null ? void 0 : di.find(wn); + if (L1 && _n(L1.parent) && Me(L1.parent.right) && (($s = Vc.symbol) != null && $s.valueDeclaration) && Di(Vc.symbol.valueDeclaration)) { + const M1 = y_ === L1.parent.right.escapedText ? void 0 : L1.parent.right; + te.approximateLength += 12 + (((ol = M1?.escapedText) == null ? void 0 : ol.length) ?? 0), ss( + N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createNamedExports([N.createExportSpecifier( + /*isTypeOnly*/ + !1, + M1, + y_ + )]) + ), + 0 + /* None */ + ), te.tracker.trackSymbol( + Vc.symbol, + te.enclosingDeclaration, + 111551 + /* Value */ + ); + } else { + const M1 = l( + te, + N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList([ + N.createVariableDeclaration( + Kf, + /*exclamationToken*/ + void 0, + Tn( + te, + /*declaration*/ + void 0, + Vc, + ht + ) + ) + ], cy) + ), + ph + ); + te.approximateLength += 7 + Kf.length, ss(M1, Kf !== y_ ? ac & -33 : ac), Kf !== y_ && !Xr && (te.approximateLength += 16 + Kf.length + y_.length, ss( + N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createNamedExports([N.createExportSpecifier( + /*isTypeOnly*/ + !1, + Kf, + y_ + )]) + ), + 0 + /* None */ + ), Fo = !1, Tc = !1); + } + } + } + if (ht.flags & 384 && V2(ht, Uo, ac), ht.flags & 32 && (ht.flags & 4 && ht.valueDeclaration && _n(ht.valueDeclaration.parent) && Rc(ht.valueDeclaration.parent.right) ? D5e(ht, Sg(ht, Uo), ac) : tge(ht, Sg(ht, Uo), ac)), (ht.flags & 1536 && (!gc || c0(ht)) || Zf) && db(ht, Uo, ac), ht.flags & 64 && !(ht.flags & 32) && al(ht, Uo, ac), ht.flags & 2097152 && D5e(ht, Sg(ht, Uo), ac), ht.flags & 4 && ht.escapedName === "export=" && hR(ht), ht.flags & 8388608 && ht.declarations) + for (const Vc of ht.declarations) { + const y_ = Mu(Vc, Vc.moduleSpecifier); + if (!y_) continue; + const cy = Vc.isTypeOnly, Kf = Oc(y_, te); + te.approximateLength += 17 + Kf.length, ss( + N.createExportDeclaration( + /*modifiers*/ + void 0, + cy, + /*exportClause*/ + void 0, + N.createStringLiteral(Kf) + ), + 0 + /* None */ + ); + } + if (Tc) { + const Vc = Sg(ht, Uo); + te.approximateLength += 16 + Vc.length, ss( + N.createExportAssignment( + /*modifiers*/ + void 0, + /*isExportEquals*/ + !1, + N.createIdentifier(Vc) + ), + 0 + /* None */ + ); + } else if (Fo) { + const Vc = Sg(ht, Uo); + te.approximateLength += 22 + Uo.length + Vc.length, ss( + N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createNamedExports([N.createExportSpecifier( + /*isTypeOnly*/ + !1, + Vc, + Uo + )]) + ), + 0 + /* None */ + ); + } + } + function xa(ht) { + if (ot(ht.declarations, Y1)) return; + E.assertIsDefined($t[$t.length - 1]), vR(Si(ht.escapedName), ht); + const Xr = !!(ht.flags & 2097152) && !ot(ht.declarations, (ri) => !!dr(ri, Bc) || Km(ri) || _l(ri) && !wh(ri.moduleReference)); + $t[Xr ? 0 : $t.length - 1].set(Xs(ht), ht); + } + function Va(ht) { + return Di(ht) && (tf(ht) || ap(ht)) || Vu(ht) && !$m(ht); + } + function ss(ht, Xr) { + if (Vp(ht)) { + const ri = pu(ht); + let si = 0; + const mn = te.enclosingDeclaration && (jp(te.enclosingDeclaration) ? xr(te.enclosingDeclaration) : te.enclosingDeclaration); + Xr & 32 && mn && (Va(mn) || jc(mn)) && CN(ht) && (si |= 32), Lr && !(si & 32) && (!mn || !(mn.flags & 33554432)) && (ov(ht) || Ic(ht) || Cc(ht) || tl(ht) || jc(ht)) && (si |= 128), Xr & 2048 && (tl(ht) || Vl(ht) || Cc(ht)) && (si |= 2048), si && (ht = N.replaceModifiers(ht, si | ri)), te.approximateLength += yR(si | ri); + } + Ze.push(ht); + } + function sl(ht, Xr, ri) { + var si; + const mn = zPe(ht), ea = Pn(ht).typeParameters, fa = hr(ea, (Tc) => Sc(Tc, te)), Cs = (si = ht.declarations) == null ? void 0 : si.find(jp), di = s3(Cs ? Cs.comment || Cs.parent.comment : void 0), $s = ve(te); + te.flags |= 8388608; + const ol = te.enclosingDeclaration; + te.enclosingDeclaration = Cs; + const Uo = Cs && Cs.typeExpression && lv(Cs.typeExpression) && Te.tryReuseExistingTypeNode(te, Cs.typeExpression.type) || jt(mn, te), ku = Sg(ht, Xr); + te.approximateLength += 8 + (di?.length ?? 0) + ku.length, ss( + tv( + N.createTypeAliasDeclaration( + /*modifiers*/ + void 0, + ku, + fa, + Uo + ), + di ? [{ kind: 3, text: `* + * ` + di.replace(/\n/g, ` + * `) + ` + `, pos: -1, end: -1, hasTrailingNewLine: !0 }] : [] + ), + ri + ), $s(), te.enclosingDeclaration = ol; + } + function al(ht, Xr, ri) { + const si = Sg(ht, Xr); + te.approximateLength += 14 + si.length; + const mn = xp(ht), ea = ia(ht), fa = hr(ea, (Fo) => Sc(Fo, te)), Cs = bd(mn), di = wr(Cs) ? sa(Cs) : void 0, $s = uu( + $a(mn), + /*isClass*/ + !1, + di + ), ol = ige( + 0, + mn, + di, + 180 + /* CallSignature */ + ), Uo = ige( + 1, + mn, + di, + 181 + /* ConstructSignature */ + ), ku = N5e(mn, di), Tc = wr(Cs) ? [N.createHeritageClause(96, Fi(Cs, (Fo) => sge( + Fo, + 111551 + /* Value */ + )))] : void 0; + ss( + N.createInterfaceDeclaration( + /*modifiers*/ + void 0, + si, + fa, + Tc, + [...ku, ...Uo, ...ol, ...$s] + ), + ri + ); + } + function uu(ht, Xr, ri, si) { + const mn = []; + let ea = 0; + for (const fa of ht) { + if (ea++, de(te) && ea + 2 < ht.length - 1) { + te.out.truncated = !0; + const di = zu(`... ${ht.length - ea} more ... `, Xr); + mn.push(di); + const $s = Xr ? Zt(ht[ht.length - 1], si, ri) : P5e(ht[ht.length - 1], ri); + as($s) ? mn.push(...$s) : mn.push($s); + break; + } + te.approximateLength += 1; + const Cs = Xr ? Zt(fa, si, ri) : P5e(fa, ri); + as(Cs) ? mn.push(...Cs) : mn.push(Cs); + } + return mn; + } + function zu(ht, Xr) { + return te.flags & 1 ? Uy(N.createNotEmittedTypeElement(), 3, ht) : Xr ? N.createPropertyDeclaration( + /*modifiers*/ + void 0, + ht, + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + ) : N.createPropertySignature( + /*modifiers*/ + void 0, + ht, + /*questionToken*/ + void 0, + /*type*/ + void 0 + ); + } + function h_(ht) { + let Xr = is(gf(ht).values()); + const ri = Oa(ht); + if (ri !== ht) { + const si = new Set(Xr); + for (const mn of gf(ri).values()) + O_(zc(mn)) & 111551 || si.add(mn); + Xr = is(si); + } + return kn(Xr, (si) => XE(si) && R_( + si.escapedName, + 99 + /* ESNext */ + )); + } + function c0(ht) { + return Ni(h_(ht), (Xr) => !(O_(zc(Xr)) & 111551)); + } + function db(ht, Xr, ri) { + const si = h_(ht), mn = pb(te), ea = BP(si, (di) => di.parent && di.parent === ht || mn ? "real" : "merged"), fa = ea.get("real") || Ge, Cs = ea.get("merged") || Ge; + if (wr(fa) || mn) { + let di; + if (mn) { + const $s = te.flags; + te.flags |= 514, di = f( + ht, + te, + /*meaning*/ + -1 + /* All */ + ), te.flags = $s; + } else { + const $s = Sg(ht, Xr); + di = N.createIdentifier($s), te.approximateLength += $s.length; + } + bg(fa, di, ri, !!(ht.flags & 67108880)); + } + if (wr(Cs)) { + const di = xr(te.enclosingDeclaration), $s = Sg(ht, Xr), ol = N.createModuleBlock([N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createNamedExports(Fi(kn( + Cs, + (Uo) => Uo.escapedName !== "export=" + /* ExportEquals */ + ), (Uo) => { + var ku, Tc; + const Fo = Si(Uo.escapedName), ac = Sg(Uo, Fo), gc = Uo.declarations && F_(Uo); + if (di && (gc ? di !== xr(gc) : !ot(Uo.declarations, (y_) => xr(y_) === di))) { + (Tc = (ku = te.tracker) == null ? void 0 : ku.reportNonlocalAugmentation) == null || Tc.call(ku, di, ht, Uo); + return; + } + const Zf = gc && qv( + gc, + /*dontRecursivelyResolve*/ + !0 + ); + xa(Zf || Uo); + const Vc = Zf ? Sg(Zf, Si(Zf.escapedName)) : ac; + return N.createExportSpecifier( + /*isTypeOnly*/ + !1, + Fo === Vc ? void 0 : Vc, + Fo + ); + })) + )]); + ss( + N.createModuleDeclaration( + /*modifiers*/ + void 0, + N.createIdentifier($s), + ol, + 32 + /* Namespace */ + ), + 0 + /* None */ + ); + } + } + function V2(ht, Xr, ri) { + const si = Sg(ht, Xr); + te.approximateLength += 9 + si.length; + const mn = [], ea = kn($a(Yr(ht)), (Cs) => !!(Cs.flags & 8)); + let fa = 0; + for (const Cs of ea) { + if (fa++, de(te) && fa + 2 < ea.length - 1) { + te.out.truncated = !0, mn.push(N.createEnumMember(` ... ${ea.length - fa} more ... `)); + const Tc = ea[ea.length - 1], Fo = Tc.declarations && Tc.declarations[0] && Ph(Tc.declarations[0]) ? zX(Tc.declarations[0]) : void 0, ac = Fo === void 0 ? void 0 : typeof Fo == "string" ? N.createStringLiteral(Fo) : N.createNumericLiteral(Fo), gc = Si(Tc.escapedName), Zf = N.createEnumMember( + gc, + ac + ); + mn.push(Zf); + break; + } + const di = Cs.declarations && Cs.declarations[0] && Ph(Cs.declarations[0]) ? Cs.declarations[0] : void 0; + let $s, ol; + if (pb(te) && di && di.initializer) + $s = qa(di.initializer), ol = di.initializer.end - di.initializer.pos; + else { + const Tc = di && zX(di); + $s = Tc === void 0 ? void 0 : typeof Tc == "string" ? N.createStringLiteral(Tc) : N.createNumericLiteral(Tc), ol = $s?.text.length ?? 0; + } + const Uo = Si(Cs.escapedName); + te.approximateLength += 4 + Uo.length + ol; + const ku = N.createEnumMember( + Uo, + $s + ); + mn.push(ku); + } + ss( + N.createEnumDeclaration( + N.createModifiersFromModifierFlags(dme(ht) ? 4096 : 0), + si, + mn + ), + ri + ); + } + function O1(ht, Xr, ri, si) { + const mn = Is( + ht, + 0 + /* Call */ + ); + for (const ea of mn) { + te.approximateLength += 1; + const fa = zn(ea, 263, te, { name: N.createIdentifier(ri) }); + ss(l(te, fa, OP(ea)), si); + } + if (!(Xr.flags & 1536 && Xr.exports && Xr.exports.size)) { + const ea = kn($a(ht), XE); + te.approximateLength += ri.length, bg( + ea, + N.createIdentifier(ri), + si, + /*suppressNewPrivateContext*/ + !0 + ); + } + } + function gC(ht) { + return te.flags & 1 ? Uy(N.createEmptyStatement(), 3, ht) : N.createExpressionStatement(N.createIdentifier(ht)); + } + function OP(ht) { + if (ht.declaration && ht.declaration.parent) { + if (_n(ht.declaration.parent) && Ac(ht.declaration.parent) === 5) + return ht.declaration.parent; + if (ei(ht.declaration.parent) && ht.declaration.parent.parent) + return ht.declaration.parent.parent; + } + return ht.declaration; + } + function bg(ht, Xr, ri, si) { + const mn = Me(Xr) ? 32 : 0, ea = pb(te); + if (wr(ht)) { + te.approximateLength += 14; + const Cs = BP(ht, (gc) => !wr(gc.declarations) || ot(gc.declarations, (Zf) => xr(Zf) === xr(te.enclosingDeclaration)) || ea ? "local" : "remote").get("local") || Ge; + let di = fv.createModuleDeclaration( + /*modifiers*/ + void 0, + Xr, + N.createModuleBlock([]), + mn + ); + za(di, Re), di.locals = Bs(ht), di.symbol = ht[0].parent; + const $s = Ze; + Ze = []; + const ol = Lr; + Lr = !1; + const Uo = { ...te, enclosingDeclaration: di }, ku = te; + te = Uo, Fn( + Bs(Cs), + si, + /*propertyAsAlias*/ + !0 + ), te = ku, Lr = ol; + const Tc = Ze; + Ze = $s; + const Fo = hr(Tc, (gc) => Mo(gc) && !gc.isExportEquals && Me(gc.expression) ? N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createNamedExports([N.createExportSpecifier( + /*isTypeOnly*/ + !1, + gc.expression, + N.createIdentifier( + "default" + /* Default */ + ) + )]) + ) : gc), ac = Ni(Fo, (gc) => Gn( + gc, + 32 + /* Export */ + )) ? hr(Fo, sr) : Fo; + di = N.updateModuleDeclaration( + di, + di.modifiers, + di.name, + N.createModuleBlock(ac) + ), ss(di, ri); + } else ea && (te.approximateLength += 14, ss( + N.createModuleDeclaration( + /*modifiers*/ + void 0, + Xr, + N.createModuleBlock([]), + mn + ), + ri + )); + } + function XE(ht) { + return !!(ht.flags & 2887656) || !(ht.flags & 4194304 || ht.escapedName === "prototype" || ht.valueDeclaration && Js(ht.valueDeclaration) && $n(ht.valueDeclaration.parent)); + } + function gR(ht) { + const Xr = Fi(ht, (ri) => { + const si = te.enclosingDeclaration; + te.enclosingDeclaration = ri; + let mn = ri.expression; + if (to(mn)) { + if (Me(mn) && An(mn) === "") + return ea( + /*result*/ + void 0 + ); + let fa; + if ({ introducesError: fa, node: mn } = mo(mn, te), fa) + return ea( + /*result*/ + void 0 + ); + } + return ea(N.createExpressionWithTypeArguments( + mn, + hr(ri.typeArguments, (fa) => Te.tryReuseExistingTypeNode(te, fa) || jt(a(te, fa), te)) + )); + function ea(fa) { + return te.enclosingDeclaration = si, fa; + } + }); + if (Xr.length === ht.length) + return Xr; + } + function tge(ht, Xr, ri) { + var si, mn; + te.approximateLength += 9 + Xr.length; + const ea = (si = ht.declarations) == null ? void 0 : si.find($n), fa = te.enclosingDeclaration; + te.enclosingDeclaration = ea || fa; + const Cs = ia(ht), di = hr(Cs, (ly) => Sc(ly, te)); + lr(Cs, (ly) => te.approximateLength += cc(ly.symbol).length); + const $s = yf(xp(ht)), ol = bd($s), Uo = ea && $C(ea), ku = Uo && gR(Uo) || Fi(wE($s), Yft), Tc = Yr(ht), Fo = !!((mn = Tc.symbol) != null && mn.valueDeclaration) && $n(Tc.symbol.valueDeclaration), ac = Fo ? Xh(Tc) : Le; + te.approximateLength += (wr(ol) ? 8 : 0) + (wr(ku) ? 11 : 0); + const gc = [ + ...wr(ol) ? [N.createHeritageClause(96, hr(ol, (ly) => Qft(ly, ac, Xr)))] : [], + ...wr(ku) ? [N.createHeritageClause(119, ku)] : [] + ], Zf = Out($s, ol, $a($s)), Vc = kn(Zf, (ly) => !mR(ly)), y_ = ot(Zf, mR), cy = y_ ? pb(te) ? uu( + kn(Zf, mR), + /*isClass*/ + !0, + ol[0], + /*isStatic*/ + !1 + ) : [N.createPropertyDeclaration( + /*modifiers*/ + void 0, + N.createPrivateIdentifier("#private"), + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + )] : Ge; + y_ && !pb(te) && (te.approximateLength += 9); + const Kf = uu( + Vc, + /*isClass*/ + !0, + ol[0], + /*isStatic*/ + !1 + ), ph = uu( + kn($a(Tc), (ly) => !(ly.flags & 4194304) && ly.escapedName !== "prototype" && !XE(ly)), + /*isClass*/ + !0, + ac, + /*isStatic*/ + !0 + ), L1 = !Fo && !!ht.valueDeclaration && an(ht.valueDeclaration) && !ot(Is( + Tc, + 1 + /* Construct */ + )); + L1 && (te.approximateLength += 21); + const M1 = L1 ? [N.createConstructorDeclaration( + N.createModifiersFromModifierFlags( + 2 + /* Private */ + ), + [], + /*body*/ + void 0 + )] : ige( + 1, + Tc, + ac, + 177 + /* Constructor */ + ), Zft = N5e($s, ol[0]); + te.enclosingDeclaration = fa, ss( + l( + te, + N.createClassDeclaration( + /*modifiers*/ + void 0, + Xr, + di, + gc, + [...Zft, ...ph, ...M1, ...Kf, ...cy] + ), + ht.declarations && kn(ht.declarations, (ly) => tl(ly) || Rc(ly))[0] + ), + ri + ); + } + function rge(ht) { + return Lc(ht, (Xr) => { + if (Xu(Xr) || Nu(Xr)) + return Iy(Xr.propertyName || Xr.name); + if (_n(Xr) || Mo(Xr)) { + const ri = Mo(Xr) ? Xr.expression : Xr.right; + if (wn(ri)) + return An(ri.name); + } + if (U0(Xr)) { + const ri = _s(Xr); + if (ri && Me(ri)) + return An(ri); + } + }); + } + function D5e(ht, Xr, ri) { + var si, mn, ea, fa, Cs; + const di = F_(ht); + if (!di) return E.fail(); + const $s = Oa(qv( + di, + /*dontRecursivelyResolve*/ + !0 + )); + if (!$s) + return; + let ol = S3($s) && rge(ht.declarations) || Si($s.escapedName); + ol === "export=" && _e && (ol = "default"); + const Uo = Sg($s, ol); + switch (xa($s), di.kind) { + case 209: + if (((mn = (si = di.parent) == null ? void 0 : si.parent) == null ? void 0 : mn.kind) === 261) { + const Fo = Oc($s.parent || $s, te), { propertyName: ac } = di, gc = ac && Me(ac) ? An(ac) : void 0; + te.approximateLength += 24 + Xr.length + Fo.length + (gc?.length ?? 0), ss( + N.createImportDeclaration( + /*modifiers*/ + void 0, + N.createImportClause( + /*phaseModifier*/ + void 0, + /*name*/ + void 0, + N.createNamedImports([N.createImportSpecifier( + /*isTypeOnly*/ + !1, + gc ? N.createIdentifier(gc) : void 0, + N.createIdentifier(Xr) + )]) + ), + N.createStringLiteral(Fo), + /*attributes*/ + void 0 + ), + 0 + /* None */ + ); + break; + } + E.failBadSyntaxKind(((ea = di.parent) == null ? void 0 : ea.parent) || di, "Unhandled binding element grandparent kind in declaration serialization"); + break; + case 305: + ((Cs = (fa = di.parent) == null ? void 0 : fa.parent) == null ? void 0 : Cs.kind) === 227 && LP( + Si(ht.escapedName), + Uo + ); + break; + case 261: + if (wn(di.initializer)) { + const Fo = di.initializer, ac = N.createUniqueName(Xr), gc = Oc($s.parent || $s, te); + te.approximateLength += 22 + gc.length + An(ac).length, ss( + N.createImportEqualsDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + ac, + N.createExternalModuleReference(N.createStringLiteral(gc)) + ), + 0 + /* None */ + ), te.approximateLength += 12 + Xr.length + An(ac).length + An(Fo.name).length, ss( + N.createImportEqualsDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createIdentifier(Xr), + N.createQualifiedName(ac, Fo.name) + ), + ri + ); + break; + } + // else fall through and treat commonjs require just like import= + case 272: + if ($s.escapedName === "export=" && ot($s.declarations, (Fo) => Di(Fo) && ap(Fo))) { + hR(ht); + break; + } + const ku = !($s.flags & 512) && !ei(di); + te.approximateLength += 11 + Xr.length + Si($s.escapedName).length, ss( + N.createImportEqualsDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createIdentifier(Xr), + ku ? wc( + $s, + te, + -1, + /*expectsIdentifier*/ + !1 + ) : N.createExternalModuleReference(N.createStringLiteral(Oc($s, te))) + ), + ku ? ri : 0 + /* None */ + ); + break; + case 271: + ss( + N.createNamespaceExportDeclaration(An(di.name)), + 0 + /* None */ + ); + break; + case 274: { + const Fo = Oc($s.parent || $s, te), ac = te.bundled ? N.createStringLiteral(Fo) : di.parent.moduleSpecifier, gc = qo(di.parent) ? di.parent.attributes : void 0, Zf = xm(di.parent); + te.approximateLength += 14 + Xr.length + 3 + (Zf ? 4 : 0), ss( + N.createImportDeclaration( + /*modifiers*/ + void 0, + N.createImportClause( + /* phaseModifier */ + Zf ? 156 : void 0, + N.createIdentifier(Xr), + /*namedBindings*/ + void 0 + ), + ac, + gc + ), + 0 + /* None */ + ); + break; + } + case 275: { + const Fo = Oc($s.parent || $s, te), ac = te.bundled ? N.createStringLiteral(Fo) : di.parent.parent.moduleSpecifier, gc = xm(di.parent.parent); + te.approximateLength += 19 + Xr.length + 3 + (gc ? 4 : 0), ss( + N.createImportDeclaration( + /*modifiers*/ + void 0, + N.createImportClause( + /* phaseModifier */ + gc ? 156 : void 0, + /*name*/ + void 0, + N.createNamespaceImport(N.createIdentifier(Xr)) + ), + ac, + di.parent.attributes + ), + 0 + /* None */ + ); + break; + } + case 281: + te.approximateLength += 19 + Xr.length + 3, ss( + N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createNamespaceExport(N.createIdentifier(Xr)), + N.createStringLiteral(Oc($s, te)) + ), + 0 + /* None */ + ); + break; + case 277: { + const Fo = Oc($s.parent || $s, te), ac = te.bundled ? N.createStringLiteral(Fo) : di.parent.parent.parent.moduleSpecifier, gc = xm(di.parent.parent.parent); + te.approximateLength += 19 + Xr.length + 3 + (gc ? 4 : 0), ss( + N.createImportDeclaration( + /*modifiers*/ + void 0, + N.createImportClause( + /* phaseModifier */ + gc ? 156 : void 0, + /*name*/ + void 0, + N.createNamedImports([ + N.createImportSpecifier( + /*isTypeOnly*/ + !1, + Xr !== ol ? N.createIdentifier(ol) : void 0, + N.createIdentifier(Xr) + ) + ]) + ), + ac, + di.parent.parent.parent.attributes + ), + 0 + /* None */ + ); + break; + } + case 282: + const Tc = di.parent.parent.moduleSpecifier; + if (Tc) { + const Fo = di.propertyName; + Fo && Gm(Fo) && (ol = "default"); + } + LP( + Si(ht.escapedName), + Tc ? ol : Uo, + Tc && ja(Tc) ? N.createStringLiteral(Tc.text) : void 0 + ); + break; + case 278: + hR(ht); + break; + case 227: + case 212: + case 213: + ht.escapedName === "default" || ht.escapedName === "export=" ? hR(ht) : LP(Xr, Uo); + break; + default: + return E.failBadSyntaxKind(di, "Unhandled alias declaration kind in symbol serializer!"); + } + } + function LP(ht, Xr, ri) { + te.approximateLength += 16 + ht.length + (ht !== Xr ? Xr.length : 0), ss( + N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createNamedExports([N.createExportSpecifier( + /*isTypeOnly*/ + !1, + ht !== Xr ? Xr : void 0, + ht + )]), + ri + ), + 0 + /* None */ + ); + } + function hR(ht) { + var Xr; + if (ht.flags & 4194304) + return !1; + const ri = Si(ht.escapedName), si = ri === "export=", ea = si || ri === "default", fa = ht.declarations && F_(ht), Cs = fa && qv( + fa, + /*dontRecursivelyResolve*/ + !0 + ); + if (Cs && wr(Cs.declarations) && ot(Cs.declarations, (di) => xr(di) === xr(Re))) { + const di = fa && (Mo(fa) || _n(fa) ? MB(fa) : BK(fa)), $s = di && to(di) ? Xut(di) : void 0, ol = $s && dc( + $s, + -1, + /*ignoreErrors*/ + !0, + /*dontResolveAlias*/ + !0, + Re + ); + (ol || Cs) && xa(ol || Cs); + const Uo = te.tracker.disableTrackSymbol; + if (te.tracker.disableTrackSymbol = !0, ea) + te.approximateLength += 10, Ze.push(N.createExportAssignment( + /*modifiers*/ + void 0, + si, + Np( + Cs, + te, + -1 + /* All */ + ) + )); + else if ($s === di && $s) + LP(ri, An($s)); + else if (di && Rc(di)) + LP(ri, Sg(Cs, cc(Cs))); + else { + const ku = vR(ri, ht); + te.approximateLength += ku.length + 10, ss( + N.createImportEqualsDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createIdentifier(ku), + wc( + Cs, + te, + -1, + /*expectsIdentifier*/ + !1 + ) + ), + 0 + /* None */ + ), LP(ri, ku); + } + return te.tracker.disableTrackSymbol = Uo, !0; + } else { + const di = vR(ri, ht), $s = Sf(Yr(Oa(ht))); + if (nge($s, ht)) + O1( + $s, + ht, + di, + ea ? 0 : 32 + /* Export */ + ); + else { + const ol = ((Xr = te.enclosingDeclaration) == null ? void 0 : Xr.kind) === 268 && (!(ht.flags & 98304) || ht.flags & 65536) ? 1 : 2; + te.approximateLength += di.length + 5; + const Uo = N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList([ + N.createVariableDeclaration( + di, + /*exclamationToken*/ + void 0, + Tn( + te, + /*declaration*/ + void 0, + $s, + ht + ) + ) + ], ol) + ); + ss( + Uo, + Cs && Cs.flags & 4 && Cs.escapedName === "export=" ? 128 : ri === di ? 32 : 0 + /* None */ + ); + } + return ea ? (te.approximateLength += di.length + 10, Ze.push(N.createExportAssignment( + /*modifiers*/ + void 0, + si, + N.createIdentifier(di) + )), !0) : ri !== di ? (LP(ri, di), !0) : !1; + } + } + function nge(ht, Xr) { + var ri; + const si = xr(te.enclosingDeclaration); + return Dn(ht) & 48 && !ot((ri = ht.symbol) == null ? void 0 : ri.declarations, li) && // If the type comes straight from a type node, we shouldn't try to break it up + !wr(Su(ht)) && !V8(ht) && // While a class instance is potentially representable as a NS, prefer printing a reference to the instance type and serializing the class + !!(wr(kn($a(ht), XE)) || wr(Is( + ht, + 0 + /* Call */ + ))) && !wr(Is( + ht, + 1 + /* Construct */ + )) && // TODO: could probably serialize as function + ns + class, now that that's OK + !It(Xr, Re) && !(ht.symbol && ot(ht.symbol.declarations, (mn) => xr(mn) !== si)) && !ot($a(ht), (mn) => X8(mn.escapedName)) && !ot($a(ht), (mn) => ot(mn.declarations, (ea) => xr(ea) !== si)) && Ni($a(ht), (mn) => R_(cc(mn), R) ? mn.flags & 98304 ? Hd(mn) === Z0(mn) : !0 : !1); + } + function w5e(ht, Xr, ri) { + return function(mn, ea, fa) { + var Cs, di, $s, ol, Uo, ku; + const Tc = up(mn), Fo = !!(Tc & 2) && !pb(te); + if (ea && mn.flags & 2887656) + return []; + if (mn.flags & 4194304 || mn.escapedName === "constructor" || fa && Ys(fa, mn.escapedName) && tm(Ys(fa, mn.escapedName)) === tm(mn) && (mn.flags & 16777216) === (Ys(fa, mn.escapedName).flags & 16777216) && lh(Yr(mn), rr(fa, mn.escapedName))) + return []; + const ac = Tc & -1025 | (ea ? 256 : 0), gc = FP(mn, te), Zf = (Cs = mn.declarations) == null ? void 0 : Cs.find(Q_(os, Dy, ei, $u, _n, wn)); + if (mn.flags & 98304 && ri) { + const Vc = []; + if (mn.flags & 65536) { + const y_ = mn.declarations && lr(mn.declarations, (ph) => { + if (ph.kind === 179) + return ph; + if (Ps(ph) && uS(ph)) + return lr(ph.arguments[2].properties, (L1) => { + const M1 = _s(L1); + if (M1 && Me(M1) && An(M1) === "set") + return L1; + }); + }); + E.assert(!!y_); + const cy = io(y_) ? Xf(y_).parameters[0] : void 0, Kf = (di = mn.declarations) == null ? void 0 : di.find(am); + te.approximateLength += yR(ac) + 7 + (cy ? cc(cy).length : 5) + (Fo ? 0 : 2), Vc.push(l( + te, + N.createSetAccessorDeclaration( + N.createModifiersFromModifierFlags(ac), + gc, + [N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + cy ? xi(cy, Dr(cy), te) : "value", + /*questionToken*/ + void 0, + Fo ? void 0 : Tn(te, Kf, Z0(mn), mn) + )], + /*body*/ + void 0 + ), + Kf ?? Zf + )); + } + if (mn.flags & 32768) { + const y_ = ($s = mn.declarations) == null ? void 0 : $s.find(Pg); + te.approximateLength += yR(ac) + 8 + (Fo ? 0 : 2), Vc.push(l( + te, + N.createGetAccessorDeclaration( + N.createModifiersFromModifierFlags(ac), + gc, + [], + Fo ? void 0 : Tn(te, y_, Yr(mn), mn), + /*body*/ + void 0 + ), + y_ ?? Zf + )); + } + return Vc; + } else if (mn.flags & 98311) { + const Vc = (tm(mn) ? 8 : 0) | ac; + return te.approximateLength += 2 + (Fo ? 0 : 2) + yR(Vc), l( + te, + ht( + N.createModifiersFromModifierFlags(Vc), + gc, + mn.flags & 16777216 ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, + Fo ? void 0 : Tn(te, (ol = mn.declarations) == null ? void 0 : ol.find(z_), Z0(mn), mn), + // TODO: https://github.com/microsoft/TypeScript/pull/32372#discussion_r328386357 + // interface members can't have initializers, however class members _can_ + /*initializer*/ + void 0 + ), + ((Uo = mn.declarations) == null ? void 0 : Uo.find(Q_(os, ei))) || Zf + ); + } + if (mn.flags & 8208) { + const Vc = Yr(mn), y_ = Is( + Vc, + 0 + /* Call */ + ); + if (Fo) { + const Kf = (tm(mn) ? 8 : 0) | ac; + return te.approximateLength += 1 + yR(Kf), l( + te, + ht( + N.createModifiersFromModifierFlags(Kf), + gc, + mn.flags & 16777216 ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + ), + ((ku = mn.declarations) == null ? void 0 : ku.find(io)) || y_[0] && y_[0].declaration || mn.declarations && mn.declarations[0] + ); + } + const cy = []; + for (const Kf of y_) { + te.approximateLength += 1; + const ph = zn( + Kf, + Xr, + te, + { + name: gc, + questionToken: mn.flags & 16777216 ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, + modifiers: ac ? N.createModifiersFromModifierFlags(ac) : void 0 + } + ), L1 = Kf.declaration && W3(Kf.declaration.parent) ? Kf.declaration.parent : Kf.declaration; + cy.push(l(te, ph, L1)); + } + return cy; + } + return E.fail(`Unhandled class member kind! ${mn.__debugFlags || mn.flags}`); + }; + } + function yR(ht) { + let Xr = 0; + return ht & 32 && (Xr += 7), ht & 128 && (Xr += 8), ht & 2048 && (Xr += 8), ht & 4096 && (Xr += 6), ht & 1 && (Xr += 7), ht & 2 && (Xr += 8), ht & 4 && (Xr += 10), ht & 64 && (Xr += 9), ht & 256 && (Xr += 7), ht & 16 && (Xr += 9), ht & 8 && (Xr += 9), ht & 512 && (Xr += 9), ht & 1024 && (Xr += 6), ht & 8192 && (Xr += 3), ht & 16384 && (Xr += 4), Xr; + } + function P5e(ht, Xr) { + return xe( + ht, + /*isStatic*/ + !1, + Xr + ); + } + function ige(ht, Xr, ri, si) { + const mn = Is(Xr, ht); + if (ht === 1) { + if (!ri && Ni(mn, (Cs) => wr(Cs.parameters) === 0)) + return []; + if (ri) { + const Cs = Is( + ri, + 1 + /* Construct */ + ); + if (!wr(Cs) && Ni(mn, (di) => wr(di.parameters) === 0)) + return []; + if (Cs.length === mn.length) { + let di = !1; + for (let $s = 0; $s < Cs.length; $s++) + if (!bM( + mn[$s], + Cs[$s], + /*partialMatch*/ + !1, + /*ignoreThisTypes*/ + !1, + /*ignoreReturnTypes*/ + !0, + lI + )) { + di = !0; + break; + } + if (!di) + return []; + } + } + let fa = 0; + for (const Cs of mn) + Cs.declaration && (fa |= xx( + Cs.declaration, + 6 + /* Protected */ + )); + if (fa) + return [l( + te, + N.createConstructorDeclaration( + N.createModifiersFromModifierFlags(fa), + /*parameters*/ + [], + /*body*/ + void 0 + ), + mn[0].declaration + )]; + } + const ea = []; + for (const fa of mn) { + te.approximateLength += 1; + const Cs = zn(fa, si, te); + ea.push(l(te, Cs, fa.declaration)); + } + return ea; + } + function N5e(ht, Xr) { + const ri = []; + for (const si of Su(ht)) { + if (Xr) { + const mn = ah(Xr, si.keyType); + if (mn && lh(si.type, mn.type)) + continue; + } + ri.push(Ri( + si, + te, + /*typeNode*/ + void 0 + )); + } + return ri; + } + function Qft(ht, Xr, ri) { + const si = sge( + ht, + 111551 + /* Value */ + ); + if (si) + return si; + const mn = vR(`${ri}_base`), ea = N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [ + N.createVariableDeclaration( + mn, + /*exclamationToken*/ + void 0, + jt(Xr, te) + ) + ], + 2 + /* Const */ + ) + ); + return ss( + ea, + 0 + /* None */ + ), N.createExpressionWithTypeArguments( + N.createIdentifier(mn), + /*typeArguments*/ + void 0 + ); + } + function sge(ht, Xr) { + let ri, si; + if (ht.target && Yw(ht.target.symbol, Re, Xr) ? (ri = hr(Ao(ht), (mn) => jt(mn, te)), si = Np( + ht.target.symbol, + te, + 788968 + /* Type */ + )) : ht.symbol && Yw(ht.symbol, Re, Xr) && (si = Np( + ht.symbol, + te, + 788968 + /* Type */ + )), si) + return N.createExpressionWithTypeArguments(si, ri); + } + function Yft(ht) { + const Xr = sge( + ht, + 788968 + /* Type */ + ); + if (Xr) + return Xr; + if (ht.symbol) + return N.createExpressionWithTypeArguments( + Np( + ht.symbol, + te, + 788968 + /* Type */ + ), + /*typeArguments*/ + void 0 + ); + } + function vR(ht, Xr) { + var ri, si; + const mn = Xr ? Xs(Xr) : void 0; + if (mn && te.remappedSymbolNames.has(mn)) + return te.remappedSymbolNames.get(mn); + Xr && (ht = A5e(Xr, ht)); + let ea = 0; + const fa = ht; + for (; (ri = te.usedSymbolNames) != null && ri.has(ht); ) + ea++, ht = `${fa}_${ea}`; + return (si = te.usedSymbolNames) == null || si.add(ht), mn && te.remappedSymbolNames.set(mn, ht), ht; + } + function A5e(ht, Xr) { + if (Xr === "default" || Xr === "__class" || Xr === "__function") { + const ri = ve(te); + te.flags |= 16777216; + const si = Yv(ht, te); + ri(), Xr = si.length > 0 && R3(si.charCodeAt(0)) ? Bp(si) : si; + } + return Xr === "default" ? Xr = "_default" : Xr === "export=" && (Xr = "_exports"), Xr = R_(Xr, R) && !Sx(Xr) ? Xr : "_" + Xr.replace(/[^a-z0-9]/gi, "_"), Xr; + } + function Sg(ht, Xr) { + const ri = Xs(ht); + return te.remappedSymbolNames.has(ri) ? te.remappedSymbolNames.get(ri) : (Xr = A5e(ht, Xr), te.remappedSymbolNames.set(ri, Xr), Xr); + } + } + function pb(we) { + return we.maxExpansionDepth !== -1; + } + function mR(we) { + return !!we.valueDeclaration && wl(we.valueDeclaration) && Ai(we.valueDeclaration.name); + } + function GX(we) { + if (we.valueDeclaration && wl(we.valueDeclaration) && Ai(we.valueDeclaration.name)) + return N.cloneNode(we.valueDeclaration.name); + } + } + function EE(r) { + var a; + const l = (Dn(r) & 4) !== 0 ? r.target.symbol : r.symbol; + return Sa(r) || !!((a = l?.declarations) != null && a.some((f) => e.isSourceFileDefaultLibrary(xr(f)))); + } + function _g(r, a, l = 16384, f) { + return f ? d(f).getText() : LC(d); + function d(y) { + const x = w2(l) | 70221824 | 512, I = pe.typePredicateToTypePredicateNode(r, a, x), J = i2(), z = a && xr(a); + return J.writeNode( + 4, + I, + /*sourceFile*/ + z, + y + ), y; + } + } + function q8(r, a) { + const l = []; + let f = 0; + for (let d = 0; d < r.length; d++) { + const y = r[d]; + if (f |= y.flags, !(y.flags & 98304)) { + if (y.flags & 512 || !a && y.flags | 1056) { + const x = y.flags & 512 ? Nt : $G(y); + if (x.flags & 1048576) { + const I = x.types.length; + if (d + I <= r.length && t_(r[d + I - 1]) === t_(x.types[I - 1])) { + l.push(x), d += I - 1; + continue; + } + } + } + l.push(y); + } + } + return f & 65536 && l.push(Mt), f & 32768 && l.push(ue), l || r; + } + function Qv(r) { + return r === 2 ? "private" : r === 4 ? "protected" : "public"; + } + function $L(r) { + if (r.symbol && r.symbol.flags & 2048 && r.symbol.declarations) { + const a = $3(r.symbol.declarations[0].parent); + if (Wp(a)) + return yn(a); + } + } + function eP(r) { + return r && r.parent && r.parent.kind === 269 && Pb(r.parent.parent); + } + function H8(r) { + return r.kind === 308 || Vu(r); + } + function tP(r, a) { + const l = Pn(r).nameType; + if (l) { + if (l.flags & 384) { + const f = "" + l.value; + return !R_(f, da(F)) && !zg(f) ? `"${Ym( + f, + 34 + /* doubleQuote */ + )}"` : zg(f) && Ui(f, "-") ? `[${f}]` : f; + } + if (l.flags & 8192) + return `[${Yv(l.symbol, a)}]`; + } + } + function Yv(r, a) { + var l; + if ((l = a?.remappedSymbolReferences) != null && l.has(Xs(r)) && (r = a.remappedSymbolReferences.get(Xs(r))), a && r.escapedName === "default" && !(a.flags & 16384) && // If it's not the first part of an entity name, it must print as `default` + (!(a.flags & 16777216) || // if the symbol is synthesized, it will only be referenced externally it must print as `default` + !r.declarations || // if not in the same binding context (source file, module declaration), it must print as `default` + a.enclosingDeclaration && dr(r.declarations[0], H8) !== dr(a.enclosingDeclaration, H8))) + return "default"; + if (r.declarations && r.declarations.length) { + let d = Lc(r.declarations, (x) => _s(x) ? x : void 0); + const y = d && _s(d); + if (d && y) { + if (Ps(d) && uS(d)) + return cc(r); + if (Gs(y) && !(uc(r) & 4096)) { + const x = Pn(r).nameType; + if (x && x.flags & 384) { + const I = tP(r, a); + if (I !== void 0) + return I; + } + } + return co(y); + } + if (d || (d = r.declarations[0]), d.parent && d.parent.kind === 261) + return co(d.parent.name); + switch (d.kind) { + case 232: + case 219: + case 220: + return a && !a.encounteredError && !(a.flags & 131072) && (a.encounteredError = !0), d.kind === 232 ? "(Anonymous class)" : "(Anonymous function)"; + } + } + const f = tP(r, a); + return f !== void 0 ? f : cc(r); + } + function fg(r) { + if (r) { + const l = xn(r); + return l.isVisible === void 0 && (l.isVisible = !!a()), l.isVisible; + } + return !1; + function a() { + switch (r.kind) { + case 339: + case 347: + case 341: + return !!(r.parent && r.parent.parent && r.parent.parent.parent && Di(r.parent.parent.parent)); + case 209: + return fg(r.parent.parent); + case 261: + if (ws(r.name) && !r.name.elements.length) + return !1; + // falls through + case 268: + case 264: + case 265: + case 266: + case 263: + case 267: + case 272: + if (Pb(r)) + return !0; + const l = bt(r); + return !(HX(r) & 32) && !(r.kind !== 272 && l.kind !== 308 && l.flags & 33554432) ? m0(l) : fg(l); + case 173: + case 172: + case 178: + case 179: + case 175: + case 174: + if (sf( + r, + 6 + /* Protected */ + )) + return !1; + // Public properties/methods are visible if its parents are visible, so: + // falls through + case 177: + case 181: + case 180: + case 182: + case 170: + case 269: + case 185: + case 186: + case 188: + case 184: + case 189: + case 190: + case 193: + case 194: + case 197: + case 203: + return fg(r.parent); + // Default binding, import specifier and namespace import is visible + // only on demand so by default it is not visible + case 274: + case 275: + case 277: + return !1; + // Type parameters are always visible + case 169: + // Source file and namespace export are always visible + // falls through + case 308: + case 271: + return !0; + // Export assignments do not create name bindings outside the module + case 278: + return !1; + default: + return !1; + } + } + } + function DE(r, a) { + let l; + r.kind !== 11 && r.parent && r.parent.kind === 278 ? l = st( + r, + r, + 2998271, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + ) : r.parent.kind === 282 && (l = Rk( + r.parent, + 2998271 + /* Alias */ + )); + let f, d; + return l && (d = /* @__PURE__ */ new Set(), d.add(Xs(l)), y(l.declarations)), f; + function y(x) { + lr(x, (I) => { + const J = bp(I) || I; + if (a ? xn(I).isVisible = !0 : (f = f || [], tp(f, J)), cS(I)) { + const z = I.moduleReference, G = i_(z), ve = st( + I, + G.escapedText, + 901119, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + ); + ve && d && u0(d, Xs(ve)) && y(ve.declarations); + } + }); + } + } + function Lm(r, a) { + const l = X(r, a); + if (l >= 0) { + const { length: f } = Xg; + for (let d = l; d < f; d++) + Nv[d] = !1; + return !1; + } + return Xg.push(r), Nv.push( + /*items*/ + !0 + ), YS.push(a), !0; + } + function X(r, a) { + for (let l = Xg.length - 1; l >= R0; l--) { + if (De(Xg[l], YS[l])) + return -1; + if (Xg[l] === r && YS[l] === a) + return l; + } + return -1; + } + function De(r, a) { + switch (a) { + case 0: + return !!Pn(r).type; + case 2: + return !!Pn(r).declaredType; + case 1: + return !!r.resolvedBaseConstructorType; + case 3: + return !!r.resolvedReturnType; + case 4: + return !!r.immediateBaseConstraint; + case 5: + return !!r.resolvedTypeArguments; + case 6: + return !!r.baseTypesResolved; + case 7: + return !!Pn(r).writeType; + case 8: + return xn(r).parameterInitializerContainsUndefined !== void 0; + } + return E.assertNever(a); + } + function He() { + return Xg.pop(), YS.pop(), Nv.pop(); + } + function bt(r) { + return dr(_m(r), (a) => { + switch (a.kind) { + case 261: + case 262: + case 277: + case 276: + case 275: + case 274: + return !1; + default: + return !0; + } + }).parent; + } + function Vt(r) { + const a = bo(Tl(r)); + return a.typeParameters ? Qh(a, hr(a.typeParameters, (l) => Le)) : a; + } + function rr(r, a) { + const l = Ys(r, a); + return l ? Yr(l) : void 0; + } + function Rn(r, a) { + var l; + let f; + return rr(r, a) || (f = (l = eC(r, a)) == null ? void 0 : l.type) && Ru( + f, + /*isProperty*/ + !0, + /*isOptional*/ + !0 + ); + } + function gn(r) { + return r && (r.flags & 1) !== 0; + } + function Gr(r) { + return r === qe || !!(r.flags & 1 && r.aliasSymbol); + } + function ii(r, a) { + if (a !== 0) + return Xk( + r, + /*includeOptionality*/ + !1, + a + ); + const l = yn(r); + return l && Pn(l).type || Xk( + r, + /*includeOptionality*/ + !1, + a + ); + } + function ji(r, a, l) { + if (r = Xc(r, (J) => !(J.flags & 98304)), r.flags & 131072) + return ta; + if (r.flags & 1048576) + return Go(r, (J) => ji(J, a, l)); + let f = Xn(hr(a, Yh)); + const d = [], y = []; + for (const J of $a(r)) { + const z = tC( + J, + 8576 + /* StringOrNumberLiteralOrUnique */ + ); + !Ms(z, f) && !(up(J) & 6) && d$(J) ? d.push(J) : y.push(z); + } + if (NT(r) || AT(f)) { + if (y.length && (f = Xn([f, ...y])), f.flags & 131072) + return r; + const J = Rtt(); + return J ? OE(J, [r, f]) : qe; + } + const x = Bs(); + for (const J of d) + x.set(J.escapedName, Tpe( + J, + /*readonly*/ + !1 + )); + const I = Ho(l, x, Ge, Ge, Su(r)); + return I.objectFlags |= 4194304, I; + } + function fo(r) { + return !!(r.flags & 465829888) && Dc( + ou(r) || yt, + 32768 + /* Undefined */ + ); + } + function Ka(r) { + const a = wp(r, fo) ? Go(r, (l) => l.flags & 465829888 ? Rm(l) : l) : r; + return Dp( + a, + 524288 + /* NEUndefined */ + ); + } + function La(r, a) { + const l = Tp(r); + return l ? s0(l, a) : a; + } + function Tp(r) { + const a = Gf(r); + if (a && HC(a) && a.flowNode) { + const l = X0(r); + if (l) { + const f = ct(fv.createStringLiteral(l), r), d = S_(a) ? a : fv.createParenthesizedExpression(a), y = ct(fv.createElementAccessExpression(d, f), r); + return za(f, y), za(y, r), d !== a && za(d, y), y.flowNode = a.flowNode, y; + } + } + } + function Gf(r) { + const a = r.parent.parent; + switch (a.kind) { + case 209: + case 304: + return Tp(a); + case 210: + return Tp(r.parent); + case 261: + return a.initializer; + case 227: + return a.right; + } + } + function X0(r) { + const a = r.parent; + return r.kind === 209 && a.kind === 207 ? Q0(r.propertyName || r.name) : r.kind === 304 || r.kind === 305 ? Q0(r.name) : "" + a.elements.indexOf(r); + } + function Q0(r) { + const a = Yh(r); + return a.flags & 384 ? "" + a.value : void 0; + } + function rh(r) { + const a = r.dotDotDotToken ? 32 : 0, l = ii(r.parent.parent, a); + return l && S1( + r, + l, + /*noTupleBoundsCheck*/ + !1 + ); + } + function S1(r, a, l) { + if (gn(a)) + return a; + const f = r.parent; + K && r.flags & 33554432 && Y1(r) ? a = n0(a) : K && f.parent.initializer && !Yd( + LAe(f.parent.initializer), + 65536 + /* EQUndefined */ + ) && (a = Dp( + a, + 524288 + /* NEUndefined */ + )); + const d = 32 | (l || lC(r) ? 16 : 0); + let y; + if (f.kind === 207) + if (r.dotDotDotToken) { + if (a = td(a), a.flags & 2 || !RM(a)) + return ze(r, p.Rest_types_may_only_be_created_from_object_types), qe; + const x = []; + for (const I of f.elements) + I.dotDotDotToken || x.push(I.propertyName || I.name); + y = ji(a, x, r.symbol); + } else { + const x = r.propertyName || r.name, I = Yh(x), J = vf(a, I, d, x); + y = La(r, J); + } + else { + const x = ay(65 | (r.dotDotDotToken ? 0 : 128), a, ue, f), I = f.elements.indexOf(r); + if (r.dotDotDotToken) { + const J = Go(a, (z) => z.flags & 58982400 ? Rm(z) : z); + y = G_(J, Sa) ? Go(J, (z) => dP(z, I)) : Tu(x); + } else if (iy(a)) { + const J = Xd(I), z = C1(a, J, d, r.name) || qe; + y = La(r, z); + } else + y = x; + } + return r.initializer ? Kc(Y2(r)) ? K && !Yd( + kP( + r, + 0 + /* Normal */ + ), + 16777216 + /* IsUndefined */ + ) ? Ka(y) : y : hme(r, Xn( + [Ka(y), kP( + r, + 0 + /* Normal */ + )], + 2 + /* Subtype */ + )) : y; + } + function Ra(r) { + const a = f0(r); + if (a) + return Ci(a); + } + function dl(r) { + const a = Ba( + r, + /*excludeJSDocTypeAssertions*/ + !0 + ); + return a.kind === 106 || a.kind === 80 && ju(a) === ne; + } + function Y0(r) { + const a = Ba( + r, + /*excludeJSDocTypeAssertions*/ + !0 + ); + return a.kind === 210 && a.elements.length === 0; + } + function Ru(r, a = !1, l = !0) { + return K && l ? P1(r, a) : r; + } + function Xk(r, a, l) { + if (ei(r) && r.parent.parent.kind === 250) { + const x = jm(jde(Hi( + r.parent.parent.expression, + /*checkMode*/ + l + ))); + return x.flags & 4456448 ? mNe(x) : at; + } + if (ei(r) && r.parent.parent.kind === 251) { + const x = r.parent.parent; + return cR(x) || Le; + } + if (ws(r.parent)) + return rh(r); + const f = os(r) && !fm(r) || $u(r) || Zte(r), d = a && Ox(r), y = x1(r); + if (lB(r)) + return y ? gn(y) || y === yt ? y : qe : q ? yt : Le; + if (y) + return Ru(y, f, d); + if ((fe || an(r)) && ei(r) && !ws(r.name) && !(HX(r) & 32) && !(r.flags & 33554432)) { + if (!(U2(r) & 6) && (!r.initializer || dl(r.initializer))) + return mt; + if (r.initializer && Y0(r.initializer)) + return Ol; + } + if (Ii(r)) { + if (!r.symbol) + return; + const x = r.parent; + if (x.kind === 179 && NE(x)) { + const z = Oo( + yn(r.parent), + 178 + /* GetAccessor */ + ); + if (z) { + const G = Xf(z), ve = Zme(x); + return ve && r === ve ? (E.assert(!ve.type), Yr(G.thisParameter)) : Wa(G); + } + } + const I = ott(x, r); + if (I) return I; + const J = r.symbol.escapedName === "this" ? kde(x) : f8e(r); + if (J) + return Ru( + J, + /*isProperty*/ + !1, + d + ); + } + if (iS(r) && r.initializer) { + if (an(r) && !Ii(r)) { + const I = qt(r, yn(r), zD(r)); + if (I) + return I; + } + const x = hme(r, kP(r, l)); + return Ru(x, f, d); + } + if (os(r) && (fe || an(r))) + if (cl(r)) { + const x = kn(r.parent.members, kc), I = x.length ? w(r.symbol, x) : pu(r) & 128 ? C$(r.symbol) : void 0; + return I && Ru( + I, + /*isProperty*/ + !0, + d + ); + } else { + const x = wN(r.parent), I = x ? j(r.symbol, x) : pu(r) & 128 ? C$(r.symbol) : void 0; + return I && Ru( + I, + /*isProperty*/ + !0, + d + ); + } + if (Tm(r)) + return rt; + if (ws(r.name)) + return rP( + r.name, + /*includePatternInType*/ + !1, + /*reportErrors*/ + !0 + ); + } + function nh(r) { + if (r.valueDeclaration && _n(r.valueDeclaration)) { + const a = Pn(r); + return a.isConstructorDeclaredProperty === void 0 && (a.isConstructorDeclaredProperty = !1, a.isConstructorDeclaredProperty = !!tn(r) && Ni(r.declarations, (l) => _n(l) && Q$(l) && (l.left.kind !== 213 || If(l.left.argumentExpression)) && !hn( + /*declaredType*/ + void 0, + l, + r, + l + ))), a.isConstructorDeclaredProperty; + } + return !1; + } + function pg(r) { + const a = r.valueDeclaration; + return a && os(a) && !Kc(a) && !a.initializer && (fe || an(a)); + } + function tn(r) { + if (r.declarations) + for (const a of r.declarations) { + const l = qu( + a, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + if (l && (l.kind === 177 || zm(l))) + return l; + } + } + function v(r) { + const a = xr(r.declarations[0]), l = Si(r.escapedName), f = r.declarations.every((y) => an(y) && To(y) && Lg(y.expression)), d = f ? N.createPropertyAccessExpression(N.createPropertyAccessExpression(N.createIdentifier("module"), N.createIdentifier("exports")), l) : N.createPropertyAccessExpression(N.createIdentifier("exports"), l); + return f && za(d.expression.expression, d.expression), za(d.expression, d), za(d, a), d.flowNode = a.endFlowNode, s0(d, mt, ue); + } + function w(r, a) { + const l = Ui(r.escapedName, "__#") ? N.createPrivateIdentifier(r.escapedName.split("@")[1]) : Si(r.escapedName); + for (const f of a) { + const d = N.createPropertyAccessExpression(N.createThis(), l); + za(d.expression, d), za(d, f), d.flowNode = f.returnFlowNode; + const y = oe(d, r); + if (fe && (y === mt || y === Ol) && ze(r.valueDeclaration, p.Member_0_implicitly_has_an_1_type, Wi(r), Wr(y)), !G_(y, JM)) + return BI(y); + } + } + function j(r, a) { + const l = Ui(r.escapedName, "__#") ? N.createPrivateIdentifier(r.escapedName.split("@")[1]) : Si(r.escapedName), f = N.createPropertyAccessExpression(N.createThis(), l); + za(f.expression, f), za(f, a), f.flowNode = a.returnFlowNode; + const d = oe(f, r); + return fe && (d === mt || d === Ol) && ze(r.valueDeclaration, p.Member_0_implicitly_has_an_1_type, Wi(r), Wr(d)), G_(d, JM) ? void 0 : BI(d); + } + function oe(r, a) { + const l = a?.valueDeclaration && (!pg(a) || pu(a.valueDeclaration) & 128) && C$(a) || ue; + return s0(r, mt, l); + } + function Ue(r, a) { + const l = mx(r.valueDeclaration); + if (l) { + const I = an(l) ? z1(l) : void 0; + return I && I.typeExpression ? Ci(I.typeExpression) : r.valueDeclaration && qt(r.valueDeclaration, r, l) || ob(mc(l)); + } + let f, d = !1, y = !1; + if (nh(r) && (f = j(r, tn(r))), !f) { + let I; + if (r.declarations) { + let J; + for (const z of r.declarations) { + const G = _n(z) || Ps(z) ? z : To(z) ? _n(z.parent) ? z.parent : z : void 0; + if (!G) + continue; + const ve = To(G) ? z3(G) : Ac(G); + (ve === 4 || _n(G) && Q$(G, ve)) && (wf(G) ? d = !0 : y = !0), Ps(G) || (J = hn(J, G, r, z)), J || (I || (I = [])).push(_n(G) || Ps(G) ? ls(r, a, G, ve) : nr); + } + f = J; + } + if (!f) { + if (!wr(I)) + return qe; + let J = d && r.declarations ? T1(I, r.declarations) : void 0; + if (y) { + const G = C$(r); + G && ((J || (J = [])).push(G), d = !0); + } + const z = ot(J, (G) => !!(G.flags & -98305)) ? J : I; + f = Xn(z); + } + } + const x = Sf(Ru( + f, + /*isProperty*/ + !1, + y && !d + )); + return r.valueDeclaration && an(r.valueDeclaration) && Xc(x, (I) => !!(I.flags & -98305)) === nr ? (cb(r.valueDeclaration, Le), Le) : x; + } + function qt(r, a, l) { + var f, d; + if (!an(r) || !l || !_a(l) || l.properties.length) + return; + const y = Bs(); + for (; _n(r) || wn(r); ) { + const J = Hf(r); + (f = J?.exports) != null && f.size && Im(y, J.exports), r = _n(r) ? r.parent : r.parent.parent; + } + const x = Hf(r); + (d = x?.exports) != null && d.size && Im(y, x.exports); + const I = Ho(a, y, Ge, Ge, Ge); + return I.objectFlags |= 4096, I; + } + function hn(r, a, l, f) { + var d; + const y = Kc(a.parent); + if (y) { + const x = Sf(Ci(y)); + if (r) + !Gr(r) && !Gr(x) && !lh(r, x) && b7e( + /*firstDeclaration*/ + void 0, + r, + f, + x + ); + else return x; + } + if ((d = l.parent) != null && d.valueDeclaration) { + const x = Gv(l.parent); + if (x.valueDeclaration) { + const I = Kc(x.valueDeclaration); + if (I) { + const J = Ys(Ci(I), l.escapedName); + if (J) + return Hd(J); + } + } + } + return r; + } + function ls(r, a, l, f) { + if (Ps(l)) { + if (a) + return Yr(a); + const x = mc(l.arguments[2]), I = rr(x, "value"); + if (I) + return I; + const J = rr(x, "get"); + if (J) { + const G = UT(J); + if (G) + return Wa(G); + } + const z = rr(x, "set"); + if (z) { + const G = UT(z); + if (G) + return ome(G); + } + return Le; + } + if (No(l.left, l.right)) + return Le; + const d = f === 1 && (wn(l.left) || uo(l.left)) && (Lg(l.left.expression) || Me(l.left.expression) && lS(l.left.expression)), y = a ? Yr(a) : d ? t_(mc(l.right)) : ob(mc(l.right)); + if (y.flags & 524288 && f === 2 && r.escapedName === "export=") { + const x = $d(y), I = Bs(); + j7(x.members, I); + const J = I.size; + a && !a.exports && (a.exports = Bs()), (a || r).exports.forEach((G, ve) => { + var de; + const We = I.get(ve); + if (We && We !== G && !(G.flags & 2097152)) + if (G.flags & 111551 && We.flags & 111551) { + if (G.valueDeclaration && We.valueDeclaration && xr(G.valueDeclaration) !== xr(We.valueDeclaration)) { + const gt = Si(G.escapedName), jt = ((de = Bn(We.valueDeclaration, wl)) == null ? void 0 : de.name) || We.valueDeclaration; + zs( + ze(G.valueDeclaration, p.Duplicate_identifier_0, gt), + sn(jt, p._0_was_also_declared_here, gt) + ), zs( + ze(jt, p.Duplicate_identifier_0, gt), + sn(G.valueDeclaration, p._0_was_also_declared_here, gt) + ); + } + const lt = ga(G.flags | We.flags, ve); + lt.links.type = Xn([Yr(G), Yr(We)]), lt.valueDeclaration = We.valueDeclaration, lt.declarations = Bi(We.declarations, G.declarations), I.set(ve, lt); + } else + I.set(ve, vp(G, We)); + else + I.set(ve, G); + }); + const z = Ho( + J !== I.size ? void 0 : x.symbol, + // Only set the type's symbol if it looks to be the same as the original type + I, + x.callSignatures, + x.constructSignatures, + x.indexInfos + ); + if (J === I.size && (y.aliasSymbol && (z.aliasSymbol = y.aliasSymbol, z.aliasTypeArguments = y.aliasTypeArguments), Dn(y) & 4)) { + z.aliasSymbol = y.symbol; + const G = Ao(y); + z.aliasTypeArguments = wr(G) ? G : void 0; + } + return z.objectFlags |= nM([y]) | Dn(y) & 20608, z.symbol && z.symbol.flags & 32 && y === xp(z.symbol) && (z.objectFlags |= 16777216), z; + } + return D$(y) ? (cb(l, Gl), Gl) : y; + } + function No(r, a) { + return wn(r) && r.expression.kind === 110 && Kx(a, (l) => Yl(r, l)); + } + function wf(r) { + const a = qu( + r, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + return a.kind === 177 || a.kind === 263 || a.kind === 219 && !W3(a.parent); + } + function T1(r, a) { + return E.assert(r.length === a.length), r.filter((l, f) => { + const d = a[f], y = _n(d) ? d : _n(d.parent) ? d.parent : void 0; + return y && wf(y); + }); + } + function qd(r, a, l) { + if (r.initializer) { + const f = ws(r.name) ? rP( + r.name, + /*includePatternInType*/ + !0, + /*reportErrors*/ + !1 + ) : yt; + return Ru(HIe(r, kP(r, 0, f))); + } + return ws(r.name) ? rP(r.name, a, l) : (l && !zG(r) && cb(r, Le), a ? rn : Le); + } + function Qk(r, a, l) { + const f = Bs(); + let d, y = 131200; + lr(r.elements, (I) => { + const J = I.propertyName || I.name; + if (I.dotDotDotToken) { + d = oh( + at, + Le, + /*isReadonly*/ + !1 + ); + return; + } + const z = Yh(J); + if (!_p(z)) { + y |= 512; + return; + } + const G = fp(z), ve = 4 | (I.initializer ? 16777216 : 0), de = ga(ve, G); + de.links.type = qd(I, a, l), f.set(de.escapedName, de); + }); + const x = Ho( + /*symbol*/ + void 0, + f, + Ge, + Ge, + d ? [d] : Ge + ); + return x.objectFlags |= y, a && (x.pattern = r, x.objectFlags |= 131072), x; + } + function vfe(r, a, l) { + const f = r.elements, d = Do(f), y = d && d.kind === 209 && d.dotDotDotToken ? d : void 0; + if (f.length === 0 || f.length === 1 && y) + return R >= 2 ? K3e(Le) : Gl; + const x = hr(f, (G) => vl(G) ? Le : qd(G, a, l)), I = GI(f, (G) => !(G === y || vl(G) || lC(G)), f.length - 1) + 1, J = hr( + f, + (G, ve) => G === y ? 4 : ve >= I ? 2 : 1 + /* Required */ + ); + let z = hg(x, J); + return a && (z = A3e(z), z.pattern = r, z.objectFlags |= 131072), z; + } + function rP(r, a = !1, l = !1) { + a && Qp.push(r); + const f = r.kind === 207 ? Qk(r, a, l) : vfe(r, a, l); + return a && Qp.pop(), f; + } + function Yk(r, a) { + return G8(Xk( + r, + /*includeOptionality*/ + !0, + 0 + /* Normal */ + ), r, a); + } + function bfe(r) { + const a = xn(r); + if (!a.resolvedType) { + const l = ga( + 4096, + "__importAttributes" + /* ImportAttributes */ + ), f = Bs(); + lr(r.elements, (y) => { + const x = ga(4, uF(y)); + x.parent = l, x.links.type = Qut(y), x.links.target = x, f.set(x.escapedName, x); + }); + const d = Ho(l, f, Ge, Ge, Ge); + d.objectFlags |= 262272, a.resolvedType = d; + } + return a.resolvedType; + } + function Sfe(r) { + const a = Hf(r), l = xtt( + /*reportErrors*/ + !1 + ); + return l && a && a === l; + } + function G8(r, a, l) { + return r ? (r.flags & 4096 && Sfe(a.parent) && (r = xpe(a)), l && L$(a, r), r.flags & 8192 && (ya(a) || !x1(a)) && r.symbol !== yn(a) && (r = Jt), Sf(r)) : (r = Ii(a) && a.dotDotDotToken ? Gl : Le, l && (zG(a) || cb(a, r)), r); + } + function zG(r) { + const a = _m(r), l = a.kind === 170 ? a.parent : a; + return rR(l); + } + function x1(r) { + const a = Kc(r); + if (a) + return Ci(a); + } + function Tfe(r) { + let a = r.valueDeclaration; + return a ? (ya(a) && (a = Y2(a)), Ii(a) ? y$(a.parent) : !1) : !1; + } + function xfe(r) { + const a = Pn(r); + if (!a.type) { + const l = kfe(r); + return !a.type && !Tfe(r) && (a.type = l), l; + } + return a.type; + } + function kfe(r) { + if (r.flags & 4194304) + return Vt(r); + if (r === Ne) + return Le; + if (r.flags & 134217728 && r.valueDeclaration) { + const f = yn(xr(r.valueDeclaration)), d = ga(f.flags, "exports"); + d.declarations = f.declarations ? f.declarations.slice() : [], d.parent = r, d.links.target = f, f.valueDeclaration && (d.valueDeclaration = f.valueDeclaration), f.members && (d.members = new Map(f.members)), f.exports && (d.exports = new Map(f.exports)); + const y = Bs(); + return y.set("exports", d), Ho(r, y, Ge, Ge, Ge); + } + E.assertIsDefined(r.valueDeclaration); + const a = r.valueDeclaration; + if (Di(a) && ap(a)) + return a.statements.length ? Sf(ob(Hi(a.statements[0].expression))) : ta; + if (Dy(a)) + return iP(r); + if (!Lm( + r, + 0 + /* Type */ + )) + return r.flags & 512 && !(r.flags & 67108864) ? sP(r) : xT(r); + let l; + if (a.kind === 278) + l = G8(x1(a) || mc(a.expression), a); + else if (_n(a) || an(a) && (Ps(a) || (wn(a) || f5(a)) && _n(a.parent))) + l = Ue(r); + else if (wn(a) || uo(a) || Me(a) || ja(a) || E_(a) || tl(a) || Cc(a) || rc(a) && !Rp(a) || cd(a) || Di(a)) { + if (r.flags & 9136) + return sP(r); + l = _n(a.parent) ? Ue(r) : x1(a) || Le; + } else if (rl(a)) + l = x1(a) || GIe(a); + else if (Tm(a)) + l = x1(a) || D8e(a); + else if (gu(a)) + l = x1(a) || EP( + a.name, + 0 + /* Normal */ + ); + else if (Rp(a)) + l = x1(a) || $Ie( + a, + 0 + /* Normal */ + ); + else if (Ii(a) || os(a) || $u(a) || ei(a) || ya(a) || kD(a)) + l = Yk( + a, + /*reportErrors*/ + !0 + ); + else if (ov(a)) + l = sP(r); + else if (Ph(a)) + l = qG(r); + else + return E.fail("Unhandled declaration kind! " + E.formatSyntaxKind(a.kind) + " for " + E.formatSymbol(r)); + return He() ? l : r.flags & 512 && !(r.flags & 67108864) ? sP(r) : xT(r); + } + function P2(r) { + if (r) + switch (r.kind) { + case 178: + return nf(r); + case 179: + return tJ(r); + case 173: + return E.assert(fm(r)), Kc(r); + } + } + function nP(r) { + const a = P2(r); + return a && Ci(a); + } + function Zk(r) { + const a = Zme(r); + return a && a.symbol; + } + function WG(r) { + return tb(Xf(r)); + } + function iP(r) { + const a = Pn(r); + if (!a.type) { + if (!Lm( + r, + 0 + /* Type */ + )) + return qe; + const l = Oo( + r, + 178 + /* GetAccessor */ + ), f = Oo( + r, + 179 + /* SetAccessor */ + ), d = Bn(Oo( + r, + 173 + /* PropertyDeclaration */ + ), b_); + let y = l && an(l) && Ra(l) || nP(l) || nP(f) || nP(d) || l && l.body && gX(l) || d && Yk( + d, + /*reportErrors*/ + !0 + ); + y || (f && !rR(f) ? dd(fe, f, p.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation, Wi(r)) : l && !rR(l) ? dd(fe, l, p.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation, Wi(r)) : d && !rR(d) && dd(fe, d, p.Member_0_implicitly_has_an_1_type, Wi(r), "any"), y = Le), He() || (P2(l) ? ze(l, p._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, Wi(r)) : P2(f) || P2(d) ? ze(f, p._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, Wi(r)) : l && fe && ze(l, p._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, Wi(r)), y = Le), a.type ?? (a.type = y); + } + return a.type; + } + function UG(r) { + const a = Pn(r); + if (!a.writeType) { + if (!Lm( + r, + 7 + /* WriteType */ + )) + return qe; + const l = Oo( + r, + 179 + /* SetAccessor */ + ) ?? Bn(Oo( + r, + 173 + /* PropertyDeclaration */ + ), b_); + let f = nP(l); + He() || (P2(l) && ze(l, p._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, Wi(r)), f = Le), a.writeType ?? (a.writeType = f || iP(r)); + } + return a.writeType; + } + function $8(r) { + const a = Xh(xp(r)); + return a.flags & 8650752 ? a : a.flags & 2097152 ? Nn(a.types, (l) => !!(l.flags & 8650752)) : void 0; + } + function sP(r) { + let a = Pn(r); + const l = a; + if (!a.type) { + const f = r.valueDeclaration && dX( + r.valueDeclaration, + /*allowDeclaration*/ + !1 + ); + if (f) { + const d = eme(r, f); + d && (r = d, a = d.links); + } + l.type = a.type = VG(r); + } + return a.type; + } + function VG(r) { + const a = r.valueDeclaration; + if (r.flags & 1536 && S3(r)) + return Le; + if (a && (a.kind === 227 || To(a) && a.parent.kind === 227)) + return Ue(r); + if (r.flags & 512 && a && Di(a) && a.commonJsModuleIndicator) { + const f = q_(r); + if (f !== r) { + if (!Lm( + r, + 0 + /* Type */ + )) + return qe; + const d = Oa(r.exports.get( + "export=" + /* ExportEquals */ + )), y = Ue(d, d === f ? void 0 : f); + return He() ? y : xT(r); + } + } + const l = Wc(16, r); + if (r.flags & 32) { + const f = $8(r); + return f ? sa([l, f]) : l; + } else + return K && r.flags & 16777216 ? P1( + l, + /*isProperty*/ + !0 + ) : l; + } + function qG(r) { + const a = Pn(r); + return a.type || (a.type = VPe(r)); + } + function Cfe(r) { + const a = Pn(r); + if (!a.type) { + if (!Lm( + r, + 0 + /* Type */ + )) + return qe; + const l = Rl(r), f = r.declarations && qv( + F_(r), + /*dontRecursivelyResolve*/ + !0 + ), d = Lc(f?.declarations, (y) => Mo(y) ? x1(y) : void 0); + if (a.type ?? (a.type = f?.declarations && MX(f.declarations) && r.declarations.length ? v(f) : MX(r.declarations) ? mt : d || (O_(l) & 111551 ? Yr(l) : qe)), !He()) + return xT(f ?? r), a.type ?? (a.type = qe); + } + return a.type; + } + function Efe(r) { + const a = Pn(r); + return a.type || (a.type = Mi(Yr(a.target), a.mapper)); + } + function Dfe(r) { + const a = Pn(r); + return a.writeType || (a.writeType = Mi(Z0(a.target), a.mapper)); + } + function xT(r) { + const a = r.valueDeclaration; + if (a) { + if (Kc(a)) + return ze(r.valueDeclaration, p._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, Wi(r)), qe; + fe && (a.kind !== 170 || a.initializer) && ze(r.valueDeclaration, p._0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer, Wi(r)); + } else if (r.flags & 2097152) { + const l = F_(r); + l && ze(l, p.Circular_definition_of_import_alias_0, Wi(r)); + } + return Le; + } + function HG(r) { + const a = Pn(r); + return a.type || (E.assertIsDefined(a.deferralParent), E.assertIsDefined(a.deferralConstituents), a.type = a.deferralParent.flags & 1048576 ? Xn(a.deferralConstituents) : sa(a.deferralConstituents)), a.type; + } + function wfe(r) { + const a = Pn(r); + return !a.writeType && a.deferralWriteConstituents && (E.assertIsDefined(a.deferralParent), E.assertIsDefined(a.deferralConstituents), a.writeType = a.deferralParent.flags & 1048576 ? Xn(a.deferralWriteConstituents) : sa(a.deferralWriteConstituents)), a.writeType; + } + function Z0(r) { + const a = uc(r); + return a & 2 ? a & 65536 ? wfe(r) || HG(r) : ( + // NOTE: cast to TransientSymbol should be safe because only TransientSymbols can have CheckFlags.SyntheticProperty + r.links.writeType || r.links.type + ) : r.flags & 4 ? i0(Yr(r), !!(r.flags & 16777216)) : r.flags & 98304 ? a & 1 ? Dfe(r) : UG(r) : Yr(r); + } + function Yr(r) { + const a = uc(r); + return a & 65536 ? HG(r) : a & 1 ? Efe(r) : a & 262144 ? Wet(r) : a & 8192 ? sit(r) : r.flags & 7 ? xfe(r) : r.flags & 9136 ? sP(r) : r.flags & 8 ? qG(r) : r.flags & 98304 ? iP(r) : r.flags & 2097152 ? Cfe(r) : qe; + } + function Hd(r) { + return i0(Yr(r), !!(r.flags & 16777216)); + } + function GG(r, a) { + if (r === void 0 || (Dn(r) & 4) === 0) + return !1; + for (const l of a) + if (r.target === l) + return !0; + return !1; + } + function hf(r, a) { + return r !== void 0 && a !== void 0 && (Dn(r) & 4) !== 0 && r.target === a; + } + function Cr(r) { + return Dn(r) & 4 ? r.target : r; + } + function En(r, a) { + return l(r); + function l(f) { + if (Dn(f) & 7) { + const d = Cr(f); + return d === a || ot(bd(d), l); + } else if (f.flags & 2097152) + return ot(f.types, l); + return !1; + } + } + function Ln(r, a) { + for (const l of a) + r = dh(r, Zv(yn(l))); + return r; + } + function pi(r, a) { + for (; ; ) { + if (r = r.parent, r && _n(r)) { + const f = Ac(r); + if (f === 6 || f === 3) { + const d = yn(r.left); + d && d.parent && !dr(d.parent.valueDeclaration, (y) => r === y) && (r = d.parent.valueDeclaration); + } + } + if (!r) + return; + const l = r.kind; + switch (l) { + case 264: + case 232: + case 265: + case 180: + case 181: + case 174: + case 185: + case 186: + case 318: + case 263: + case 175: + case 219: + case 220: + case 266: + case 346: + case 347: + case 341: + case 339: + case 201: + case 195: { + const d = pi(r, a); + if ((l === 219 || l === 220 || Rp(r)) && Qf(r)) { + const I = Yc(Is( + Yr(yn(r)), + 0 + /* Call */ + )); + if (I && I.typeParameters) + return [...d || Ge, ...I.typeParameters]; + } + if (l === 201) + return Er(d, Zv(yn(r.typeParameter))); + if (l === 195) + return Bi(d, vpe(r)); + const y = Ln(d, xy(r)), x = a && (l === 264 || l === 232 || l === 265 || zm(r)) && xp(yn(r)).thisType; + return x ? Er(y, x) : y; + } + case 342: + const f = G3(r); + f && (r = f.valueDeclaration); + break; + case 321: { + const d = pi(r, a); + return r.tags ? Ln(d, ka(r.tags, (y) => Up(y) ? y.typeParameters : void 0)) : d; + } + } + } + } + function yi(r) { + var a; + const l = r.flags & 32 || r.flags & 16 ? r.valueDeclaration : (a = r.declarations) == null ? void 0 : a.find((f) => { + if (f.kind === 265) + return !0; + if (f.kind !== 261) + return !1; + const d = f.initializer; + return !!d && (d.kind === 219 || d.kind === 220); + }); + return E.assert(!!l, "Class was missing valueDeclaration -OR- non-class had no interface declarations"), pi(l); + } + function ia(r) { + if (!r.declarations) + return; + let a; + for (const l of r.declarations) + (l.kind === 265 || l.kind === 264 || l.kind === 232 || zm(l) || q3(l)) && (a = Ln(a, xy(l))); + return a; + } + function po(r) { + return Bi(yi(r), ia(r)); + } + function Ql(r) { + const a = Is( + r, + 1 + /* Construct */ + ); + if (a.length === 1) { + const l = a[0]; + if (!l.typeParameters && l.parameters.length === 1 && Iu(l)) { + const f = GM(l.parameters[0]); + return gn(f) || TM(f) === Le; + } + } + return !1; + } + function Gd(r) { + if (Is( + r, + 1 + /* Construct */ + ).length > 0) + return !0; + if (r.flags & 8650752) { + const a = ou(r); + return !!a && Ql(a); + } + return !1; + } + function ed(r) { + const a = Eh(r.symbol); + return a && wd(a); + } + function vd(r, a, l) { + const f = wr(a), d = an(l); + return kn(Is( + r, + 1 + /* Construct */ + ), (y) => (d || f >= gg(y.typeParameters)) && f <= wr(y.typeParameters)); + } + function ih(r, a, l) { + const f = vd(r, a, l), d = hr(a, Ci); + return Qc(f, (y) => ot(y.typeParameters) ? tI(y, d, an(l)) : y); + } + function Xh(r) { + if (!r.resolvedBaseConstructorType) { + const a = Eh(r.symbol), l = a && wd(a), f = ed(r); + if (!f) + return r.resolvedBaseConstructorType = ue; + if (!Lm( + r, + 1 + /* ResolvedBaseConstructorType */ + )) + return qe; + const d = Hi(f.expression); + if (l && f !== l && (E.assert(!l.typeArguments), Hi(l.expression)), d.flags & 2621440 && $d(d), !He()) + return ze(r.symbol.valueDeclaration, p._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, Wi(r.symbol)), r.resolvedBaseConstructorType ?? (r.resolvedBaseConstructorType = qe); + if (!(d.flags & 1) && d !== ke && !Gd(d)) { + const y = ze(f.expression, p.Type_0_is_not_a_constructor_function_type, Wr(d)); + if (d.flags & 262144) { + const x = _P(d); + let I = yt; + if (x) { + const J = Is( + x, + 1 + /* Construct */ + ); + J[0] && (I = Wa(J[0])); + } + d.symbol.declarations && zs(y, sn(d.symbol.declarations[0], p.Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1, Wi(d.symbol), Wr(I))); + } + return r.resolvedBaseConstructorType ?? (r.resolvedBaseConstructorType = qe); + } + r.resolvedBaseConstructorType ?? (r.resolvedBaseConstructorType = d); + } + return r.resolvedBaseConstructorType; + } + function wE(r) { + let a = Ge; + if (r.symbol.declarations) + for (const l of r.symbol.declarations) { + const f = $C(l); + if (f) + for (const d of f) { + const y = Ci(d); + Gr(y) || (a === Ge ? a = [y] : a.push(y)); + } + } + return a; + } + function aP(r, a) { + ze(r, p.Type_0_recursively_references_itself_as_a_base_type, Wr( + a, + /*enclosingDeclaration*/ + void 0, + 2 + /* WriteArrayAsGenericType */ + )); + } + function bd(r) { + if (!r.baseTypesResolved) { + if (Lm( + r, + 6 + /* ResolvedBaseTypes */ + ) && (r.objectFlags & 8 ? r.resolvedBaseTypes = [fet(r)] : r.symbol.flags & 96 ? (r.symbol.flags & 32 && pet(r), r.symbol.flags & 64 && met(r)) : E.fail("type must be class or interface"), !He() && r.symbol.declarations)) + for (const a of r.symbol.declarations) + (a.kind === 264 || a.kind === 265) && aP(a, r); + r.baseTypesResolved = !0; + } + return r.resolvedBaseTypes; + } + function fet(r) { + const a = Qc(r.typeParameters, (l, f) => r.elementFlags[f] & 8 ? vf(l, wt) : l); + return Tu(Xn(a || Ge), r.readonly); + } + function pet(r) { + r.resolvedBaseTypes = Kj; + const a = e_(Xh(r)); + if (!(a.flags & 2621441)) + return r.resolvedBaseTypes = Ge; + const l = ed(r); + let f; + const d = a.symbol ? bo(a.symbol) : void 0; + if (a.symbol && a.symbol.flags & 32 && det(d)) + f = I3e(l, a.symbol); + else if (a.flags & 1) + f = a; + else { + const x = ih(a, l.typeArguments, l); + if (!x.length) + return ze(l.expression, p.No_base_constructor_has_the_specified_number_of_type_arguments), r.resolvedBaseTypes = Ge; + f = Wa(x[0]); + } + if (Gr(f)) + return r.resolvedBaseTypes = Ge; + const y = td(f); + if (!XL(y)) { + const x = zfe( + /*errorInfo*/ + void 0, + f + ), I = Ts(x, p.Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members, Wr(y)); + return Aa.add(Fg(xr(l.expression), l.expression, I)), r.resolvedBaseTypes = Ge; + } + return r === y || En(y, r) ? (ze(r.symbol.valueDeclaration, p.Type_0_recursively_references_itself_as_a_base_type, Wr( + r, + /*enclosingDeclaration*/ + void 0, + 2 + /* WriteArrayAsGenericType */ + )), r.resolvedBaseTypes = Ge) : (r.resolvedBaseTypes === Kj && (r.members = void 0), r.resolvedBaseTypes = [y]); + } + function det(r) { + const a = r.outerTypeParameters; + if (a) { + const l = a.length - 1, f = Ao(r); + return a[l].symbol !== f[l].symbol; + } + return !0; + } + function XL(r) { + if (r.flags & 262144) { + const a = ou(r); + if (a) + return XL(a); + } + return !!(r.flags & 67633153 && !L_(r) || r.flags & 2097152 && Ni(r.types, XL)); + } + function met(r) { + if (r.resolvedBaseTypes = r.resolvedBaseTypes || Ge, r.symbol.declarations) { + for (const a of r.symbol.declarations) + if (a.kind === 265 && GD(a)) + for (const l of GD(a)) { + const f = td(Ci(l)); + Gr(f) || (XL(f) ? r !== f && !En(f, r) ? r.resolvedBaseTypes === Ge ? r.resolvedBaseTypes = [f] : r.resolvedBaseTypes.push(f) : aP(a, r) : ze(l, p.An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members)); + } + } + } + function get(r) { + if (!r.declarations) + return !0; + for (const a of r.declarations) + if (a.kind === 265) { + if (a.flags & 256) + return !1; + const l = GD(a); + if (l) { + for (const f of l) + if (to(f.expression)) { + const d = dc( + f.expression, + 788968, + /*ignoreErrors*/ + !0 + ); + if (!d || !(d.flags & 64) || xp(d).thisType) + return !1; + } + } + } + return !0; + } + function xp(r) { + let a = Pn(r); + const l = a; + if (!a.declaredType) { + const f = r.flags & 32 ? 1 : 2, d = eme(r, r.valueDeclaration && hot(r.valueDeclaration)); + d && (r = d, a = d.links); + const y = l.declaredType = a.declaredType = Wc(f, r), x = yi(r), I = ia(r); + (x || I || f === 1 || !get(r)) && (y.objectFlags |= 4, y.typeParameters = Bi(x, I), y.outerTypeParameters = x, y.localTypeParameters = I, y.instantiations = /* @__PURE__ */ new Map(), y.instantiations.set(rd(y.typeParameters), y), y.target = y, y.resolvedTypeArguments = y.typeParameters, y.thisType = p_(r), y.thisType.isThisType = !0, y.thisType.constraint = y); + } + return a.declaredType; + } + function zPe(r) { + var a; + const l = Pn(r); + if (!l.declaredType) { + if (!Lm( + r, + 2 + /* DeclaredType */ + )) + return qe; + const f = E.checkDefined((a = r.declarations) == null ? void 0 : a.find(q3), "Type alias symbol with no valid declaration found"), d = jp(f) ? f.typeExpression : f.type; + let y = d ? Ci(d) : qe; + if (He()) { + const x = ia(r); + x && (l.typeParameters = x, l.instantiations = /* @__PURE__ */ new Map(), l.instantiations.set(rd(x), y)), y === Pe && r.escapedName === "BuiltinIteratorReturn" && (y = npe()); + } else + y = qe, f.kind === 341 ? ze(f.typeExpression.type, p.Type_alias_0_circularly_references_itself, Wi(r)) : ze(wl(f) && f.name || f, p.Type_alias_0_circularly_references_itself, Wi(r)); + l.declaredType ?? (l.declaredType = y); + } + return l.declaredType; + } + function $G(r) { + return r.flags & 1056 && r.symbol.flags & 8 ? bo(Tl(r.symbol)) : r; + } + function WPe(r) { + const a = Pn(r); + if (!a.declaredType) { + const l = []; + if (r.declarations) { + for (const d of r.declarations) + if (d.kind === 267) { + for (const y of d.members) + if (NE(y)) { + const x = yn(y), I = qT(y).value, J = iC( + I !== void 0 ? Brt(I, Xs(r), x) : UPe(x) + ); + Pn(x).declaredType = J, l.push(t_(J)); + } + } + } + const f = l.length ? Xn( + l, + 1, + r, + /*aliasTypeArguments*/ + void 0 + ) : UPe(r); + f.flags & 1048576 && (f.flags |= 1024, f.symbol = r), a.declaredType = f; + } + return a.declaredType; + } + function UPe(r) { + const a = gi(32, r), l = gi(32, r); + return a.regularType = a, a.freshType = l, l.regularType = a, l.freshType = l, a; + } + function VPe(r) { + const a = Pn(r); + if (!a.declaredType) { + const l = WPe(Tl(r)); + a.declaredType || (a.declaredType = l); + } + return a.declaredType; + } + function Zv(r) { + const a = Pn(r); + return a.declaredType || (a.declaredType = p_(r)); + } + function het(r) { + const a = Pn(r); + return a.declaredType || (a.declaredType = bo(Rl(r))); + } + function bo(r) { + return qPe(r) || qe; + } + function qPe(r) { + if (r.flags & 96) + return xp(r); + if (r.flags & 524288) + return zPe(r); + if (r.flags & 262144) + return Zv(r); + if (r.flags & 384) + return WPe(r); + if (r.flags & 8) + return VPe(r); + if (r.flags & 2097152) + return het(r); + } + function QL(r) { + switch (r.kind) { + case 133: + case 159: + case 154: + case 150: + case 163: + case 136: + case 155: + case 151: + case 116: + case 157: + case 146: + case 202: + return !0; + case 189: + return QL(r.elementType); + case 184: + return !r.typeArguments || r.typeArguments.every(QL); + } + return !1; + } + function yet(r) { + const a = PC(r); + return !a || QL(a); + } + function HPe(r) { + const a = Kc(r); + return a ? QL(a) : !d0(r); + } + function vet(r) { + const a = nf(r), l = xy(r); + return (r.kind === 177 || !!a && QL(a)) && r.parameters.every(HPe) && l.every(yet); + } + function bet(r) { + if (r.declarations && r.declarations.length === 1) { + const a = r.declarations[0]; + if (a) + switch (a.kind) { + case 173: + case 172: + return HPe(a); + case 175: + case 174: + case 177: + case 178: + case 179: + return vet(a); + } + } + return !1; + } + function GPe(r, a, l) { + const f = Bs(); + for (const d of r) + f.set(d.escapedName, l && bet(d) ? d : Dpe(d, a)); + return f; + } + function $Pe(r, a) { + for (const l of a) { + if (XPe(l)) + continue; + const f = r.get(l.escapedName); + (!f || f.valueDeclaration && _n(f.valueDeclaration) && !nh(f) && !SK(f.valueDeclaration)) && (r.set(l.escapedName, l), r.set(l.escapedName, l)); + } + } + function XPe(r) { + return !!r.valueDeclaration && Du(r.valueDeclaration) && Js(r.valueDeclaration); + } + function Pfe(r) { + if (!r.declaredProperties) { + const a = r.symbol, l = dg(a); + r.declaredProperties = d_(l), r.declaredCallSignatures = Ge, r.declaredConstructSignatures = Ge, r.declaredIndexInfos = Ge, r.declaredCallSignatures = I2(l.get( + "__call" + /* Call */ + )), r.declaredConstructSignatures = I2(l.get( + "__new" + /* New */ + )), r.declaredIndexInfos = w3e(a); + } + return r; + } + function Nfe(r) { + return YPe(r) && _p(Gs(r) ? Td(r) : mc(r.argumentExpression)); + } + function QPe(r) { + return YPe(r) && Tet(Gs(r) ? Td(r) : mc(r.argumentExpression)); + } + function YPe(r) { + if (!Gs(r) && !uo(r)) + return !1; + const a = Gs(r) ? r.expression : r.argumentExpression; + return to(a); + } + function Tet(r) { + return Ms(r, oi); + } + function X8(r) { + return r.charCodeAt(0) === 95 && r.charCodeAt(1) === 95 && r.charCodeAt(2) === 64; + } + function PE(r) { + const a = _s(r); + return !!a && Nfe(a); + } + function ZPe(r) { + const a = _s(r); + return !!a && QPe(a); + } + function NE(r) { + return !Th(r) || PE(r); + } + function KPe(r) { + return v5(r) && !Nfe(r); + } + function xet(r, a, l) { + E.assert(!!(uc(r) & 4096), "Expected a late-bound symbol."), r.flags |= l, Pn(a.symbol).lateSymbol = r, r.declarations ? a.symbol.isReplaceableByMethod || r.declarations.push(a) : r.declarations = [a], l & 111551 && WD(r, a); + } + function e3e(r, a, l, f) { + E.assert(!!f.symbol, "The member is expected to have a symbol."); + const d = xn(f); + if (!d.resolvedSymbol) { + d.resolvedSymbol = f.symbol; + const y = _n(f) ? f.left : f.name, x = uo(y) ? mc(y.argumentExpression) : Td(y); + if (_p(x)) { + const I = fp(x), J = f.symbol.flags; + let z = l.get(I); + z || l.set(I, z = ga( + 0, + I, + 4096 + /* Late */ + )); + const G = a && a.get(I); + if (!(r.flags & 32) && z.flags & iT(J)) { + const ve = G ? Bi(G.declarations, z.declarations) : z.declarations, de = !(x.flags & 8192) && Si(I) || co(y); + lr(ve, (We) => ze(_s(We) || We, p.Property_0_was_also_declared_here, de)), ze(y || f, p.Duplicate_property_0, de), z = ga( + 0, + I, + 4096 + /* Late */ + ); + } + return z.links.nameType = x, xet(z, f, J), z.parent ? E.assert(z.parent === r, "Existing symbol parent should match new one") : z.parent = r, d.resolvedSymbol = z; + } + } + return d.resolvedSymbol; + } + function ket(r, a, l, f) { + let d = l.get( + "__index" + /* Index */ + ); + if (!d) { + const y = a?.get( + "__index" + /* Index */ + ); + y ? (d = v2(y), d.links.checkFlags |= 4096) : d = ga( + 0, + "__index", + 4096 + /* Late */ + ), l.set("__index", d); + } + d.declarations ? f.symbol.isReplaceableByMethod || d.declarations.push(f) : d.declarations = [f]; + } + function Afe(r, a) { + const l = Pn(r); + if (!l[a]) { + const f = a === "resolvedExports", d = f ? r.flags & 1536 ? gT(r).exports : r.exports : r.members; + l[a] = d || A; + const y = Bs(); + for (const J of r.declarations || Ge) { + const z = dK(J); + if (z) + for (const G of z) + f === cl(G) && (PE(G) ? e3e(r, d, y, G) : ZPe(G) && ket(r, d, y, G)); + } + const x = Gv(r).assignmentDeclarationMembers; + if (x) { + const J = is(x.values()); + for (const z of J) { + const G = Ac(z), ve = G === 3 || _n(z) && Q$(z, G) || G === 9 || G === 6; + f === !ve && PE(z) && e3e(r, d, y, z); + } + } + let I = W0(d, y); + if (r.flags & 33554432 && l.cjsExportMerged && r.declarations) + for (const J of r.declarations) { + const z = Pn(J.symbol)[a]; + if (!I) { + I = z; + continue; + } + z && z.forEach((G, ve) => { + const de = I.get(ve); + if (!de) I.set(ve, G); + else { + if (de === G) return; + I.set(ve, vp(de, G)); + } + }); + } + l[a] = I || A; + } + return l[a]; + } + function dg(r) { + return r.flags & 6256 ? Afe( + r, + "resolvedMembers" + /* resolvedMembers */ + ) : r.members || A; + } + function XG(r) { + if (r.flags & 106500 && r.escapedName === "__computed") { + const a = Pn(r); + if (!a.lateSymbol && ot(r.declarations, PE)) { + const l = Oa(r.parent); + ot(r.declarations, cl) ? gf(l) : dg(l); + } + return a.lateSymbol || (a.lateSymbol = r); + } + return r; + } + function yf(r, a, l) { + if (Dn(r) & 4) { + const f = r.target, d = Ao(r); + return wr(f.typeParameters) === wr(d) ? Qh(f, Bi(d, [a || f.thisType])) : r; + } else if (r.flags & 2097152) { + const f = Qc(r.types, (d) => yf(d, a, l)); + return f !== r.types ? sa(f) : r; + } + return l ? e_(r) : r; + } + function t3e(r, a, l, f) { + let d, y, x, I, J; + AR(l, f, 0, l.length) ? (y = a.symbol ? dg(a.symbol) : Bs(a.declaredProperties), x = a.declaredCallSignatures, I = a.declaredConstructSignatures, J = a.declaredIndexInfos) : (d = bf(l, f), y = GPe( + a.declaredProperties, + d, + /*mappingThisOnly*/ + l.length === 1 + ), x = g$(a.declaredCallSignatures, d), I = g$(a.declaredConstructSignatures, d), J = INe(a.declaredIndexInfos, d)); + const z = bd(a); + if (z.length) { + if (a.symbol && y === dg(a.symbol)) { + const ve = Bs(a.declaredProperties), de = e$(a.symbol); + de && ve.set("__index", de), y = ve; + } + Kp(r, y, x, I, J); + const G = Do(f); + for (const ve of z) { + const de = G ? yf(Mi(ve, d), G) : ve; + $Pe(y, $a(de)), x = Bi(x, Is( + de, + 0 + /* Call */ + )), I = Bi(I, Is( + de, + 1 + /* Construct */ + )); + const We = de !== Le ? Su(de) : [Yi]; + J = Bi(J, kn(We, (lt) => !lP(J, lt.keyType))); + } + } + Kp(r, y, x, I, J); + } + function Cet(r) { + t3e(r, Pfe(r), Ge, Ge); + } + function Eet(r) { + const a = Pfe(r.target), l = Bi(a.typeParameters, [a.thisType]), f = Ao(r), d = f.length === l.length ? f : Bi(f, [r]); + t3e(r, a, l, d); + } + function Mm(r, a, l, f, d, y, x, I) { + const J = new _(Jr, I); + return J.declaration = r, J.typeParameters = a, J.parameters = f, J.thisParameter = l, J.resolvedReturnType = d, J.resolvedTypePredicate = y, J.minArgumentCount = x, J.resolvedMinArgumentCount = void 0, J.target = void 0, J.mapper = void 0, J.compositeSignatures = void 0, J.compositeKind = void 0, J; + } + function Q8(r) { + const a = Mm( + r.declaration, + r.typeParameters, + r.thisParameter, + r.parameters, + /*resolvedReturnType*/ + void 0, + /*resolvedTypePredicate*/ + void 0, + r.minArgumentCount, + r.flags & 167 + /* PropagatingFlags */ + ); + return a.target = r.target, a.mapper = r.mapper, a.compositeSignatures = r.compositeSignatures, a.compositeKind = r.compositeKind, a; + } + function r3e(r, a) { + const l = Q8(r); + return l.compositeSignatures = a, l.compositeKind = 1048576, l.target = void 0, l.mapper = void 0, l; + } + function Det(r, a) { + if ((r.flags & 24) === a) + return r; + r.optionalCallSignatureCache || (r.optionalCallSignatureCache = {}); + const l = a === 8 ? "inner" : "outer"; + return r.optionalCallSignatureCache[l] || (r.optionalCallSignatureCache[l] = wet(r, a)); + } + function wet(r, a) { + E.assert(a === 8 || a === 16, "An optional call signature can either be for an inner call chain or an outer call chain, but not both."); + const l = Q8(r); + return l.flags |= a, l; + } + function n3e(r, a) { + if (Iu(r)) { + const d = r.parameters.length - 1, y = r.parameters[d], x = Yr(y); + if (Sa(x)) + return [l(x, d, y)]; + if (!a && x.flags & 1048576 && Ni(x.types, Sa)) + return hr(x.types, (I) => l(I, d, y)); + } + return [r.parameters]; + function l(d, y, x) { + const I = Ao(d), J = f(d, x), z = hr(I, (G, ve) => { + const de = J && J[ve] ? J[ve] : xP(r, y + ve, d), We = d.target.elementFlags[ve], lt = We & 12 ? 32768 : We & 2 ? 16384 : 0, gt = ga(1, de, lt); + return gt.links.type = We & 4 ? Tu(G) : G, gt; + }); + return Bi(r.parameters.slice(0, y), z); + } + function f(d, y) { + const x = hr(d.target.labeledElementDeclarations, (I, J) => ame(I, J, d.target.elementFlags[J], y)); + if (x) { + const I = [], J = /* @__PURE__ */ new Set(); + for (let G = 0; G < x.length; G++) { + const ve = x[G]; + u0(J, ve) || I.push(G); + } + const z = /* @__PURE__ */ new Map(); + for (const G of I) { + let ve = z.get(x[G]) ?? 1, de; + for (; !u0(J, de = `${x[G]}_${ve}`); ) + ve++; + x[G] = de, z.set(x[G], ve + 1); + } + } + return x; + } + } + function Pet(r) { + const a = Xh(r), l = Is( + a, + 1 + /* Construct */ + ), f = Eh(r.symbol), d = !!f && Gn( + f, + 64 + /* Abstract */ + ); + if (l.length === 0) + return [Mm( + /*declaration*/ + void 0, + r.localTypeParameters, + /*thisParameter*/ + void 0, + Ge, + r, + /*resolvedTypePredicate*/ + void 0, + 0, + d ? 4 : 0 + /* None */ + )]; + const y = ed(r), x = an(y), I = iM(y), J = wr(I), z = []; + for (const G of l) { + const ve = gg(G.typeParameters), de = wr(G.typeParameters); + if (x || J >= ve && J <= de) { + const We = de ? KG(G, ty(I, G.typeParameters, ve, x)) : Q8(G); + We.typeParameters = r.localTypeParameters, We.resolvedReturnType = r, We.flags = d ? We.flags | 4 : We.flags & -5, z.push(We); + } + } + return z; + } + function QG(r, a, l, f, d) { + for (const y of r) + if (bM(y, a, l, f, d, l ? rnt : lI)) + return y; + } + function Net(r, a, l) { + if (a.typeParameters) { + if (l > 0) + return; + for (let d = 1; d < r.length; d++) + if (!QG( + r[d], + a, + /*partialMatch*/ + !1, + /*ignoreThisTypes*/ + !1, + /*ignoreReturnTypes*/ + !1 + )) + return; + return [a]; + } + let f; + for (let d = 0; d < r.length; d++) { + const y = d === l ? a : QG( + r[d], + a, + /*partialMatch*/ + !1, + /*ignoreThisTypes*/ + !1, + /*ignoreReturnTypes*/ + !0 + ) || QG( + r[d], + a, + /*partialMatch*/ + !0, + /*ignoreThisTypes*/ + !1, + /*ignoreReturnTypes*/ + !0 + ); + if (!y) + return; + f = dh(f, y); + } + return f; + } + function Ife(r) { + let a, l; + for (let f = 0; f < r.length; f++) { + if (r[f].length === 0) return Ge; + r[f].length > 1 && (l = l === void 0 ? f : -1); + for (const d of r[f]) + if (!a || !QG( + a, + d, + /*partialMatch*/ + !1, + /*ignoreThisTypes*/ + !1, + /*ignoreReturnTypes*/ + !0 + )) { + const y = Net(r, d, f); + if (y) { + let x = d; + if (y.length > 1) { + let I = d.thisParameter; + const J = lr(y, (z) => z.thisParameter); + if (J) { + const z = sa(Fi(y, (G) => G.thisParameter && Yr(G.thisParameter))); + I = LT(J, z); + } + x = r3e(d, y), x.thisParameter = I; + } + (a || (a = [])).push(x); + } + } + } + if (!wr(a) && l !== -1) { + const f = r[l !== void 0 ? l : 0]; + let d = f.slice(); + for (const y of r) + if (y !== f) { + const x = y[0]; + if (E.assert(!!x, "getUnionSignatures bails early on empty signature lists and should not have empty lists on second pass"), d = x.typeParameters && ot(d, (I) => !!I.typeParameters && !i3e(x.typeParameters, I.typeParameters)) ? void 0 : hr(d, (I) => Fet(I, x)), !d) + break; + } + a = d; + } + return a || Ge; + } + function i3e(r, a) { + if (wr(r) !== wr(a)) + return !1; + if (!r || !a) + return !0; + const l = bf(a, r); + for (let f = 0; f < r.length; f++) { + const d = r[f], y = a[f]; + if (d !== y && !lh(_P(d) || yt, Mi(_P(y) || yt, l))) + return !1; + } + return !0; + } + function Aet(r, a, l) { + if (!r || !a) + return r || a; + const f = sa([Yr(r), Mi(Yr(a), l)]); + return LT(r, f); + } + function Iet(r, a, l) { + const f = $_(r), d = $_(a), y = f >= d ? r : a, x = y === r ? a : r, I = y === r ? f : d, J = vg(r) || vg(a), z = J && !vg(y), G = new Array(I + (z ? 1 : 0)); + for (let ve = 0; ve < I; ve++) { + let de = W2(y, ve); + y === a && (de = Mi(de, l)); + let We = W2(x, ve) || yt; + x === a && (We = Mi(We, l)); + const lt = sa([de, We]), gt = J && !z && ve === I - 1, jt = ve >= em(y) && ve >= em(x), ar = ve >= f ? void 0 : xP(r, ve), jr = ve >= d ? void 0 : xP(a, ve), Kr = ar === jr ? ar : ar ? jr ? void 0 : ar : jr, or = ga( + 1 | (jt && !gt ? 16777216 : 0), + Kr || `arg${ve}`, + gt ? 32768 : jt ? 16384 : 0 + ); + or.links.type = gt ? Tu(lt) : lt, G[ve] = or; + } + if (z) { + const ve = ga( + 1, + "args", + 32768 + /* RestParameter */ + ); + ve.links.type = Tu(Kd(x, I)), x === a && (ve.links.type = Mi(ve.links.type, l)), G[I] = ve; + } + return G; + } + function Fet(r, a) { + const l = r.typeParameters || a.typeParameters; + let f; + r.typeParameters && a.typeParameters && (f = bf(a.typeParameters, r.typeParameters)); + let d = (r.flags | a.flags) & 166; + const y = r.declaration, x = Iet(r, a, f), I = Do(x); + I && uc(I) & 32768 && (d |= 1); + const J = Aet(r.thisParameter, a.thisParameter, f), z = Math.max(r.minArgumentCount, a.minArgumentCount), G = Mm( + y, + l, + J, + x, + /*resolvedReturnType*/ + void 0, + /*resolvedTypePredicate*/ + void 0, + z, + d + ); + return G.compositeKind = 1048576, G.compositeSignatures = Bi(r.compositeKind !== 2097152 && r.compositeSignatures || [r], [a]), f ? G.mapper = r.compositeKind !== 2097152 && r.mapper && r.compositeSignatures ? ib(r.mapper, f) : f : r.compositeKind !== 2097152 && r.mapper && r.compositeSignatures && (G.mapper = r.mapper), G; + } + function s3e(r) { + const a = Su(r[0]); + if (a) { + const l = []; + for (const f of a) { + const d = f.keyType; + Ni(r, (y) => !!ah(y, d)) && l.push(oh(d, Xn(hr(r, (y) => eb(y, d))), ot(r, (y) => ah(y, d).isReadonly))); + } + return l; + } + return Ge; + } + function Oet(r) { + const a = Ife(hr(r.types, (d) => d === Mr ? [Vn] : Is( + d, + 0 + /* Call */ + ))), l = Ife(hr(r.types, (d) => Is( + d, + 1 + /* Construct */ + ))), f = s3e(r.types); + Kp(r, A, a, l, f); + } + function YL(r, a) { + return r ? a ? sa([r, a]) : r : a; + } + function a3e(r) { + const a = l0(r, (f) => Is( + f, + 1 + /* Construct */ + ).length > 0), l = hr(r, Ql); + if (a > 0 && a === l0(l, (f) => f)) { + const f = l.indexOf( + /*searchElement*/ + !0 + ); + l[f] = !1; + } + return l; + } + function Let(r, a, l, f) { + const d = []; + for (let y = 0; y < a.length; y++) + y === f ? d.push(r) : l[y] && d.push(Wa(Is( + a[y], + 1 + /* Construct */ + )[0])); + return sa(d); + } + function Met(r) { + let a, l, f; + const d = r.types, y = a3e(d), x = l0(y, (I) => I); + for (let I = 0; I < d.length; I++) { + const J = r.types[I]; + if (!y[I]) { + let z = Is( + J, + 1 + /* Construct */ + ); + z.length && x > 0 && (z = hr(z, (G) => { + const ve = Q8(G); + return ve.resolvedReturnType = Let(Wa(G), d, y, I), ve; + })), l = o3e(l, z); + } + a = o3e(a, Is( + J, + 0 + /* Call */ + )), f = Wu(Su(J), (z, G) => c3e( + z, + G, + /*union*/ + !1 + ), f); + } + Kp(r, A, a || Ge, l || Ge, f || Ge); + } + function o3e(r, a) { + for (const l of a) + (!r || Ni(r, (f) => !bM( + f, + l, + /*partialMatch*/ + !1, + /*ignoreThisTypes*/ + !1, + /*ignoreReturnTypes*/ + !1, + lI + ))) && (r = Er(r, l)); + return r; + } + function c3e(r, a, l) { + if (r) + for (let f = 0; f < r.length; f++) { + const d = r[f]; + if (d.keyType === a.keyType) + return r[f] = oh(d.keyType, l ? Xn([d.type, a.type]) : sa([d.type, a.type]), l ? d.isReadonly || a.isReadonly : d.isReadonly && a.isReadonly), r; + } + return Er(r, a); + } + function Ret(r) { + if (r.target) { + Kp(r, A, Ge, Ge, Ge); + const x = GPe( + ey(r.target), + r.mapper, + /*mappingThisOnly*/ + !1 + ), I = g$(Is( + r.target, + 0 + /* Call */ + ), r.mapper), J = g$(Is( + r.target, + 1 + /* Construct */ + ), r.mapper), z = INe(Su(r.target), r.mapper); + Kp(r, x, I, J, z); + return; + } + const a = Oa(r.symbol); + if (a.flags & 2048) { + Kp(r, A, Ge, Ge, Ge); + const x = dg(a), I = I2(x.get( + "__call" + /* Call */ + )), J = I2(x.get( + "__new" + /* New */ + )), z = w3e(a); + Kp(r, x, I, J, z); + return; + } + let l = gf(a), f; + if (a === Se) { + const x = /* @__PURE__ */ new Map(); + l.forEach((I) => { + var J; + !(I.flags & 418) && !(I.flags & 512 && ((J = I.declarations) != null && J.length) && Ni(I.declarations, Vu)) && x.set(I.escapedName, I); + }), l = x; + } + let d; + if (Kp(r, l, Ge, Ge, Ge), a.flags & 32) { + const x = xp(a), I = Xh(x); + I.flags & 11272192 ? (l = Bs(qk(l)), $Pe(l, $a(I))) : I === Le && (d = Yi); + } + const y = t$(l); + if (y ? f = r$(y, is(l.values())) : (d && (f = Er(f, d)), a.flags & 384 && (bo(a).flags & 32 || ot(r.properties, (x) => !!(Yr(x).flags & 296))) && (f = Er(f, Li))), Kp(r, l, Ge, Ge, f || Ge), a.flags & 8208 && (r.callSignatures = I2(a)), a.flags & 32) { + const x = xp(a); + let I = a.members ? I2(a.members.get( + "__constructor" + /* Constructor */ + )) : Ge; + a.flags & 16 && (I = In( + I.slice(), + Fi( + r.callSignatures, + (J) => zm(J.declaration) ? Mm( + J.declaration, + J.typeParameters, + J.thisParameter, + J.parameters, + x, + /*resolvedTypePredicate*/ + void 0, + J.minArgumentCount, + J.flags & 167 + /* PropagatingFlags */ + ) : void 0 + ) + )), I.length || (I = Pet(x)), r.constructSignatures = I; + } + } + function jet(r, a, l) { + return Mi(r, bf([a.indexType, a.objectType], [Xd(0), hg([l])])); + } + function Bet(r) { + const a = $f(r.mappedType); + if (!(a.flags & 1048576 || a.flags & 2097152)) + return; + const l = a.flags & 1048576 ? a.origin : a; + if (!l || !(l.flags & 2097152)) + return; + const f = sa(l.types.filter((d) => d !== r.constraintType)); + return f !== nr ? f : void 0; + } + function Jet(r) { + const a = ah(r.source, at), l = mg(r.mappedType), f = !(l & 1), d = l & 4 ? 0 : 16777216, y = a ? [oh(at, R$(a.type, r.mappedType, r.constraintType) || yt, f && a.isReadonly)] : Ge, x = Bs(), I = Bet(r); + for (const J of $a(r.source)) { + if (I) { + const ve = tC( + J, + 8576 + /* StringOrNumberLiteralOrUnique */ + ); + if (!Ms(ve, I)) + continue; + } + const z = 8192 | (f && tm(J) ? 8 : 0), G = ga(4 | J.flags & d, J.escapedName, z); + if (G.declarations = J.declarations, G.links.nameType = Pn(J).nameType, G.links.propertyType = Yr(J), r.constraintType.type.flags & 8388608 && r.constraintType.type.objectType.flags & 262144 && r.constraintType.type.indexType.flags & 262144) { + const ve = r.constraintType.type.objectType, de = jet(r.mappedType, r.constraintType.type, ve); + G.links.mappedType = de, G.links.constraintType = jm(ve); + } else + G.links.mappedType = r.mappedType, G.links.constraintType = r.constraintType; + x.set(J.escapedName, G); + } + Kp(r, x, Ge, Ge, y); + } + function ZL(r) { + if (r.flags & 4194304) { + const a = e_(r.type); + return w1(a) ? nNe(a) : jm(a); + } + if (r.flags & 16777216) { + if (r.root.isDistributive) { + const a = r.checkType, l = ZL(a); + if (l !== a) + return Ppe( + r, + IT(r.root.checkType, l, r.mapper), + /*forConstraint*/ + !1 + ); + } + return r; + } + if (r.flags & 1048576) + return Go( + r, + ZL, + /*noReductions*/ + !0 + ); + if (r.flags & 2097152) { + const a = r.types; + return a.length === 2 && a[0].flags & 76 && a[1] === Ws ? r : sa(Qc(r.types, ZL)); + } + return r; + } + function Ffe(r) { + return uc(r) & 4096; + } + function Ofe(r, a, l, f) { + for (const d of $a(r)) + f(tC(d, a)); + if (r.flags & 1) + f(at); + else + for (const d of Su(r)) + (!l || d.keyType.flags & 134217732) && f(d.keyType); + } + function zet(r) { + const a = Bs(); + let l; + Kp(r, A, Ge, Ge, Ge); + const f = Sd(r), d = $f(r), y = r.target || r, x = K0(y), I = Y8(y) !== 2, J = sh(y), z = e_(Kv(r)), G = mg(r); + AE(r) ? Ofe( + z, + 8576, + /*stringsOnly*/ + !1, + de + ) : BT(ZL(d), de), Kp(r, a, Ge, Ge, l || Ge); + function de(lt) { + const gt = x ? Mi(x, aI(r.mapper, f, lt)) : lt; + BT(gt, (jt) => We(lt, jt)); + } + function We(lt, gt) { + if (_p(gt)) { + const jt = fp(gt), ar = a.get(jt); + if (ar) + ar.links.nameType = Xn([ar.links.nameType, gt]), ar.links.keyType = Xn([ar.links.keyType, lt]); + else { + const jr = _p(lt) ? Ys(z, fp(lt)) : void 0, Kr = !!(G & 4 || !(G & 8) && jr && jr.flags & 16777216), or = !!(G & 1 || !(G & 2) && jr && tm(jr)), ir = K && !Kr && jr && jr.flags & 16777216, nn = jr ? Ffe(jr) : 0, Qn = ga(4 | (Kr ? 16777216 : 0), jt, nn | 262144 | (or ? 8 : 0) | (ir ? 524288 : 0)); + Qn.links.mappedType = r, Qn.links.nameType = gt, Qn.links.keyType = lt, jr && (Qn.links.syntheticOrigin = jr, Qn.declarations = I ? jr.declarations : void 0), a.set(jt, Qn); + } + } else if (n$(gt) || gt.flags & 33) { + const jt = gt.flags & 5 ? at : gt.flags & 40 ? wt : gt, ar = Mi(J, aI(r.mapper, f, lt)), jr = Z8(z, gt), Kr = !!(G & 1 || !(G & 2) && jr?.isReadonly), or = oh(jt, ar, Kr); + l = c3e( + l, + or, + /*union*/ + !0 + ); + } + } + } + function Wet(r) { + var a; + if (!r.links.type) { + const l = r.links.mappedType; + if (!Lm( + r, + 0 + /* Type */ + )) + return l.containsError = !0, qe; + const f = sh(l.target || l), d = aI(l.mapper, Sd(l), r.links.keyType), y = Mi(f, d); + let x = K && r.flags & 16777216 && !Dc( + y, + 49152 + /* Void */ + ) ? P1( + y, + /*isProperty*/ + !0 + ) : r.links.checkFlags & 524288 ? I$(y) : y; + He() || (ze(k, p.Type_of_property_0_circularly_references_itself_in_mapped_type_1, Wi(r), Wr(l)), x = qe), (a = r.links).type ?? (a.type = x); + } + return r.links.type; + } + function Sd(r) { + return r.typeParameter || (r.typeParameter = Zv(yn(r.declaration.typeParameter))); + } + function $f(r) { + return r.constraintType || (r.constraintType = m_(Sd(r)) || qe); + } + function K0(r) { + return r.declaration.nameType ? r.nameType || (r.nameType = Mi(Ci(r.declaration.nameType), r.mapper)) : void 0; + } + function sh(r) { + return r.templateType || (r.templateType = r.declaration.type ? Mi(Ru( + Ci(r.declaration.type), + /*isProperty*/ + !0, + !!(mg(r) & 4) + ), r.mapper) : qe); + } + function l3e(r) { + return PC(r.declaration.typeParameter); + } + function AE(r) { + const a = l3e(r); + return a.kind === 199 && a.operator === 143; + } + function Kv(r) { + if (!r.modifiersType) + if (AE(r)) + r.modifiersType = Mi(Ci(l3e(r).type), r.mapper); + else { + const a = hpe(r.declaration), l = $f(a), f = l && l.flags & 262144 ? m_(l) : l; + r.modifiersType = f && f.flags & 4194304 ? Mi(f.type, r.mapper) : yt; + } + return r.modifiersType; + } + function mg(r) { + const a = r.declaration; + return (a.readonlyToken ? a.readonlyToken.kind === 41 ? 2 : 1 : 0) | (a.questionToken ? a.questionToken.kind === 41 ? 8 : 4 : 0); + } + function u3e(r) { + const a = mg(r); + return a & 8 ? -1 : a & 4 ? 1 : 0; + } + function oP(r) { + if (Dn(r) & 32) + return u3e(r) || oP(Kv(r)); + if (r.flags & 2097152) { + const a = oP(r.types[0]); + return Ni(r.types, (l, f) => f === 0 || oP(l) === a) ? a : 0; + } + return 0; + } + function Uet(r) { + return !!(Dn(r) & 32 && mg(r) & 4); + } + function L_(r) { + if (Dn(r) & 32) { + const a = $f(r); + if (AT(a)) + return !0; + const l = K0(r); + if (l && AT(Mi(l, M2(Sd(r), a)))) + return !0; + } + return !1; + } + function Y8(r) { + const a = K0(r); + return a ? Ms(a, Sd(r)) ? 1 : 2 : 0; + } + function $d(r) { + return r.members || (r.flags & 524288 ? r.objectFlags & 4 ? Eet(r) : r.objectFlags & 3 ? Cet(r) : r.objectFlags & 1024 ? Jet(r) : r.objectFlags & 16 ? Ret(r) : r.objectFlags & 32 ? zet(r) : E.fail("Unhandled object type " + E.formatObjectFlags(r.objectFlags)) : r.flags & 1048576 ? Oet(r) : r.flags & 2097152 ? Met(r) : E.fail("Unhandled type " + E.formatTypeFlags(r.flags))), r; + } + function ey(r) { + return r.flags & 524288 ? $d(r).properties : Ge; + } + function N2(r, a) { + if (r.flags & 524288) { + const f = $d(r).members.get(a); + if (f && ur(f)) + return f; + } + } + function KL(r) { + if (!r.resolvedProperties) { + const a = Bs(); + for (const l of r.types) { + for (const f of $a(l)) + if (!a.has(f.escapedName)) { + const d = tM( + r, + f.escapedName, + /*skipObjectFunctionPropertyAugment*/ + !!(r.flags & 2097152) + ); + d && a.set(f.escapedName, d); + } + if (r.flags & 1048576 && Su(l).length === 0) + break; + } + r.resolvedProperties = d_(a); + } + return r.resolvedProperties; + } + function $a(r) { + return r = cP(r), r.flags & 3145728 ? KL(r) : ey(r); + } + function Vet(r, a) { + r = cP(r), r.flags & 3670016 && $d(r).members.forEach((l, f) => { + y1(l, f) && a(l, f); + }); + } + function qet(r, a) { + return a.properties.some((f) => { + const d = f.name && (Fd(f.name) ? H_(DN(f.name)) : Yh(f.name)), y = d && _p(d) ? fp(d) : void 0, x = y === void 0 ? void 0 : rr(r, y); + return !!x && fI(x) && !Ms(pC(f), x); + }); + } + function Het(r) { + const a = Xn(r); + if (!(a.flags & 1048576)) + return Ume(a); + const l = Bs(); + for (const f of r) + for (const { escapedName: d } of Ume(f)) + if (!l.has(d)) { + const y = h3e(a, d); + y && l.set(d, y); + } + return is(l.values()); + } + function kT(r) { + return r.flags & 262144 ? m_(r) : r.flags & 8388608 ? $et(r) : r.flags & 16777216 ? p3e(r) : ou(r); + } + function m_(r) { + return eM(r) ? _P(r) : void 0; + } + function Get(r, a) { + const l = oI(r); + return !!l && CT(l, a); + } + function CT(r, a = 0) { + var l; + return a < 5 && !!(r && (r.flags & 262144 && ot((l = r.symbol) == null ? void 0 : l.declarations, (f) => Gn( + f, + 4096 + /* Const */ + )) || r.flags & 3145728 && ot(r.types, (f) => CT(f, a)) || r.flags & 8388608 && CT(r.objectType, a + 1) || r.flags & 16777216 && CT(p3e(r), a + 1) || r.flags & 33554432 && CT(r.baseType, a) || Dn(r) & 32 && Get(r, a) || w1(r) && oc(F2(r), (f, d) => !!(r.target.elementFlags[d] & 8) && CT(f, a)) >= 0)); + } + function $et(r) { + return eM(r) ? Xet(r) : void 0; + } + function Lfe(r) { + const a = Zh( + r, + /*writing*/ + !1 + ); + return a !== r ? a : kT(r); + } + function Xet(r) { + if (Bfe(r)) + return f$(r.objectType, r.indexType); + const a = Lfe(r.indexType); + if (a && a !== r.indexType) { + const f = C1(r.objectType, a, r.accessFlags); + if (f) + return f; + } + const l = Lfe(r.objectType); + if (l && l !== r.objectType) + return C1(l, r.indexType, r.accessFlags); + } + function Mfe(r) { + if (!r.resolvedDefaultConstraint) { + const a = Ort(r), l = D1(r); + r.resolvedDefaultConstraint = gn(a) ? l : gn(l) ? a : Xn([a, l]); + } + return r.resolvedDefaultConstraint; + } + function _3e(r) { + if (r.resolvedConstraintOfDistributive !== void 0) + return r.resolvedConstraintOfDistributive || void 0; + if (r.root.isDistributive && r.restrictiveInstantiation !== r) { + const a = Zh( + r.checkType, + /*writing*/ + !1 + ), l = a === r.checkType ? kT(a) : a; + if (l && l !== r.checkType) { + const f = Ppe( + r, + IT(r.root.checkType, l, r.mapper), + /*forConstraint*/ + !0 + ); + if (!(f.flags & 131072)) + return r.resolvedConstraintOfDistributive = f, f; + } + } + r.resolvedConstraintOfDistributive = !1; + } + function f3e(r) { + return _3e(r) || Mfe(r); + } + function p3e(r) { + return eM(r) ? f3e(r) : void 0; + } + function Qet(r, a) { + let l, f = !1; + for (const d of r) + if (d.flags & 465829888) { + let y = kT(d); + for (; y && y.flags & 21233664; ) + y = kT(y); + y && (l = Er(l, y), a && (l = Er(l, d))); + } else (d.flags & 469892092 || yg(d)) && (f = !0); + if (l && (a || f)) { + if (f) + for (const d of r) + (d.flags & 469892092 || yg(d)) && (l = Er(l, d)); + return hM( + sa( + l, + 2 + /* NoConstraintReduction */ + ), + /*writing*/ + !1 + ); + } + } + function ou(r) { + if (r.flags & 464781312 || w1(r)) { + const a = Rfe(r); + return a !== yc && a !== Fc ? a : void 0; + } + return r.flags & 4194304 ? oi : void 0; + } + function Rm(r) { + return ou(r) || r; + } + function eM(r) { + return Rfe(r) !== Fc; + } + function Rfe(r) { + if (r.resolvedBaseConstraint) + return r.resolvedBaseConstraint; + const a = []; + return r.resolvedBaseConstraint = l(r); + function l(y) { + if (!y.immediateBaseConstraint) { + if (!Lm( + y, + 4 + /* ImmediateBaseConstraint */ + )) + return Fc; + let x; + const I = E$(y); + if ((a.length < 10 || a.length < 50 && !ms(a, I)) && (a.push(I), x = d(Zh( + y, + /*writing*/ + !1 + )), a.pop()), !He()) { + if (y.flags & 262144) { + const J = i$(y); + if (J) { + const z = ze(J, p.Type_parameter_0_has_a_circular_constraint, Wr(y)); + k && !Ob(J, k) && !Ob(k, J) && zs(z, sn(k, p.Circularity_originates_in_type_at_this_location)); + } + } + x = Fc; + } + y.immediateBaseConstraint ?? (y.immediateBaseConstraint = x || yc); + } + return y.immediateBaseConstraint; + } + function f(y) { + const x = l(y); + return x !== yc && x !== Fc ? x : void 0; + } + function d(y) { + if (y.flags & 262144) { + const x = _P(y); + return y.isThisType || !x ? x : f(x); + } + if (y.flags & 3145728) { + const x = y.types, I = []; + let J = !1; + for (const z of x) { + const G = f(z); + G ? (G !== z && (J = !0), I.push(G)) : J = !0; + } + return J ? y.flags & 1048576 && I.length === x.length ? Xn(I) : y.flags & 2097152 && I.length ? sa(I) : void 0 : y; + } + if (y.flags & 4194304) + return oi; + if (y.flags & 134217728) { + const x = y.types, I = Fi(x, f); + return I.length === x.length ? wT(y.texts, I) : at; + } + if (y.flags & 268435456) { + const x = f(y.type); + return x && x !== y.type ? rC(y.symbol, x) : at; + } + if (y.flags & 8388608) { + if (Bfe(y)) + return f(f$(y.objectType, y.indexType)); + const x = f(y.objectType), I = f(y.indexType), J = x && I && C1(x, I, y.accessFlags); + return J && f(J); + } + if (y.flags & 16777216) { + const x = f3e(y); + return x && f(x); + } + if (y.flags & 33554432) + return f(Zfe(y)); + if (w1(y)) { + const x = hr(F2(y), (I, J) => { + const z = I.flags & 262144 && y.target.elementFlags[J] & 8 && f(I) || I; + return z !== I && G_(z, (G) => ab(G) && !w1(G)) ? z : I; + }); + return hg(x, y.target.elementFlags, y.target.readonly, y.target.labeledElementDeclarations); + } + return y; + } + } + function Yet(r, a) { + if (r === a) + return r.resolvedApparentType || (r.resolvedApparentType = yf( + r, + a, + /*needApparentType*/ + !0 + )); + const l = `I${jl(r)},${jl(a)}`; + return f_(l) ?? Yp(l, yf( + r, + a, + /*needApparentType*/ + !0 + )); + } + function jfe(r) { + if (r.default) + r.default === Hl && (r.default = Fc); + else if (r.target) { + const a = jfe(r.target); + r.default = a ? Mi(a, r.mapper) : yc; + } else { + r.default = Hl; + const a = r.symbol && lr(r.symbol.declarations, (f) => Lo(f) && f.default), l = a ? Ci(a) : yc; + r.default === Hl && (r.default = l); + } + return r.default; + } + function A2(r) { + const a = jfe(r); + return a !== yc && a !== Fc ? a : void 0; + } + function Zet(r) { + return jfe(r) !== Fc; + } + function d3e(r) { + return !!(r.symbol && lr(r.symbol.declarations, (a) => Lo(a) && a.default)); + } + function m3e(r) { + return r.resolvedApparentType || (r.resolvedApparentType = Ket(r)); + } + function Ket(r) { + const a = r.target ?? r, l = oI(a); + if (l && !a.declaration.nameType) { + const f = Kv(r), d = L_(f) ? m3e(f) : ou(f); + if (d && G_(d, (y) => ab(y) || g3e(y))) + return Mi(a, IT(l, d, r.mapper)); + } + return r; + } + function g3e(r) { + return !!(r.flags & 2097152) && Ni(r.types, ab); + } + function Bfe(r) { + let a; + return !!(r.flags & 8388608 && Dn(a = r.objectType) & 32 && !L_(a) && AT(r.indexType) && !(mg(a) & 8) && !a.declaration.nameType); + } + function e_(r) { + const a = r.flags & 465829888 ? ou(r) || yt : r, l = Dn(a); + return l & 32 ? m3e(a) : l & 4 && a !== r ? yf(a, r) : a.flags & 2097152 ? Yet(a, r) : a.flags & 402653316 ? il : a.flags & 296 ? Po : a.flags & 2112 ? jtt() : a.flags & 528 ? sc : a.flags & 12288 ? H3e() : a.flags & 67108864 ? ta : a.flags & 4194304 ? oi : a.flags & 2 && !K ? ta : a; + } + function cP(r) { + return td(e_(td(r))); + } + function h3e(r, a, l) { + var f, d, y; + let x = 0, I, J, z; + const G = r.flags & 1048576; + let ve, de = 4, We = G ? 0 : 8, lt = !1; + for (const Ri of r.types) { + const zn = e_(Ri); + if (!(Gr(zn) || zn.flags & 131072)) { + const bi = Ys(zn, a, l), ks = bi ? up(bi) : 0; + if (bi) { + if (bi.flags & 106500 && (ve ?? (ve = G ? 0 : 16777216), G ? ve |= bi.flags & 16777216 : ve &= bi.flags), !I) + I = bi, x = bi.flags & 98304 || 4; + else if (bi !== I) { + if (($E(bi) || bi) === ($E(I) || I) && Jpe( + I, + bi, + (Vi, jo) => Vi === jo ? -1 : 0 + /* False */ + ) === -1) + lt = !!I.parent && !!wr(ia(I.parent)); + else { + J || (J = /* @__PURE__ */ new Map(), J.set(Xs(I), I)); + const Vi = Xs(bi); + J.has(Vi) || J.set(Vi, bi); + } + x & 98304 && (bi.flags & 98304) !== (x & 98304) && (x = x & -98305 | 4); + } + G && tm(bi) ? We |= 8 : !G && !tm(bi) && (We &= -9), We |= (ks & 6 ? 0 : 256) | (ks & 4 ? 512 : 0) | (ks & 2 ? 1024 : 0) | (ks & 256 ? 2048 : 0), Mde(bi) || (de = 2); + } else if (G) { + const Ua = !X8(a) && eC(zn, a); + Ua ? (x = x & -98305 | 4, We |= 32 | (Ua.isReadonly ? 8 : 0), z = Er(z, Sa(zn) ? P$(zn) || ue : Ua.type)) : sy(zn) && !(Dn(zn) & 2097152) ? (We |= 32, z = Er(z, ue)) : We |= 16; + } + } + } + if (!I || G && (J || We & 48) && We & 1536 && !(J && ett(J.values()))) + return; + if (!J && !(We & 16) && !z) + if (lt) { + const Ri = (f = Bn(I, Ng)) == null ? void 0 : f.links, zn = LT(I, Ri?.type); + return zn.parent = (y = (d = I.valueDeclaration) == null ? void 0 : d.symbol) == null ? void 0 : y.parent, zn.links.containingType = r, zn.links.mapper = Ri?.mapper, zn.links.writeType = Z0(I), zn; + } else + return I; + const gt = J ? is(J.values()) : [I]; + let jt, ar, jr; + const Kr = []; + let or, ir, nn = !1; + for (const Ri of gt) { + ir ? Ri.valueDeclaration && Ri.valueDeclaration !== ir && (nn = !0) : ir = Ri.valueDeclaration, jt = In(jt, Ri.declarations); + const zn = Yr(Ri); + ar || (ar = zn, jr = Pn(Ri).nameType); + const bi = Z0(Ri); + (or || bi !== zn) && (or = Er(or || Kr.slice(), bi)), zn !== ar && (We |= 64), (fI(zn) || PT(zn)) && (We |= 128), zn.flags & 131072 && zn !== so && (We |= 131072), Kr.push(zn); + } + In(Kr, z); + const Qn = ga(x | (ve ?? 0), a, de | We); + return Qn.links.containingType = r, !nn && ir && (Qn.valueDeclaration = ir, ir.symbol.parent && (Qn.parent = ir.symbol.parent)), Qn.declarations = jt, Qn.links.nameType = jr, Kr.length > 2 ? (Qn.links.checkFlags |= 65536, Qn.links.deferralParent = r, Qn.links.deferralConstituents = Kr, Qn.links.deferralWriteConstituents = or) : (Qn.links.type = G ? Xn(Kr) : sa(Kr), or && (Qn.links.writeType = G ? Xn(or) : sa(or))), Qn; + } + function y3e(r, a, l) { + var f, d, y; + let x = l ? (f = r.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? void 0 : f.get(a) : (d = r.propertyCache) == null ? void 0 : d.get(a); + return x || (x = h3e(r, a, l), x && ((l ? r.propertyCacheWithoutObjectFunctionPropertyAugment || (r.propertyCacheWithoutObjectFunctionPropertyAugment = Bs()) : r.propertyCache || (r.propertyCache = Bs())).set(a, x), l && !(uc(x) & 48) && !((y = r.propertyCache) != null && y.get(a)) && (r.propertyCache || (r.propertyCache = Bs())).set(a, x))), x; + } + function ett(r) { + let a; + for (const l of r) { + if (!l.declarations) + return; + if (!a) { + a = new Set(l.declarations); + continue; + } + if (a.forEach((f) => { + ms(l.declarations, f) || a.delete(f); + }), a.size === 0) + return; + } + return a; + } + function tM(r, a, l) { + const f = y3e(r, a, l); + return f && !(uc(f) & 16) ? f : void 0; + } + function td(r) { + return r.flags & 1048576 && r.objectFlags & 16777216 ? r.resolvedReducedType || (r.resolvedReducedType = ttt(r)) : r.flags & 2097152 ? (r.objectFlags & 16777216 || (r.objectFlags |= 16777216 | (ot(KL(r), rtt) ? 33554432 : 0)), r.objectFlags & 33554432 ? nr : r) : r; + } + function ttt(r) { + const a = Qc(r.types, td); + if (a === r.types) + return r; + const l = Xn(a); + return l.flags & 1048576 && (l.resolvedReducedType = l), l; + } + function rtt(r) { + return v3e(r) || b3e(r); + } + function v3e(r) { + return !(r.flags & 16777216) && (uc(r) & 131264) === 192 && !!(Yr(r).flags & 131072); + } + function b3e(r) { + return !r.valueDeclaration && !!(uc(r) & 1024); + } + function Jfe(r) { + return !!(r.flags & 1048576 && r.objectFlags & 16777216 && ot(r.types, Jfe) || r.flags & 2097152 && ntt(r)); + } + function ntt(r) { + const a = r.uniqueLiteralFilledInstantiation || (r.uniqueLiteralFilledInstantiation = Mi(r, zi)); + return td(a) !== a; + } + function zfe(r, a) { + if (a.flags & 2097152 && Dn(a) & 33554432) { + const l = Nn(KL(a), v3e); + if (l) + return Ts(r, p.The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents, Wr( + a, + /*enclosingDeclaration*/ + void 0, + 536870912 + /* NoTypeReduction */ + ), Wi(l)); + const f = Nn(KL(a), b3e); + if (f) + return Ts(r, p.The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some, Wr( + a, + /*enclosingDeclaration*/ + void 0, + 536870912 + /* NoTypeReduction */ + ), Wi(f)); + } + return r; + } + function Ys(r, a, l, f) { + var d, y; + if (r = cP(r), r.flags & 524288) { + const x = $d(r), I = x.members.get(a); + if (I && !f && ((d = r.symbol) == null ? void 0 : d.flags) & 512 && ((y = Pn(r.symbol).typeOnlyExportStarMap) != null && y.has(a))) + return; + if (I && ur(I, f)) + return I; + if (l) return; + const J = x === Za ? Mr : x.callSignatures.length ? Gi : x.constructSignatures.length ? Da : void 0; + if (J) { + const z = N2(J, a); + if (z) + return z; + } + return N2(Ot, a); + } + if (r.flags & 2097152) { + const x = tM( + r, + a, + /*skipObjectFunctionPropertyAugment*/ + !0 + ); + return x || (l ? void 0 : tM(r, a, l)); + } + if (r.flags & 1048576) + return tM(r, a, l); + } + function rM(r, a) { + if (r.flags & 3670016) { + const l = $d(r); + return a === 0 ? l.callSignatures : l.constructSignatures; + } + return Ge; + } + function Is(r, a) { + const l = rM(cP(r), a); + if (a === 0 && !wr(l) && r.flags & 1048576) { + if (r.arrayFallbackSignatures) + return r.arrayFallbackSignatures; + let f; + if (G_(r, (d) => { + var y; + return !!((y = d.symbol) != null && y.parent) && itt(d.symbol.parent) && (f ? f === d.symbol.escapedName : (f = d.symbol.escapedName, !0)); + })) { + const d = Go(r, (x) => ny((S3e(x.symbol.parent) ? ma : wa).typeParameters[0], x.mapper)), y = Tu(d, wp(r, (x) => S3e(x.symbol.parent))); + return r.arrayFallbackSignatures = Is(rr(y, f), a); + } + r.arrayFallbackSignatures = l; + } + return l; + } + function itt(r) { + return !r || !wa.symbol || !ma.symbol ? !1 : !!le(r, wa.symbol) || !!le(r, ma.symbol); + } + function S3e(r) { + return !r || !ma.symbol ? !1 : !!le(r, ma.symbol); + } + function lP(r, a) { + return Nn(r, (l) => l.keyType === a); + } + function Wfe(r, a) { + let l, f, d; + for (const y of r) + y.keyType === at ? l = y : Kk(a, y.keyType) && (f ? (d || (d = [f])).push(y) : f = y); + return d ? oh(yt, sa(hr(d, (y) => y.type)), Wu( + d, + (y, x) => y && x.isReadonly, + /*initial*/ + !0 + )) : f || (l && Kk(a, at) ? l : void 0); + } + function Kk(r, a) { + return Ms(r, a) || a === at && Ms(r, wt) || a === wt && (r === ds || !!(r.flags & 128) && zg(r.value)); + } + function Ufe(r) { + return r.flags & 3670016 ? $d(r).indexInfos : Ge; + } + function Su(r) { + return Ufe(cP(r)); + } + function ah(r, a) { + return lP(Su(r), a); + } + function eb(r, a) { + var l; + return (l = ah(r, a)) == null ? void 0 : l.type; + } + function Vfe(r, a) { + return Su(r).filter((l) => Kk(a, l.keyType)); + } + function Z8(r, a) { + return Wfe(Su(r), a); + } + function eC(r, a) { + return Z8(r, X8(a) ? Jt : H_(Si(a))); + } + function T3e(r) { + var a; + let l; + for (const f of xy(r)) + l = dh(l, Zv(f.symbol)); + return l?.length ? l : Cc(r) ? (a = uP(r)) == null ? void 0 : a.typeParameters : void 0; + } + function qfe(r) { + const a = []; + return r.forEach((l, f) => { + Xv(f) || a.push(l); + }), a; + } + function x3e(r, a) { + if (Dl(r)) + return; + const l = Xl( + Ye, + '"' + r + '"', + 512 + /* ValueModule */ + ); + return l && a ? Oa(l) : l; + } + function YG(r) { + return yx(r) || EN(r) || Ii(r) && cF(r); + } + function K8(r) { + if (YG(r)) + return !0; + if (!Ii(r)) + return !1; + if (r.initializer) { + const l = Xf(r.parent), f = r.parent.parameters.indexOf(r); + return E.assert(f >= 0), f >= em( + l, + 3 + /* VoidIsNonOptional */ + ); + } + const a = q1(r.parent); + return a ? !r.type && !r.dotDotDotToken && r.parent.parameters.indexOf(r) >= fX(a).length : !1; + } + function stt(r) { + return os(r) && !fm(r) && r.questionToken; + } + function eI(r, a, l, f) { + return { kind: r, parameterName: a, parameterIndex: l, type: f }; + } + function gg(r) { + let a = 0; + if (r) + for (let l = 0; l < r.length; l++) + d3e(r[l]) || (a = l + 1); + return a; + } + function ty(r, a, l, f) { + const d = wr(a); + if (!d) + return []; + const y = wr(r); + if (f || y >= l && y <= d) { + const x = r ? r.slice() : []; + for (let J = y; J < d; J++) + x[J] = qe; + const I = sde(f); + for (let J = y; J < d; J++) { + let z = A2(a[J]); + f && z && (lh(z, yt) || lh(z, ta)) && (z = Le), x[J] = z ? Mi(z, bf(a, x)) : I; + } + return x.length = a.length, x; + } + return r && r.slice(); + } + function Xf(r) { + const a = xn(r); + if (!a.resolvedSignature) { + const l = []; + let f = 0, d = 0, y, x = an(r) ? v7(r) : void 0, I = !1; + const J = q1(r), z = vx(r); + !J && an(r) && pS(r) && !uZ(r) && !ot(r.parameters, (lt) => !!f0(lt)) && !f0(r) && !eX(r) && (f |= 32); + for (let lt = z ? 1 : 0; lt < r.parameters.length; lt++) { + const gt = r.parameters[lt]; + if (an(gt) && Dz(gt)) { + x = gt; + continue; + } + let jt = gt.symbol; + const ar = Lf(gt) ? gt.typeExpression && gt.typeExpression.type : gt.type; + jt && jt.flags & 4 && !ws(gt.name) && (jt = st( + gt, + jt.escapedName, + 111551, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + )), lt === 0 && jt.escapedName === "this" ? (I = !0, y = gt.symbol) : l.push(jt), ar && ar.kind === 202 && (f |= 2), YG(gt) || Ii(gt) && gt.initializer || Hm(gt) || J && l.length > J.arguments.length && !ar || (d = l.length); + } + if ((r.kind === 178 || r.kind === 179) && NE(r) && (!I || !y)) { + const lt = r.kind === 178 ? 179 : 178, gt = Oo(yn(r), lt); + gt && (y = Zk(gt)); + } + x && x.typeExpression && (y = LT(ga( + 1, + "this" + /* This */ + ), Ci(x.typeExpression))); + const ve = w0(r) ? X1(r) : r, de = ve && nc(ve) ? xp(Oa(ve.parent.symbol)) : void 0, We = de ? de.localTypeParameters : T3e(r); + (Zj(r) || an(r) && att(r, l)) && (f |= 1), (_6(r) && Gn( + r, + 64 + /* Abstract */ + ) || nc(r) && Gn( + r.parent, + 64 + /* Abstract */ + )) && (f |= 4), a.resolvedSignature = Mm( + r, + We, + y, + l, + /*resolvedReturnType*/ + void 0, + /*resolvedTypePredicate*/ + void 0, + d, + f + ); + } + return a.resolvedSignature; + } + function att(r, a) { + if (w0(r) || !Hfe(r)) + return !1; + const l = Do(r.parameters), f = l ? wC(l) : W1(r).filter(Lf), d = Lc(f, (x) => x.typeExpression && IF(x.typeExpression.type) ? x.typeExpression.type : void 0), y = ga( + 3, + "args", + 32768 + /* RestParameter */ + ); + return d ? y.links.type = Tu(Ci(d.type)) : (y.links.checkFlags |= 65536, y.links.deferralParent = nr, y.links.deferralConstituents = [Gl], y.links.deferralWriteConstituents = [Gl]), d && a.pop(), a.push(y), !0; + } + function uP(r) { + if (!(an(r) && io(r))) return; + const a = z1(r); + return a?.typeExpression && UT(Ci(a.typeExpression)); + } + function ott(r, a) { + const l = uP(r); + if (!l) return; + const f = r.parameters.indexOf(a); + return a.dotDotDotToken ? $M(l, f) : Kd(l, f); + } + function ctt(r) { + const a = uP(r); + return a && Wa(a); + } + function Hfe(r) { + const a = xn(r); + return a.containsArgumentsReference === void 0 && (a.flags & 512 ? a.containsArgumentsReference = !0 : a.containsArgumentsReference = l(r.body)), a.containsArgumentsReference; + function l(f) { + if (!f) return !1; + switch (f.kind) { + case 80: + return f.escapedText === ie.escapedName && WI(f) === ie; + case 173: + case 175: + case 178: + case 179: + return f.name.kind === 168 && l(f.name); + case 212: + case 213: + return l(f.expression); + case 304: + return l(f.initializer); + default: + return !WB(f) && !lm(f) && !!xs(f, l); + } + } + } + function I2(r) { + if (!r || !r.declarations) return Ge; + const a = []; + for (let l = 0; l < r.declarations.length; l++) { + const f = r.declarations[l]; + if (Es(f)) { + if (l > 0 && f.body) { + const d = r.declarations[l - 1]; + if (f.parent === d.parent && f.kind === d.kind && f.pos === d.end) + continue; + } + if (an(f) && f.jsDoc) { + const d = IB(f); + if (wr(d)) { + for (const y of d) { + const x = y.typeExpression; + x.type === void 0 && !nc(f) && cb(x, Le), a.push(Xf(x)); + } + continue; + } + } + a.push( + !zy(f) && !Rp(f) && uP(f) || Xf(f) + ); + } + } + return a; + } + function k3e(r) { + const a = Mu(r, r); + if (a) { + const l = q_(a); + if (l) + return Yr(l); + } + return Le; + } + function tb(r) { + if (r.thisParameter) + return Yr(r.thisParameter); + } + function kp(r) { + if (!r.resolvedTypePredicate) { + if (r.target) { + const a = kp(r.target); + r.resolvedTypePredicate = a ? MNe(a, r.mapper) : Kt; + } else if (r.compositeSignatures) + r.resolvedTypePredicate = lrt(r.compositeSignatures, r.compositeKind) || Kt; + else { + const a = r.declaration && nf(r.declaration); + let l; + if (!a) { + const f = uP(r.declaration); + f && r !== f && (l = kp(f)); + } + if (a || l) + r.resolvedTypePredicate = a && Vx(a) ? ltt(a, r) : l || Kt; + else if (r.declaration && io(r.declaration) && (!r.resolvedReturnType || r.resolvedReturnType.flags & 16) && $_(r) > 0) { + const { declaration: f } = r; + r.resolvedTypePredicate = Kt, r.resolvedTypePredicate = Xot(f) || Kt; + } else + r.resolvedTypePredicate = Kt; + } + E.assert(!!r.resolvedTypePredicate); + } + return r.resolvedTypePredicate === Kt ? void 0 : r.resolvedTypePredicate; + } + function ltt(r, a) { + const l = r.parameterName, f = r.type && Ci(r.type); + return l.kind === 198 ? eI( + r.assertsModifier ? 2 : 0, + /*parameterName*/ + void 0, + /*parameterIndex*/ + void 0, + f + ) : eI(r.assertsModifier ? 3 : 1, l.escapedText, oc(a.parameters, (d) => d.escapedName === l.escapedText), f); + } + function C3e(r, a, l) { + return a !== 2097152 ? Xn(r, l) : sa(r); + } + function Wa(r) { + if (!r.resolvedReturnType) { + if (!Lm( + r, + 3 + /* ResolvedReturnType */ + )) + return qe; + let a = r.target ? Mi(Wa(r.target), r.mapper) : r.compositeSignatures ? Mi(C3e( + hr(r.compositeSignatures, Wa), + r.compositeKind, + 2 + /* Subtype */ + ), r.mapper) : IE(r.declaration) || (lc(r.declaration.body) ? Le : gX(r.declaration)); + if (r.flags & 8 ? a = _Ae(a) : r.flags & 16 && (a = P1(a)), !He()) { + if (r.declaration) { + const l = nf(r.declaration); + if (l) + ze(l, p.Return_type_annotation_circularly_references_itself); + else if (fe) { + const f = r.declaration, d = _s(f); + d ? ze(d, p._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, co(d)) : ze(f, p.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions); + } + } + a = Le; + } + r.resolvedReturnType ?? (r.resolvedReturnType = a); + } + return r.resolvedReturnType; + } + function IE(r) { + if (r.kind === 177) + return xp(Oa(r.parent.symbol)); + const a = nf(r); + if (w0(r)) { + const l = GC(r); + if (l && nc(l.parent) && !a) + return xp(Oa(l.parent.parent.symbol)); + } + if (vx(r)) + return Ci(r.parameters[0].type); + if (a) + return Ci(a); + if (r.kind === 178 && NE(r)) { + const l = an(r) && Ra(r); + if (l) + return l; + const f = Oo( + yn(r), + 179 + /* SetAccessor */ + ), d = nP(f); + if (d) + return d; + } + return ctt(r); + } + function ZG(r) { + return r.compositeSignatures && ot(r.compositeSignatures, ZG) || !r.resolvedReturnType && X( + r, + 3 + /* ResolvedReturnType */ + ) >= 0; + } + function utt(r) { + return E3e(r) || Le; + } + function E3e(r) { + if (Iu(r)) { + const a = Yr(r.parameters[r.parameters.length - 1]), l = Sa(a) ? P$(a) : a; + return l && eb(l, wt); + } + } + function tI(r, a, l, f) { + const d = Gfe(r, ty(a, r.typeParameters, gg(r.typeParameters), l)); + if (f) { + const y = rIe(Wa(d)); + if (y) { + const x = Q8(y); + x.typeParameters = f; + const I = ET(x); + I.mapper = d.mapper; + const J = Q8(d); + return J.resolvedReturnType = I, J; + } + } + return d; + } + function Gfe(r, a) { + const l = r.instantiations || (r.instantiations = /* @__PURE__ */ new Map()), f = rd(a); + let d = l.get(f); + return d || l.set(f, d = KG(r, a)), d; + } + function KG(r, a) { + return FT( + r, + _tt(r, a), + /*eraseTypeParameters*/ + !0 + ); + } + function D3e(r) { + return Qc(r.typeParameters, (a) => a.mapper ? Mi(a, a.mapper) : a); + } + function _tt(r, a) { + return bf(D3e(r), a); + } + function rI(r) { + return r.typeParameters ? r.erasedSignatureCache || (r.erasedSignatureCache = ftt(r)) : r; + } + function ftt(r) { + return FT( + r, + ONe(r.typeParameters), + /*eraseTypeParameters*/ + !0 + ); + } + function ptt(r) { + return r.typeParameters ? r.canonicalSignatureCache || (r.canonicalSignatureCache = dtt(r)) : r; + } + function dtt(r) { + return tI( + r, + hr(r.typeParameters, (a) => a.target && !m_(a.target) ? a.target : a), + an(r.declaration) + ); + } + function mtt(r) { + const a = r.typeParameters; + if (a) { + if (r.baseSignatureCache) + return r.baseSignatureCache; + const l = ONe(a), f = bf(a, hr(a, (y) => m_(y) || yt)); + let d = hr(a, (y) => Mi(y, f) || yt); + for (let y = 0; y < a.length - 1; y++) + d = e0(d, f); + return d = e0(d, l), r.baseSignatureCache = FT( + r, + bf(a, d), + /*eraseTypeParameters*/ + !0 + ); + } + return r; + } + function ET(r) { + var a, l; + if (!r.isolatedSignatureType) { + const f = (a = r.declaration) == null ? void 0 : a.kind, d = f === void 0 || f === 177 || f === 181 || f === 186, y = Wc(134217744, (l = r.declaration) == null ? void 0 : l.symbol); + y.members = A, y.properties = Ge, y.callSignatures = d ? Ge : [r], y.constructSignatures = d ? [r] : Ge, y.indexInfos = Ge, r.isolatedSignatureType = y; + } + return r.isolatedSignatureType; + } + function e$(r) { + return r.members ? t$(dg(r)) : void 0; + } + function t$(r) { + return r.get( + "__index" + /* Index */ + ); + } + function oh(r, a, l, f, d) { + return { keyType: r, type: a, isReadonly: l, declaration: f, components: d }; + } + function w3e(r) { + const a = e$(r); + return a ? r$(a, is(dg(r).values())) : Ge; + } + function r$(r, a = r.parent ? is(dg(r.parent).values()) : void 0) { + if (r.declarations) { + const l = []; + let f = !1, d = !0, y = !1, x = !0, I = !1, J = !0; + const z = []; + for (const ve of r.declarations) + if (qy(ve)) { + if (ve.parameters.length === 1) { + const de = ve.parameters[0]; + de.type && BT(Ci(de.type), (We) => { + n$(We) && !lP(l, We) && l.push(oh(We, ve.type ? Ci(ve.type) : Le, sf( + ve, + 8 + /* Readonly */ + ), ve)); + }); + } + } else if (ZPe(ve)) { + const de = _n(ve) ? ve.left : ve.name, We = uo(de) ? mc(de.argumentExpression) : Td(de); + if (lP(l, We)) + continue; + Ms(We, oi) && (Ms(We, wt) ? (f = !0, gS(ve) || (d = !1)) : Ms(We, Jt) ? (y = !0, gS(ve) || (x = !1)) : (I = !0, gS(ve) || (J = !1)), z.push(ve.symbol)); + } + const G = Bi(z, kn(a, (ve) => ve !== r)); + return I && !lP(l, at) && l.push(xI(J, 0, G, at)), f && !lP(l, wt) && l.push(xI(d, 0, G, wt)), y && !lP(l, Jt) && l.push(xI(x, 0, G, Jt)), l; + } + return Ge; + } + function n$(r) { + return !!(r.flags & 4108) || PT(r) || !!(r.flags & 2097152) && !nb(r) && ot(r.types, n$); + } + function i$(r) { + return Fi(kn(r.symbol && r.symbol.declarations, Lo), PC)[0]; + } + function P3e(r, a) { + var l; + let f; + if ((l = r.symbol) != null && l.declarations) { + for (const d of r.symbol.declarations) + if (d.parent.kind === 196) { + const [y = d.parent, x] = RK(d.parent.parent); + if (x.kind === 184 && !a) { + const I = x, J = Tme(I); + if (J) { + const z = I.typeArguments.indexOf(y); + if (z < J.length) { + const G = m_(J[z]); + if (G) { + const ve = Cpe( + J, + J.map((We, lt) => () => $ct(I, J, lt)) + ), de = Mi(G, ve); + de !== r && (f = Er(f, de)); + } + } + } + } else if (x.kind === 170 && x.dotDotDotToken || x.kind === 192 || x.kind === 203 && x.dotDotDotToken) + f = Er(f, Tu(yt)); + else if (x.kind === 205) + f = Er(f, at); + else if (x.kind === 169 && x.parent.kind === 201) + f = Er(f, oi); + else if (x.kind === 201 && x.type && Ba(x.type) === d.parent && x.parent.kind === 195 && x.parent.extendsType === x && x.parent.checkType.kind === 201 && x.parent.checkType.type) { + const I = x.parent.checkType, J = Ci(I.type); + f = Er(f, Mi(J, M2(Zv(yn(I.typeParameter)), I.typeParameter.constraint ? Ci(I.typeParameter.constraint) : oi))); + } + } + } + return f && sa(f); + } + function _P(r) { + if (!r.constraint) + if (r.target) { + const a = m_(r.target); + r.constraint = a ? Mi(a, r.mapper) : yc; + } else { + const a = i$(r); + if (!a) + r.constraint = P3e(r) || yc; + else { + let l = Ci(a); + l.flags & 1 && !Gr(l) && (l = a.parent.parent.kind === 201 ? oi : yt), r.constraint = l; + } + } + return r.constraint === yc ? void 0 : r.constraint; + } + function N3e(r) { + const a = Oo( + r.symbol, + 169 + /* TypeParameter */ + ), l = Up(a.parent) ? d5(a.parent) : a.parent; + return l && Hf(l); + } + function rd(r) { + let a = ""; + if (r) { + const l = r.length; + let f = 0; + for (; f < l; ) { + const d = r[f].id; + let y = 1; + for (; f + y < l && r[f + y].id === d + y; ) + y++; + a.length && (a += ","), a += d, y > 1 && (a += ":" + y), f += y; + } + } + return a; + } + function DT(r, a) { + return r ? `@${Xs(r)}` + (a ? `:${rd(a)}` : "") : ""; + } + function nM(r, a) { + let l = 0; + for (const f of r) + (a === void 0 || !(f.flags & a)) && (l |= Dn(f)); + return l & 458752; + } + function FE(r, a) { + return ot(a) && r === zt ? yt : Qh(r, a); + } + function Qh(r, a) { + const l = rd(a); + let f = r.instantiations.get(l); + return f || (f = Wc(4, r.symbol), r.instantiations.set(l, f), f.objectFlags |= a ? nM(a) : 0, f.target = r, f.resolvedTypeArguments = a), f; + } + function A3e(r) { + const a = gi(r.flags, r.symbol); + return a.objectFlags = r.objectFlags, a.target = r.target, a.resolvedTypeArguments = r.resolvedTypeArguments, a; + } + function $fe(r, a, l, f, d) { + if (!f) { + f = nC(a); + const x = RE(f); + d = l ? e0(x, l) : x; + } + const y = Wc(4, r.symbol); + return y.target = r, y.node = a, y.mapper = l, y.aliasSymbol = f, y.aliasTypeArguments = d, y; + } + function Ao(r) { + var a, l; + if (!r.resolvedTypeArguments) { + if (!Lm( + r, + 5 + /* ResolvedTypeArguments */ + )) + return Bi(r.target.outerTypeParameters, (a = r.target.localTypeParameters) == null ? void 0 : a.map(() => qe)) || Ge; + const f = r.node, d = f ? f.kind === 184 ? Bi(r.target.outerTypeParameters, TX(f, r.target.localTypeParameters)) : f.kind === 189 ? [Ci(f.elementType)] : hr(f.elements, Ci) : Ge; + He() ? r.resolvedTypeArguments ?? (r.resolvedTypeArguments = r.mapper ? e0(d, r.mapper) : d) : (r.resolvedTypeArguments ?? (r.resolvedTypeArguments = Bi(r.target.outerTypeParameters, ((l = r.target.localTypeParameters) == null ? void 0 : l.map(() => qe)) || Ge)), ze( + r.node || k, + r.target.symbol ? p.Type_arguments_for_0_circularly_reference_themselves : p.Tuple_type_arguments_circularly_reference_themselves, + r.target.symbol && Wi(r.target.symbol) + )); + } + return r.resolvedTypeArguments; + } + function ry(r) { + return wr(r.target.typeParameters); + } + function I3e(r, a) { + const l = bo(Oa(a)), f = l.localTypeParameters; + if (f) { + const d = wr(r.typeArguments), y = gg(f), x = an(r); + if (!(!fe && x) && (d < y || d > f.length)) { + const z = x && Dh(r) && !Yx(r.parent), G = y === f.length ? z ? p.Expected_0_type_arguments_provide_these_with_an_extends_tag : p.Generic_type_0_requires_1_type_argument_s : z ? p.Expected_0_1_type_arguments_provide_these_with_an_extends_tag : p.Generic_type_0_requires_between_1_and_2_type_arguments, ve = Wr( + l, + /*enclosingDeclaration*/ + void 0, + 2 + /* WriteArrayAsGenericType */ + ); + if (ze(r, G, ve, y, f.length), !x) + return qe; + } + if (r.kind === 184 && tNe(r, wr(r.typeArguments) !== f.length)) + return $fe( + l, + r, + /*mapper*/ + void 0 + ); + const J = Bi(l.outerTypeParameters, ty(iM(r), f, y, x)); + return Qh(l, J); + } + return rb(r, a) ? l : qe; + } + function OE(r, a, l, f) { + const d = bo(r); + if (d === Pe) { + const z = AW.get(r.escapedName); + if (z !== void 0 && a && a.length === 1) + return z === 4 ? Xfe(a[0]) : rC(r, a[0]); + } + const y = Pn(r), x = y.typeParameters, I = rd(a) + DT(l, f); + let J = y.instantiations.get(I); + return J || y.instantiations.set(I, J = BNe(d, bf(x, ty(a, x, gg(x), an(r.valueDeclaration))), l, f)), J; + } + function gtt(r, a) { + if (uc(a) & 1048576) { + const d = iM(r), y = DT(a, d); + let x = Ke.get(y); + return x || (x = mi( + 1, + "error", + /*objectFlags*/ + void 0, + `alias ${y}` + ), x.aliasSymbol = a, x.aliasTypeArguments = d, Ke.set(y, x)), x; + } + const l = bo(a), f = Pn(a).typeParameters; + if (f) { + const d = wr(r.typeArguments), y = gg(f); + if (d < y || d > f.length) + return ze( + r, + y === f.length ? p.Generic_type_0_requires_1_type_argument_s : p.Generic_type_0_requires_between_1_and_2_type_arguments, + Wi(a), + y, + f.length + ), qe; + const x = nC(r); + let I = x && (F3e(a) || !F3e(x)) ? x : void 0, J; + if (I) + J = RE(I); + else if (L7(r)) { + const z = fP( + r, + 2097152, + /*ignoreErrors*/ + !0 + ); + if (z && z !== Y) { + const G = Rl(z); + G && G.flags & 524288 && (I = G, J = iM(r) || (f ? [] : void 0)); + } + } + return OE(a, iM(r), I, J); + } + return rb(r, a) ? l : qe; + } + function F3e(r) { + var a; + const l = (a = r.declarations) == null ? void 0 : a.find(q3); + return !!(l && Af(l)); + } + function htt(r) { + switch (r.kind) { + case 184: + return r.typeName; + case 234: + const a = r.expression; + if (to(a)) + return a; + } + } + function O3e(r) { + return r.parent ? `${O3e(r.parent)}.${r.escapedName}` : r.escapedName; + } + function s$(r) { + const l = (r.kind === 167 ? r.right : r.kind === 212 ? r.name : r).escapedText; + if (l) { + const f = r.kind === 167 ? s$(r.left) : r.kind === 212 ? s$(r.expression) : void 0, d = f ? `${O3e(f)}.${l}` : l; + let y = $e.get(d); + return y || ($e.set(d, y = ga( + 524288, + l, + 1048576 + /* Unresolved */ + )), y.parent = f, y.links.declaredType = Lt), y; + } + return Y; + } + function fP(r, a, l) { + const f = htt(r); + if (!f) + return Y; + const d = dc(f, a, l); + return d && d !== Y ? d : l ? Y : s$(f); + } + function a$(r, a) { + if (a === Y) + return qe; + if (a = Jk(a) || a, a.flags & 96) + return I3e(r, a); + if (a.flags & 524288) + return gtt(r, a); + const l = qPe(a); + if (l) + return rb(r, a) ? t_(l) : qe; + if (a.flags & 111551 && o$(r)) { + const f = ytt(r, a); + return f || (fP( + r, + 788968 + /* Type */ + ), Yr(a)); + } + return qe; + } + function ytt(r, a) { + const l = xn(r); + if (!l.resolvedJSDocType) { + const f = Yr(a); + let d = f; + if (a.valueDeclaration) { + const y = r.kind === 206 && r.qualifier; + f.symbol && f.symbol !== a && y && (d = a$(r, f.symbol)); + } + l.resolvedJSDocType = d; + } + return l.resolvedJSDocType; + } + function Xfe(r) { + return Qfe(r) ? L3e(r, yt) : r; + } + function Qfe(r) { + return !!(r.flags & 3145728 && ot(r.types, Qfe) || r.flags & 33554432 && !LE(r) && Qfe(r.baseType) || r.flags & 524288 && !yg(r) || r.flags & 432275456 && !PT(r)); + } + function LE(r) { + return !!(r.flags & 33554432 && r.constraint.flags & 2); + } + function Yfe(r, a) { + return a.flags & 3 || a === r || r.flags & 1 ? r : L3e(r, a); + } + function L3e(r, a) { + const l = `${jl(r)}>${jl(a)}`, f = Ks.get(l); + if (f) + return f; + const d = ti( + 33554432 + /* Substitution */ + ); + return d.baseType = r, d.constraint = a, Ks.set(l, d), d; + } + function Zfe(r) { + return LE(r) ? r.baseType : sa([r.constraint, r.baseType]); + } + function M3e(r) { + return r.kind === 190 && r.elements.length === 1; + } + function R3e(r, a, l) { + return M3e(a) && M3e(l) ? R3e(r, a.elements[0], l.elements[0]) : Kh(Ci(a)) === Kh(r) ? Ci(l) : void 0; + } + function vtt(r, a) { + let l, f = !0; + for (; a && !Ti(a) && a.kind !== 321; ) { + const d = a.parent; + if (d.kind === 170 && (f = !f), (f || r.flags & 8650752) && d.kind === 195 && a === d.trueType) { + const y = R3e(r, d.checkType, d.extendsType); + y && (l = Er(l, y)); + } else if (r.flags & 262144 && d.kind === 201 && !d.nameType && a === d.type) { + const y = Ci(d); + if (Sd(y) === Kh(r)) { + const x = oI(y); + if (x) { + const I = m_(x); + I && G_(I, ab) && (l = Er(l, Xn([wt, ds]))); + } + } + } + a = d; + } + return l ? Yfe(r, sa(l)) : r; + } + function o$(r) { + return !!(r.flags & 16777216) && (r.kind === 184 || r.kind === 206); + } + function rb(r, a) { + return r.typeArguments ? (ze(r, p.Type_0_is_not_generic, a ? Wi(a) : r.typeName ? co(r.typeName) : DW), !1) : !0; + } + function j3e(r) { + if (Me(r.typeName)) { + const a = r.typeArguments; + switch (r.typeName.escapedText) { + case "String": + return rb(r), at; + case "Number": + return rb(r), wt; + case "BigInt": + return rb(r), Zr; + case "Boolean": + return rb(r), Nt; + case "Void": + return rb(r), _r; + case "Undefined": + return rb(r), ue; + case "Null": + return rb(r), Mt; + case "Function": + case "function": + return rb(r), Mr; + case "array": + return (!a || !a.length) && !fe ? Gl : void 0; + case "promise": + return (!a || !a.length) && !fe ? QM(Le) : void 0; + case "Object": + if (a && a.length === 2) { + if (u5(r)) { + const l = Ci(a[0]), f = Ci(a[1]), d = l === at || l === wt ? [oh( + l, + f, + /*isReadonly*/ + !1 + )] : Ge; + return Ho( + /*symbol*/ + void 0, + A, + Ge, + Ge, + d + ); + } + return Le; + } + return rb(r), fe ? void 0 : Le; + } + } + } + function btt(r) { + const a = Ci(r.type); + return K ? xM( + a, + 65536 + /* Null */ + ) : a; + } + function c$(r) { + const a = xn(r); + if (!a.resolvedType) { + if (nd(r) && Eb(r.parent)) + return a.resolvedSymbol = Y, a.resolvedType = mc(r.parent.expression); + let l, f; + const d = 788968; + o$(r) && (f = j3e(r), f || (l = fP( + r, + d, + /*ignoreErrors*/ + !0 + ), l === Y ? l = fP( + r, + d | 111551 + /* Value */ + ) : fP(r, d), f = a$(r, l))), f || (l = fP(r, d), f = a$(r, l)), a.resolvedSymbol = l, a.resolvedType = f; + } + return a.resolvedType; + } + function iM(r) { + return hr(r.typeArguments, Ci); + } + function B3e(r) { + const a = xn(r); + if (!a.resolvedType) { + const l = xIe(r); + a.resolvedType = t_(Sf(l)); + } + return a.resolvedType; + } + function J3e(r, a) { + function l(d) { + const y = d.declarations; + if (y) + for (const x of y) + switch (x.kind) { + case 264: + case 265: + case 267: + return x; + } + } + if (!r) + return a ? zt : ta; + const f = bo(r); + return f.flags & 524288 ? wr(f.typeParameters) !== a ? (ze(l(r), p.Global_type_0_must_have_1_type_parameter_s, cc(r), a), a ? zt : ta) : f : (ze(l(r), p.Global_type_0_must_be_a_class_or_interface_type, cc(r)), a ? zt : ta); + } + function Kfe(r, a) { + return ME(r, 111551, a ? p.Cannot_find_global_value_0 : void 0); + } + function epe(r, a) { + return ME(r, 788968, a ? p.Cannot_find_global_type_0 : void 0); + } + function l$(r, a, l) { + const f = ME(r, 788968, l ? p.Cannot_find_global_type_0 : void 0); + if (f && (bo(f), wr(Pn(f).typeParameters) !== a)) { + const d = f.declarations && Nn(f.declarations, Wp); + ze(d, p.Global_type_0_must_have_1_type_parameter_s, cc(f), a); + return; + } + return f; + } + function ME(r, a, l) { + return st( + /*location*/ + void 0, + r, + a, + l, + /*isUse*/ + !1, + /*excludeGlobals*/ + !1 + ); + } + function bc(r, a, l) { + const f = epe(r, l); + return f || l ? J3e(f, a) : void 0; + } + function z3e(r, a) { + let l; + for (const f of r) + l = Er(l, bc( + f, + a, + /*reportErrors*/ + !1 + )); + return l ?? Ge; + } + function Stt() { + return $g || ($g = bc( + "TypedPropertyDescriptor", + /*arity*/ + 1, + /*reportErrors*/ + !0 + ) || zt); + } + function Ttt() { + return $i || ($i = bc( + "TemplateStringsArray", + /*arity*/ + 0, + /*reportErrors*/ + !0 + ) || ta); + } + function W3e() { + return As || (As = bc( + "ImportMeta", + /*arity*/ + 0, + /*reportErrors*/ + !0 + ) || ta); + } + function U3e() { + if (!Zi) { + const r = ga(0, "ImportMetaExpression"), a = W3e(), l = ga( + 4, + "meta", + 8 + /* Readonly */ + ); + l.parent = r, l.links.type = a; + const f = Bs([l]); + r.members = f, Zi = Ho(r, f, Ge, Ge, Ge); + } + return Zi; + } + function V3e(r) { + return ys || (ys = bc( + "ImportCallOptions", + /*arity*/ + 0, + r + )) || ta; + } + function tpe(r) { + return zo || (zo = bc( + "ImportAttributes", + /*arity*/ + 0, + r + )) || ta; + } + function q3e(r) { + return hp || (hp = Kfe("Symbol", r)); + } + function xtt(r) { + return ig || (ig = epe("SymbolConstructor", r)); + } + function H3e() { + return Gg || (Gg = bc( + "Symbol", + /*arity*/ + 0, + /*reportErrors*/ + !1 + )) || ta; + } + function sM(r) { + return N_ || (N_ = bc( + "Promise", + /*arity*/ + 1, + r + )) || zt; + } + function G3e(r) { + return Sl || (Sl = bc( + "PromiseLike", + /*arity*/ + 1, + r + )) || zt; + } + function rpe(r) { + return Jd || (Jd = Kfe("Promise", r)); + } + function ktt(r) { + return Wf || (Wf = bc( + "PromiseConstructorLike", + /*arity*/ + 0, + r + )) || ta; + } + function aM(r) { + return jn || (jn = bc( + "AsyncIterable", + /*arity*/ + 3, + r + )) || zt; + } + function Ctt(r) { + return ni || (ni = bc( + "AsyncIterator", + /*arity*/ + 3, + r + )) || zt; + } + function $3e(r) { + return wi || (wi = bc( + "AsyncIterableIterator", + /*arity*/ + 3, + r + )) || zt; + } + function Ett() { + return Oe ?? (Oe = z3e(["ReadableStreamAsyncIterator"], 1)); + } + function Dtt(r) { + return xt || (xt = bc( + "AsyncIteratorObject", + /*arity*/ + 3, + r + )) || zt; + } + function wtt(r) { + return Tr || (Tr = bc( + "AsyncGenerator", + /*arity*/ + 3, + r + )) || zt; + } + function u$(r) { + return Nm || (Nm = bc( + "Iterable", + /*arity*/ + 3, + r + )) || zt; + } + function Ptt(r) { + return ee || (ee = bc( + "Iterator", + /*arity*/ + 3, + r + )) || zt; + } + function X3e(r) { + return et || (et = bc( + "IterableIterator", + /*arity*/ + 3, + r + )) || zt; + } + function npe() { + return ce ? ue : Le; + } + function Ntt() { + return L ?? (L = z3e(["ArrayIterator", "MapIterator", "SetIterator", "StringIterator"], 1)); + } + function Att(r) { + return Ut || (Ut = bc( + "IteratorObject", + /*arity*/ + 3, + r + )) || zt; + } + function Itt(r) { + return Gt || (Gt = bc( + "Generator", + /*arity*/ + 3, + r + )) || zt; + } + function Ftt(r) { + return Sr || (Sr = bc( + "IteratorYieldResult", + /*arity*/ + 1, + r + )) || zt; + } + function Ott(r) { + return zr || (zr = bc( + "IteratorReturnResult", + /*arity*/ + 1, + r + )) || zt; + } + function Q3e(r) { + return na || (na = bc( + "Disposable", + /*arity*/ + 0, + r + )) || ta; + } + function Ltt(r) { + return Ll || (Ll = bc( + "AsyncDisposable", + /*arity*/ + 0, + r + )) || ta; + } + function Y3e(r, a = 0) { + const l = ME( + r, + 788968, + /*diagnostic*/ + void 0 + ); + return l && J3e(l, a); + } + function Mtt() { + return df || (df = l$( + "Extract", + /*arity*/ + 2, + /*reportErrors*/ + !0 + ) || Y), df === Y ? void 0 : df; + } + function Rtt() { + return Uf || (Uf = l$( + "Omit", + /*arity*/ + 2, + /*reportErrors*/ + !0 + ) || Y), Uf === Y ? void 0 : Uf; + } + function ipe(r) { + return yp || (yp = l$( + "Awaited", + /*arity*/ + 1, + r + ) || (r ? Y : void 0)), yp === Y ? void 0 : yp; + } + function jtt() { + return jh || (jh = bc( + "BigInt", + /*arity*/ + 0, + /*reportErrors*/ + !1 + )) || ta; + } + function Btt(r) { + return sg ?? (sg = bc( + "ClassDecoratorContext", + /*arity*/ + 1, + r + )) ?? zt; + } + function Jtt(r) { + return zd ?? (zd = bc( + "ClassMethodDecoratorContext", + /*arity*/ + 2, + r + )) ?? zt; + } + function ztt(r) { + return $p ?? ($p = bc( + "ClassGetterDecoratorContext", + /*arity*/ + 2, + r + )) ?? zt; + } + function Wtt(r) { + return s1 ?? (s1 = bc( + "ClassSetterDecoratorContext", + /*arity*/ + 2, + r + )) ?? zt; + } + function Utt(r) { + return Be ?? (Be = bc( + "ClassAccessorDecoratorContext", + /*arity*/ + 2, + r + )) ?? zt; + } + function Vtt(r) { + return nt ?? (nt = bc( + "ClassAccessorDecoratorTarget", + /*arity*/ + 2, + r + )) ?? zt; + } + function qtt(r) { + return Rt ?? (Rt = bc( + "ClassAccessorDecoratorResult", + /*arity*/ + 2, + r + )) ?? zt; + } + function Htt(r) { + return pr ?? (pr = bc( + "ClassFieldDecoratorContext", + /*arity*/ + 2, + r + )) ?? zt; + } + function Gtt() { + return M0 || (M0 = Kfe( + "NaN", + /*reportErrors*/ + !1 + )); + } + function $tt() { + return __ || (__ = l$( + "Record", + /*arity*/ + 2, + /*reportErrors*/ + !0 + ) || Y), __ === Y ? void 0 : __; + } + function pP(r, a) { + return r !== zt ? Qh(r, a) : ta; + } + function Z3e(r) { + return pP(Stt(), [r]); + } + function K3e(r) { + return pP(u$( + /*reportErrors*/ + !0 + ), [r, _r, ue]); + } + function Tu(r, a) { + return pP(a ? ma : wa, [r]); + } + function spe(r) { + switch (r.kind) { + case 191: + return 2; + case 192: + return eNe(r); + case 203: + return r.questionToken ? 2 : r.dotDotDotToken ? eNe(r) : 1; + default: + return 1; + } + } + function eNe(r) { + return fM(r.type) ? 4 : 8; + } + function Xtt(r) { + const a = Ztt(r.parent); + if (fM(r)) + return a ? ma : wa; + const f = hr(r.elements, spe); + return ape(f, a, hr(r.elements, Qtt)); + } + function Qtt(r) { + return f6(r) || Ii(r) ? r : void 0; + } + function tNe(r, a) { + return !!nC(r) || rNe(r) && (r.kind === 189 ? k1(r.elementType) : r.kind === 190 ? ot(r.elements, k1) : a || ot(r.typeArguments, k1)); + } + function rNe(r) { + const a = r.parent; + switch (a.kind) { + case 197: + case 203: + case 184: + case 193: + case 194: + case 200: + case 195: + case 199: + case 189: + case 190: + return rNe(a); + case 266: + return !0; + } + return !1; + } + function k1(r) { + switch (r.kind) { + case 184: + return o$(r) || !!(fP( + r, + 788968 + /* Type */ + ).flags & 524288); + case 187: + return !0; + case 199: + return r.operator !== 158 && k1(r.type); + case 197: + case 191: + case 203: + case 317: + case 315: + case 316: + case 310: + return k1(r.type); + case 192: + return r.type.kind !== 189 || k1(r.type.elementType); + case 193: + case 194: + return ot(r.types, k1); + case 200: + return k1(r.objectType) || k1(r.indexType); + case 195: + return k1(r.checkType) || k1(r.extendsType) || k1(r.trueType) || k1(r.falseType); + } + return !1; + } + function Ytt(r) { + const a = xn(r); + if (!a.resolvedType) { + const l = Xtt(r); + if (l === zt) + a.resolvedType = ta; + else if (!(r.kind === 190 && ot(r.elements, (f) => !!(spe(f) & 8))) && tNe(r)) + a.resolvedType = r.kind === 190 && r.elements.length === 0 ? l : $fe( + l, + r, + /*mapper*/ + void 0 + ); + else { + const f = r.kind === 189 ? [Ci(r.elementType)] : hr(r.elements, Ci); + a.resolvedType = ope(l, f); + } + } + return a.resolvedType; + } + function Ztt(r) { + return rv(r) && r.operator === 148; + } + function hg(r, a, l = !1, f = []) { + const d = ape(a || hr( + r, + (y) => 1 + /* Required */ + ), l, f); + return d === zt ? ta : r.length ? ope(d, r) : d; + } + function ape(r, a, l) { + if (r.length === 1 && r[0] & 4) + return a ? ma : wa; + const f = hr(r, (y) => y & 1 ? "#" : y & 2 ? "?" : y & 4 ? "." : "*").join() + (a ? "R" : "") + (ot(l, (y) => !!y) ? "," + hr(l, (y) => y ? Ma(y) : "_").join(",") : ""); + let d = fi.get(f); + return d || fi.set(f, d = Ktt(r, a, l)), d; + } + function Ktt(r, a, l) { + const f = r.length, d = l0(r, (ve) => !!(ve & 9)); + let y; + const x = []; + let I = 0; + if (f) { + y = new Array(f); + for (let ve = 0; ve < f; ve++) { + const de = y[ve] = p_(), We = r[ve]; + if (I |= We, !(I & 12)) { + const lt = ga(4 | (We & 2 ? 16777216 : 0), "" + ve, a ? 8 : 0); + lt.links.tupleLabelDeclaration = l?.[ve], lt.links.type = de, x.push(lt); + } + } + } + const J = x.length, z = ga(4, "length", a ? 8 : 0); + if (I & 12) + z.links.type = wt; + else { + const ve = []; + for (let de = d; de <= f; de++) ve.push(Xd(de)); + z.links.type = Xn(ve); + } + x.push(z); + const G = Wc( + 12 + /* Reference */ + ); + return G.typeParameters = y, G.outerTypeParameters = void 0, G.localTypeParameters = y, G.instantiations = /* @__PURE__ */ new Map(), G.instantiations.set(rd(G.typeParameters), G), G.target = G, G.resolvedTypeArguments = G.typeParameters, G.thisType = p_(), G.thisType.isThisType = !0, G.thisType.constraint = G, G.declaredProperties = x, G.declaredCallSignatures = Ge, G.declaredConstructSignatures = Ge, G.declaredIndexInfos = Ge, G.elementFlags = r, G.minLength = d, G.fixedLength = J, G.hasRestElement = !!(I & 12), G.combinedFlags = I, G.readonly = a, G.labeledElementDeclarations = l, G; + } + function ope(r, a) { + return r.objectFlags & 8 ? cpe(r, a) : Qh(r, a); + } + function cpe(r, a) { + var l, f, d, y; + if (!(r.combinedFlags & 14)) + return Qh(r, a); + if (r.combinedFlags & 8) { + const lt = oc(a, (gt, jt) => !!(r.elementFlags[jt] & 8 && gt.flags & 1179648)); + if (lt >= 0) + return cM(hr(a, (gt, jt) => r.elementFlags[jt] & 8 ? gt : yt)) ? Go(a[lt], (gt) => cpe(r, OR(a, lt, gt))) : qe; + } + const x = [], I = [], J = []; + let z = -1, G = -1, ve = -1; + for (let lt = 0; lt < a.length; lt++) { + const gt = a[lt], jt = r.elementFlags[lt]; + if (jt & 8) + if (gt.flags & 1) + We(gt, 4, (l = r.labeledElementDeclarations) == null ? void 0 : l[lt]); + else if (gt.flags & 58982400 || L_(gt)) + We(gt, 8, (f = r.labeledElementDeclarations) == null ? void 0 : f[lt]); + else if (Sa(gt)) { + const ar = F2(gt); + if (ar.length + x.length >= 1e4) + return ze( + k, + lm(k) ? p.Type_produces_a_tuple_type_that_is_too_large_to_represent : p.Expression_produces_a_tuple_type_that_is_too_large_to_represent + ), qe; + lr(ar, (jr, Kr) => { + var or; + return We(jr, gt.target.elementFlags[Kr], (or = gt.target.labeledElementDeclarations) == null ? void 0 : or[Kr]); + }); + } else + We(iy(gt) && eb(gt, wt) || qe, 4, (d = r.labeledElementDeclarations) == null ? void 0 : d[lt]); + else + We(gt, jt, (y = r.labeledElementDeclarations) == null ? void 0 : y[lt]); + } + for (let lt = 0; lt < z; lt++) + I[lt] & 2 && (I[lt] = 1); + G >= 0 && G < ve && (x[G] = Xn(Qc(x.slice(G, ve + 1), (lt, gt) => I[G + gt] & 8 ? vf(lt, wt) : lt)), x.splice(G + 1, ve - G), I.splice(G + 1, ve - G), J.splice(G + 1, ve - G)); + const de = ape(I, r.readonly, J); + return de === zt ? ta : I.length ? Qh(de, x) : de; + function We(lt, gt, jt) { + gt & 1 && (z = I.length), gt & 4 && G < 0 && (G = I.length), gt & 6 && (ve = I.length), x.push(gt & 2 ? Ru( + lt, + /*isProperty*/ + !0 + ) : lt), I.push(gt), J.push(jt); + } + } + function dP(r, a, l = 0) { + const f = r.target, d = ry(r) - l; + return a > f.fixedLength ? Jnt(r) || hg(Ge) : hg( + Ao(r).slice(a, d), + f.elementFlags.slice(a, d), + /*readonly*/ + !1, + f.labeledElementDeclarations && f.labeledElementDeclarations.slice(a, d) + ); + } + function nNe(r) { + return Xn(Er(sQ(r.target.fixedLength, (a) => H_("" + a)), jm(r.target.readonly ? ma : wa))); + } + function ert(r, a) { + const l = oc(r.elementFlags, (f) => !(f & a)); + return l >= 0 ? l : r.elementFlags.length; + } + function nI(r, a) { + return r.elementFlags.length - GI(r.elementFlags, (l) => !(l & a)) - 1; + } + function lpe(r) { + return r.fixedLength + nI( + r, + 3 + /* Fixed */ + ); + } + function F2(r) { + const a = Ao(r), l = ry(r); + return a.length === l ? a : a.slice(0, l); + } + function trt(r) { + return Ru( + Ci(r.type), + /*isProperty*/ + !0 + ); + } + function jl(r) { + return r.id; + } + function ch(r, a) { + return py(r, a, jl, ho) >= 0; + } + function oM(r, a) { + const l = py(r, a, jl, ho); + return l < 0 ? (r.splice(~l, 0, a), !0) : !1; + } + function rrt(r, a, l) { + const f = l.flags; + if (!(f & 131072)) + if (a |= f & 473694207, f & 465829888 && (a |= 33554432), f & 2097152 && Dn(l) & 67108864 && (a |= 536870912), l === pt && (a |= 8388608), Gr(l) && (a |= 1073741824), !K && f & 98304) + Dn(l) & 65536 || (a |= 4194304); + else { + const d = r.length, y = d && l.id > r[d - 1].id ? ~d : py(r, l, jl, ho); + y < 0 && r.splice(~y, 0, l); + } + return a; + } + function iNe(r, a, l) { + let f; + for (const d of l) + d !== f && (a = d.flags & 1048576 ? iNe(r, a | (crt(d) ? 1048576 : 0), d.types) : rrt(r, a, d), f = d); + return a; + } + function nrt(r, a) { + var l; + if (r.length < 2) + return r; + const f = rd(r), d = yr.get(f); + if (d) + return d; + const y = a && ot(r, (z) => !!(z.flags & 524288) && !L_(z) && Fpe($d(z))), x = r.length; + let I = x, J = 0; + for (; I > 0; ) { + I--; + const z = r[I]; + if (y || z.flags & 469499904) { + if (z.flags & 262144 && Rm(z).flags & 1048576) { + Bm(z, Xn(hr(r, (de) => de === z ? nr : de)), Ro) && yy(r, I); + continue; + } + const G = z.flags & 61603840 ? Nn($a(z), (de) => Qd(Yr(de))) : void 0, ve = G && t_(Yr(G)); + for (const de of r) + if (z !== de) { + if (J === 1e5 && J / (x - I) * x > 1e6) { + (l = on) == null || l.instant(on.Phase.CheckTypes, "removeSubtypes_DepthLimit", { typeIds: r.map((lt) => lt.id) }), ze(k, p.Expression_produces_a_union_type_that_is_too_complex_to_represent); + return; + } + if (J++, G && de.flags & 61603840) { + const We = rr(de, G.escapedName); + if (We && Qd(We) && t_(We) !== ve) + continue; + } + if (Bm(z, de, Ro) && (!(Dn(Cr(z)) & 1) || !(Dn(Cr(de)) & 1) || sb(z, de))) { + yy(r, I); + break; + } + } + } + } + return yr.set(f, r), r; + } + function irt(r, a, l) { + let f = r.length; + for (; f > 0; ) { + f--; + const d = r[f], y = d.flags; + (y & 402653312 && a & 4 || y & 256 && a & 8 || y & 2048 && a & 64 || y & 8192 && a & 4096 || l && y & 32768 && a & 16384 || L2(d) && ch(r, d.regularType)) && yy(r, f); + } + } + function srt(r) { + const a = kn(r, PT); + if (a.length) { + let l = r.length; + for (; l > 0; ) { + l--; + const f = r[l]; + f.flags & 128 && ot(a, (d) => art(f, d)) && yy(r, l); + } + } + } + function art(r, a) { + return a.flags & 134217728 ? B$(r, a) : j$(r, a); + } + function ort(r) { + const a = []; + for (const l of r) + if (l.flags & 2097152 && Dn(l) & 67108864) { + const f = l.types[0].flags & 8650752 ? 0 : 1; + tp(a, l.types[f]); + } + for (const l of a) { + const f = []; + for (const y of r) + if (y.flags & 2097152 && Dn(y) & 67108864) { + const x = y.types[0].flags & 8650752 ? 0 : 1; + y.types[x] === l && oM(f, y.types[1 - x]); + } + const d = ou(l); + if (G_(d, (y) => ch(f, y))) { + let y = r.length; + for (; y > 0; ) { + y--; + const x = r[y]; + if (x.flags & 2097152 && Dn(x) & 67108864) { + const I = x.types[0].flags & 8650752 ? 0 : 1; + x.types[I] === l && ch(f, x.types[1 - I]) && yy(r, y); + } + } + oM(r, l); + } + } + } + function crt(r) { + return !!(r.flags & 1048576 && (r.aliasSymbol || r.origin)); + } + function sNe(r, a) { + for (const l of a) + if (l.flags & 1048576) { + const f = l.origin; + l.aliasSymbol || f && !(f.flags & 1048576) ? tp(r, l) : f && f.flags & 1048576 && sNe(r, f.types); + } + } + function upe(r, a) { + const l = Ki(r); + return l.types = a, l; + } + function Xn(r, a = 1, l, f, d) { + if (r.length === 0) + return nr; + if (r.length === 1) + return r[0]; + if (r.length === 2 && !d && (r[0].flags & 1048576 || r[1].flags & 1048576)) { + const y = a === 0 ? "N" : a === 2 ? "S" : "L", x = r[0].id < r[1].id ? 0 : 1, I = r[x].id + y + r[1 - x].id + DT(l, f); + let J = _i.get(I); + return J || (J = aNe( + r, + a, + l, + f, + /*origin*/ + void 0 + ), _i.set(I, J)), J; + } + return aNe(r, a, l, f, d); + } + function aNe(r, a, l, f, d) { + let y = []; + const x = iNe(y, 0, r); + if (a !== 0) { + if (x & 3) + return x & 1 ? x & 8388608 ? pt : x & 1073741824 ? qe : Le : yt; + if (x & 32768 && y.length >= 2 && y[0] === ue && y[1] === ye && yy(y, 1), (x & 402664352 || x & 16384 && x & 32768) && irt(y, x, !!(a & 2)), x & 128 && x & 402653184 && srt(y), x & 536870912 && ort(y), a === 2 && (y = nrt(y, !!(x & 524288)), !y)) + return qe; + if (y.length === 0) + return x & 65536 ? x & 4194304 ? Mt : ke : x & 32768 ? x & 4194304 ? ue : M : nr; + } + if (!d && x & 1048576) { + const J = []; + sNe(J, r); + const z = []; + for (const ve of y) + ot(J, (de) => ch(de.types, ve)) || z.push(ve); + if (!l && J.length === 1 && z.length === 0) + return J[0]; + if (Wu(J, (ve, de) => ve + de.types.length, 0) + z.length === y.length) { + for (const ve of J) + oM(z, ve); + d = upe(1048576, z); + } + } + const I = (x & 36323331 ? 0 : 32768) | (x & 2097152 ? 16777216 : 0); + return fpe(y, I, l, f, d); + } + function lrt(r, a) { + let l; + const f = []; + for (const y of r) { + const x = kp(y); + if (x) { + if (x.kind !== 0 && x.kind !== 1 || l && !_pe(l, x)) + return; + l = x, f.push(x.type); + } else { + const I = a !== 2097152 ? Wa(y) : void 0; + if (I !== Rr && I !== Pr) + return; + } + } + if (!l) + return; + const d = C3e(f, a); + return eI(l.kind, l.parameterName, l.parameterIndex, d); + } + function _pe(r, a) { + return r.kind === a.kind && r.parameterIndex === a.parameterIndex; + } + function fpe(r, a, l, f, d) { + if (r.length === 0) + return nr; + if (r.length === 1) + return r[0]; + const x = (d ? d.flags & 1048576 ? `|${rd(d.types)}` : d.flags & 2097152 ? `&${rd(d.types)}` : `#${d.type.id}|${rd(r)}` : rd(r)) + DT(l, f); + let I = pn.get(x); + return I || (I = ti( + 1048576 + /* Union */ + ), I.objectFlags = a | nM( + r, + /*excludeKinds*/ + 98304 + /* Nullable */ + ), I.types = r, I.origin = d, I.aliasSymbol = l, I.aliasTypeArguments = f, r.length === 2 && r[0].flags & 512 && r[1].flags & 512 && (I.flags |= 16, I.intrinsicName = "boolean"), pn.set(x, I)), I; + } + function urt(r) { + const a = xn(r); + if (!a.resolvedType) { + const l = nC(r); + a.resolvedType = Xn(hr(r.types, Ci), 1, l, RE(l)); + } + return a.resolvedType; + } + function _rt(r, a, l) { + const f = l.flags; + return f & 2097152 ? oNe(r, a, l.types) : (yg(l) ? a & 16777216 || (a |= 16777216, r.set(l.id.toString(), l)) : (f & 3 ? (l === pt && (a |= 8388608), Gr(l) && (a |= 1073741824)) : (K || !(f & 98304)) && (l === ye && (a |= 262144, l = ue), r.has(l.id.toString()) || (l.flags & 109472 && a & 109472 && (a |= 67108864), r.set(l.id.toString(), l))), a |= f & 473694207), a); + } + function oNe(r, a, l) { + for (const f of l) + a = _rt(r, a, t_(f)); + return a; + } + function frt(r, a) { + let l = r.length; + for (; l > 0; ) { + l--; + const f = r[l]; + (f.flags & 4 && a & 402653312 || f.flags & 8 && a & 256 || f.flags & 64 && a & 2048 || f.flags & 4096 && a & 8192 || f.flags & 16384 && a & 32768 || yg(f) && a & 470302716) && yy(r, l); + } + } + function prt(r, a) { + for (const l of r) + if (!ch(l.types, a)) { + if (a === ye) + return ch(l.types, ue); + if (a === ue) + return ch(l.types, ye); + const f = a.flags & 128 ? at : a.flags & 288 ? wt : a.flags & 2048 ? Zr : a.flags & 8192 ? Jt : void 0; + if (!f || !ch(l.types, f)) + return !1; + } + return !0; + } + function drt(r) { + let a = r.length; + const l = kn(r, (f) => !!(f.flags & 128)); + for (; a > 0; ) { + a--; + const f = r[a]; + if (f.flags & 402653184) { + for (const d of l) + if (R2(d, f)) { + yy(r, a); + break; + } else if (PT(f)) + return !0; + } + } + return !1; + } + function cNe(r, a) { + for (let l = 0; l < r.length; l++) + r[l] = Xc(r[l], (f) => !(f.flags & a)); + } + function mrt(r) { + let a; + const l = oc(r, (x) => !!(Dn(x) & 32768)); + if (l < 0) + return !1; + let f = l + 1; + for (; f < r.length; ) { + const x = r[f]; + Dn(x) & 32768 ? ((a || (a = [r[l]])).push(x), yy(r, f)) : f++; + } + if (!a) + return !1; + const d = [], y = []; + for (const x of a) + for (const I of x.types) + if (oM(d, I) && prt(a, I)) { + if (I === ue && y.length && y[0] === ye) + continue; + if (I === ye && y.length && y[0] === ue) { + y[0] = ye; + continue; + } + oM(y, I); + } + return r[l] = fpe( + y, + 32768 + /* PrimitiveUnion */ + ), !0; + } + function grt(r, a, l, f) { + const d = ti( + 2097152 + /* Intersection */ + ); + return d.objectFlags = a | nM( + r, + /*excludeKinds*/ + 98304 + /* Nullable */ + ), d.types = r, d.aliasSymbol = l, d.aliasTypeArguments = f, d; + } + function sa(r, a = 0, l, f) { + const d = /* @__PURE__ */ new Map(), y = oNe(d, 0, r), x = is(d.values()); + let I = 0; + if (y & 131072) + return ms(x, kt) ? kt : nr; + if (K && y & 98304 && y & 84410368 || y & 67108864 && y & 402783228 || y & 402653316 && y & 67238776 || y & 296 && y & 469891796 || y & 2112 && y & 469889980 || y & 12288 && y & 469879804 || y & 49152 && y & 469842940 || y & 402653184 && y & 128 && drt(x)) + return nr; + if (y & 1) + return y & 8388608 ? pt : y & 1073741824 ? qe : Le; + if (!K && y & 98304) + return y & 16777216 ? nr : y & 32768 ? ue : Mt; + if ((y & 4 && y & 402653312 || y & 8 && y & 256 || y & 64 && y & 2048 || y & 4096 && y & 8192 || y & 16384 && y & 32768 || y & 16777216 && y & 470302716) && (a & 1 || frt(x, y)), y & 262144 && (x[x.indexOf(ue)] = ye), x.length === 0) + return yt; + if (x.length === 1) + return x[0]; + if (x.length === 2 && !(a & 2)) { + const G = x[0].flags & 8650752 ? 0 : 1, ve = x[G], de = x[1 - G]; + if (ve.flags & 8650752 && (de.flags & 469893116 && !vNe(de) || y & 16777216)) { + const We = ou(ve); + if (We && G_(We, (lt) => !!(lt.flags & 469893116) || yg(lt))) { + if (mP(We, de)) + return ve; + if (!(We.flags & 1048576 && wp(We, (lt) => mP(lt, de))) && !mP(de, We)) + return nr; + I = 67108864; + } + } + } + const J = rd(x) + (a & 2 ? "*" : DT(l, f)); + let z = Je.get(J); + if (!z) { + if (y & 1048576) + if (mrt(x)) + z = sa(x, a, l, f); + else if (Ni(x, (G) => !!(G.flags & 1048576 && G.types[0].flags & 32768))) { + const G = ot(x, dI) ? ye : ue; + cNe( + x, + 32768 + /* Undefined */ + ), z = Xn([sa(x, a), G], 1, l, f); + } else if (Ni(x, (G) => !!(G.flags & 1048576 && (G.types[0].flags & 65536 || G.types[1].flags & 65536)))) + cNe( + x, + 65536 + /* Null */ + ), z = Xn([sa(x, a), Mt], 1, l, f); + else if (x.length >= 3 && r.length > 2) { + const G = Math.floor(x.length / 2); + z = sa([sa(x.slice(0, G), a), sa(x.slice(G), a)], a, l, f); + } else { + if (!cM(x)) + return qe; + const G = hrt(x, a), ve = ot(G, (de) => !!(de.flags & 2097152)) && ppe(G) > ppe(x) ? upe(2097152, x) : void 0; + z = Xn(G, 1, l, f, ve); + } + else + z = grt(x, I, l, f); + Je.set(J, z); + } + return z; + } + function lNe(r) { + return Wu(r, (a, l) => l.flags & 1048576 ? a * l.types.length : l.flags & 131072 ? 0 : a, 1); + } + function cM(r) { + var a; + const l = lNe(r); + return l >= 1e5 ? ((a = on) == null || a.instant(on.Phase.CheckTypes, "checkCrossProductUnion_DepthLimit", { typeIds: r.map((f) => f.id), size: l }), ze(k, p.Expression_produces_a_union_type_that_is_too_complex_to_represent), !1) : !0; + } + function hrt(r, a) { + const l = lNe(r), f = []; + for (let d = 0; d < l; d++) { + const y = r.slice(); + let x = d; + for (let J = r.length - 1; J >= 0; J--) + if (r[J].flags & 1048576) { + const z = r[J].types, G = z.length; + y[J] = z[x % G], x = Math.floor(x / G); + } + const I = sa(y, a); + I.flags & 131072 || f.push(I); + } + return f; + } + function uNe(r) { + return !(r.flags & 3145728) || r.aliasSymbol ? 1 : r.flags & 1048576 && r.origin ? uNe(r.origin) : ppe(r.types); + } + function ppe(r) { + return Wu(r, (a, l) => a + uNe(l), 0); + } + function yrt(r) { + const a = xn(r); + if (!a.resolvedType) { + const l = nC(r), f = hr(r.types, Ci), d = f.length === 2 ? f.indexOf(Ws) : -1, y = d >= 0 ? f[1 - d] : yt, x = !!(y.flags & 76 || y.flags & 134217728 && PT(y)); + a.resolvedType = sa(f, x ? 1 : 0, l, RE(l)); + } + return a.resolvedType; + } + function _Ne(r, a) { + const l = ti( + 4194304 + /* Index */ + ); + return l.type = r, l.indexFlags = a, l; + } + function vrt(r) { + const a = Ki( + 4194304 + /* Index */ + ); + return a.type = r, a; + } + function fNe(r, a) { + return a & 1 ? r.resolvedStringIndexType || (r.resolvedStringIndexType = _Ne( + r, + 1 + /* StringsOnly */ + )) : r.resolvedIndexType || (r.resolvedIndexType = _Ne( + r, + 0 + /* None */ + )); + } + function pNe(r, a) { + const l = Sd(r), f = $f(r), d = K0(r.target || r); + if (!d && !(a & 2)) + return f; + const y = []; + if (AT(f)) { + if (AE(r)) + return fNe(r, a); + BT(f, I); + } else if (AE(r)) { + const J = e_(Kv(r)); + Ofe(J, 8576, !!(a & 1), I); + } else + BT(ZL(f), I); + const x = a & 2 ? Xc(Xn(y), (J) => !(J.flags & 5)) : Xn(y); + if (x.flags & 1048576 && f.flags & 1048576 && rd(x.types) === rd(f.types)) + return f; + return x; + function I(J) { + const z = d ? Mi(d, aI(r.mapper, l, J)) : J; + y.push(z === at ? Xt : z); + } + } + function brt(r) { + const a = Sd(r); + return l(K0(r) || a); + function l(f) { + return f.flags & 470810623 ? !0 : f.flags & 16777216 ? f.root.isDistributive && f.checkType === a : f.flags & 137363456 ? Ni(f.types, l) : f.flags & 8388608 ? l(f.objectType) && l(f.indexType) : f.flags & 33554432 ? l(f.baseType) && l(f.constraint) : f.flags & 268435456 ? l(f.type) : !1; + } + } + function Yh(r) { + if (Ai(r)) + return nr; + if (E_(r)) + return t_(Hi(r)); + if (Gs(r)) + return t_(Td(r)); + const a = dS(r); + return a !== void 0 ? H_(Si(a)) : ut(r) ? t_(Hi(r)) : nr; + } + function tC(r, a, l) { + if (l || !(up(r) & 6)) { + let f = Pn(XG(r)).nameType; + if (!f) { + const d = _s(r.valueDeclaration); + f = r.escapedName === "default" ? H_("default") : d && Yh(d) || (QD(r) ? void 0 : H_(cc(r))); + } + if (f && f.flags & a) + return f; + } + return nr; + } + function dNe(r, a) { + return !!(r.flags & a || r.flags & 2097152 && ot(r.types, (l) => dNe(l, a))); + } + function Srt(r, a, l) { + const f = l && (Dn(r) & 7 || r.aliasSymbol) ? vrt(r) : void 0, d = hr($a(r), (x) => tC(x, a)), y = hr(Su(r), (x) => x !== Li && dNe(x.keyType, a) ? x.keyType === at && a & 8 ? Xt : x.keyType : nr); + return Xn( + Bi(d, y), + 1, + /*aliasSymbol*/ + void 0, + /*aliasTypeArguments*/ + void 0, + f + ); + } + function dpe(r, a = 0) { + return !!(r.flags & 58982400 || w1(r) || L_(r) && (!brt(r) || Y8(r) === 2) || r.flags & 1048576 && !(a & 4) && Jfe(r) || r.flags & 2097152 && Dc( + r, + 465829888 + /* Instantiable */ + ) && ot(r.types, yg)); + } + function jm(r, a = 0) { + return r = td(r), LE(r) ? Xfe(jm(r.baseType, a)) : dpe(r, a) ? fNe(r, a) : r.flags & 1048576 ? sa(hr(r.types, (l) => jm(l, a))) : r.flags & 2097152 ? Xn(hr(r.types, (l) => jm(l, a))) : Dn(r) & 32 ? pNe(r, a) : r === pt ? pt : r.flags & 2 ? nr : r.flags & 131073 ? oi : Srt( + r, + (a & 2 ? 128 : 402653316) | (a & 1 ? 0 : 12584), + a === 0 + /* None */ + ); + } + function mNe(r) { + const a = Mtt(); + return a ? OE(a, [r, at]) : at; + } + function Trt(r) { + const a = mNe(jm(r)); + return a.flags & 131072 ? at : a; + } + function xrt(r) { + const a = xn(r); + if (!a.resolvedType) + switch (r.operator) { + case 143: + a.resolvedType = jm(Ci(r.type)); + break; + case 158: + a.resolvedType = r.type.kind === 155 ? xpe($3(r.parent)) : qe; + break; + case 148: + a.resolvedType = Ci(r.type); + break; + default: + E.assertNever(r.operator); + } + return a.resolvedType; + } + function krt(r) { + const a = xn(r); + return a.resolvedType || (a.resolvedType = wT( + [r.head.text, ...hr(r.templateSpans, (l) => l.literal.text)], + hr(r.templateSpans, (l) => Ci(l.type)) + )), a.resolvedType; + } + function wT(r, a) { + const l = oc(a, (z) => !!(z.flags & 1179648)); + if (l >= 0) + return cM(a) ? Go(a[l], (z) => wT(r, OR(a, l, z))) : qe; + if (ms(a, pt)) + return pt; + const f = [], d = []; + let y = r[0]; + if (!J(r, a)) + return at; + if (f.length === 0) + return H_(y); + if (d.push(y), Ni(d, (z) => z === "")) { + if (Ni(f, (z) => !!(z.flags & 4))) + return at; + if (f.length === 1 && PT(f[0])) + return f[0]; + } + const x = `${rd(f)}|${hr(d, (z) => z.length).join(",")}|${d.join("")}`; + let I = ki.get(x); + return I || ki.set(x, I = Ert(d, f)), I; + function J(z, G) { + for (let ve = 0; ve < G.length; ve++) { + const de = G[ve]; + if (de.flags & 101248) + y += Crt(de) || "", y += z[ve + 1]; + else if (de.flags & 134217728) { + if (y += de.texts[0], !J(de.texts, de.types)) return !1; + y += z[ve + 1]; + } else if (AT(de) || lM(de)) + f.push(de), d.push(y), y = z[ve + 1]; + else + return !1; + } + return !0; + } + } + function Crt(r) { + return r.flags & 128 ? r.value : r.flags & 256 ? "" + r.value : r.flags & 2048 ? Ub(r.value) : r.flags & 98816 ? r.intrinsicName : void 0; + } + function Ert(r, a) { + const l = ti( + 134217728 + /* TemplateLiteral */ + ); + return l.texts = r, l.types = a, l; + } + function rC(r, a) { + return a.flags & 1179648 ? Go(a, (l) => rC(r, l)) : a.flags & 128 ? H_(gNe(r, a.value)) : a.flags & 134217728 ? wT(...Drt(r, a.texts, a.types)) : ( + // Mapping> === Mapping + a.flags & 268435456 && r === a.symbol ? a : a.flags & 268435461 || AT(a) ? hNe(r, a) : ( + // This handles Mapping<`${number}`> and Mapping<`${bigint}`> + lM(a) ? hNe(r, wT(["", ""], [a])) : a + ) + ); + } + function gNe(r, a) { + switch (AW.get(r.escapedName)) { + case 0: + return a.toUpperCase(); + case 1: + return a.toLowerCase(); + case 2: + return a.charAt(0).toUpperCase() + a.slice(1); + case 3: + return a.charAt(0).toLowerCase() + a.slice(1); + } + return a; + } + function Drt(r, a, l) { + switch (AW.get(r.escapedName)) { + case 0: + return [a.map((f) => f.toUpperCase()), l.map((f) => rC(r, f))]; + case 1: + return [a.map((f) => f.toLowerCase()), l.map((f) => rC(r, f))]; + case 2: + return [a[0] === "" ? a : [a[0].charAt(0).toUpperCase() + a[0].slice(1), ...a.slice(1)], a[0] === "" ? [rC(r, l[0]), ...l.slice(1)] : l]; + case 3: + return [a[0] === "" ? a : [a[0].charAt(0).toLowerCase() + a[0].slice(1), ...a.slice(1)], a[0] === "" ? [rC(r, l[0]), ...l.slice(1)] : l]; + } + return [a, l]; + } + function hNe(r, a) { + const l = `${Xs(r)},${jl(a)}`; + let f = Ds.get(l); + return f || Ds.set(l, f = wrt(r, a)), f; + } + function wrt(r, a) { + const l = gi(268435456, r); + return l.type = a, l; + } + function Prt(r, a, l, f, d) { + const y = ti( + 8388608 + /* IndexedAccess */ + ); + return y.objectType = r, y.indexType = a, y.accessFlags = l, y.aliasSymbol = f, y.aliasTypeArguments = d, y; + } + function iI(r) { + if (fe) + return !1; + if (Dn(r) & 4096) + return !0; + if (r.flags & 1048576) + return Ni(r.types, iI); + if (r.flags & 2097152) + return ot(r.types, iI); + if (r.flags & 465829888) { + const a = Rfe(r); + return a !== r && iI(a); + } + return !1; + } + function _$(r, a) { + return _p(r) ? fp(r) : a && qc(a) ? ( + // late bound names are handled in the first branch, so here we only need to handle normal names + dS(a) + ) : void 0; + } + function mpe(r, a) { + if (a.flags & 8208) { + const l = dr(r.parent, (f) => !To(f)) || r.parent; + return Cb(l) ? sm(l) && Me(r) && PAe(l, r) : Ni(a.declarations, (f) => !Es(f) || Wd(f)); + } + return !0; + } + function yNe(r, a, l, f, d, y) { + const x = d && d.kind === 213 ? d : void 0, I = d && Ai(d) ? void 0 : _$(l, d); + if (I !== void 0) { + if (y & 256) + return lb(a, I) || Le; + const z = Ys(a, I); + if (z) { + if (y & 64 && d && z.declarations && Zu(z) && mpe(d, z)) { + const ve = x?.argumentExpression ?? ($b(d) ? d.indexType : d); + Zp(ve, z.declarations, I); + } + if (x) { + if (UM(z, x, Q8e(x.expression, a.symbol)), jIe(x, z, Oy(x))) { + ze(x.argumentExpression, p.Cannot_assign_to_0_because_it_is_a_read_only_property, Wi(z)); + return; + } + if (y & 8 && (xn(d).resolvedSymbol = z), W8e(x, z)) + return mt; + } + const G = y & 4 ? Z0(z) : Yr(z); + return x && Oy(x) !== 1 ? s0(x, G) : d && $b(d) && dI(G) ? Xn([G, ue]) : G; + } + if (G_(a, Sa) && zg(I)) { + const G = +I; + if (d && G_(a, (ve) => !(ve.target.combinedFlags & 12)) && !(y & 16)) { + const ve = gpe(d); + if (Sa(a)) { + if (G < 0) + return ze(ve, p.A_tuple_type_cannot_be_indexed_with_a_negative_value), ue; + ze(ve, p.Tuple_type_0_of_length_1_has_no_element_at_index_2, Wr(a), ry(a), Si(I)); + } else + ze(ve, p.Property_0_does_not_exist_on_type_1, Si(I), Wr(a)); + } + if (G >= 0) + return J(ah(a, wt)), cAe(a, G, y & 1 ? ye : void 0); + } + } + if (!(l.flags & 98304) && cu( + l, + 402665900 + /* ESSymbolLike */ + )) { + if (a.flags & 131073) + return a; + const z = Z8(a, l) || ah(a, at); + if (z) { + if (y & 2 && z.keyType !== wt) { + x && (y & 4 ? ze(x, p.Type_0_is_generic_and_can_only_be_indexed_for_reading, Wr(r)) : ze(x, p.Type_0_cannot_be_used_to_index_type_1, Wr(l), Wr(r))); + return; + } + if (d && z.keyType === at && !cu( + l, + 12 + /* Number */ + )) { + const G = gpe(d); + return ze(G, p.Type_0_cannot_be_used_as_an_index_type, Wr(l)), y & 1 ? Xn([z.type, ye]) : z.type; + } + return J(z), y & 1 && !(a.symbol && a.symbol.flags & 384 && l.symbol && l.flags & 1024 && Tl(l.symbol) === a.symbol) ? Xn([z.type, ye]) : z.type; + } + if (l.flags & 131072) + return nr; + if (iI(a)) + return Le; + if (x && !vX(a)) { + if (sy(a)) { + if (fe && l.flags & 384) + return Aa.add(sn(x, p.Property_0_does_not_exist_on_type_1, l.value, Wr(a))), ue; + if (l.flags & 12) { + const G = hr(a.properties, (ve) => Yr(ve)); + return Xn(Er(G, ue)); + } + } + if (a.symbol === Se && I !== void 0 && Se.exports.has(I) && Se.exports.get(I).flags & 418) + ze(x, p.Property_0_does_not_exist_on_type_1, Si(I), Wr(a)); + else if (fe && !(y & 128)) + if (I !== void 0 && q8e(I, a)) { + const G = Wr(a); + ze(x, p.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead, I, G, G + "[" + Qo(x.argumentExpression) + "]"); + } else if (eb(a, wt)) + ze(x.argumentExpression, p.Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number); + else { + let G; + if (I !== void 0 && (G = $8e(I, a))) + G !== void 0 && ze(x.argumentExpression, p.Property_0_does_not_exist_on_type_1_Did_you_mean_2, I, Wr(a), G); + else { + const ve = Mat(a, x, l); + if (ve !== void 0) + ze(x, p.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1, Wr(a), ve); + else { + let de; + if (l.flags & 1024) + de = Ts( + /*details*/ + void 0, + p.Property_0_does_not_exist_on_type_1, + "[" + Wr(l) + "]", + Wr(a) + ); + else if (l.flags & 8192) { + const We = q0(l.symbol, x); + de = Ts( + /*details*/ + void 0, + p.Property_0_does_not_exist_on_type_1, + "[" + We + "]", + Wr(a) + ); + } else l.flags & 128 || l.flags & 256 ? de = Ts( + /*details*/ + void 0, + p.Property_0_does_not_exist_on_type_1, + l.value, + Wr(a) + ) : l.flags & 12 && (de = Ts( + /*details*/ + void 0, + p.No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1, + Wr(l), + Wr(a) + )); + de = Ts( + de, + p.Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1, + Wr(f), + Wr(a) + ), Aa.add(Fg(xr(x), x, de)); + } + } + } + return; + } + } + if (y & 16 && sy(a)) + return ue; + if (iI(a)) + return Le; + if (d) { + const z = gpe(d); + if (z.kind !== 10 && l.flags & 384) + ze(z, p.Property_0_does_not_exist_on_type_1, "" + l.value, Wr(a)); + else if (l.flags & 12) + ze(z, p.Type_0_has_no_matching_index_signature_for_type_1, Wr(a), Wr(l)); + else { + const G = z.kind === 10 ? "bigint" : Wr(l); + ze(z, p.Type_0_cannot_be_used_as_an_index_type, G); + } + } + if (gn(l)) + return l; + return; + function J(z) { + z && z.isReadonly && x && (Ly(x) || OB(x)) && ze(x, p.Index_signature_in_type_0_only_permits_reading, Wr(a)); + } + } + function gpe(r) { + return r.kind === 213 ? r.argumentExpression : r.kind === 200 ? r.indexType : r.kind === 168 ? r.expression : r; + } + function lM(r) { + if (r.flags & 2097152) { + let a = !1; + for (const l of r.types) + if (l.flags & 101248 || lM(l)) + a = !0; + else if (!(l.flags & 524288)) + return !1; + return a; + } + return !!(r.flags & 77) || PT(r); + } + function PT(r) { + return !!(r.flags & 134217728) && Ni(r.types, lM) || !!(r.flags & 268435456) && lM(r.type); + } + function vNe(r) { + return !!(r.flags & 402653184) && !PT(r); + } + function nb(r) { + return !!sI(r); + } + function NT(r) { + return !!(sI(r) & 4194304); + } + function AT(r) { + return !!(sI(r) & 8388608); + } + function sI(r) { + return r.flags & 3145728 ? (r.objectFlags & 2097152 || (r.objectFlags |= 2097152 | Wu(r.types, (a, l) => a | sI(l), 0)), r.objectFlags & 12582912) : r.flags & 33554432 ? (r.objectFlags & 2097152 || (r.objectFlags |= 2097152 | sI(r.baseType) | sI(r.constraint)), r.objectFlags & 12582912) : (r.flags & 58982400 || L_(r) || w1(r) ? 4194304 : 0) | (r.flags & 63176704 || vNe(r) ? 8388608 : 0); + } + function Zh(r, a) { + return r.flags & 8388608 ? Art(r, a) : r.flags & 16777216 ? Irt(r, a) : r; + } + function bNe(r, a, l) { + if (r.flags & 1048576 || r.flags & 2097152 && !dpe(r)) { + const f = hr(r.types, (d) => Zh(vf(d, a), l)); + return r.flags & 2097152 || l ? sa(f) : Xn(f); + } + } + function Nrt(r, a, l) { + if (a.flags & 1048576) { + const f = hr(a.types, (d) => Zh(vf(r, d), l)); + return l ? sa(f) : Xn(f); + } + } + function Art(r, a) { + const l = a ? "simplifiedForWriting" : "simplifiedForReading"; + if (r[l]) + return r[l] === Fc ? r : r[l]; + r[l] = Fc; + const f = Zh(r.objectType, a), d = Zh(r.indexType, a), y = Nrt(f, d, a); + if (y) + return r[l] = y; + if (!(d.flags & 465829888)) { + const x = bNe(f, d, a); + if (x) + return r[l] = x; + } + if (w1(f) && d.flags & 296) { + const x = yP( + f, + d.flags & 8 ? 0 : f.target.fixedLength, + /*endSkipCount*/ + 0, + a + ); + if (x) + return r[l] = x; + } + return L_(f) && Y8(f) !== 2 ? r[l] = Go(f$(f, r.indexType), (x) => Zh(x, a)) : r[l] = r; + } + function Irt(r, a) { + const l = r.checkType, f = r.extendsType, d = E1(r), y = D1(r); + if (y.flags & 131072 && Kh(d) === Kh(l)) { + if (l.flags & 1 || Ms(OT(l), OT(f))) + return Zh(d, a); + if (SNe(l, f)) + return nr; + } else if (d.flags & 131072 && Kh(y) === Kh(l)) { + if (!(l.flags & 1) && Ms(OT(l), OT(f))) + return nr; + if (l.flags & 1 || SNe(l, f)) + return Zh(y, a); + } + return r; + } + function SNe(r, a) { + return !!(Xn([YL(r, a), nr]).flags & 131072); + } + function f$(r, a) { + const l = bf([Sd(r)], [a]), f = ib(r.mapper, l), d = Mi(sh(r.target || r), f), y = u3e(r) > 0 || (nb(r) ? oP(Kv(r)) > 0 : Frt(r, a)); + return Ru( + d, + /*isProperty*/ + !0, + y + ); + } + function Frt(r, a) { + const l = ou(a); + return !!l && ot($a(r), (f) => !!(f.flags & 16777216) && Ms(tC( + f, + 8576 + /* StringOrNumberLiteralOrUnique */ + ), l)); + } + function vf(r, a, l = 0, f, d, y) { + return C1(r, a, l, f, d, y) || (f ? qe : yt); + } + function TNe(r, a) { + return G_(r, (l) => { + if (l.flags & 384) { + const f = fp(l); + if (zg(f)) { + const d = +f; + return d >= 0 && d < a; + } + } + return !1; + }); + } + function C1(r, a, l = 0, f, d, y) { + if (r === pt || a === pt) + return pt; + if (r = td(r), $Ne(r) && !(a.flags & 98304) && cu( + a, + 12 + /* Number */ + ) && (a = at), F.noUncheckedIndexedAccess && l & 32 && (l |= 1), AT(a) || (f && f.kind !== 200 ? w1(r) && !TNe(a, lpe(r.target)) : NT(r) && !(Sa(r) && TNe(a, lpe(r.target))) || Jfe(r))) { + if (r.flags & 3) + return r; + const I = l & 1, J = r.id + "," + a.id + "," + I + DT(d, y); + let z = Un.get(J); + return z || Un.set(J, z = Prt(r, a, I, d, y)), z; + } + const x = cP(r); + if (a.flags & 1048576 && !(a.flags & 16)) { + const I = []; + let J = !1; + for (const z of a.types) { + const G = yNe(r, x, z, a, f, l | (J ? 128 : 0)); + if (G) + I.push(G); + else if (f) + J = !0; + else + return; + } + return J ? void 0 : l & 4 ? sa(I, 0, d, y) : Xn(I, 1, d, y); + } + return yNe( + r, + x, + a, + a, + f, + l | 8 | 64 + /* ReportDeprecated */ + ); + } + function xNe(r) { + const a = xn(r); + if (!a.resolvedType) { + const l = Ci(r.objectType), f = Ci(r.indexType), d = nC(r); + a.resolvedType = vf(l, f, 0, r, d, RE(d)); + } + return a.resolvedType; + } + function hpe(r) { + const a = xn(r); + if (!a.resolvedType) { + const l = Wc(32, r.symbol); + l.declaration = r, l.aliasSymbol = nC(r), l.aliasTypeArguments = RE(l.aliasSymbol), a.resolvedType = l, $f(l); + } + return a.resolvedType; + } + function Kh(r) { + return r.flags & 33554432 ? Kh(r.baseType) : r.flags & 8388608 && (r.objectType.flags & 33554432 || r.indexType.flags & 33554432) ? vf(Kh(r.objectType), Kh(r.indexType)) : r; + } + function kNe(r) { + return qx(r) && wr(r.elements) > 0 && !ot(r.elements, (a) => CF(a) || EF(a) || f6(a) && !!(a.questionToken || a.dotDotDotToken)); + } + function CNe(r, a) { + return nb(r) || a && Sa(r) && ot(F2(r), nb); + } + function ype(r, a, l, f, d) { + let y, x, I = 0; + for (; ; ) { + if (I === 1e3) + return ze(k, p.Type_instantiation_is_excessively_deep_and_possibly_infinite), qe; + const z = Mi(Kh(r.checkType), a), G = Mi(r.extendsType, a); + if (z === qe || G === qe) + return qe; + if (z === pt || G === pt) + return pt; + const ve = VD(r.node.checkType), de = VD(r.node.extendsType), We = kNe(ve) && kNe(de) && wr(ve.elements) === wr(de.elements), lt = CNe(z, We); + let gt; + if (r.inferTypeParameters) { + const ar = gI( + r.inferTypeParameters, + /*signature*/ + void 0, + 0 + /* None */ + ); + a && (ar.nonFixingMapper = ib(ar.nonFixingMapper, a)), lt || uh( + ar.inferences, + z, + G, + 1536 + /* AlwaysStrict */ + ), gt = a ? ib(ar.mapper, a) : ar.mapper; + } + const jt = gt ? Mi(r.extendsType, gt) : G; + if (!lt && !CNe(jt, We)) { + if (!(jt.flags & 3) && (z.flags & 1 || !Ms(cI(z), cI(jt)))) { + (z.flags & 1 || l && !(jt.flags & 131072) && wp(cI(jt), (jr) => Ms(jr, cI(z)))) && (x || (x = [])).push(Mi(Ci(r.node.trueType), gt || a)); + const ar = Ci(r.node.falseType); + if (ar.flags & 16777216) { + const jr = ar.root; + if (jr.node.parent === r.node && (!jr.isDistributive || jr.checkType === r.checkType)) { + r = jr; + continue; + } + if (J(ar, a)) + continue; + } + y = Mi(ar, a); + break; + } + if (jt.flags & 3 || Ms(OT(z), OT(jt))) { + const ar = Ci(r.node.trueType), jr = gt || a; + if (J(ar, jr)) + continue; + y = Mi(ar, jr); + break; + } + } + y = ti( + 16777216 + /* Conditional */ + ), y.root = r, y.checkType = Mi(r.checkType, a), y.extendsType = Mi(r.extendsType, a), y.mapper = a, y.combinedMapper = gt, y.aliasSymbol = f || r.aliasSymbol, y.aliasTypeArguments = f ? d : e0(r.aliasTypeArguments, a); + break; + } + return x ? Xn(Er(x, y)) : y; + function J(z, G) { + if (z.flags & 16777216 && G) { + const ve = z.root; + if (ve.outerTypeParameters) { + const de = ib(z.mapper, G), We = hr(ve.outerTypeParameters, (jt) => ny(jt, de)), lt = bf(ve.outerTypeParameters, We), gt = ve.isDistributive ? ny(ve.checkType, lt) : void 0; + if (!gt || gt === ve.checkType || !(gt.flags & 1179648)) + return r = ve, a = lt, f = void 0, d = void 0, ve.aliasSymbol && I++, !0; + } + } + return !1; + } + } + function E1(r) { + return r.resolvedTrueType || (r.resolvedTrueType = Mi(Ci(r.root.node.trueType), r.mapper)); + } + function D1(r) { + return r.resolvedFalseType || (r.resolvedFalseType = Mi(Ci(r.root.node.falseType), r.mapper)); + } + function Ort(r) { + return r.resolvedInferredTrueType || (r.resolvedInferredTrueType = r.combinedMapper ? Mi(Ci(r.root.node.trueType), r.combinedMapper) : E1(r)); + } + function vpe(r) { + let a; + return r.locals && r.locals.forEach((l) => { + l.flags & 262144 && (a = Er(a, bo(l))); + }), a; + } + function Lrt(r) { + return r.isDistributive && (dM(r.checkType, r.node.trueType) || dM(r.checkType, r.node.falseType)); + } + function Mrt(r) { + const a = xn(r); + if (!a.resolvedType) { + const l = Ci(r.checkType), f = nC(r), d = RE(f), y = pi( + r, + /*includeThisTypes*/ + !0 + ), x = d ? y : kn(y, (J) => dM(J, r)), I = { + node: r, + checkType: l, + extendsType: Ci(r.extendsType), + isDistributive: !!(l.flags & 262144), + inferTypeParameters: vpe(r), + outerTypeParameters: x, + instantiations: void 0, + aliasSymbol: f, + aliasTypeArguments: d + }; + a.resolvedType = ype( + I, + /*mapper*/ + void 0, + /*forConstraint*/ + !1 + ), x && (I.instantiations = /* @__PURE__ */ new Map(), I.instantiations.set(rd(x), a.resolvedType)); + } + return a.resolvedType; + } + function Rrt(r) { + const a = xn(r); + return a.resolvedType || (a.resolvedType = Zv(yn(r.typeParameter))), a.resolvedType; + } + function ENe(r) { + return Me(r) ? [r] : Er(ENe(r.left), r.right); + } + function DNe(r) { + var a; + const l = xn(r); + if (!l.resolvedType) { + if (!bh(r)) + return ze(r.argument, p.String_literal_expected), l.resolvedSymbol = Y, l.resolvedType = qe; + const f = r.isTypeOf ? 111551 : r.flags & 16777216 ? 900095 : 788968, d = Mu(r, r.argument.literal); + if (!d) + return l.resolvedSymbol = Y, l.resolvedType = qe; + const y = !!((a = d.exports) != null && a.get( + "export=" + /* ExportEquals */ + )), x = q_( + d, + /*dontResolveAlias*/ + !1 + ); + if (lc(r.qualifier)) + if (x.flags & f) + l.resolvedType = wNe(r, l, x, f); + else { + const I = f === 111551 ? p.Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here : p.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0; + ze(r, I, r.argument.literal.text), l.resolvedSymbol = Y, l.resolvedType = qe; + } + else { + const I = ENe(r.qualifier); + let J = x, z; + for (; z = I.shift(); ) { + const G = I.length ? 1920 : f, ve = Oa(zc(J)), de = r.isTypeOf || an(r) && y ? Ys( + Yr(ve), + z.escapedText, + /*skipObjectFunctionPropertyAugment*/ + !1, + /*includeTypeOnlyMembers*/ + !0 + ) : void 0, lt = (r.isTypeOf ? void 0 : Xl(gf(ve), z.escapedText, G)) ?? de; + if (!lt) + return ze(z, p.Namespace_0_has_no_exported_member_1, q0(J), co(z)), l.resolvedType = qe; + xn(z).resolvedSymbol = lt, xn(z.parent).resolvedSymbol = lt, J = lt; + } + l.resolvedType = wNe(r, l, J, f); + } + } + return l.resolvedType; + } + function wNe(r, a, l, f) { + const d = zc(l); + return a.resolvedSymbol = d, f === 111551 ? kIe(Yr(l), r) : a$(r, d); + } + function PNe(r) { + const a = xn(r); + if (!a.resolvedType) { + const l = nC(r); + if (!r.symbol || dg(r.symbol).size === 0 && !l) + a.resolvedType = Ws; + else { + let f = Wc(16, r.symbol); + f.aliasSymbol = l, f.aliasTypeArguments = RE(l), AS(r) && r.isArrayType && (f = Tu(f)), a.resolvedType = f; + } + } + return a.resolvedType; + } + function nC(r) { + let a = r.parent; + for (; kS(a) || lv(a) || rv(a) && a.operator === 148; ) + a = a.parent; + return q3(a) ? yn(a) : void 0; + } + function RE(r) { + return r ? ia(r) : void 0; + } + function p$(r) { + return !!(r.flags & 524288) && !L_(r); + } + function bpe(r) { + return t0(r) || !!(r.flags & 474058748); + } + function Spe(r, a) { + if (!(r.flags & 1048576)) + return r; + if (Ni(r.types, bpe)) + return Nn(r.types, t0) || ta; + const l = Nn(r.types, (y) => !bpe(y)); + if (!l || Nn(r.types, (y) => y !== l && !bpe(y))) + return r; + return d(l); + function d(y) { + const x = Bs(); + for (const J of $a(y)) + if (!(up(J) & 6)) { + if (d$(J)) { + const z = J.flags & 65536 && !(J.flags & 32768), ve = ga(16777220, J.escapedName, Ffe(J) | (a ? 8 : 0)); + ve.links.type = z ? ue : Ru( + Yr(J), + /*isProperty*/ + !0 + ), ve.declarations = J.declarations, ve.links.nameType = Pn(J).nameType, ve.links.syntheticOrigin = J, x.set(J.escapedName, ve); + } + } + const I = Ho(y.symbol, x, Ge, Ge, Su(y)); + return I.objectFlags |= 131200, I; + } + } + function O2(r, a, l, f, d) { + if (r.flags & 1 || a.flags & 1) + return Le; + if (r.flags & 2 || a.flags & 2) + return yt; + if (r.flags & 131072) + return a; + if (a.flags & 131072) + return r; + if (r = Spe(r, d), r.flags & 1048576) + return cM([r, a]) ? Go(r, (z) => O2(z, a, l, f, d)) : qe; + if (a = Spe(a, d), a.flags & 1048576) + return cM([r, a]) ? Go(a, (z) => O2(r, z, l, f, d)) : qe; + if (a.flags & 473960444) + return r; + if (NT(r) || NT(a)) { + if (t0(r)) + return a; + if (r.flags & 2097152) { + const z = r.types, G = z[z.length - 1]; + if (p$(G) && p$(a)) + return sa(Bi(z.slice(0, z.length - 1), [O2(G, a, l, f, d)])); + } + return sa([r, a]); + } + const y = Bs(), x = /* @__PURE__ */ new Set(), I = r === ta ? Su(a) : s3e([r, a]); + for (const z of $a(a)) + up(z) & 6 ? x.add(z.escapedName) : d$(z) && y.set(z.escapedName, Tpe(z, d)); + for (const z of $a(r)) + if (!(x.has(z.escapedName) || !d$(z))) + if (y.has(z.escapedName)) { + const G = y.get(z.escapedName), ve = Yr(G); + if (G.flags & 16777216) { + const de = Bi(z.declarations, G.declarations), We = 4 | z.flags & 16777216, lt = ga(We, z.escapedName), gt = Yr(z), jt = I$(gt), ar = I$(ve); + lt.links.type = jt === ar ? gt : Xn( + [gt, ar], + 2 + /* Subtype */ + ), lt.links.leftSpread = z, lt.links.rightSpread = G, lt.declarations = de, lt.links.nameType = Pn(z).nameType, y.set(z.escapedName, lt); + } + } else + y.set(z.escapedName, Tpe(z, d)); + const J = Ho(l, y, Ge, Ge, Qc(I, (z) => jrt(z, d))); + return J.objectFlags |= 2228352 | f, J; + } + function d$(r) { + var a; + return !ot(r.declarations, Du) && (!(r.flags & 106496) || !((a = r.declarations) != null && a.some((l) => $n(l.parent)))); + } + function Tpe(r, a) { + const l = r.flags & 65536 && !(r.flags & 32768); + if (!l && a === tm(r)) + return r; + const f = 4 | r.flags & 16777216, d = ga(f, r.escapedName, Ffe(r) | (a ? 8 : 0)); + return d.links.type = l ? ue : Yr(r), d.declarations = r.declarations, d.links.nameType = Pn(r).nameType, d.links.syntheticOrigin = r, d; + } + function jrt(r, a) { + return r.isReadonly !== a ? oh(r.keyType, r.type, a, r.declaration, r.components) : r; + } + function uM(r, a, l, f) { + const d = gi(r, l); + return d.value = a, d.regularType = f || d, d; + } + function iC(r) { + if (r.flags & 2976) { + if (!r.freshType) { + const a = uM(r.flags, r.value, r.symbol, r); + a.freshType = a, r.freshType = a; + } + return r.freshType; + } + return r; + } + function t_(r) { + return r.flags & 2976 ? r.regularType : r.flags & 1048576 ? r.regularType || (r.regularType = Go(r, t_)) : r; + } + function L2(r) { + return !!(r.flags & 2976) && r.freshType === r; + } + function H_(r) { + let a; + return ft.get(r) || (ft.set(r, a = uM(128, r)), a); + } + function Xd(r) { + let a; + return er.get(r) || (er.set(r, a = uM(256, r)), a); + } + function _M(r) { + let a; + const l = Ub(r); + return qr.get(l) || (qr.set(l, a = uM(2048, r)), a); + } + function Brt(r, a, l) { + let f; + const d = `${a}${typeof r == "string" ? "@" : "#"}${r}`, y = 1024 | (typeof r == "string" ? 128 : 256); + return Jn.get(d) || (Jn.set(d, f = uM(y, r, l)), f); + } + function Jrt(r) { + if (r.literal.kind === 106) + return Mt; + const a = xn(r); + return a.resolvedType || (a.resolvedType = t_(Hi(r.literal))), a.resolvedType; + } + function zrt(r) { + const a = gi(8192, r); + return a.escapedName = `__@${a.symbol.escapedName}@${Xs(a.symbol)}`, a; + } + function xpe(r) { + if (an(r) && lv(r)) { + const a = Fb(r); + a && (r = bx(a) || a); + } + if (gK(r)) { + const a = Z7(r) ? Hf(r.left) : Hf(r); + if (a) { + const l = Pn(a); + return l.uniqueESSymbolType || (l.uniqueESSymbolType = zrt(a)); + } + } + return Jt; + } + function Wrt(r) { + const a = qu( + r, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ), l = a && a.parent; + if (l && ($n(l) || l.kind === 265) && !Js(a) && (!nc(a) || Ob(r, a.body))) + return xp(yn(l)).thisType; + if (l && _a(l) && _n(l.parent) && Ac(l.parent) === 6) + return xp(Hf(l.parent.left).parent).thisType; + const f = r.flags & 16777216 ? $1(r) : void 0; + return f && yo(f) && _n(f.parent) && Ac(f.parent) === 3 ? xp(Hf(f.parent.left).parent).thisType : zm(a) && Ob(r, a.body) ? xp(yn(a)).thisType : (ze(r, p.A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface), qe); + } + function kpe(r) { + const a = xn(r); + return a.resolvedType || (a.resolvedType = Wrt(r)), a.resolvedType; + } + function NNe(r) { + return Ci(fM(r.type) || r.type); + } + function fM(r) { + switch (r.kind) { + case 197: + return fM(r.type); + case 190: + if (r.elements.length === 1 && (r = r.elements[0], r.kind === 192 || r.kind === 203 && r.dotDotDotToken)) + return fM(r.type); + break; + case 189: + return r.elementType; + } + } + function Urt(r) { + const a = xn(r); + return a.resolvedType || (a.resolvedType = r.dotDotDotToken ? NNe(r) : Ru( + Ci(r.type), + /*isProperty*/ + !0, + !!r.questionToken + )); + } + function Ci(r) { + return vtt(ANe(r), r); + } + function ANe(r) { + switch (r.kind) { + case 133: + case 313: + case 314: + return Le; + case 159: + return yt; + case 154: + return at; + case 150: + return wt; + case 163: + return Zr; + case 136: + return Nt; + case 155: + return Jt; + case 116: + return _r; + case 157: + return ue; + case 106: + return Mt; + case 146: + return nr; + case 151: + return r.flags & 524288 && !fe ? Le : vr; + case 141: + return Pe; + case 198: + case 110: + return kpe(r); + case 202: + return Jrt(r); + case 184: + return c$(r); + case 183: + return r.assertsModifier ? _r : Nt; + case 234: + return c$(r); + case 187: + return B3e(r); + case 189: + case 190: + return Ytt(r); + case 191: + return trt(r); + case 193: + return urt(r); + case 194: + return yrt(r); + case 315: + return btt(r); + case 317: + return Ru(Ci(r.type)); + case 203: + return Urt(r); + case 197: + case 316: + case 310: + return Ci(r.type); + case 192: + return NNe(r); + case 319: + return o_t(r); + case 185: + case 186: + case 188: + case 323: + case 318: + case 324: + return PNe(r); + case 199: + return xrt(r); + case 200: + return xNe(r); + case 201: + return hpe(r); + case 195: + return Mrt(r); + case 196: + return Rrt(r); + case 204: + return krt(r); + case 206: + return DNe(r); + // This function assumes that an identifier, qualified name, or property access expression is a type expression + // Callers should first ensure this by calling `isPartOfTypeNode` + // TODO(rbuckton): These aren't valid TypeNodes, but we treat them as such because of `isPartOfTypeNode`, which returns `true` for things that aren't `TypeNode`s. + case 80: + case 167: + case 212: + const a = Pp(r); + return a ? bo(a) : qe; + default: + return qe; + } + } + function m$(r, a, l) { + if (r && r.length) + for (let f = 0; f < r.length; f++) { + const d = r[f], y = l(d, a); + if (d !== y) { + const x = f === 0 ? [] : r.slice(0, f); + for (x.push(y), f++; f < r.length; f++) + x.push(l(r[f], a)); + return x; + } + } + return r; + } + function e0(r, a) { + return m$(r, a, Mi); + } + function g$(r, a) { + return m$(r, a, FT); + } + function INe(r, a) { + return m$(r, a, ent); + } + function bf(r, a) { + return r.length === 1 ? M2(r[0], a ? a[0] : Le) : FNe(r, a); + } + function ny(r, a) { + switch (a.kind) { + case 0: + return r === a.source ? a.target : r; + case 1: { + const f = a.sources, d = a.targets; + for (let y = 0; y < f.length; y++) + if (r === f[y]) + return d ? d[y] : Le; + return r; + } + case 2: { + const f = a.sources, d = a.targets; + for (let y = 0; y < f.length; y++) + if (r === f[y]) + return d[y](); + return r; + } + case 3: + return a.func(r); + case 4: + case 5: + const l = ny(r, a.mapper1); + return l !== r && a.kind === 4 ? Mi(l, a.mapper2) : ny(l, a.mapper2); + } + } + function M2(r, a) { + return E.attachDebugPrototypeIfDebug({ kind: 0, source: r, target: a }); + } + function FNe(r, a) { + return E.attachDebugPrototypeIfDebug({ kind: 1, sources: r, targets: a }); + } + function pM(r, a) { + return E.attachDebugPrototypeIfDebug({ kind: 3, func: r, debugInfo: E.isDebugging ? a : void 0 }); + } + function Cpe(r, a) { + return E.attachDebugPrototypeIfDebug({ kind: 2, sources: r, targets: a }); + } + function h$(r, a, l) { + return E.attachDebugPrototypeIfDebug({ kind: r, mapper1: a, mapper2: l }); + } + function ONe(r) { + return bf( + r, + /*targets*/ + void 0 + ); + } + function Vrt(r, a) { + const l = r.inferences.slice(a); + return bf(hr(l, (f) => f.typeParameter), hr(l, () => yt)); + } + function qrt(r) { + return r.outerReturnMapper ?? (r.outerReturnMapper = LNe(r.returnMapper, dAe(r).mapper)); + } + function ib(r, a) { + return r ? h$(4, r, a) : a; + } + function LNe(r, a) { + return r ? h$(5, r, a) : a; + } + function IT(r, a, l) { + return l ? h$(5, M2(r, a), l) : M2(r, a); + } + function aI(r, a, l) { + return r ? h$(5, r, M2(a, l)) : M2(a, l); + } + function Hrt(r) { + return !r.constraint && !i$(r) || r.constraint === yc ? r : r.restrictiveInstantiation || (r.restrictiveInstantiation = p_(r.symbol), r.restrictiveInstantiation.constraint = yc, r.restrictiveInstantiation); + } + function Epe(r) { + const a = p_(r.symbol); + return a.target = r, a; + } + function MNe(r, a) { + return eI(r.kind, r.parameterName, r.parameterIndex, Mi(r.type, a)); + } + function FT(r, a, l) { + let f; + if (r.typeParameters && !l) { + f = hr(r.typeParameters, Epe), a = ib(bf(r.typeParameters, f), a); + for (const y of f) + y.mapper = a; + } + const d = Mm( + r.declaration, + f, + r.thisParameter && Dpe(r.thisParameter, a), + m$(r.parameters, a, Dpe), + /*resolvedReturnType*/ + void 0, + /*resolvedTypePredicate*/ + void 0, + r.minArgumentCount, + r.flags & 167 + /* PropagatingFlags */ + ); + return d.target = r, d.mapper = a, d; + } + function Dpe(r, a) { + const l = Pn(r); + if (l.type && !N1(l.type) && (!(r.flags & 65536) || l.writeType && !N1(l.writeType))) + return r; + uc(r) & 1 && (r = l.target, a = ib(l.mapper, a)); + const f = ga(r.flags, r.escapedName, 1 | uc(r) & 53256); + return f.declarations = r.declarations, f.parent = r.parent, f.links.target = r, f.links.mapper = a, r.valueDeclaration && (f.valueDeclaration = r.valueDeclaration), l.nameType && (f.links.nameType = l.nameType), f; + } + function Grt(r, a, l, f) { + const d = r.objectFlags & 4 || r.objectFlags & 8388608 ? r.node : r.symbol.declarations[0], y = xn(d), x = r.objectFlags & 4 ? y.resolvedType : r.objectFlags & 64 ? r.target : r; + let I = y.outerTypeParameters; + if (!I) { + let J = pi( + d, + /*includeThisTypes*/ + !0 + ); + if (zm(d)) { + const G = T3e(d); + J = In(J, G); + } + I = J || Ge; + const z = r.objectFlags & 8388612 ? [d] : r.symbol.declarations; + I = (x.objectFlags & 8388612 || x.symbol.flags & 8192 || x.symbol.flags & 2048) && !x.aliasTypeArguments ? kn(I, (G) => ot(z, (ve) => dM(G, ve))) : I, y.outerTypeParameters = I; + } + if (I.length) { + const J = ib(r.mapper, a), z = hr(I, (lt) => ny(lt, J)), G = l || r.aliasSymbol, ve = l ? f : e0(r.aliasTypeArguments, a), de = rd(z) + DT(G, ve); + x.instantiations || (x.instantiations = /* @__PURE__ */ new Map(), x.instantiations.set(rd(I) + DT(x.aliasSymbol, x.aliasTypeArguments), x)); + let We = x.instantiations.get(de); + if (!We) { + let lt = bf(I, z); + x.objectFlags & 134217728 && a && (lt = ib(lt, a)), We = x.objectFlags & 4 ? $fe(r.target, r.node, lt, G, ve) : x.objectFlags & 32 ? Xrt(x, lt, G, ve) : wpe(x, lt, G, ve), x.instantiations.set(de, We); + const gt = Dn(We); + if (We.flags & 3899393 && !(gt & 524288)) { + const jt = ot(z, N1); + Dn(We) & 524288 || (gt & 52 ? We.objectFlags |= 524288 | (jt ? 1048576 : 0) : We.objectFlags |= jt ? 0 : 524288); + } + } + return We; + } + return r; + } + function $rt(r) { + return !(r.parent.kind === 184 && r.parent.typeArguments && r === r.parent.typeName || r.parent.kind === 206 && r.parent.typeArguments && r === r.parent.qualifier); + } + function dM(r, a) { + if (r.symbol && r.symbol.declarations && r.symbol.declarations.length === 1) { + const f = r.symbol.declarations[0].parent; + for (let d = a; d !== f; d = d.parent) + if (!d || d.kind === 242 || d.kind === 195 && xs(d.extendsType, l)) + return !0; + return l(a); + } + return !0; + function l(f) { + switch (f.kind) { + case 198: + return !!r.isThisType; + case 80: + return !r.isThisType && lm(f) && $rt(f) && ANe(f) === r; + // use worker because we're looking for === equality + case 187: + const d = f.exprName, y = i_(d); + if (!Ry(y)) { + const x = ju(y), I = r.symbol.declarations[0], J = I.kind === 169 ? I.parent : ( + // Type parameter is a regular type parameter, e.g. foo + r.isThisType ? I : ( + // Type parameter is the this type, and its declaration is the class declaration. + void 0 + ) + ); + if (x.declarations && J) + return ot(x.declarations, (z) => Ob(z, J)) || ot(f.typeArguments, l); + } + return !0; + case 175: + case 174: + return !f.type && !!f.body || ot(f.typeParameters, l) || ot(f.parameters, l) || !!f.type && l(f.type); + } + return !!xs(f, l); + } + } + function oI(r) { + const a = $f(r); + if (a.flags & 4194304) { + const l = Kh(a.type); + if (l.flags & 262144) + return l; + } + } + function Xrt(r, a, l, f) { + const d = oI(r); + if (d) { + const x = Mi(d, a); + if (d !== x) + return BAe(td(x), y, l, f); + } + return Mi($f(r), a) === pt ? pt : wpe(r, a, l, f); + function y(x) { + if (x.flags & 61603843 && x !== pt && !Gr(x)) { + if (!r.declaration.nameType) { + let I; + if (Ep(x) || x.flags & 1 && X( + d, + 4 + /* ImmediateBaseConstraint */ + ) < 0 && (I = m_(d)) && G_(I, ab)) + return Yrt(x, r, IT(d, x, a)); + if (Sa(x)) + return Qrt(x, r, d, a); + if (g3e(x)) + return sa(hr(x.types, y)); + } + return wpe(r, IT(d, x, a)); + } + return x; + } + } + function RNe(r, a) { + return a & 1 ? !0 : a & 2 ? !1 : r; + } + function Qrt(r, a, l, f) { + const d = r.target.elementFlags, y = r.target.fixedLength, x = y ? IT(l, r, f) : f, I = hr(F2(r), (ve, de) => { + const We = d[de]; + return de < y ? jNe(a, H_("" + de), !!(We & 2), x) : We & 8 ? Mi(a, IT(l, ve, f)) : TM(Mi(a, IT(l, Tu(ve), f))) ?? yt; + }), J = mg(a), z = J & 4 ? hr(d, (ve) => ve & 1 ? 2 : ve) : J & 8 ? hr(d, (ve) => ve & 2 ? 1 : ve) : d, G = RNe(r.target.readonly, mg(a)); + return ms(I, qe) ? qe : hg(I, z, G, r.target.labeledElementDeclarations); + } + function Yrt(r, a, l) { + const f = jNe( + a, + wt, + /*isOptional*/ + !0, + l + ); + return Gr(f) ? qe : Tu(f, RNe(gP(r), mg(a))); + } + function jNe(r, a, l, f) { + const d = aI(f, Sd(r), a), y = Mi(sh(r.target || r), d), x = mg(r); + return K && x & 4 && !Dc( + y, + 49152 + /* Void */ + ) ? P1( + y, + /*isProperty*/ + !0 + ) : K && x & 8 && l ? Dp( + y, + 524288 + /* NEUndefined */ + ) : y; + } + function wpe(r, a, l, f) { + E.assert(r.symbol, "anonymous type must have symbol to be instantiated"); + const d = Wc(r.objectFlags & -1572865 | 64, r.symbol); + if (r.objectFlags & 32) { + d.declaration = r.declaration; + const y = Sd(r), x = Epe(y); + d.typeParameter = x, a = ib(M2(y, x), a), x.mapper = a; + } + return r.objectFlags & 8388608 && (d.node = r.node), d.target = r, d.mapper = a, d.aliasSymbol = l || r.aliasSymbol, d.aliasTypeArguments = l ? f : e0(r.aliasTypeArguments, a), d.objectFlags |= d.aliasTypeArguments ? nM(d.aliasTypeArguments) : 0, d; + } + function Ppe(r, a, l, f, d) { + const y = r.root; + if (y.outerTypeParameters) { + const x = hr(y.outerTypeParameters, (z) => ny(z, a)), I = (l ? "C" : "") + rd(x) + DT(f, d); + let J = y.instantiations.get(I); + if (!J) { + const z = bf(y.outerTypeParameters, x), G = y.checkType, ve = y.isDistributive ? td(ny(G, z)) : void 0; + J = ve && G !== ve && ve.flags & 1179648 ? BAe(ve, (de) => ype(y, IT(G, de, z), l), f, d) : ype(y, z, l, f, d), y.instantiations.set(I, J); + } + return J; + } + return r; + } + function Mi(r, a) { + return r && a ? BNe( + r, + a, + /*aliasSymbol*/ + void 0, + /*aliasTypeArguments*/ + void 0 + ) : r; + } + function BNe(r, a, l, f) { + var d; + if (!N1(r)) + return r; + if (S === 100 || h >= 5e6) + return (d = on) == null || d.instant(on.Phase.CheckTypes, "instantiateType_DepthLimit", { typeId: r.id, instantiationDepth: S, instantiationCount: h }), ze(k, p.Type_instantiation_is_excessively_deep_and_possibly_infinite), qe; + const y = Rst(a); + y === -1 && Lst(a); + const x = r.id + DT(l, f), I = Pv[y !== -1 ? y : og - 1], J = I.get(x); + if (J) + return J; + m++, h++, S++; + const z = Zrt(r, a, l, f); + return y === -1 ? Mst() : I.set(x, z), S--, z; + } + function Zrt(r, a, l, f) { + const d = r.flags; + if (d & 262144) + return ny(r, a); + if (d & 524288) { + const y = r.objectFlags; + if (y & 52) { + if (y & 4 && !r.node) { + const x = r.resolvedTypeArguments, I = e0(x, a); + return I !== x ? ope(r.target, I) : r; + } + return y & 1024 ? Krt(r, a) : Grt(r, a, l, f); + } + return r; + } + if (d & 3145728) { + const y = r.flags & 1048576 ? r.origin : void 0, x = y && y.flags & 3145728 ? y.types : r.types, I = e0(x, a); + if (I === x && l === r.aliasSymbol) + return r; + const J = l || r.aliasSymbol, z = l ? f : e0(r.aliasTypeArguments, a); + return d & 2097152 || y && y.flags & 2097152 ? sa(I, 0, J, z) : Xn(I, 1, J, z); + } + if (d & 4194304) + return jm(Mi(r.type, a)); + if (d & 134217728) + return wT(r.texts, e0(r.types, a)); + if (d & 268435456) + return rC(r.symbol, Mi(r.type, a)); + if (d & 8388608) { + const y = l || r.aliasSymbol, x = l ? f : e0(r.aliasTypeArguments, a); + return vf( + Mi(r.objectType, a), + Mi(r.indexType, a), + r.accessFlags, + /*accessNode*/ + void 0, + y, + x + ); + } + if (d & 16777216) + return Ppe( + r, + ib(r.mapper, a), + /*forConstraint*/ + !1, + l, + f + ); + if (d & 33554432) { + const y = Mi(r.baseType, a); + if (LE(r)) + return Xfe(y); + const x = Mi(r.constraint, a); + return y.flags & 8650752 && nb(x) ? Yfe(y, x) : x.flags & 3 || Ms(OT(y), OT(x)) ? y : y.flags & 8650752 ? Yfe(y, x) : sa([x, y]); + } + return r; + } + function Krt(r, a) { + const l = Mi(r.mappedType, a); + if (!(Dn(l) & 32)) + return r; + const f = Mi(r.constraintType, a); + if (!(f.flags & 4194304)) + return r; + const d = hAe( + Mi(r.source, a), + l, + f + ); + return d || r; + } + function cI(r) { + return r.flags & 402915327 ? r : r.permissiveInstantiation || (r.permissiveInstantiation = Mi(r, Zo)); + } + function OT(r) { + return r.flags & 402915327 ? r : (r.restrictiveInstantiation || (r.restrictiveInstantiation = Mi(r, pc), r.restrictiveInstantiation.restrictiveInstantiation = r.restrictiveInstantiation), r.restrictiveInstantiation); + } + function ent(r, a) { + return oh(r.keyType, Mi(r.type, a), r.isReadonly, r.declaration, r.components); + } + function Qf(r) { + switch (E.assert(r.kind !== 175 || Rp(r)), r.kind) { + case 219: + case 220: + case 175: + case 263: + return JNe(r); + case 211: + return ot(r.properties, Qf); + case 210: + return ot(r.elements, Qf); + case 228: + return Qf(r.whenTrue) || Qf(r.whenFalse); + case 227: + return (r.operatorToken.kind === 57 || r.operatorToken.kind === 61) && (Qf(r.left) || Qf(r.right)); + case 304: + return Qf(r.initializer); + case 218: + return Qf(r.expression); + case 293: + return ot(r.properties, Qf) || Id(r.parent) && ot(r.parent.parent.children, Qf); + case 292: { + const { initializer: a } = r; + return !!a && Qf(a); + } + case 295: { + const { expression: a } = r; + return !!a && Qf(a); + } + } + return !1; + } + function JNe(r) { + return aF(r) || tnt(r); + } + function tnt(r) { + return r.typeParameters || nf(r) || !r.body ? !1 : r.body.kind !== 242 ? Qf(r.body) : !!Fy(r.body, (a) => !!a.expression && Qf(a.expression)); + } + function y$(r) { + return (zy(r) || Rp(r)) && JNe(r); + } + function zNe(r) { + if (r.flags & 524288) { + const a = $d(r); + if (a.constructSignatures.length || a.callSignatures.length) { + const l = Wc(16, r.symbol); + return l.members = a.members, l.properties = a.properties, l.callSignatures = Ge, l.constructSignatures = Ge, l.indexInfos = Ge, l; + } + } else if (r.flags & 2097152) + return sa(hr(r.types, zNe)); + return r; + } + function lh(r, a) { + return Bm(r, a, vu); + } + function lI(r, a) { + return Bm(r, a, vu) ? -1 : 0; + } + function Npe(r, a) { + return Bm(r, a, yu) ? -1 : 0; + } + function rnt(r, a) { + return Bm(r, a, cg) ? -1 : 0; + } + function R2(r, a) { + return Bm(r, a, cg); + } + function mP(r, a) { + return Bm(r, a, Ro); + } + function Ms(r, a) { + return Bm(r, a, yu); + } + function sb(r, a) { + return r.flags & 1048576 ? Ni(r.types, (l) => sb(l, a)) : a.flags & 1048576 ? ot(a.types, (l) => sb(r, l)) : r.flags & 2097152 ? ot(r.types, (l) => sb(l, a)) : r.flags & 58982400 ? sb(ou(r) || yt, a) : yg(a) ? !!(r.flags & 67633152) : a === Ot ? !!(r.flags & 67633152) && !yg(r) : a === Mr ? !!(r.flags & 524288) && ude(r) : En(r, Cr(a)) || Ep(a) && !gP(a) && sb(r, ma); + } + function v$(r, a) { + return Bm(r, a, I_); + } + function mM(r, a) { + return v$(r, a) || v$(a, r); + } + function xu(r, a, l, f, d, y) { + return Cp(r, a, yu, l, f, d, y); + } + function j2(r, a, l, f, d, y) { + return Ape( + r, + a, + yu, + l, + f, + d, + y, + /*errorOutputContainer*/ + void 0 + ); + } + function Ape(r, a, l, f, d, y, x, I) { + return Bm(r, a, l) ? !0 : !f || !uI(d, r, a, l, y, x, I) ? Cp(r, a, l, f, y, x, I) : !1; + } + function WNe(r) { + return !!(r.flags & 16777216 || r.flags & 2097152 && ot(r.types, WNe)); + } + function uI(r, a, l, f, d, y, x) { + if (!r || WNe(l)) return !1; + if (!Cp( + a, + l, + f, + /*errorNode*/ + void 0 + ) && nnt(r, a, l, f, d, y, x)) + return !0; + switch (r.kind) { + case 235: + if (!HJ(r)) + break; + // fallthrough + case 295: + case 218: + return uI(r.expression, a, l, f, d, y, x); + case 227: + switch (r.operatorToken.kind) { + case 64: + case 28: + return uI(r.right, a, l, f, d, y, x); + } + break; + case 211: + return _nt(r, a, l, f, y, x); + case 210: + return lnt(r, a, l, f, y, x); + case 293: + return cnt(r, a, l, f, y, x); + case 220: + return int(r, a, l, f, y, x); + } + return !1; + } + function nnt(r, a, l, f, d, y, x) { + const I = Is( + a, + 0 + /* Call */ + ), J = Is( + a, + 1 + /* Construct */ + ); + for (const z of [J, I]) + if (ot(z, (G) => { + const ve = Wa(G); + return !(ve.flags & 131073) && Cp( + ve, + l, + f, + /*errorNode*/ + void 0 + ); + })) { + const G = x || {}; + xu(a, l, r, d, y, G); + const ve = G.errors[G.errors.length - 1]; + return zs( + ve, + sn( + r, + z === J ? p.Did_you_mean_to_use_new_with_this_expression : p.Did_you_mean_to_call_this_expression + ) + ), !0; + } + return !1; + } + function int(r, a, l, f, d, y) { + if (Ns(r.body) || ot(r.parameters, O7)) + return !1; + const x = UT(a); + if (!x) + return !1; + const I = Is( + l, + 0 + /* Call */ + ); + if (!wr(I)) + return !1; + const J = r.body, z = Wa(x), G = Xn(hr(I, Wa)); + if (!Cp( + z, + G, + f, + /*errorNode*/ + void 0 + )) { + const ve = J && uI( + J, + z, + G, + f, + /*headMessage*/ + void 0, + d, + y + ); + if (ve) + return ve; + const de = y || {}; + if (Cp( + z, + G, + f, + J, + /*headMessage*/ + void 0, + d, + de + ), de.errors) + return l.symbol && wr(l.symbol.declarations) && zs( + de.errors[de.errors.length - 1], + sn( + l.symbol.declarations[0], + p.The_expected_type_comes_from_the_return_type_of_this_signature + ) + ), (Mc(r) & 2) === 0 && !rr(z, "then") && Cp( + QM(z), + G, + f, + /*errorNode*/ + void 0 + ) && zs( + de.errors[de.errors.length - 1], + sn( + r, + p.Did_you_mean_to_mark_this_function_as_async + ) + ), !0; + } + return !1; + } + function UNe(r, a, l) { + const f = C1(a, l); + if (f) + return f; + if (a.flags & 1048576) { + const d = YNe(r, a); + if (d) + return C1(d, l); + } + } + function VNe(r, a) { + MM( + r, + a, + /*isCache*/ + !1 + ); + const l = EP( + r, + 1 + /* Contextual */ + ); + return SI(), l; + } + function gM(r, a, l, f, d, y) { + let x = !1; + for (const I of r) { + const { errorNode: J, innerExpression: z, nameType: G, errorMessage: ve } = I; + let de = UNe(a, l, G); + if (!de || de.flags & 8388608) continue; + let We = C1(a, G); + if (!We) continue; + const lt = _$( + G, + /*accessNode*/ + void 0 + ); + if (!Cp( + We, + de, + f, + /*errorNode*/ + void 0 + )) { + const gt = z && uI( + z, + We, + de, + f, + /*headMessage*/ + void 0, + d, + y + ); + if (x = !0, !gt) { + const jt = y || {}, ar = z ? VNe(z, We) : We; + if (be && S$(ar, de)) { + const jr = sn(J, p.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target, Wr(ar), Wr(de)); + Aa.add(jr), jt.errors = [jr]; + } else { + const jr = !!(lt && (Ys(l, lt) || Y).flags & 16777216), Kr = !!(lt && (Ys(a, lt) || Y).flags & 16777216); + de = i0(de, jr), We = i0(We, jr && Kr), Cp(ar, de, f, J, ve, d, jt) && ar !== We && Cp(We, de, f, J, ve, d, jt); + } + if (jt.errors) { + const jr = jt.errors[jt.errors.length - 1], Kr = _p(G) ? fp(G) : void 0, or = Kr !== void 0 ? Ys(l, Kr) : void 0; + let ir = !1; + if (!or) { + const nn = Z8(l, G); + nn && nn.declaration && !xr(nn.declaration).hasNoDefaultLib && (ir = !0, zs(jr, sn(nn.declaration, p.The_expected_type_comes_from_this_index_signature))); + } + if (!ir && (or && wr(or.declarations) || l.symbol && wr(l.symbol.declarations))) { + const nn = or && wr(or.declarations) ? or.declarations[0] : l.symbol.declarations[0]; + xr(nn).hasNoDefaultLib || zs( + jr, + sn( + nn, + p.The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1, + Kr && !(G.flags & 8192) ? Si(Kr) : Wr(G), + Wr(l) + ) + ); + } + } + } + } + } + return x; + } + function snt(r, a, l, f, d, y) { + const x = Xc(l, w$), I = Xc(l, (G) => !w$(G)), J = I !== nr ? Ime( + 13, + 0, + I, + /*errorNode*/ + void 0 + ) : void 0; + let z = !1; + for (let G = r.next(); !G.done; G = r.next()) { + const { errorNode: ve, innerExpression: de, nameType: We, errorMessage: lt } = G.value; + let gt = J; + const jt = x !== nr ? UNe(a, x, We) : void 0; + if (jt && !(jt.flags & 8388608) && (gt = J ? Xn([J, jt]) : jt), !gt) continue; + let ar = C1(a, We); + if (!ar) continue; + const jr = _$( + We, + /*accessNode*/ + void 0 + ); + if (!Cp( + ar, + gt, + f, + /*errorNode*/ + void 0 + )) { + const Kr = de && uI( + de, + ar, + gt, + f, + /*headMessage*/ + void 0, + d, + y + ); + if (z = !0, !Kr) { + const or = y || {}, ir = de ? VNe(de, ar) : ar; + if (be && S$(ir, gt)) { + const nn = sn(ve, p.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target, Wr(ir), Wr(gt)); + Aa.add(nn), or.errors = [nn]; + } else { + const nn = !!(jr && (Ys(x, jr) || Y).flags & 16777216), Qn = !!(jr && (Ys(a, jr) || Y).flags & 16777216); + gt = i0(gt, nn), ar = i0(ar, nn && Qn), Cp(ir, gt, f, ve, lt, d, or) && ir !== ar && Cp(ar, gt, f, ve, lt, d, or); + } + } + } + } + return z; + } + function* ant(r) { + if (wr(r.properties)) + for (const a of r.properties) + Qx(a) || Fde(DN(a.name)) || (yield { errorNode: a.name, innerExpression: a.initializer, nameType: H_(DN(a.name)) }); + } + function* ont(r, a) { + if (!wr(r.children)) return; + let l = 0; + for (let f = 0; f < r.children.length; f++) { + const d = r.children[f], y = Xd(f - l), x = qNe(d, y, a); + x ? yield x : l++; + } + } + function qNe(r, a, l) { + switch (r.kind) { + case 295: + return { errorNode: r, innerExpression: r.expression, nameType: a }; + case 12: + if (r.containsOnlyTriviaWhiteSpaces) + break; + return { errorNode: r, innerExpression: void 0, nameType: a, errorMessage: l() }; + case 285: + case 286: + case 289: + return { errorNode: r, innerExpression: r, nameType: a }; + default: + return E.assertNever(r, "Found invalid jsx child"); + } + } + function cnt(r, a, l, f, d, y) { + let x = gM(ant(r), a, l, f, d, y), I; + if (Id(r.parent) && Sm(r.parent.parent)) { + const z = r.parent.parent, G = jM(zT(r)), ve = G === void 0 ? "children" : Si(G), de = H_(ve), We = vf(l, de), lt = QC(z.children); + if (!wr(lt)) + return x; + const gt = wr(lt) > 1; + let jt, ar; + if (u$( + /*reportErrors*/ + !1 + ) !== zt) { + const Kr = K3e(Le); + jt = Xc(We, (or) => Ms(or, Kr)), ar = Xc(We, (or) => !Ms(or, Kr)); + } else + jt = Xc(We, w$), ar = Xc(We, (Kr) => !w$(Kr)); + if (gt) { + if (jt !== nr) { + const Kr = hg(rX( + z, + 0 + /* Normal */ + )), or = ont(z, J); + x = snt(or, Kr, jt, f, d, y) || x; + } else if (!Bm(vf(a, de), We, f)) { + x = !0; + const Kr = ze( + z.openingElement.tagName, + p.This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided, + ve, + Wr(We) + ); + y && y.skipLogging && (y.errors || (y.errors = [])).push(Kr); + } + } else if (ar !== nr) { + const Kr = lt[0], or = qNe(Kr, de, J); + or && (x = gM( + function* () { + yield or; + }(), + a, + l, + f, + d, + y + ) || x); + } else if (!Bm(vf(a, de), We, f)) { + x = !0; + const Kr = ze( + z.openingElement.tagName, + p.This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided, + ve, + Wr(We) + ); + y && y.skipLogging && (y.errors || (y.errors = [])).push(Kr); + } + } + return x; + function J() { + if (!I) { + const z = Qo(r.parent.tagName), G = jM(zT(r)), ve = G === void 0 ? "children" : Si(G), de = vf(l, H_(ve)), We = p._0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2; + I = { ...We, key: "!!ALREADY FORMATTED!!", message: Nx(We, z, ve, Wr(de)) }; + } + return I; + } + } + function* HNe(r, a) { + const l = wr(r.elements); + if (l) + for (let f = 0; f < l; f++) { + if (hP(a) && !Ys(a, "" + f)) continue; + const d = r.elements[f]; + if (vl(d)) continue; + const y = Xd(f), x = _X(d); + yield { errorNode: x, innerExpression: x, nameType: y }; + } + } + function lnt(r, a, l, f, d, y) { + if (l.flags & 402915324) return !1; + if (hP(a)) + return gM(HNe(r, l), a, l, f, d, y); + MM( + r, + l, + /*isCache*/ + !1 + ); + const x = k8e( + r, + 1, + /*forceTuple*/ + !0 + ); + return SI(), hP(x) ? gM(HNe(r, l), x, l, f, d, y) : !1; + } + function* unt(r) { + if (wr(r.properties)) + for (const a of r.properties) { + if (Vg(a)) continue; + const l = tC( + yn(a), + 8576 + /* StringOrNumberLiteralOrUnique */ + ); + if (!(!l || l.flags & 131072)) + switch (a.kind) { + case 179: + case 178: + case 175: + case 305: + yield { errorNode: a.name, innerExpression: void 0, nameType: l }; + break; + case 304: + yield { errorNode: a.name, innerExpression: a.initializer, nameType: l, errorMessage: x3(a.name) ? p.Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1 : void 0 }; + break; + default: + E.assertNever(a); + } + } + } + function _nt(r, a, l, f, d, y) { + return l.flags & 402915324 ? !1 : gM(unt(r), a, l, f, d, y); + } + function GNe(r, a, l, f, d) { + return Cp(r, a, I_, l, f, d); + } + function fnt(r, a, l) { + return Ipe( + r, + a, + 4, + /*reportErrors*/ + !1, + /*errorReporter*/ + void 0, + /*incompatibleErrorReporter*/ + void 0, + Npe, + /*reportUnreliableMarkers*/ + void 0 + ) !== 0; + } + function b$(r) { + if (!r.typeParameters && (!r.thisParameter || gn(GM(r.thisParameter))) && r.parameters.length === 1 && Iu(r)) { + const a = GM(r.parameters[0]); + return !!((Ep(a) ? Ao(a)[0] : a).flags & 131073 && Wa(r).flags & 3); + } + return !1; + } + function Ipe(r, a, l, f, d, y, x, I) { + if (r === a || !(l & 16 && b$(r)) && b$(a)) + return -1; + if (l & 16 && b$(r) && !b$(a)) + return 0; + const J = $_(a); + if (!vg(a) && (l & 8 ? vg(r) || $_(r) > J : em(r) > J)) + return f && !(l & 8) && d(p.Target_signature_provides_too_few_arguments_Expected_0_or_more_but_got_1, em(r), J), 0; + r.typeParameters && r.typeParameters !== a.typeParameters && (a = ptt(a), r = nIe( + r, + a, + /*inferenceContext*/ + void 0, + x + )); + const G = $_(r), ve = PI(r), de = PI(a); + (ve || de) && Mi(ve || de, I); + const We = a.declaration ? a.declaration.kind : 0, lt = !(l & 3) && V && We !== 175 && We !== 174 && We !== 177; + let gt = -1; + const jt = tb(r); + if (jt && jt !== _r) { + const Kr = tb(a); + if (Kr) { + const or = !lt && x( + jt, + Kr, + /*reportErrors*/ + !1 + ) || x(Kr, jt, f); + if (!or) + return f && d(p.The_this_types_of_each_signature_are_incompatible), 0; + gt &= or; + } + } + const ar = ve || de ? Math.min(G, J) : Math.max(G, J), jr = ve || de ? ar - 1 : -1; + for (let Kr = 0; Kr < ar; Kr++) { + const or = Kr === jr ? wIe(r, Kr) : W2(r, Kr), ir = Kr === jr ? wIe(a, Kr) : W2(a, Kr); + if (or && ir && (or !== ir || l & 8)) { + const nn = l & 3 || tIe(r, Kr) ? void 0 : UT(n0(or)), Qn = l & 3 || tIe(a, Kr) ? void 0 : UT(n0(ir)); + let zn = nn && Qn && !kp(nn) && !kp(Qn) && BE( + or, + 50331648 + /* IsUndefinedOrNull */ + ) === BE( + ir, + 50331648 + /* IsUndefinedOrNull */ + ) ? Ipe(Qn, nn, l & 8 | (lt ? 2 : 1), f, d, y, x, I) : !(l & 3) && !lt && x( + or, + ir, + /*reportErrors*/ + !1 + ) || x(ir, or, f); + if (zn && l & 8 && Kr >= em(r) && Kr < em(a) && x( + or, + ir, + /*reportErrors*/ + !1 + ) && (zn = 0), !zn) + return f && d(p.Types_of_parameters_0_and_1_are_incompatible, Si(xP(r, Kr)), Si(xP(a, Kr))), 0; + gt &= zn; + } + } + if (!(l & 4)) { + const Kr = ZG(a) ? Le : a.declaration && zm(a.declaration) ? xp(Oa(a.declaration.symbol)) : Wa(a); + if (Kr === _r || Kr === Le) + return gt; + const or = ZG(r) ? Le : r.declaration && zm(r.declaration) ? xp(Oa(r.declaration.symbol)) : Wa(r), ir = kp(a); + if (ir) { + const nn = kp(r); + if (nn) + gt &= pnt(nn, ir, f, d, x); + else if (yK(ir) || vK(ir)) + return f && d(p.Signature_0_must_be_a_type_predicate, b1(r)), 0; + } else + gt &= l & 1 && x( + Kr, + or, + /*reportErrors*/ + !1 + ) || x(or, Kr, f), !gt && f && y && y(or, Kr); + } + return gt; + } + function pnt(r, a, l, f, d) { + if (r.kind !== a.kind) + return l && (f(p.A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard), f(p.Type_predicate_0_is_not_assignable_to_1, _g(r), _g(a))), 0; + if ((r.kind === 1 || r.kind === 3) && r.parameterIndex !== a.parameterIndex) + return l && (f(p.Parameter_0_is_not_in_the_same_position_as_parameter_1, r.parameterName, a.parameterName), f(p.Type_predicate_0_is_not_assignable_to_1, _g(r), _g(a))), 0; + const y = r.type === a.type ? -1 : r.type && a.type ? d(r.type, a.type, l) : 0; + return y === 0 && l && f(p.Type_predicate_0_is_not_assignable_to_1, _g(r), _g(a)), y; + } + function dnt(r, a) { + const l = rI(r), f = rI(a), d = Wa(l), y = Wa(f); + return y === _r || Bm(y, d, yu) || Bm(d, y, yu) ? fnt( + l, + f + ) : !1; + } + function Fpe(r) { + return r !== Za && r.properties.length === 0 && r.callSignatures.length === 0 && r.constructSignatures.length === 0 && r.indexInfos.length === 0; + } + function t0(r) { + return r.flags & 524288 ? !L_(r) && Fpe($d(r)) : r.flags & 67108864 ? !0 : r.flags & 1048576 ? ot(r.types, t0) : r.flags & 2097152 ? Ni(r.types, t0) : !1; + } + function yg(r) { + return !!(Dn(r) & 16 && (r.members && Fpe(r) || r.symbol && r.symbol.flags & 2048 && dg(r.symbol).size === 0)); + } + function mnt(r) { + if (K && r.flags & 1048576) { + if (!(r.objectFlags & 33554432)) { + const a = r.types; + r.objectFlags |= 33554432 | (a.length >= 3 && a[0].flags & 32768 && a[1].flags & 65536 && ot(a, yg) ? 67108864 : 0); + } + return !!(r.objectFlags & 67108864); + } + return !1; + } + function jE(r) { + return !!((r.flags & 1048576 ? r.types[0] : r).flags & 32768); + } + function gnt(r) { + const a = r.flags & 1048576 ? r.types[0] : r; + return !!(a.flags & 32768) && a !== ye; + } + function $Ne(r) { + return r.flags & 524288 && !L_(r) && $a(r).length === 0 && Su(r).length === 1 && !!ah(r, at) || r.flags & 3145728 && Ni(r.types, $Ne) || !1; + } + function Ope(r, a, l) { + const f = r.flags & 8 ? Tl(r) : r, d = a.flags & 8 ? Tl(a) : a; + if (f === d) + return !0; + if (f.escapedName !== d.escapedName || !(f.flags & 256) || !(d.flags & 256)) + return !1; + const y = Xs(f) + "," + Xs(d), x = Ov.get(y); + if (x !== void 0 && !(x & 2 && l)) + return !!(x & 1); + const I = Yr(d); + for (const J of $a(Yr(f))) + if (J.flags & 8) { + const z = Ys(I, J.escapedName); + if (!z || !(z.flags & 8)) + return l && l(p.Property_0_is_missing_in_type_1, cc(J), Wr( + bo(d), + /*enclosingDeclaration*/ + void 0, + 64 + /* UseFullyQualifiedType */ + )), Ov.set( + y, + 2 + /* Failed */ + ), !1; + const G = qT(Oo( + J, + 307 + /* EnumMember */ + )).value, ve = qT(Oo( + z, + 307 + /* EnumMember */ + )).value; + if (G !== ve) { + const de = typeof G == "string", We = typeof ve == "string"; + if (G !== void 0 && ve !== void 0) { + if (l) { + const lt = de ? `"${Ym(G)}"` : G, gt = We ? `"${Ym(ve)}"` : ve; + l(p.Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given, cc(d), cc(z), gt, lt); + } + return Ov.set( + y, + 2 + /* Failed */ + ), !1; + } + if (de || We) { + if (l) { + const lt = G ?? ve; + E.assert(typeof lt == "string"); + const gt = `"${Ym(lt)}"`; + l(p.One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value, cc(d), cc(z), gt); + } + return Ov.set( + y, + 2 + /* Failed */ + ), !1; + } + } + } + return Ov.set( + y, + 1 + /* Succeeded */ + ), !0; + } + function _I(r, a, l, f) { + const d = r.flags, y = a.flags; + return y & 1 || d & 131072 || r === pt || y & 2 && !(l === Ro && d & 1) ? !0 : y & 131072 ? !1 : !!(d & 402653316 && y & 4 || d & 128 && d & 1024 && y & 128 && !(y & 1024) && r.value === a.value || d & 296 && y & 8 || d & 256 && d & 1024 && y & 256 && !(y & 1024) && r.value === a.value || d & 2112 && y & 64 || d & 528 && y & 16 || d & 12288 && y & 4096 || d & 32 && y & 32 && r.symbol.escapedName === a.symbol.escapedName && Ope(r.symbol, a.symbol, f) || d & 1024 && y & 1024 && (d & 1048576 && y & 1048576 && Ope(r.symbol, a.symbol, f) || d & 2944 && y & 2944 && r.value === a.value && Ope(r.symbol, a.symbol, f)) || d & 32768 && (!K && !(y & 3145728) || y & 49152) || d & 65536 && (!K && !(y & 3145728) || y & 65536) || d & 524288 && y & 67108864 && !(l === Ro && yg(r) && !(Dn(r) & 8192)) || (l === yu || l === I_) && (d & 1 || d & 8 && (y & 32 || y & 256 && y & 1024) || d & 256 && !(d & 1024) && (y & 32 || y & 256 && y & 1024 && r.value === a.value) || mnt(a))); + } + function Bm(r, a, l) { + if (L2(r) && (r = r.regularType), L2(a) && (a = a.regularType), r === a) + return !0; + if (l !== vu) { + if (l === I_ && !(a.flags & 131072) && _I(a, r, l) || _I(r, a, l)) + return !0; + } else if (!((r.flags | a.flags) & 61865984)) { + if (r.flags !== a.flags) return !1; + if (r.flags & 67358815) return !0; + } + if (r.flags & 524288 && a.flags & 524288) { + const f = l.get(k$( + r, + a, + 0, + l, + /*ignoreConstraints*/ + !1 + )); + if (f !== void 0) + return !!(f & 1); + } + return r.flags & 469499904 || a.flags & 469499904 ? Cp( + r, + a, + l, + /*errorNode*/ + void 0 + ) : !1; + } + function XNe(r, a) { + return Dn(r) & 2048 && Fde(a.escapedName); + } + function hM(r, a) { + for (; ; ) { + const l = L2(r) ? r.regularType : w1(r) ? vnt(r, a) : Dn(r) & 4 ? r.node ? Qh(r.target, Ao(r)) : Wpe(r) || r : r.flags & 3145728 ? hnt(r, a) : r.flags & 33554432 ? a ? r.baseType : Zfe(r) : r.flags & 25165824 ? Zh(r, a) : r; + if (l === r) return l; + r = l; + } + } + function hnt(r, a) { + const l = td(r); + if (l !== r) + return l; + if (r.flags & 2097152 && ynt(r)) { + const f = Qc(r.types, (d) => hM(d, a)); + if (f !== r.types) + return sa(f); + } + return r; + } + function ynt(r) { + let a = !1, l = !1; + for (const f of r.types) + if (a || (a = !!(f.flags & 465829888)), l || (l = !!(f.flags & 98304) || yg(f)), a && l) return !0; + return !1; + } + function vnt(r, a) { + const l = F2(r), f = Qc(l, (d) => d.flags & 25165824 ? Zh(d, a) : d); + return l !== f ? cpe(r.target, f) : r; + } + function Cp(r, a, l, f, d, y, x) { + var I; + let J, z, G, ve, de, We, lt = 0, gt = 0, jt = 0, ar = 0, jr = !1, Kr = 0, or = 0, ir, nn, Qn = 16e6 - l.size >> 3; + E.assert(l !== vu || !f, "no error reporting in identity checking"); + const Ri = en( + r, + a, + 3, + /*reportErrors*/ + !!f, + d + ); + if (nn && Ua(), jr) { + const xe = k$( + r, + a, + /*intersectionState*/ + 0, + l, + /*ignoreConstraints*/ + !1 + ); + l.set(xe, 2 | (Qn <= 0 ? 32 : 64)), (I = on) == null || I.instant(on.Phase.CheckTypes, "checkTypeRelatedTo_DepthLimit", { sourceId: r.id, targetId: a.id, depth: gt, targetDepth: jt }); + const Re = Qn <= 0 ? p.Excessive_complexity_comparing_types_0_and_1 : p.Excessive_stack_depth_comparing_types_0_and_1, Ze = ze(f || k, Re, Wr(r), Wr(a)); + x && (x.errors || (x.errors = [])).push(Ze); + } else if (J) { + if (y) { + const Ze = y(); + Ze && (xee(Ze, J), J = Ze); + } + let xe; + if (d && f && !Ri && r.symbol) { + const Ze = Pn(r.symbol); + if (Ze.originatingImport && !T_(Ze.originatingImport) && Cp( + Yr(Ze.target), + a, + l, + /*errorNode*/ + void 0 + )) { + const $t = sn(Ze.originatingImport, p.Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead); + xe = Er(xe, $t); + } + } + const Re = Fg(xr(f), f, J, xe); + z && zs(Re, ...z), x && (x.errors || (x.errors = [])).push(Re), (!x || !x.skipLogging) && Aa.add(Re); + } + return f && x && x.skipLogging && Ri === 0 && E.assert(!!x.errors, "missed opportunity to interact with error."), Ri !== 0; + function zn(xe) { + J = xe.errorInfo, ir = xe.lastSkippedInfo, nn = xe.incompatibleStack, Kr = xe.overrideNextErrorInfo, or = xe.skipParentCounter, z = xe.relatedInfo; + } + function bi() { + return { + errorInfo: J, + lastSkippedInfo: ir, + incompatibleStack: nn?.slice(), + overrideNextErrorInfo: Kr, + skipParentCounter: or, + relatedInfo: z?.slice() + }; + } + function ks(xe, ...Re) { + Kr++, ir = void 0, (nn || (nn = [])).push([xe, ...Re]); + } + function Ua() { + const xe = nn || []; + nn = void 0; + const Re = ir; + if (ir = void 0, xe.length === 1) { + Vi(...xe[0]), Re && Bu( + /*message*/ + void 0, + ...Re + ); + return; + } + let Ze = ""; + const Pt = []; + for (; xe.length; ) { + const [$t, ...At] = xe.pop(); + switch ($t.code) { + case p.Types_of_property_0_are_incompatible.code: { + Ze.indexOf("new ") === 0 && (Ze = `(${Ze})`); + const Yt = "" + At[0]; + Ze.length === 0 ? Ze = `${Yt}` : R_(Yt, da(F)) ? Ze = `${Ze}.${Yt}` : Yt[0] === "[" && Yt[Yt.length - 1] === "]" ? Ze = `${Ze}${Yt}` : Ze = `${Ze}[${Yt}]`; + break; + } + case p.Call_signature_return_types_0_and_1_are_incompatible.code: + case p.Construct_signature_return_types_0_and_1_are_incompatible.code: + case p.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code: + case p.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code: { + if (Ze.length === 0) { + let Yt = $t; + $t.code === p.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code ? Yt = p.Call_signature_return_types_0_and_1_are_incompatible : $t.code === p.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code && (Yt = p.Construct_signature_return_types_0_and_1_are_incompatible), Pt.unshift([Yt, At[0], At[1]]); + } else { + const Yt = $t.code === p.Construct_signature_return_types_0_and_1_are_incompatible.code || $t.code === p.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code ? "new " : "", Lr = $t.code === p.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code || $t.code === p.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code ? "" : "..."; + Ze = `${Yt}${Ze}(${Lr})`; + } + break; + } + case p.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target.code: { + Pt.unshift([p.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target, At[0], At[1]]); + break; + } + case p.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target.code: { + Pt.unshift([p.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target, At[0], At[1], At[2]]); + break; + } + default: + return E.fail(`Unhandled Diagnostic: ${$t.code}`); + } + } + Ze ? Vi( + Ze[Ze.length - 1] === ")" ? p.The_types_returned_by_0_are_incompatible_between_these_types : p.The_types_of_0_are_incompatible_between_these_types, + Ze + ) : Pt.shift(); + for (const [$t, ...At] of Pt) { + const Yt = $t.elidedInCompatabilityPyramid; + $t.elidedInCompatabilityPyramid = !1, Vi($t, ...At), $t.elidedInCompatabilityPyramid = Yt; + } + Re && Bu( + /*message*/ + void 0, + ...Re + ); + } + function Vi(xe, ...Re) { + E.assert(!!f), nn && Ua(), !xe.elidedInCompatabilityPyramid && (or === 0 ? J = Ts(J, xe, ...Re) : or--); + } + function jo(xe, ...Re) { + Vi(xe, ...Re), or++; + } + function Sc(xe) { + E.assert(!!J), z ? z.push(xe) : z = [xe]; + } + function Bu(xe, Re, Ze) { + nn && Ua(); + const [Pt, $t] = Kw(Re, Ze); + let At = Re, Yt = Pt; + if (!(Ze.flags & 131072) && fI(Re) && !Lpe(Ze) && (At = r0(Re), E.assert(!Ms(At, Ze), "generalized source shouldn't be assignable"), Yt = kE(At)), (Ze.flags & 8388608 && !(Re.flags & 8388608) ? Ze.objectType.flags : Ze.flags) & 262144 && Ze !== tt && Ze !== Ft) { + const $r = ou(Ze); + let Sn; + $r && (Ms(At, $r) || (Sn = Ms(Re, $r))) ? Vi( + p._0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2, + Sn ? Pt : Yt, + $t, + Wr($r) + ) : (J = void 0, Vi( + p._0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1, + $t, + Yt + )); + } + if (xe) + xe === p.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1 && be && QNe(Re, Ze).length && (xe = p.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties); + else if (l === I_) + xe = p.Type_0_is_not_comparable_to_type_1; + else if (Pt === $t) + xe = p.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated; + else if (be && QNe(Re, Ze).length) + xe = p.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties; + else { + if (Re.flags & 128 && Ze.flags & 1048576) { + const $r = Rat(Re, Ze); + if ($r) { + Vi(p.Type_0_is_not_assignable_to_type_1_Did_you_mean_2, Yt, $t, Wr($r)); + return; + } + } + xe = p.Type_0_is_not_assignable_to_type_1; + } + Vi(xe, Yt, $t); + } + function Dr(xe, Re) { + const Ze = CE(xe.symbol) ? Wr(xe, xe.symbol.valueDeclaration) : Wr(xe), Pt = CE(Re.symbol) ? Wr(Re, Re.symbol.valueDeclaration) : Wr(Re); + (il === xe && at === Re || Po === xe && wt === Re || sc === xe && Nt === Re || H3e() === xe && Jt === Re) && Vi(p._0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible, Pt, Ze); + } + function Br(xe, Re, Ze) { + return Sa(xe) ? xe.target.readonly && SM(Re) ? (Ze && Vi(p.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1, Wr(xe), Wr(Re)), !1) : ab(Re) : gP(xe) && SM(Re) ? (Ze && Vi(p.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1, Wr(xe), Wr(Re)), !1) : Sa(Re) ? Ep(xe) : !0; + } + function xi(xe, Re, Ze) { + return en(xe, Re, 3, Ze); + } + function en(xe, Re, Ze = 3, Pt = !1, $t, At = 0) { + if (xe === Re) return -1; + if (xe.flags & 524288 && Re.flags & 402784252) + return l === I_ && !(Re.flags & 131072) && _I(Re, xe, l) || _I(xe, Re, l, Pt ? Vi : void 0) ? -1 : (Pt && us(xe, Re, xe, Re, $t), 0); + const Yt = hM( + xe, + /*writing*/ + !1 + ); + let Lr = hM( + Re, + /*writing*/ + !0 + ); + if (Yt === Lr) return -1; + if (l === vu) + return Yt.flags !== Lr.flags ? 0 : Yt.flags & 67358815 ? -1 : (Ga(Yt, Lr), VI( + Yt, + Lr, + /*reportErrors*/ + !1, + 0, + Ze + )); + if (Yt.flags & 262144 && kT(Yt) === Lr) + return -1; + if (Yt.flags & 470302716 && Lr.flags & 1048576) { + const $r = Lr.types, Sn = $r.length === 2 && $r[0].flags & 98304 ? $r[1] : $r.length === 3 && $r[0].flags & 98304 && $r[1].flags & 98304 ? $r[2] : void 0; + if (Sn && !(Sn.flags & 98304) && (Lr = hM( + Sn, + /*writing*/ + !0 + ), Yt === Lr)) + return -1; + } + if (l === I_ && !(Lr.flags & 131072) && _I(Lr, Yt, l) || _I(Yt, Lr, l, Pt ? Vi : void 0)) return -1; + if (Yt.flags & 469499904 || Lr.flags & 469499904) { + if (!(At & 2) && sy(Yt) && Dn(Yt) & 8192 && Jl(Yt, Lr, Pt)) + return Pt && Bu($t, Yt, Re.aliasSymbol ? Re : Lr), 0; + const Sn = (l !== I_ || Qd(Yt)) && !(At & 2) && Yt.flags & 405405692 && Yt !== Ot && Lr.flags & 2621440 && Rpe(Lr) && ($a(Yt).length > 0 || BX(Yt)), qn = !!(Dn(Yt) & 2048); + if (Sn && !Snt(Yt, Lr, qn)) { + if (Pt) { + const ci = Wr(xe.aliasSymbol ? xe : Yt), qi = Wr(Re.aliasSymbol ? Re : Lr), Pa = Is( + Yt, + 0 + /* Call */ + ), sr = Is( + Yt, + 1 + /* Construct */ + ); + Pa.length > 0 && en( + Wa(Pa[0]), + Lr, + 1, + /*reportErrors*/ + !1 + ) || sr.length > 0 && en( + Wa(sr[0]), + Lr, + 1, + /*reportErrors*/ + !1 + ) ? Vi(p.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it, ci, qi) : Vi(p.Type_0_has_no_properties_in_common_with_type_1, ci, qi); + } + return 0; + } + Ga(Yt, Lr); + const Ur = Yt.flags & 1048576 && Yt.types.length < 4 && !(Lr.flags & 1048576) || Lr.flags & 1048576 && Lr.types.length < 4 && !(Yt.flags & 469499904) ? Oc(Yt, Lr, Pt, At) : VI(Yt, Lr, Pt, At, Ze); + if (Ur) + return Ur; + } + return Pt && us(xe, Re, Yt, Lr, $t), 0; + } + function us(xe, Re, Ze, Pt, $t) { + var At, Yt; + const Lr = !!Wpe(xe), $r = !!Wpe(Re); + Ze = xe.aliasSymbol || Lr ? xe : Ze, Pt = Re.aliasSymbol || $r ? Re : Pt; + let Sn = Kr > 0; + if (Sn && Kr--, Ze.flags & 524288 && Pt.flags & 524288) { + const qn = J; + Br( + Ze, + Pt, + /*reportErrors*/ + !0 + ), J !== qn && (Sn = !!J); + } + if (Ze.flags & 524288 && Pt.flags & 402784252) + Dr(Ze, Pt); + else if (Ze.symbol && Ze.flags & 524288 && Ot === Ze) + Vi(p.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead); + else if (Dn(Ze) & 2048 && Pt.flags & 2097152) { + const qn = Pt.types, Yn = z2(Rf.IntrinsicAttributes, f), Ur = z2(Rf.IntrinsicClassAttributes, f); + if (!Gr(Yn) && !Gr(Ur) && (ms(qn, Yn) || ms(qn, Ur))) + return; + } else + J = zfe(J, Re); + if (!$t && Sn) { + const qn = bi(); + Bu($t, Ze, Pt); + let Yn; + J && J !== qn.errorInfo && (Yn = { code: J.code, messageText: J.messageText }), zn(qn), Yn && J && (J.canonicalHead = Yn), ir = [Ze, Pt]; + return; + } + if (Bu($t, Ze, Pt), Ze.flags & 262144 && ((Yt = (At = Ze.symbol) == null ? void 0 : At.declarations) != null && Yt[0]) && !kT(Ze)) { + const qn = Epe(Ze); + if (qn.constraint = Mi(Pt, M2(Ze, qn)), eM(qn)) { + const Yn = Wr(Pt, Ze.symbol.declarations[0]); + Sc(sn(Ze.symbol.declarations[0], p.This_type_parameter_might_need_an_extends_0_constraint, Yn)); + } + } + } + function Ga(xe, Re) { + if (on && xe.flags & 3145728 && Re.flags & 3145728) { + const Ze = xe, Pt = Re; + if (Ze.objectFlags & Pt.objectFlags & 32768) + return; + const $t = Ze.types.length, At = Pt.types.length; + $t * At > 1e6 && on.instant(on.Phase.CheckTypes, "traceUnionsOrIntersectionsTooLarge_DepthLimit", { + sourceId: xe.id, + sourceSize: $t, + targetId: Re.id, + targetSize: At, + pos: f?.pos, + end: f?.end + }); + } + } + function Io(xe, Re) { + return Xn(Wu( + xe, + (Pt, $t) => { + var At; + $t = e_($t); + const Yt = $t.flags & 3145728 ? tM($t, Re) : N2($t, Re), Lr = Yt && Yr(Yt) || ((At = eC($t, Re)) == null ? void 0 : At.type) || ue; + return Er(Pt, Lr); + }, + /*initial*/ + void 0 + ) || Ge); + } + function Jl(xe, Re, Ze) { + var Pt; + if (!kI(Re) || !fe && Dn(Re) & 4096) + return !1; + const $t = !!(Dn(xe) & 2048); + if ((l === yu || l === I_) && (bP(Ot, Re) || !$t && t0(Re))) + return !1; + let At = Re, Yt; + Re.flags & 1048576 && (At = E5e(xe, Re, en) || Gft(Re), Yt = At.flags & 1048576 ? At.types : [At]); + for (const Lr of $a(xe)) + if (Ta(Lr, xe.symbol) && !XNe(xe, Lr)) { + if (!sX(At, Lr.escapedName, $t)) { + if (Ze) { + const $r = Xc(At, kI); + if (!f) return E.fail(); + if (Yb(f) || wu(f) || wu(f.parent)) { + Lr.valueDeclaration && Tm(Lr.valueDeclaration) && xr(f) === xr(Lr.valueDeclaration.name) && (f = Lr.valueDeclaration.name); + const Sn = Wi(Lr), qn = G8e(Sn, $r), Yn = qn ? Wi(qn) : void 0; + Yn ? Vi(p.Property_0_does_not_exist_on_type_1_Did_you_mean_2, Sn, Wr($r), Yn) : Vi(p.Property_0_does_not_exist_on_type_1, Sn, Wr($r)); + } else { + const Sn = ((Pt = xe.symbol) == null ? void 0 : Pt.declarations) && Yc(xe.symbol.declarations); + let qn; + if (Lr.valueDeclaration && dr(Lr.valueDeclaration, (Yn) => Yn === Sn) && xr(Sn) === xr(f)) { + const Yn = Lr.valueDeclaration; + E.assertNode(Yn, vh); + const Ur = Yn.name; + f = Ur, Me(Ur) && (qn = $8e(Ur, $r)); + } + qn !== void 0 ? jo(p.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2, Wi(Lr), Wr($r), qn) : jo(p.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, Wi(Lr), Wr($r)); + } + } + return !0; + } + if (Yt && !en(Yr(Lr), Io(Yt, Lr.escapedName), 3, Ze)) + return Ze && ks(p.Types_of_property_0_are_incompatible, Wi(Lr)), !0; + } + return !1; + } + function Ta(xe, Re) { + return xe.valueDeclaration && Re.valueDeclaration && xe.valueDeclaration.parent === Re.valueDeclaration; + } + function Oc(xe, Re, Ze, Pt) { + if (xe.flags & 1048576) { + if (Re.flags & 1048576) { + const $t = xe.origin; + if ($t && $t.flags & 2097152 && Re.aliasSymbol && ms($t.types, Re)) + return -1; + const At = Re.origin; + if (At && At.flags & 1048576 && xe.aliasSymbol && ms(At.types, xe)) + return -1; + } + return l === I_ ? $o(xe, Re, Ze && !(xe.flags & 402784252), Pt) : Np(xe, Re, Ze && !(xe.flags & 402784252), Pt); + } + if (Re.flags & 1048576) + return Xa(mI(xe), Re, Ze && !(xe.flags & 402784252) && !(Re.flags & 402784252), Pt); + if (Re.flags & 2097152) + return Yf( + xe, + Re, + Ze, + 2 + /* Target */ + ); + if (l === I_ && Re.flags & 402784252) { + const $t = Qc(xe.types, (At) => At.flags & 465829888 ? ou(At) || yt : At); + if ($t !== xe.types) { + if (xe = sa($t), xe.flags & 131072) + return 0; + if (!(xe.flags & 2097152)) + return en( + xe, + Re, + 1, + /*reportErrors*/ + !1 + ) || en( + Re, + xe, + 1, + /*reportErrors*/ + !1 + ); + } + } + return $o( + xe, + Re, + /*reportErrors*/ + !1, + 1 + /* Source */ + ); + } + function Uc(xe, Re) { + let Ze = -1; + const Pt = xe.types; + for (const $t of Pt) { + const At = Xa( + $t, + Re, + /*reportErrors*/ + !1, + 0 + /* None */ + ); + if (!At) + return 0; + Ze &= At; + } + return Ze; + } + function Xa(xe, Re, Ze, Pt) { + const $t = Re.types; + if (Re.flags & 1048576) { + if (ch($t, xe)) + return -1; + if (l !== I_ && Dn(Re) & 32768 && !(xe.flags & 1024) && (xe.flags & 2688 || (l === cg || l === Ro) && xe.flags & 256)) { + const Yt = xe === xe.regularType ? xe.freshType : xe.regularType, Lr = xe.flags & 128 ? at : xe.flags & 256 ? wt : xe.flags & 2048 ? Zr : void 0; + return Lr && ch($t, Lr) || Yt && ch($t, Yt) ? -1 : 0; + } + const At = DAe(Re, xe); + if (At) { + const Yt = en( + xe, + At, + 2, + /*reportErrors*/ + !1, + /*headMessage*/ + void 0, + Pt + ); + if (Yt) + return Yt; + } + } + for (const At of $t) { + const Yt = en( + xe, + At, + 2, + /*reportErrors*/ + !1, + /*headMessage*/ + void 0, + Pt + ); + if (Yt) + return Yt; + } + if (Ze) { + const At = YNe(xe, Re, en); + At && en( + xe, + At, + 2, + /*reportErrors*/ + !0, + /*headMessage*/ + void 0, + Pt + ); + } + return 0; + } + function Yf(xe, Re, Ze, Pt) { + let $t = -1; + const At = Re.types; + for (const Yt of At) { + const Lr = en( + xe, + Yt, + 2, + Ze, + /*headMessage*/ + void 0, + Pt + ); + if (!Lr) + return 0; + $t &= Lr; + } + return $t; + } + function $o(xe, Re, Ze, Pt) { + const $t = xe.types; + if (xe.flags & 1048576 && ch($t, Re)) + return -1; + const At = $t.length; + for (let Yt = 0; Yt < At; Yt++) { + const Lr = en( + $t[Yt], + Re, + 1, + Ze && Yt === At - 1, + /*headMessage*/ + void 0, + Pt + ); + if (Lr) + return Lr; + } + return 0; + } + function wc(xe, Re) { + return xe.flags & 1048576 && Re.flags & 1048576 && !(xe.types[0].flags & 32768) && Re.types[0].flags & 32768 ? SP( + Re, + -32769 + /* Undefined */ + ) : Re; + } + function Np(xe, Re, Ze, Pt) { + let $t = -1; + const At = xe.types, Yt = wc(xe, Re); + for (let Lr = 0; Lr < At.length; Lr++) { + const $r = At[Lr]; + if (Yt.flags & 1048576 && At.length >= Yt.types.length && At.length % Yt.types.length === 0) { + const qn = en( + $r, + Yt.types[Lr % Yt.types.length], + 3, + /*reportErrors*/ + !1, + /*headMessage*/ + void 0, + Pt + ); + if (qn) { + $t &= qn; + continue; + } + } + const Sn = en( + $r, + Re, + 1, + Ze, + /*headMessage*/ + void 0, + Pt + ); + if (!Sn) + return 0; + $t &= Sn; + } + return $t; + } + function IP(xe = Ge, Re = Ge, Ze = Ge, Pt, $t) { + if (xe.length !== Re.length && l === vu) + return 0; + const At = xe.length <= Re.length ? xe.length : Re.length; + let Yt = -1; + for (let Lr = 0; Lr < At; Lr++) { + const $r = Lr < Ze.length ? Ze[Lr] : 1, Sn = $r & 7; + if (Sn !== 4) { + const qn = xe[Lr], Yn = Re[Lr]; + let Ur = -1; + if ($r & 8 ? Ur = l === vu ? en( + qn, + Yn, + 3, + /*reportErrors*/ + !1 + ) : lI(qn, Yn) : Sn === 1 ? Ur = en( + qn, + Yn, + 3, + Pt, + /*headMessage*/ + void 0, + $t + ) : Sn === 2 ? Ur = en( + Yn, + qn, + 3, + Pt, + /*headMessage*/ + void 0, + $t + ) : Sn === 3 ? (Ur = en( + Yn, + qn, + 3, + /*reportErrors*/ + !1 + ), Ur || (Ur = en( + qn, + Yn, + 3, + Pt, + /*headMessage*/ + void 0, + $t + ))) : (Ur = en( + qn, + Yn, + 3, + Pt, + /*headMessage*/ + void 0, + $t + ), Ur && (Ur &= en( + Yn, + qn, + 3, + Pt, + /*headMessage*/ + void 0, + $t + ))), !Ur) + return 0; + Yt &= Ur; + } + } + return Yt; + } + function VI(xe, Re, Ze, Pt, $t) { + var At, Yt, Lr; + if (jr) + return 0; + const $r = k$( + xe, + Re, + Pt, + l, + /*ignoreConstraints*/ + !1 + ), Sn = l.get($r); + if (Sn !== void 0 && !(Ze && Sn & 2 && !(Sn & 96))) { + if (hs) { + const sr = Sn & 24; + sr & 8 && Mi(xe, Co), sr & 16 && Mi(xe, Gc); + } + if (Ze && Sn & 96) { + const sr = Sn & 32 ? p.Excessive_complexity_comparing_types_0_and_1 : p.Excessive_stack_depth_comparing_types_0_and_1; + Vi(sr, Wr(xe), Wr(Re)), Kr++; + } + return Sn & 1 ? -1 : 0; + } + if (Qn <= 0) + return jr = !0, 0; + if (!G) + G = [], ve = /* @__PURE__ */ new Set(), de = [], We = []; + else { + if (ve.has($r)) + return 3; + const sr = $r.startsWith("*") ? k$( + xe, + Re, + Pt, + l, + /*ignoreConstraints*/ + !0 + ) : void 0; + if (sr && ve.has(sr)) + return 3; + if (gt === 100 || jt === 100) + return jr = !0, 0; + } + const qn = lt; + G[lt] = $r, ve.add($r), lt++; + const Yn = ar; + $t & 1 && (de[gt] = xe, gt++, !(ar & 1) && aC(xe, de, gt) && (ar |= 1)), $t & 2 && (We[jt] = Re, jt++, !(ar & 2) && aC(Re, We, jt) && (ar |= 2)); + let Ur, ci = 0; + hs && (Ur = hs, hs = (sr) => (ci |= sr ? 16 : 8, Ur(sr))); + let qi; + return ar === 3 ? ((At = on) == null || At.instant(on.Phase.CheckTypes, "recursiveTypeRelatedTo_DepthLimit", { + sourceId: xe.id, + sourceIdStack: de.map((sr) => sr.id), + targetId: Re.id, + targetIdStack: We.map((sr) => sr.id), + depth: gt, + targetDepth: jt + }), qi = 3) : ((Yt = on) == null || Yt.push(on.Phase.CheckTypes, "structuredTypeRelatedTo", { sourceId: xe.id, targetId: Re.id }), qi = FP(xe, Re, Ze, Pt), (Lr = on) == null || Lr.pop()), hs && (hs = Ur), $t & 1 && gt--, $t & 2 && jt--, ar = Yn, qi ? (qi === -1 || gt === 0 && jt === 0) && Pa( + qi === -1 || qi === 3 + ) : (l.set($r, 2 | ci), Qn--, Pa( + /*markAllAsSucceeded*/ + !1 + )), qi; + function Pa(sr) { + for (let Fn = qn; Fn < lt; Fn++) + ve.delete(G[Fn]), sr && (l.set(G[Fn], 1 | ci), Qn--); + lt = qn; + } + } + function FP(xe, Re, Ze, Pt) { + const $t = bi(); + let At = qI(xe, Re, Ze, Pt, $t); + if (l !== vu) { + if (!At && (xe.flags & 2097152 || xe.flags & 262144 && Re.flags & 1048576)) { + const Yt = Qet(xe.flags & 2097152 ? xe.types : [xe], !!(Re.flags & 1048576)); + Yt && G_(Yt, (Lr) => Lr !== xe) && (At = en( + Yt, + Re, + 1, + /*reportErrors*/ + !1, + /*headMessage*/ + void 0, + Pt + )); + } + At && !(Pt & 2) && Re.flags & 2097152 && !NT(Re) && xe.flags & 2621440 ? (At &= aa( + xe, + Re, + Ze, + /*excludedProperties*/ + void 0, + /*optionalsOnly*/ + !1, + 0 + /* None */ + ), At && sy(xe) && Dn(xe) & 8192 && (At &= we( + xe, + Re, + /*sourceIsPrimitive*/ + !1, + Ze, + 0 + /* None */ + ))) : At && p$(Re) && !ab(Re) && xe.flags & 2097152 && e_(xe).flags & 3670016 && !ot(xe.types, (Yt) => Yt === Re || !!(Dn(Yt) & 262144)) && (At &= aa( + xe, + Re, + Ze, + /*excludedProperties*/ + void 0, + /*optionalsOnly*/ + !0, + Pt + )); + } + return At && zn($t), At; + } + function Pf(xe, Re) { + const Ze = e_(Kv(Re)), Pt = []; + return Ofe( + Ze, + 8576, + /*stringsOnly*/ + !1, + ($t) => void Pt.push(Mi(xe, aI(Re.mapper, Sd(Re), $t))) + ), Xn(Pt); + } + function qI(xe, Re, Ze, Pt, $t) { + let At, Yt, Lr = !1, $r = xe.flags; + const Sn = Re.flags; + if (l === vu) { + if ($r & 3145728) { + let Ur = Uc(xe, Re); + return Ur && (Ur &= Uc(Re, xe)), Ur; + } + if ($r & 4194304) + return en( + xe.type, + Re.type, + 3, + /*reportErrors*/ + !1 + ); + if ($r & 8388608 && (At = en( + xe.objectType, + Re.objectType, + 3, + /*reportErrors*/ + !1 + )) && (At &= en( + xe.indexType, + Re.indexType, + 3, + /*reportErrors*/ + !1 + )) || $r & 16777216 && xe.root.isDistributive === Re.root.isDistributive && (At = en( + xe.checkType, + Re.checkType, + 3, + /*reportErrors*/ + !1 + )) && (At &= en( + xe.extendsType, + Re.extendsType, + 3, + /*reportErrors*/ + !1 + )) && (At &= en( + E1(xe), + E1(Re), + 3, + /*reportErrors*/ + !1 + )) && (At &= en( + D1(xe), + D1(Re), + 3, + /*reportErrors*/ + !1 + )) || $r & 33554432 && (At = en( + xe.baseType, + Re.baseType, + 3, + /*reportErrors*/ + !1 + )) && (At &= en( + xe.constraint, + Re.constraint, + 3, + /*reportErrors*/ + !1 + ))) + return At; + if ($r & 134217728 && Tf(xe.texts, Re.texts)) { + const Ur = xe.types, ci = Re.types; + At = -1; + for (let qi = 0; qi < Ur.length && (At &= en( + Ur[qi], + ci[qi], + 3, + /*reportErrors*/ + !1 + )); qi++) + ; + return At; + } + if ($r & 268435456 && xe.symbol === Re.symbol) + return en( + xe.type, + Re.type, + 3, + /*reportErrors*/ + !1 + ); + if (!($r & 524288)) + return 0; + } else if ($r & 3145728 || Sn & 3145728) { + if (At = Oc(xe, Re, Ze, Pt)) + return At; + if (!($r & 465829888 || $r & 524288 && Sn & 1048576 || $r & 2097152 && Sn & 467402752)) + return 0; + } + if ($r & 17301504 && xe.aliasSymbol && xe.aliasTypeArguments && xe.aliasSymbol === Re.aliasSymbol && !(T$(xe) || T$(Re))) { + const Ur = ZNe(xe.aliasSymbol); + if (Ur === Ge) + return 1; + const ci = Pn(xe.aliasSymbol).typeParameters, qi = gg(ci), Pa = ty(xe.aliasTypeArguments, ci, qi, an(xe.aliasSymbol.valueDeclaration)), sr = ty(Re.aliasTypeArguments, ci, qi, an(xe.aliasSymbol.valueDeclaration)), Fn = Yn(Pa, sr, Ur, Pt); + if (Fn !== void 0) + return Fn; + } + if (oAe(xe) && !xe.target.readonly && (At = en( + Ao(xe)[0], + Re, + 1 + /* Source */ + )) || oAe(Re) && (Re.target.readonly || SM(ou(xe) || xe)) && (At = en( + xe, + Ao(Re)[0], + 2 + /* Target */ + ))) + return At; + if (Sn & 262144) { + if (Dn(xe) & 32 && !xe.declaration.nameType && en( + jm(Re), + $f(xe), + 3 + /* Both */ + ) && !(mg(xe) & 4)) { + const Ur = sh(xe), ci = vf(Re, Sd(xe)); + if (At = en(Ur, ci, 3, Ze)) + return At; + } + if (l === I_ && $r & 262144) { + let Ur = m_(xe); + if (Ur) + for (; Ur && wp(Ur, (ci) => !!(ci.flags & 262144)); ) { + if (At = en( + Ur, + Re, + 1, + /*reportErrors*/ + !1 + )) + return At; + Ur = m_(Ur); + } + return 0; + } + } else if (Sn & 4194304) { + const Ur = Re.type; + if ($r & 4194304 && (At = en( + Ur, + xe.type, + 3, + /*reportErrors*/ + !1 + ))) + return At; + if (Sa(Ur)) { + if (At = en(xe, nNe(Ur), 2, Ze)) + return At; + } else { + const ci = Lfe(Ur); + if (ci) { + if (en(xe, jm( + ci, + Re.indexFlags | 4 + /* NoReducibleCheck */ + ), 2, Ze) === -1) + return -1; + } else if (L_(Ur)) { + const qi = K0(Ur), Pa = $f(Ur); + let sr; + if (qi && AE(Ur)) { + const Fn = Pf(qi, Ur); + sr = Xn([Fn, qi]); + } else + sr = qi || Pa; + if (en(xe, sr, 2, Ze) === -1) + return -1; + } + } + } else if (Sn & 8388608) { + if ($r & 8388608) { + if ((At = en(xe.objectType, Re.objectType, 3, Ze)) && (At &= en(xe.indexType, Re.indexType, 3, Ze)), At) + return At; + Ze && (Yt = J); + } + if (l === yu || l === I_) { + const Ur = Re.objectType, ci = Re.indexType, qi = ou(Ur) || Ur, Pa = ou(ci) || ci; + if (!NT(qi) && !AT(Pa)) { + const sr = 4 | (qi !== Ur ? 2 : 0), Fn = C1(qi, Pa, sr); + if (Fn) { + if (Ze && Yt && zn($t), At = en( + xe, + Fn, + 2, + Ze, + /*headMessage*/ + void 0, + Pt + )) + return At; + Ze && Yt && J && (J = qn([Yt]) <= qn([J]) ? Yt : J); + } + } + } + Ze && (Yt = void 0); + } else if (L_(Re) && l !== vu) { + const Ur = !!Re.declaration.nameType, ci = sh(Re), qi = mg(Re); + if (!(qi & 8)) { + if (!Ur && ci.flags & 8388608 && ci.objectType === xe && ci.indexType === Sd(Re)) + return -1; + if (!L_(xe)) { + const Pa = Ur ? K0(Re) : $f(Re), sr = jm( + xe, + 2 + /* NoIndexSignatures */ + ), Fn = qi & 4, ps = Fn ? YL(Pa, sr) : void 0; + if (Fn ? !(ps.flags & 131072) : en( + Pa, + sr, + 3 + /* Both */ + )) { + const Xi = sh(Re), xa = Sd(Re), Va = SP( + Xi, + -98305 + /* Nullable */ + ); + if (!Ur && Va.flags & 8388608 && Va.indexType === xa) { + if (At = en(xe, Va.objectType, 2, Ze)) + return At; + } else { + const ss = Ur ? ps || Pa : ps ? sa([ps, xa]) : xa, sl = vf(xe, ss); + if (At = en(sl, Xi, 3, Ze)) + return At; + } + } + Yt = J, zn($t); + } + } + } else if (Sn & 16777216) { + if (aC(Re, We, jt, 10)) + return 3; + const Ur = Re; + if (!Ur.root.inferTypeParameters && !Lrt(Ur.root) && !(xe.flags & 16777216 && xe.root === Ur.root)) { + const ci = !Ms(cI(Ur.checkType), cI(Ur.extendsType)), qi = !ci && Ms(OT(Ur.checkType), OT(Ur.extendsType)); + if ((At = ci ? -1 : en( + xe, + E1(Ur), + 2, + /*reportErrors*/ + !1, + /*headMessage*/ + void 0, + Pt + )) && (At &= qi ? -1 : en( + xe, + D1(Ur), + 2, + /*reportErrors*/ + !1, + /*headMessage*/ + void 0, + Pt + ), At)) + return At; + } + } else if (Sn & 134217728) { + if ($r & 134217728) { + if (l === I_) + return lit(xe, Re) ? 0 : -1; + Mi(xe, Gc); + } + if (B$(xe, Re)) + return -1; + } else if (Re.flags & 268435456 && !(xe.flags & 268435456) && j$(xe, Re)) + return -1; + if ($r & 8650752) { + if (!($r & 8388608 && Sn & 8388608)) { + const Ur = kT(xe) || yt; + if (At = en( + Ur, + Re, + 1, + /*reportErrors*/ + !1, + /*headMessage*/ + void 0, + Pt + )) + return At; + if (At = en( + yf(Ur, xe), + Re, + 1, + Ze && Ur !== yt && !(Sn & $r & 262144), + /*headMessage*/ + void 0, + Pt + )) + return At; + if (Bfe(xe)) { + const ci = kT(xe.indexType); + if (ci && (At = en(vf(xe.objectType, ci), Re, 1, Ze))) + return At; + } + } + } else if ($r & 4194304) { + const Ur = dpe(xe.type, xe.indexFlags) && Dn(xe.type) & 32; + if (At = en(oi, Re, 1, Ze && !Ur)) + return At; + if (Ur) { + const ci = xe.type, qi = K0(ci), Pa = qi && AE(ci) ? Pf(qi, ci) : qi || $f(ci); + if (At = en(Pa, Re, 1, Ze)) + return At; + } + } else if ($r & 134217728 && !(Sn & 524288)) { + if (!(Sn & 134217728)) { + const Ur = ou(xe); + if (Ur && Ur !== xe && (At = en(Ur, Re, 1, Ze))) + return At; + } + } else if ($r & 268435456) + if (Sn & 268435456) { + if (xe.symbol !== Re.symbol) + return 0; + if (At = en(xe.type, Re.type, 3, Ze)) + return At; + } else { + const Ur = ou(xe); + if (Ur && (At = en(Ur, Re, 1, Ze))) + return At; + } + else if ($r & 16777216) { + if (aC(xe, de, gt, 10)) + return 3; + if (Sn & 16777216) { + const qi = xe.root.inferTypeParameters; + let Pa = xe.extendsType, sr; + if (qi) { + const Fn = gI( + qi, + /*signature*/ + void 0, + 0, + xi + ); + uh( + Fn.inferences, + Re.extendsType, + Pa, + 1536 + /* AlwaysStrict */ + ), Pa = Mi(Pa, Fn.mapper), sr = Fn.mapper; + } + if (lh(Pa, Re.extendsType) && (en( + xe.checkType, + Re.checkType, + 3 + /* Both */ + ) || en( + Re.checkType, + xe.checkType, + 3 + /* Both */ + )) && ((At = en(Mi(E1(xe), sr), E1(Re), 3, Ze)) && (At &= en(D1(xe), D1(Re), 3, Ze)), At)) + return At; + } + const Ur = Mfe(xe); + if (Ur && (At = en(Ur, Re, 1, Ze))) + return At; + const ci = !(Sn & 16777216) && eM(xe) ? _3e(xe) : void 0; + if (ci && (zn($t), At = en(ci, Re, 1, Ze))) + return At; + } else { + if (l !== cg && l !== Ro && Uet(Re) && t0(xe)) + return -1; + if (L_(Re)) + return L_(xe) && (At = It(xe, Re, Ze)) ? At : 0; + const Ur = !!($r & 402784252); + if (l !== vu) + xe = e_(xe), $r = xe.flags; + else if (L_(xe)) + return 0; + if (Dn(xe) & 4 && Dn(Re) & 4 && xe.target === Re.target && !Sa(xe) && !(T$(xe) || T$(Re))) { + if (D$(xe)) + return -1; + const ci = jpe(xe.target); + if (ci === Ge) + return 1; + const qi = Yn(Ao(xe), Ao(Re), ci, Pt); + if (qi !== void 0) + return qi; + } else { + if (gP(Re) ? G_(xe, ab) : Ep(Re) && G_(xe, (ci) => Sa(ci) && !ci.target.readonly)) + return l !== vu ? en(eb(xe, wt) || Le, eb(Re, wt) || Le, 3, Ze) : 0; + if (w1(xe) && Sa(Re) && !w1(Re)) { + const ci = Rm(xe); + if (ci !== xe) + return en(ci, Re, 1, Ze); + } else if ((l === cg || l === Ro) && t0(Re) && Dn(Re) & 8192 && !t0(xe)) + return 0; + } + if ($r & 2621440 && Sn & 524288) { + const ci = Ze && J === $t.errorInfo && !Ur; + if (At = aa( + xe, + Re, + ci, + /*excludedProperties*/ + void 0, + /*optionalsOnly*/ + !1, + Pt + ), At && (At &= mo(xe, Re, 0, ci, Pt), At && (At &= mo(xe, Re, 1, ci, Pt), At && (At &= we(xe, Re, Ur, ci, Pt)))), Lr && At) + J = Yt || J || $t.errorInfo; + else if (At) + return At; + } + if ($r & 2621440 && Sn & 1048576) { + const ci = SP( + Re, + 36175872 + /* Substitution */ + ); + if (ci.flags & 1048576) { + const qi = gr(xe, ci); + if (qi) + return qi; + } + } + } + return 0; + function qn(Ur) { + return Ur ? Wu(Ur, (ci, qi) => ci + 1 + qn(qi.next), 0) : 0; + } + function Yn(Ur, ci, qi, Pa) { + if (At = IP(Ur, ci, qi, Ze, Pa)) + return At; + if (ot(qi, (Fn) => !!(Fn & 24))) { + Yt = void 0, zn($t); + return; + } + const sr = ci && Tnt(ci, qi); + if (Lr = !sr, qi !== Ge && !sr) { + if (Lr && !(Ze && ot( + qi, + (Fn) => (Fn & 7) === 0 + /* Invariant */ + ))) + return 0; + Yt = J, zn($t); + } + } + } + function It(xe, Re, Ze) { + if (l === I_ || (l === vu ? mg(xe) === mg(Re) : oP(xe) <= oP(Re))) { + let $t; + const At = $f(Re), Yt = Mi($f(xe), oP(xe) < 0 ? Co : Gc); + if ($t = en(At, Yt, 3, Ze)) { + const Lr = bf([Sd(xe)], [Sd(Re)]); + if (Mi(K0(xe), Lr) === Mi(K0(Re), Lr)) + return $t & en(Mi(sh(xe), Lr), sh(Re), 3, Ze); + } + } + return 0; + } + function gr(xe, Re) { + var Ze; + const Pt = $a(xe), $t = EAe(Pt, Re); + if (!$t) return 0; + let At = 1; + for (const Yn of $t) + if (At *= Rit(Hd(Yn)), At > 25) + return (Ze = on) == null || Ze.instant(on.Phase.CheckTypes, "typeRelatedToDiscriminatedType_DepthLimit", { sourceId: xe.id, targetId: Re.id, numCombinations: At }), 0; + const Yt = new Array($t.length), Lr = /* @__PURE__ */ new Set(); + for (let Yn = 0; Yn < $t.length; Yn++) { + const Ur = $t[Yn], ci = Hd(Ur); + Yt[Yn] = ci.flags & 1048576 ? ci.types : [ci], Lr.add(Ur.escapedName); + } + const $r = hQ(Yt), Sn = []; + for (const Yn of $r) { + let Ur = !1; + e: + for (const ci of Re.types) { + for (let qi = 0; qi < $t.length; qi++) { + const Pa = $t[qi], sr = Ys(ci, Pa.escapedName); + if (!sr) continue e; + if (Pa === sr) continue; + if (!Tn( + xe, + Re, + Pa, + sr, + (ps) => Yn[qi], + /*reportErrors*/ + !1, + 0, + /*skipOptional*/ + K || l === I_ + )) + continue e; + } + tp(Sn, ci, gy), Ur = !0; + } + if (!Ur) + return 0; + } + let qn = -1; + for (const Yn of Sn) + if (qn &= aa( + xe, + Yn, + /*reportErrors*/ + !1, + Lr, + /*optionalsOnly*/ + !1, + 0 + /* None */ + ), qn && (qn &= mo( + xe, + Yn, + 0, + /*reportErrors*/ + !1, + 0 + /* None */ + ), qn && (qn &= mo( + xe, + Yn, + 1, + /*reportErrors*/ + !1, + 0 + /* None */ + ), qn && !(Sa(xe) && Sa(Yn)) && (qn &= we( + xe, + Yn, + /*sourceIsPrimitive*/ + !1, + /*reportErrors*/ + !1, + 0 + /* None */ + )))), !qn) + return qn; + return qn; + } + function Fr(xe, Re) { + if (!Re || xe.length === 0) return xe; + let Ze; + for (let Pt = 0; Pt < xe.length; Pt++) + Re.has(xe[Pt].escapedName) ? Ze || (Ze = xe.slice(0, Pt)) : Ze && Ze.push(xe[Pt]); + return Ze || xe; + } + function Qr(xe, Re, Ze, Pt, $t) { + const At = K && !!(uc(Re) & 48), Yt = Ru( + Hd(Re), + /*isProperty*/ + !1, + At + ); + if (Yt.flags & (l === Ro ? 1 : 3)) + return -1; + const Lr = Ze(xe); + return en( + Lr, + Yt, + 3, + Pt, + /*headMessage*/ + void 0, + $t + ); + } + function Tn(xe, Re, Ze, Pt, $t, At, Yt, Lr) { + const $r = up(Ze), Sn = up(Pt); + if ($r & 2 || Sn & 2) { + if (Ze.valueDeclaration !== Pt.valueDeclaration) + return At && ($r & 2 && Sn & 2 ? Vi(p.Types_have_separate_declarations_of_a_private_property_0, Wi(Pt)) : Vi(p.Property_0_is_private_in_type_1_but_not_in_type_2, Wi(Pt), Wr($r & 2 ? xe : Re), Wr($r & 2 ? Re : xe))), 0; + } else if (Sn & 4) { + if (!Dnt(Ze, Pt)) + return At && Vi(p.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2, Wi(Pt), Wr(sC(Ze) || xe), Wr(sC(Pt) || Re)), 0; + } else if ($r & 4) + return At && Vi(p.Property_0_is_protected_in_type_1_but_public_in_type_2, Wi(Pt), Wr(xe), Wr(Re)), 0; + if (l === Ro && tm(Ze) && !tm(Pt)) + return 0; + const qn = Qr(Ze, Pt, $t, At, Yt); + return qn ? !Lr && Ze.flags & 16777216 && Pt.flags & 106500 && !(Pt.flags & 16777216) ? (At && Vi(p.Property_0_is_optional_in_type_1_but_required_in_type_2, Wi(Pt), Wr(xe), Wr(Re)), 0) : qn : (At && ks(p.Types_of_property_0_are_incompatible, Wi(Pt)), 0); + } + function Kn(xe, Re, Ze, Pt) { + let $t = !1; + if (Ze.valueDeclaration && wl(Ze.valueDeclaration) && Ai(Ze.valueDeclaration.name) && xe.symbol && xe.symbol.flags & 32) { + const Yt = Ze.valueDeclaration.name.escapedText, Lr = Z3(xe.symbol, Yt); + if (Lr && Ys(xe, Lr)) { + const $r = N.getDeclarationName(xe.symbol.valueDeclaration), Sn = N.getDeclarationName(Re.symbol.valueDeclaration); + Vi( + p.Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2, + U_(Yt), + U_($r.escapedText === "" ? DW : $r), + U_(Sn.escapedText === "" ? DW : Sn) + ); + return; + } + } + const At = is(ede( + xe, + Re, + Pt, + /*matchDiscriminantProperties*/ + !1 + )); + if ((!d || d.code !== p.Class_0_incorrectly_implements_interface_1.code && d.code !== p.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass.code) && ($t = !0), At.length === 1) { + const Yt = Wi( + Ze, + /*enclosingDeclaration*/ + void 0, + 0, + 20 + /* WriteComputedProps */ + ); + Vi(p.Property_0_is_missing_in_type_1_but_required_in_type_2, Yt, ...Kw(xe, Re)), wr(Ze.declarations) && Sc(sn(Ze.declarations[0], p._0_is_declared_here, Yt)), $t && J && Kr++; + } else Br( + xe, + Re, + /*reportErrors*/ + !1 + ) && (At.length > 5 ? Vi(p.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more, Wr(xe), Wr(Re), hr(At.slice(0, 4), (Yt) => Wi(Yt)).join(", "), At.length - 4) : Vi(p.Type_0_is_missing_the_following_properties_from_type_1_Colon_2, Wr(xe), Wr(Re), hr(At, (Yt) => Wi(Yt)).join(", ")), $t && J && Kr++); + } + function aa(xe, Re, Ze, Pt, $t, At) { + if (l === vu) + return ua(xe, Re, Pt); + let Yt = -1; + if (Sa(Re)) { + if (ab(xe)) { + if (!Re.target.readonly && (gP(xe) || Sa(xe) && xe.target.readonly)) + return 0; + const Yn = ry(xe), Ur = ry(Re), ci = Sa(xe) ? xe.target.combinedFlags & 4 : 4, qi = !!(Re.target.combinedFlags & 12), Pa = Sa(xe) ? xe.target.minLength : 0, sr = Re.target.minLength; + if (!ci && Yn < sr) + return Ze && Vi(p.Source_has_0_element_s_but_target_requires_1, Yn, sr), 0; + if (!qi && Ur < Pa) + return Ze && Vi(p.Source_has_0_element_s_but_target_allows_only_1, Pa, Ur), 0; + if (!qi && (ci || Ur < Yn)) + return Ze && (Pa < sr ? Vi(p.Target_requires_0_element_s_but_source_may_have_fewer, sr) : Vi(p.Target_allows_only_0_element_s_but_source_may_have_more, Ur)), 0; + const Fn = Ao(xe), ps = Ao(Re), Xi = ert( + Re.target, + 11 + /* NonRest */ + ), xa = nI( + Re.target, + 11 + /* NonRest */ + ); + let Va = !!Pt; + for (let ss = 0; ss < Yn; ss++) { + const sl = Sa(xe) ? xe.target.elementFlags[ss] : 4, al = Yn - 1 - ss, uu = qi && ss >= Xi ? Ur - 1 - Math.min(al, xa) : ss, zu = Re.target.elementFlags[uu]; + if (zu & 8 && !(sl & 8)) + return Ze && Vi(p.Source_provides_no_match_for_variadic_element_at_position_0_in_target, uu), 0; + if (sl & 8 && !(zu & 12)) + return Ze && Vi(p.Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target, ss, uu), 0; + if (zu & 1 && !(sl & 1)) + return Ze && Vi(p.Source_provides_no_match_for_required_element_at_position_0_in_target, uu), 0; + if (Va && ((sl & 12 || zu & 12) && (Va = !1), Va && Pt?.has("" + ss))) + continue; + const h_ = i0(Fn[ss], !!(sl & zu & 2)), c0 = ps[uu], db = sl & 8 && zu & 4 ? Tu(c0) : i0(c0, !!(zu & 2)), V2 = en( + h_, + db, + 3, + Ze, + /*headMessage*/ + void 0, + At + ); + if (!V2) + return Ze && (Ur > 1 || Yn > 1) && (qi && ss >= Xi && al >= xa && Xi !== Yn - xa - 1 ? ks(p.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target, Xi, Yn - xa - 1, uu) : ks(p.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target, ss, uu)), 0; + Yt &= V2; + } + return Yt; + } + if (Re.target.combinedFlags & 12) + return 0; + } + const Lr = (l === cg || l === Ro) && !sy(xe) && !D$(xe) && !Sa(xe), $r = tde( + xe, + Re, + Lr, + /*matchDiscriminantProperties*/ + !1 + ); + if ($r) + return Ze && kl(xe, Re) && Kn(xe, Re, $r, Lr), 0; + if (sy(Re)) { + for (const Yn of Fr($a(xe), Pt)) + if (!N2(Re, Yn.escapedName) && !(Yr(Yn).flags & 32768)) + return Ze && Vi(p.Property_0_does_not_exist_on_type_1, Wi(Yn), Wr(Re)), 0; + } + const Sn = $a(Re), qn = Sa(xe) && Sa(Re); + for (const Yn of Fr(Sn, Pt)) { + const Ur = Yn.escapedName; + if (!(Yn.flags & 4194304) && (!qn || zg(Ur) || Ur === "length") && (!$t || Yn.flags & 16777216)) { + const ci = Ys(xe, Ur); + if (ci && ci !== Yn) { + const qi = Tn(xe, Re, ci, Yn, Hd, Ze, At, l === I_); + if (!qi) + return 0; + Yt &= qi; + } + } + } + return Yt; + } + function ua(xe, Re, Ze) { + if (!(xe.flags & 524288 && Re.flags & 524288)) + return 0; + const Pt = Fr(ey(xe), Ze), $t = Fr(ey(Re), Ze); + if (Pt.length !== $t.length) + return 0; + let At = -1; + for (const Yt of Pt) { + const Lr = N2(Re, Yt.escapedName); + if (!Lr) + return 0; + const $r = Jpe(Yt, Lr, en); + if (!$r) + return 0; + At &= $r; + } + return At; + } + function mo(xe, Re, Ze, Pt, $t) { + var At, Yt; + if (l === vu) + return pb(xe, Re, Ze); + if (Re === Za || xe === Za) + return -1; + const Lr = xe.symbol && zm(xe.symbol.valueDeclaration), $r = Re.symbol && zm(Re.symbol.valueDeclaration), Sn = Is( + xe, + Lr && Ze === 1 ? 0 : Ze + ), qn = Is( + Re, + $r && Ze === 1 ? 0 : Ze + ); + if (Ze === 1 && Sn.length && qn.length) { + const Pa = !!(Sn[0].flags & 4), sr = !!(qn[0].flags & 4); + if (Pa && !sr) + return Pt && Vi(p.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type), 0; + if (!Zt(Sn[0], qn[0], Pt)) + return 0; + } + let Yn = -1; + const Ur = Ze === 1 ? M_ : Ju, ci = Dn(xe), qi = Dn(Re); + if (ci & 64 && qi & 64 && xe.symbol === Re.symbol || ci & 4 && qi & 4 && xe.target === Re.target) { + E.assertEqual(Sn.length, qn.length); + for (let Pa = 0; Pa < qn.length; Pa++) { + const sr = fb( + Sn[Pa], + qn[Pa], + /*erase*/ + !0, + Pt, + $t, + Ur(Sn[Pa], qn[Pa]) + ); + if (!sr) + return 0; + Yn &= sr; + } + } else if (Sn.length === 1 && qn.length === 1) { + const Pa = l === I_, sr = Ca(Sn), Fn = Ca(qn); + if (Yn = fb(sr, Fn, Pa, Pt, $t, Ur(sr, Fn)), !Yn && Pt && Ze === 1 && ci & qi && (((At = Fn.declaration) == null ? void 0 : At.kind) === 177 || ((Yt = sr.declaration) == null ? void 0 : Yt.kind) === 177)) { + const ps = (Xi) => b1( + Xi, + /*enclosingDeclaration*/ + void 0, + 262144, + Ze + ); + return Vi(p.Type_0_is_not_assignable_to_type_1, ps(sr), ps(Fn)), Vi(p.Types_of_construct_signatures_are_incompatible), Yn; + } + } else + e: + for (const Pa of qn) { + const sr = bi(); + let Fn = Pt; + for (const ps of Sn) { + const Xi = fb( + ps, + Pa, + /*erase*/ + !0, + Fn, + $t, + Ur(ps, Pa) + ); + if (Xi) { + Yn &= Xi, zn(sr); + continue e; + } + Fn = !1; + } + return Fn && Vi(p.Type_0_provides_no_match_for_the_signature_1, Wr(xe), b1( + Pa, + /*enclosingDeclaration*/ + void 0, + /*flags*/ + void 0, + Ze + )), 0; + } + return Yn; + } + function kl(xe, Re) { + const Ze = rM( + xe, + 0 + /* Call */ + ), Pt = rM( + xe, + 1 + /* Construct */ + ), $t = ey(xe); + return (Ze.length || Pt.length) && !$t.length ? !!(Is( + Re, + 0 + /* Call */ + ).length && Ze.length || Is( + Re, + 1 + /* Construct */ + ).length && Pt.length) : !0; + } + function Ju(xe, Re) { + return xe.parameters.length === 0 && Re.parameters.length === 0 ? (Ze, Pt) => ks(p.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, Wr(Ze), Wr(Pt)) : (Ze, Pt) => ks(p.Call_signature_return_types_0_and_1_are_incompatible, Wr(Ze), Wr(Pt)); + } + function M_(xe, Re) { + return xe.parameters.length === 0 && Re.parameters.length === 0 ? (Ze, Pt) => ks(p.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, Wr(Ze), Wr(Pt)) : (Ze, Pt) => ks(p.Construct_signature_return_types_0_and_1_are_incompatible, Wr(Ze), Wr(Pt)); + } + function fb(xe, Re, Ze, Pt, $t, At) { + const Yt = l === cg ? 16 : l === Ro ? 24 : 0; + return Ipe(Ze ? rI(xe) : xe, Ze ? rI(Re) : Re, Yt, Pt, Vi, At, Lr, Gc); + function Lr($r, Sn, qn) { + return en( + $r, + Sn, + 3, + qn, + /*headMessage*/ + void 0, + $t + ); + } + } + function pb(xe, Re, Ze) { + const Pt = Is(xe, Ze), $t = Is(Re, Ze); + if (Pt.length !== $t.length) + return 0; + let At = -1; + for (let Yt = 0; Yt < Pt.length; Yt++) { + const Lr = bM( + Pt[Yt], + $t[Yt], + /*partialMatch*/ + !1, + /*ignoreThisTypes*/ + !1, + /*ignoreReturnTypes*/ + !1, + en + ); + if (!Lr) + return 0; + At &= Lr; + } + return At; + } + function mR(xe, Re, Ze, Pt) { + let $t = -1; + const At = Re.keyType, Yt = xe.flags & 2097152 ? KL(xe) : ey(xe); + for (const Lr of Yt) + if (!XNe(xe, Lr) && Kk(tC( + Lr, + 8576 + /* StringOrNumberLiteralOrUnique */ + ), At)) { + const $r = Hd(Lr), Sn = be || $r.flags & 32768 || At === wt || !(Lr.flags & 16777216) ? $r : Dp( + $r, + 524288 + /* NEUndefined */ + ), qn = en( + Sn, + Re.type, + 3, + Ze, + /*headMessage*/ + void 0, + Pt + ); + if (!qn) + return Ze && Vi(p.Property_0_is_incompatible_with_index_signature, Wi(Lr)), 0; + $t &= qn; + } + for (const Lr of Su(xe)) + if (Kk(Lr.keyType, At)) { + const $r = GX(Lr, Re, Ze, Pt); + if (!$r) + return 0; + $t &= $r; + } + return $t; + } + function GX(xe, Re, Ze, Pt) { + const $t = en( + xe.type, + Re.type, + 3, + Ze, + /*headMessage*/ + void 0, + Pt + ); + return !$t && Ze && (xe.keyType === Re.keyType ? Vi(p._0_index_signatures_are_incompatible, Wr(xe.keyType)) : Vi(p._0_and_1_index_signatures_are_incompatible, Wr(xe.keyType), Wr(Re.keyType))), $t; + } + function we(xe, Re, Ze, Pt, $t) { + if (l === vu) + return Ht(xe, Re); + const At = Su(Re), Yt = ot(At, ($r) => $r.keyType === at); + let Lr = -1; + for (const $r of At) { + const Sn = l !== Ro && !Ze && Yt && $r.type.flags & 1 ? -1 : L_(xe) && Yt ? en(sh(xe), $r.type, 3, Pt) : te(xe, $r, Pt, $t); + if (!Sn) + return 0; + Lr &= Sn; + } + return Lr; + } + function te(xe, Re, Ze, Pt) { + const $t = Z8(xe, Re.keyType); + return $t ? GX($t, Re, Ze, Pt) : !(Pt & 1) && (l !== Ro || Dn(xe) & 8192) && F$(xe) ? mR(xe, Re, Ze, Pt) : (Ze && Vi(p.Index_signature_for_type_0_is_missing_in_type_1, Wr(Re.keyType), Wr(xe)), 0); + } + function Ht(xe, Re) { + const Ze = Su(xe), Pt = Su(Re); + if (Ze.length !== Pt.length) + return 0; + for (const $t of Pt) { + const At = ah(xe, $t.keyType); + if (!(At && en( + At.type, + $t.type, + 3 + /* Both */ + ) && At.isReadonly === $t.isReadonly)) + return 0; + } + return -1; + } + function Zt(xe, Re, Ze) { + if (!xe.declaration || !Re.declaration) + return !0; + const Pt = xx( + xe.declaration, + 6 + /* NonPublicAccessibilityModifier */ + ), $t = xx( + Re.declaration, + 6 + /* NonPublicAccessibilityModifier */ + ); + return $t === 2 || $t === 4 && Pt !== 2 || $t !== 4 && !Pt ? !0 : (Ze && Vi(p.Cannot_assign_a_0_constructor_type_to_a_1_constructor_type, Qv(Pt), Qv($t)), !1); + } + } + function Lpe(r) { + if (r.flags & 16) + return !1; + if (r.flags & 3145728) + return !!lr(r.types, Lpe); + if (r.flags & 465829888) { + const a = kT(r); + if (a && a !== r) + return Lpe(a); + } + return Qd(r) || !!(r.flags & 134217728) || !!(r.flags & 268435456); + } + function QNe(r, a) { + return Sa(r) && Sa(a) ? Ge : $a(a).filter((l) => S$(rr(r, l.escapedName), Yr(l))); + } + function S$(r, a) { + return !!r && !!a && Dc( + r, + 32768 + /* Undefined */ + ) && !!dI(a); + } + function bnt(r) { + return $a(r).filter((a) => dI(Yr(a))); + } + function YNe(r, a, l = Npe) { + return E5e(r, a, l) || Uft(r, a) || Vft(r, a) || qft(r, a) || Hft(r, a); + } + function Mpe(r, a, l) { + const f = r.types, d = f.map( + (x) => x.flags & 402784252 ? 0 : -1 + /* True */ + ); + for (const [x, I] of a) { + let J = !1; + for (let z = 0; z < f.length; z++) + if (d[z]) { + const G = Rn(f[z], I); + G && (wp(x(), (ve) => !!l(ve, G)) ? J = !0 : d[z] = 3); + } + for (let z = 0; z < f.length; z++) + d[z] === 3 && (d[z] = J ? 0 : -1); + } + const y = ms( + d, + 0 + /* False */ + ) ? Xn( + f.filter((x, I) => d[I]), + 0 + /* None */ + ) : r; + return y.flags & 131072 ? r : y; + } + function Rpe(r) { + if (r.flags & 524288) { + const a = $d(r); + return a.callSignatures.length === 0 && a.constructSignatures.length === 0 && a.indexInfos.length === 0 && a.properties.length > 0 && Ni(a.properties, (l) => !!(l.flags & 16777216)); + } + return r.flags & 33554432 ? Rpe(r.baseType) : r.flags & 2097152 ? Ni(r.types, Rpe) : !1; + } + function Snt(r, a, l) { + for (const f of $a(r)) + if (sX(a, f.escapedName, l)) + return !0; + return !1; + } + function jpe(r) { + return r === wa || r === ma || r.objectFlags & 8 ? O : KNe(r.symbol, r.typeParameters); + } + function ZNe(r) { + return KNe(r, Pn(r).typeParameters); + } + function KNe(r, a = Ge) { + var l, f; + const d = Pn(r); + if (!d.variances) { + (l = on) == null || l.push(on.Phase.CheckTypes, "getVariancesWorker", { arity: a.length, id: jl(bo(r)) }); + const y = ZS, x = R0; + ZS || (ZS = !0, R0 = Xg.length), d.variances = Ge; + const I = []; + for (const J of a) { + const z = Bpe(J); + let G = z & 16384 ? z & 8192 ? 0 : 1 : z & 8192 ? 2 : void 0; + if (G === void 0) { + let ve = !1, de = !1; + const We = hs; + hs = (jt) => jt ? de = !0 : ve = !0; + const lt = yM(r, J, _o), gt = yM(r, J, ge); + G = (Ms(gt, lt) ? 1 : 0) | (Ms(lt, gt) ? 2 : 0), G === 3 && Ms(yM(r, J, H), lt) && (G = 4), hs = We, (ve || de) && (ve && (G |= 8), de && (G |= 16)); + } + I.push(G); + } + y || (ZS = !1, R0 = x), d.variances = I, (f = on) == null || f.pop({ variances: I.map(E.formatVariance) }); + } + return d.variances; + } + function yM(r, a, l) { + const f = M2(a, l), d = bo(r); + if (Gr(d)) + return d; + const y = r.flags & 524288 ? OE(r, e0(Pn(r).typeParameters, f)) : Qh(d, e0(d.typeParameters, f)); + return it.add(jl(y)), y; + } + function T$(r) { + return it.has(jl(r)); + } + function Bpe(r) { + var a; + return Wu( + (a = r.symbol) == null ? void 0 : a.declarations, + (l, f) => l | pu(f), + 0 + /* None */ + ) & 28672; + } + function Tnt(r, a) { + for (let l = 0; l < a.length; l++) + if ((a[l] & 7) === 1 && r[l].flags & 16384) + return !0; + return !1; + } + function xnt(r) { + return r.flags & 262144 && !m_(r); + } + function knt(r) { + return !!(Dn(r) & 4) && !r.node; + } + function x$(r) { + return knt(r) && ot(Ao(r), (a) => !!(a.flags & 262144) || x$(a)); + } + function Cnt(r, a, l, f) { + const d = []; + let y = ""; + const x = J(r, 0), I = J(a, 0); + return `${y}${x},${I}${l}`; + function J(z, G = 0) { + let ve = "" + z.target.id; + for (const de of Ao(z)) { + if (de.flags & 262144) { + if (f || xnt(de)) { + let We = d.indexOf(de); + We < 0 && (We = d.length, d.push(de)), ve += "=" + We; + continue; + } + y = "*"; + } else if (G < 4 && x$(de)) { + ve += "<" + J(de, G + 1) + ">"; + continue; + } + ve += "-" + de.id; + } + return ve; + } + } + function k$(r, a, l, f, d) { + if (f === vu && r.id > a.id) { + const x = r; + r = a, a = x; + } + const y = l ? ":" + l : ""; + return x$(r) && x$(a) ? Cnt(r, a, y, d) : `${r.id},${a.id}${y}`; + } + function vM(r, a) { + if (uc(r) & 6) { + for (const l of r.links.containingType.types) { + const f = Ys(l, r.escapedName), d = f && vM(f, a); + if (d) + return d; + } + return; + } + return a(r); + } + function sC(r) { + return r.parent && r.parent.flags & 32 ? bo(Tl(r)) : void 0; + } + function C$(r) { + const a = sC(r), l = a && bd(a)[0]; + return l && rr(l, r.escapedName); + } + function Ent(r, a) { + return vM(r, (l) => { + const f = sC(l); + return f ? En(f, a) : !1; + }); + } + function Dnt(r, a) { + return !vM(a, (l) => up(l) & 4 ? !Ent(r, sC(l)) : !1); + } + function eAe(r, a, l) { + return vM(a, (f) => up(f, l) & 4 ? !En(r, sC(f)) : !1) ? void 0 : r; + } + function aC(r, a, l, f = 3) { + if (l >= f) { + if ((Dn(r) & 96) === 96 && (r = tAe(r)), r.flags & 2097152) + return ot(r.types, (I) => aC(I, a, l, f)); + const d = E$(r); + let y = 0, x = 0; + for (let I = 0; I < l; I++) { + const J = a[I]; + if (rAe(J, d)) { + if (J.id >= x && (y++, y >= f)) + return !0; + x = J.id; + } + } + } + return !1; + } + function tAe(r) { + let a; + for (; (Dn(r) & 96) === 96 && (a = Kv(r)) && (a.symbol || a.flags & 2097152 && ot(a.types, (l) => !!l.symbol)); ) + r = a; + return r; + } + function rAe(r, a) { + return (Dn(r) & 96) === 96 && (r = tAe(r)), r.flags & 2097152 ? ot(r.types, (l) => rAe(l, a)) : E$(r) === a; + } + function E$(r) { + if (r.flags & 524288 && !nde(r)) { + if (Dn(r) & 4 && r.node) + return r.node; + if (r.symbol && !(Dn(r) & 16 && r.symbol.flags & 32)) + return r.symbol; + if (Sa(r)) + return r.target; + } + if (r.flags & 262144) + return r.symbol; + if (r.flags & 8388608) { + do + r = r.objectType; + while (r.flags & 8388608); + return r; + } + return r.flags & 16777216 ? r.root : r; + } + function wnt(r, a) { + return Jpe(r, a, lI) !== 0; + } + function Jpe(r, a, l) { + if (r === a) + return -1; + const f = up(r) & 6, d = up(a) & 6; + if (f !== d) + return 0; + if (f) { + if ($E(r) !== $E(a)) + return 0; + } else if ((r.flags & 16777216) !== (a.flags & 16777216)) + return 0; + return tm(r) !== tm(a) ? 0 : l(Yr(r), Yr(a)); + } + function Pnt(r, a, l) { + const f = $_(r), d = $_(a), y = em(r), x = em(a), I = vg(r), J = vg(a); + return !!(f === d && y === x && I === J || l && y <= x); + } + function bM(r, a, l, f, d, y) { + if (r === a) + return -1; + if (!Pnt(r, a, l) || wr(r.typeParameters) !== wr(a.typeParameters)) + return 0; + if (a.typeParameters) { + const J = bf(r.typeParameters, a.typeParameters); + for (let z = 0; z < a.typeParameters.length; z++) { + const G = r.typeParameters[z], ve = a.typeParameters[z]; + if (!(G === ve || y(Mi(_P(G), J) || yt, _P(ve) || yt) && y(Mi(A2(G), J) || yt, A2(ve) || yt))) + return 0; + } + r = FT( + r, + J, + /*eraseTypeParameters*/ + !0 + ); + } + let x = -1; + if (!f) { + const J = tb(r); + if (J) { + const z = tb(a); + if (z) { + const G = y(J, z); + if (!G) + return 0; + x &= G; + } + } + } + const I = $_(a); + for (let J = 0; J < I; J++) { + const z = Kd(r, J), G = Kd(a, J), ve = y(G, z); + if (!ve) + return 0; + x &= ve; + } + if (!d) { + const J = kp(r), z = kp(a); + x &= J || z ? Nnt(J, z, y) : y(Wa(r), Wa(a)); + } + return x; + } + function Nnt(r, a, l) { + return r && a && _pe(r, a) ? r.type === a.type ? -1 : r.type && a.type ? l(r.type, a.type) : 0 : 0; + } + function Ant(r) { + let a; + for (const l of r) + if (!(l.flags & 131072)) { + const f = r0(l); + if (a ?? (a = f), f === l || f !== a) + return !1; + } + return !0; + } + function nAe(r) { + return Wu(r, (a, l) => a | (l.flags & 1048576 ? nAe(l.types) : l.flags), 0); + } + function Int(r) { + if (r.length === 1) + return r[0]; + const a = K ? Qc(r, (f) => Xc(f, (d) => !(d.flags & 98304))) : r, l = Ant(a) ? Xn(a) : Fnt(a); + return a === r ? l : xM( + l, + nAe(r) & 98304 + /* Nullable */ + ); + } + function Fnt(r) { + const a = Wu(r, (l, f) => mP(l, f) ? f : l); + return Ni(r, (l) => l === a || mP(l, a)) ? a : Wu(r, (l, f) => R2(l, f) ? f : l); + } + function Ont(r) { + return Wu(r, (a, l) => R2(l, a) ? l : a); + } + function Ep(r) { + return !!(Dn(r) & 4) && (r.target === wa || r.target === ma); + } + function gP(r) { + return !!(Dn(r) & 4) && r.target === ma; + } + function ab(r) { + return Ep(r) || Sa(r); + } + function SM(r) { + return Ep(r) && !gP(r) || Sa(r) && !r.target.readonly; + } + function TM(r) { + return Ep(r) ? Ao(r)[0] : void 0; + } + function iy(r) { + return Ep(r) || !(r.flags & 98304) && Ms(r, pf); + } + function zpe(r) { + return SM(r) || !(r.flags & 98305) && Ms(r, Gl); + } + function Wpe(r) { + if (!(Dn(r) & 4) || !(Dn(r.target) & 3)) + return; + if (Dn(r) & 33554432) + return Dn(r) & 67108864 ? r.cachedEquivalentBaseType : void 0; + r.objectFlags |= 33554432; + const a = r.target; + if (Dn(a) & 1) { + const d = ed(a); + if (d && d.expression.kind !== 80 && d.expression.kind !== 212) + return; + } + const l = bd(a); + if (l.length !== 1 || dg(r.symbol).size) + return; + let f = wr(a.typeParameters) ? Mi(l[0], bf(a.typeParameters, Ao(r).slice(0, a.typeParameters.length))) : l[0]; + return wr(Ao(r)) > wr(a.typeParameters) && (f = yf(f, pa(Ao(r)))), r.objectFlags |= 67108864, r.cachedEquivalentBaseType = f; + } + function iAe(r) { + return K ? r === cr : r === M; + } + function D$(r) { + const a = TM(r); + return !!a && iAe(a); + } + function hP(r) { + let a; + return Sa(r) || !!Ys(r, "0") || iy(r) && !!(a = rr(r, "length")) && G_(a, (l) => !!(l.flags & 256)); + } + function w$(r) { + return iy(r) || hP(r); + } + function Lnt(r, a) { + const l = rr(r, "" + a); + if (l) + return l; + if (G_(r, Sa)) + return cAe(r, a, F.noUncheckedIndexedAccess ? ue : void 0); + } + function Mnt(r) { + return !(r.flags & 240544); + } + function Qd(r) { + return !!(r.flags & 109472); + } + function sAe(r) { + const a = Rm(r); + return a.flags & 2097152 ? ot(a.types, Qd) : Qd(a); + } + function Rnt(r) { + return r.flags & 2097152 && Nn(r.types, Qd) || r; + } + function fI(r) { + return r.flags & 16 ? !0 : r.flags & 1048576 ? r.flags & 1024 ? !0 : Ni(r.types, Qd) : Qd(r); + } + function r0(r) { + return r.flags & 1056 ? $G(r) : r.flags & 402653312 ? at : r.flags & 256 ? wt : r.flags & 2048 ? Zr : r.flags & 512 ? Nt : r.flags & 1048576 ? jnt(r) : r; + } + function jnt(r) { + const a = `B${jl(r)}`; + return f_(a) ?? Yp(a, Go(r, r0)); + } + function Upe(r) { + return r.flags & 402653312 ? at : r.flags & 288 ? wt : r.flags & 2048 ? Zr : r.flags & 512 ? Nt : r.flags & 1048576 ? Go(r, Upe) : r; + } + function ob(r) { + return r.flags & 1056 && L2(r) ? $G(r) : r.flags & 128 && L2(r) ? at : r.flags & 256 && L2(r) ? wt : r.flags & 2048 && L2(r) ? Zr : r.flags & 512 && L2(r) ? Nt : r.flags & 1048576 ? Go(r, ob) : r; + } + function aAe(r) { + return r.flags & 8192 ? Jt : r.flags & 1048576 ? Go(r, aAe) : r; + } + function Vpe(r, a) { + return bX(r, a) || (r = aAe(ob(r))), t_(r); + } + function Bnt(r, a, l) { + if (r && Qd(r)) { + const f = a ? l ? LI(a) : a : void 0; + r = Vpe(r, f); + } + return r; + } + function qpe(r, a, l, f) { + if (r && Qd(r)) { + const d = a ? oy(l, a, f) : void 0; + r = Vpe(r, d); + } + return r; + } + function Sa(r) { + return !!(Dn(r) & 4 && r.target.objectFlags & 8); + } + function w1(r) { + return Sa(r) && !!(r.target.combinedFlags & 8); + } + function oAe(r) { + return w1(r) && r.target.elementFlags.length === 1; + } + function P$(r) { + return yP(r, r.target.fixedLength); + } + function cAe(r, a, l) { + return Go(r, (f) => { + const d = f, y = P$(d); + return y ? l && a >= lpe(d.target) ? Xn([y, l]) : y : ue; + }); + } + function Jnt(r) { + const a = P$(r); + return a && Tu(a); + } + function yP(r, a, l = 0, f = !1, d = !1) { + const y = ry(r) - l; + if (a < y) { + const x = Ao(r), I = []; + for (let J = a; J < y; J++) { + const z = x[J]; + I.push(r.target.elementFlags[J] & 8 ? vf(z, wt) : z); + } + return f ? sa(I) : Xn( + I, + d ? 0 : 1 + /* Literal */ + ); + } + } + function znt(r, a) { + return ry(r) === ry(a) && Ni(r.target.elementFlags, (l, f) => (l & 12) === (a.target.elementFlags[f] & 12)); + } + function lAe({ value: r }) { + return r.base10Value === "0"; + } + function uAe(r) { + return Xc(r, (a) => Yd( + a, + 4194304 + /* Truthy */ + )); + } + function Wnt(r) { + return Go(r, Unt); + } + function Unt(r) { + return r.flags & 4 ? pE : r.flags & 8 ? Vw : r.flags & 64 ? dE : r === Pr || r === Rr || r.flags & 114691 || r.flags & 128 && r.value === "" || r.flags & 256 && r.value === 0 || r.flags & 2048 && lAe(r) ? r : nr; + } + function xM(r, a) { + const l = a & ~r.flags & 98304; + return l === 0 ? r : Xn(l === 32768 ? [r, ue] : l === 65536 ? [r, Mt] : [r, ue, Mt]); + } + function P1(r, a = !1) { + E.assert(K); + const l = a ? Q : ue; + return r === l || r.flags & 1048576 && r.types[0] === l ? r : Xn([r, l]); + } + function Vnt(r) { + return Qu || (Qu = ME( + "NonNullable", + 524288, + /*diagnostic*/ + void 0 + ) || Y), Qu !== Y ? OE(Qu, [r]) : sa([r, ta]); + } + function n0(r) { + return K ? jT( + r, + 2097152 + /* NEUndefinedOrNull */ + ) : r; + } + function _Ae(r) { + return K ? Xn([r, dt]) : r; + } + function N$(r) { + return K ? z$(r, dt) : r; + } + function A$(r, a, l) { + return l ? TD(a) ? P1(r) : _Ae(r) : r; + } + function pI(r, a) { + return x7(a) ? n0(r) : Eu(a) ? N$(r) : r; + } + function i0(r, a) { + return be && a ? z$(r, ye) : r; + } + function dI(r) { + return r === ye || !!(r.flags & 1048576) && r.types[0] === ye; + } + function I$(r) { + return be ? z$(r, ye) : Dp( + r, + 524288 + /* NEUndefined */ + ); + } + function qnt(r, a) { + return (r.flags & 524) !== 0 && (a.flags & 28) !== 0; + } + function F$(r) { + const a = Dn(r); + return r.flags & 2097152 ? Ni(r.types, F$) : !!(r.symbol && (r.symbol.flags & 7040) !== 0 && !(r.symbol.flags & 32) && !BX(r)) || !!(a & 4194304) || !!(a & 1024 && F$(r.source)); + } + function LT(r, a) { + const l = ga( + r.flags, + r.escapedName, + uc(r) & 8 + /* Readonly */ + ); + l.declarations = r.declarations, l.parent = r.parent, l.links.type = a, l.links.target = r, r.valueDeclaration && (l.valueDeclaration = r.valueDeclaration); + const f = Pn(r).nameType; + return f && (l.links.nameType = f), l; + } + function Hnt(r, a) { + const l = Bs(); + for (const f of ey(r)) { + const d = Yr(f), y = a(d); + l.set(f.escapedName, y === d ? f : LT(f, y)); + } + return l; + } + function mI(r) { + if (!(sy(r) && Dn(r) & 8192)) + return r; + const a = r.regularType; + if (a) + return a; + const l = r, f = Hnt(r, mI), d = Ho(l.symbol, f, l.callSignatures, l.constructSignatures, l.indexInfos); + return d.flags = l.flags, d.objectFlags |= l.objectFlags & -8193, r.regularType = d, d; + } + function fAe(r, a, l) { + return { parent: r, propertyName: a, siblings: l, resolvedProperties: void 0 }; + } + function pAe(r) { + if (!r.siblings) { + const a = []; + for (const l of pAe(r.parent)) + if (sy(l)) { + const f = N2(l, r.propertyName); + f && BT(Yr(f), (d) => { + a.push(d); + }); + } + r.siblings = a; + } + return r.siblings; + } + function Gnt(r) { + if (!r.resolvedProperties) { + const a = /* @__PURE__ */ new Map(); + for (const l of pAe(r)) + if (sy(l) && !(Dn(l) & 2097152)) + for (const f of $a(l)) + a.set(f.escapedName, f); + r.resolvedProperties = is(a.values()); + } + return r.resolvedProperties; + } + function $nt(r, a) { + if (!(r.flags & 4)) + return r; + const l = Yr(r), f = a && fAe( + a, + r.escapedName, + /*siblings*/ + void 0 + ), d = Hpe(l, f); + return d === l ? r : LT(r, d); + } + function Xnt(r) { + const a = re.get(r.escapedName); + if (a) + return a; + const l = LT(r, Q); + return l.flags |= 16777216, re.set(r.escapedName, l), l; + } + function Qnt(r, a) { + const l = Bs(); + for (const d of ey(r)) + l.set(d.escapedName, $nt(d, a)); + if (a) + for (const d of Gnt(a)) + l.has(d.escapedName) || l.set(d.escapedName, Xnt(d)); + const f = Ho(r.symbol, l, Ge, Ge, Qc(Su(r), (d) => oh(d.keyType, Sf(d.type), d.isReadonly, d.declaration, d.components))); + return f.objectFlags |= Dn(r) & 266240, f; + } + function Sf(r) { + return Hpe( + r, + /*context*/ + void 0 + ); + } + function Hpe(r, a) { + if (Dn(r) & 196608) { + if (a === void 0 && r.widened) + return r.widened; + let l; + if (r.flags & 98305) + l = Le; + else if (sy(r)) + l = Qnt(r, a); + else if (r.flags & 1048576) { + const f = a || fAe( + /*parent*/ + void 0, + /*propertyName*/ + void 0, + r.types + ), d = Qc(r.types, (y) => y.flags & 98304 ? y : Hpe(y, f)); + l = Xn( + d, + ot(d, t0) ? 2 : 1 + /* Literal */ + ); + } else r.flags & 2097152 ? l = sa(Qc(r.types, Sf)) : ab(r) && (l = Qh(r.target, Qc(Ao(r), Sf))); + return l && a === void 0 && (r.widened = l), l || r; + } + return r; + } + function O$(r) { + var a; + let l = !1; + if (Dn(r) & 65536) { + if (r.flags & 1048576) + if (ot(r.types, t0)) + l = !0; + else + for (const f of r.types) + l || (l = O$(f)); + else if (ab(r)) + for (const f of Ao(r)) + l || (l = O$(f)); + else if (sy(r)) + for (const f of ey(r)) { + const d = Yr(f); + if (Dn(d) & 65536 && (l = O$(d), !l)) { + const y = (a = f.declarations) == null ? void 0 : a.find((x) => { + var I; + return ((I = x.symbol.valueDeclaration) == null ? void 0 : I.parent) === r.symbol.valueDeclaration; + }); + y && (ze(y, p.Object_literal_s_property_0_implicitly_has_an_1_type, Wi(f), Wr(Sf(d))), l = !0); + } + } + } + return l; + } + function cb(r, a, l) { + const f = Wr(Sf(a)); + if (an(r) && !d4(xr(r), F)) + return; + let d; + switch (r.kind) { + case 227: + case 173: + case 172: + d = fe ? p.Member_0_implicitly_has_an_1_type : p.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage; + break; + case 170: + const y = r; + if (Me(y.name)) { + const x = Z2(y.name); + if ((Ux(y.parent) || cd(y.parent) || Zm(y.parent)) && y.parent.parameters.includes(y) && (st( + y, + y.name.escapedText, + 788968, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !0 + ) || x && yJ(x))) { + const I = "arg" + y.parent.parameters.indexOf(y), J = co(y.name) + (y.dotDotDotToken ? "[]" : ""); + dd(fe, r, p.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1, I, J); + return; + } + } + d = r.dotDotDotToken ? fe ? p.Rest_parameter_0_implicitly_has_an_any_type : p.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage : fe ? p.Parameter_0_implicitly_has_an_1_type : p.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage; + break; + case 209: + if (d = p.Binding_element_0_implicitly_has_an_1_type, !fe) + return; + break; + case 318: + ze(r, p.Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, f); + return; + case 324: + fe && S6(r.parent) && ze(r.parent.tagName, p.This_overload_implicitly_returns_the_type_0_because_it_lacks_a_return_type_annotation, f); + return; + case 263: + case 175: + case 174: + case 178: + case 179: + case 219: + case 220: + if (fe && !r.name) { + l === 3 ? ze(r, p.Generator_implicitly_has_yield_type_0_Consider_supplying_a_return_type_annotation, f) : ze(r, p.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, f); + return; + } + d = fe ? l === 3 ? p._0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type : p._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type : p._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage; + break; + case 201: + fe && ze(r, p.Mapped_object_type_implicitly_has_an_any_template_type); + return; + default: + d = fe ? p.Variable_0_implicitly_has_an_1_type : p.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage; + } + dd(fe, r, d, co(_s(r)), f); + } + function Ynt(r, a) { + const l = eX(r); + if (!l) + return !0; + let f = Wa(l); + const d = Mc(r); + switch (a) { + case 1: + return d & 1 ? f = oy(1, f, !!(d & 2)) ?? f : d & 2 && (f = a0(f) ?? f), nb(f); + case 3: + const y = oy(0, f, !!(d & 2)); + return !!y && nb(y); + case 2: + const x = oy(2, f, !!(d & 2)); + return !!x && nb(x); + } + return !1; + } + function L$(r, a, l) { + n(() => { + fe && Dn(a) & 65536 && (!l || io(r) && Ynt(r, l)) && (O$(a) || cb(r, a, l)); + }); + } + function Gpe(r, a, l) { + const f = $_(r), d = $_(a), y = wI(r), x = wI(a), I = x ? d - 1 : d, J = y ? I : Math.min(f, I), z = tb(r); + if (z) { + const G = tb(a); + G && l(z, G); + } + for (let G = 0; G < J; G++) + l(Kd(r, G), Kd(a, G)); + x && l($M( + r, + J, + /*readonly*/ + CT(x) && !wp(x, zpe) + ), x); + } + function $pe(r, a, l) { + const f = kp(a); + if (f) { + const y = kp(r); + if (y && _pe(y, f) && y.type && f.type) { + l(y.type, f.type); + return; + } + } + const d = Wa(a); + N1(d) && l(Wa(r), d); + } + function gI(r, a, l, f) { + return Xpe(r.map(Ype), a, l, f || Npe); + } + function dAe(r, a = 0) { + return r && Xpe(hr(r.inferences, mAe), r.signature, r.flags | a, r.compareTypes); + } + function Xpe(r, a, l, f) { + const d = { + inferences: r, + signature: a, + flags: l, + compareTypes: f, + mapper: Co, + // initialize to a noop mapper so the context object is available, but the underlying object shape is right upon construction + nonFixingMapper: Co + }; + return d.mapper = Znt(d), d.nonFixingMapper = Knt(d), d; + } + function Znt(r) { + return Cpe( + hr(r.inferences, (a) => a.typeParameter), + hr(r.inferences, (a, l) => () => (a.isFixed || (eit(r), M$(r.inferences), a.isFixed = !0), ide(r, l))) + ); + } + function Knt(r) { + return Cpe( + hr(r.inferences, (a) => a.typeParameter), + hr(r.inferences, (a, l) => () => ide(r, l)) + ); + } + function M$(r) { + for (const a of r) + a.isFixed || (a.inferredType = void 0); + } + function Qpe(r, a, l) { + (r.intraExpressionInferenceSites ?? (r.intraExpressionInferenceSites = [])).push({ node: a, type: l }); + } + function eit(r) { + if (r.intraExpressionInferenceSites) { + for (const { node: a, type: l } of r.intraExpressionInferenceSites) { + const f = a.kind === 175 ? v8e( + a, + 2 + /* NoConstraints */ + ) : g_( + a, + 2 + /* NoConstraints */ + ); + f && uh(r.inferences, l, f); + } + r.intraExpressionInferenceSites = void 0; + } + } + function Ype(r) { + return { + typeParameter: r, + candidates: void 0, + contraCandidates: void 0, + inferredType: void 0, + priority: void 0, + topLevel: !0, + isFixed: !1, + impliedArity: void 0 + }; + } + function mAe(r) { + return { + typeParameter: r.typeParameter, + candidates: r.candidates && r.candidates.slice(), + contraCandidates: r.contraCandidates && r.contraCandidates.slice(), + inferredType: r.inferredType, + priority: r.priority, + topLevel: r.topLevel, + isFixed: r.isFixed, + impliedArity: r.impliedArity + }; + } + function tit(r) { + const a = kn(r.inferences, GE); + return a.length ? Xpe(hr(a, mAe), r.signature, r.flags, r.compareTypes) : void 0; + } + function Zpe(r) { + return r && r.mapper; + } + function N1(r) { + const a = Dn(r); + if (a & 524288) + return !!(a & 1048576); + const l = !!(r.flags & 465829888 || r.flags & 524288 && !gAe(r) && (a & 4 && (r.node || ot(Ao(r), N1)) || a & 16 && r.symbol && r.symbol.flags & 14384 && r.symbol.declarations || a & 12583968) || r.flags & 3145728 && !(r.flags & 1024) && !gAe(r) && ot(r.types, N1)); + return r.flags & 3899393 && (r.objectFlags |= 524288 | (l ? 1048576 : 0)), l; + } + function gAe(r) { + if (r.aliasSymbol && !r.aliasTypeArguments) { + const a = Oo( + r.aliasSymbol, + 266 + /* TypeAliasDeclaration */ + ); + return !!(a && dr(a.parent, (l) => l.kind === 308 ? !0 : l.kind === 268 ? !1 : "quit")); + } + return !1; + } + function hI(r, a, l = 0) { + return !!(r === a || r.flags & 3145728 && ot(r.types, (f) => hI(f, a, l)) || l < 3 && r.flags & 16777216 && (hI(E1(r), a, l + 1) || hI(D1(r), a, l + 1))); + } + function rit(r, a) { + const l = kp(r); + return l ? !!l.type && hI(l.type, a) : hI(Wa(r), a); + } + function nit(r) { + const a = Bs(); + BT(r, (f) => { + if (!(f.flags & 128)) + return; + const d = tc(f.value), y = ga(4, d); + y.links.type = Le, f.symbol && (y.declarations = f.symbol.declarations, y.valueDeclaration = f.symbol.valueDeclaration), a.set(d, y); + }); + const l = r.flags & 4 ? [oh( + at, + ta, + /*isReadonly*/ + !1 + )] : Ge; + return Ho( + /*symbol*/ + void 0, + a, + Ge, + Ge, + l + ); + } + function hAe(r, a, l) { + const f = r.id + "," + a.id + "," + l.id; + if (au.has(f)) + return au.get(f); + const d = iit(r, a, l); + return au.set(f, d), d; + } + function Kpe(r) { + return !(Dn(r) & 262144) || sy(r) && ot($a(r), (a) => Kpe(Yr(a))) || Sa(r) && ot(F2(r), Kpe); + } + function iit(r, a, l) { + if (!(ah(r, at) || $a(r).length !== 0 && Kpe(r))) + return; + if (Ep(r)) { + const d = R$(Ao(r)[0], a, l); + return d ? Tu(d, gP(r)) : void 0; + } + if (Sa(r)) { + const d = hr(F2(r), (x) => R$(x, a, l)); + if (!Ni(d, (x) => !!x)) + return; + const y = mg(a) & 4 ? Qc(r.target.elementFlags, (x) => x & 2 ? 1 : x) : r.target.elementFlags; + return hg(d, y, r.target.readonly, r.target.labeledElementDeclarations); + } + const f = Wc( + 1040, + /*symbol*/ + void 0 + ); + return f.source = r, f.mappedType = a, f.constraintType = l, f; + } + function sit(r) { + const a = Pn(r); + return a.type || (a.type = R$(r.links.propertyType, r.links.mappedType, r.links.constraintType) || yt), a.type; + } + function ait(r, a, l) { + const f = vf(l.type, Sd(a)), d = sh(a), y = Ype(f); + return uh([y], r, d), yAe(y) || yt; + } + function R$(r, a, l) { + const f = r.id + "," + a.id + "," + l.id; + if (Bd.has(f)) + return Bd.get(f) || yt; + Iv.push(r), tT.push(a); + const d = Fv; + aC(r, Iv, Iv.length, 2) && (Fv |= 1), aC(a, tT, tT.length, 2) && (Fv |= 2); + let y; + return Fv !== 3 && (y = ait(r, a, l)), Iv.pop(), tT.pop(), Fv = d, Bd.set(f, y), y; + } + function* ede(r, a, l, f) { + const d = $a(a); + for (const y of d) + if (!XPe(y) && (l || !(y.flags & 16777216 || uc(y) & 48))) { + const x = Ys(r, y.escapedName); + if (!x) + yield y; + else if (f) { + const I = Yr(y); + if (I.flags & 109472) { + const J = Yr(x); + J.flags & 1 || t_(J) === t_(I) || (yield y); + } + } + } + } + function tde(r, a, l, f) { + return XI(ede(r, a, l, f)); + } + function oit(r, a) { + return !(a.target.combinedFlags & 8) && a.target.minLength > r.target.minLength || !(a.target.combinedFlags & 12) && (!!(r.target.combinedFlags & 12) || a.target.fixedLength < r.target.fixedLength); + } + function cit(r, a) { + return Sa(r) && Sa(a) ? oit(r, a) : !!tde( + r, + a, + /*requireOptionalProperties*/ + !1, + /*matchDiscriminantProperties*/ + !0 + ) && !!tde( + a, + r, + /*requireOptionalProperties*/ + !1, + /*matchDiscriminantProperties*/ + !1 + ); + } + function yAe(r) { + return r.candidates ? Xn( + r.candidates, + 2 + /* Subtype */ + ) : r.contraCandidates ? sa(r.contraCandidates) : void 0; + } + function rde(r) { + return !!xn(r).skipDirectInference; + } + function vAe(r) { + return !!(r.symbol && ot(r.symbol.declarations, rde)); + } + function lit(r, a) { + const l = r.texts[0], f = a.texts[0], d = r.texts[r.texts.length - 1], y = a.texts[a.texts.length - 1], x = Math.min(l.length, f.length), I = Math.min(d.length, y.length); + return l.slice(0, x) !== f.slice(0, x) || d.slice(d.length - I) !== y.slice(y.length - I); + } + function bAe(r, a) { + if (r === "") return !1; + const l = +r; + return isFinite(l) && (!a || "" + l === r); + } + function uit(r) { + return _M(BJ(r)); + } + function j$(r, a) { + if (a.flags & 1) + return !0; + if (a.flags & 134217732) + return Ms(r, a); + if (a.flags & 268435456) { + const l = []; + for (; a.flags & 268435456; ) + l.unshift(a.symbol), a = a.type; + return Wu(l, (d, y) => rC(y, d), r) === r && j$(r, a); + } + return !1; + } + function SAe(r, a) { + if (a.flags & 2097152) + return Ni(a.types, (l) => l === Ws || SAe(r, l)); + if (a.flags & 4 || Ms(r, a)) + return !0; + if (r.flags & 128) { + const l = r.value; + return !!(a.flags & 8 && bAe( + l, + /*roundTripOnly*/ + !1 + ) || a.flags & 64 && sF( + l, + /*roundTripOnly*/ + !1 + ) || a.flags & 98816 && l === a.intrinsicName || a.flags & 268435456 && j$(r, a) || a.flags & 134217728 && B$(r, a)); + } + if (r.flags & 134217728) { + const l = r.texts; + return l.length === 2 && l[0] === "" && l[1] === "" && Ms(r.types[0], a); + } + return !1; + } + function TAe(r, a) { + return r.flags & 128 ? xAe([r.value], Ge, a) : r.flags & 134217728 ? Tf(r.texts, a.texts) ? hr(r.types, (l, f) => Ms(Rm(l), Rm(a.types[f])) ? l : _it(l)) : xAe(r.texts, r.types, a) : void 0; + } + function B$(r, a) { + const l = TAe(r, a); + return !!l && Ni(l, (f, d) => SAe(f, a.types[d])); + } + function _it(r) { + return r.flags & 402653317 ? r : wT(["", ""], [r]); + } + function xAe(r, a, l) { + const f = r.length - 1, d = r[0], y = r[f], x = l.texts, I = x.length - 1, J = x[0], z = x[I]; + if (f === 0 && d.length < J.length + z.length || !d.startsWith(J) || !y.endsWith(z)) return; + const G = y.slice(0, y.length - z.length), ve = []; + let de = 0, We = J.length; + for (let jt = 1; jt < I; jt++) { + const ar = x[jt]; + if (ar.length > 0) { + let jr = de, Kr = We; + for (; Kr = lt(jr).indexOf(ar, Kr), !(Kr >= 0); ) { + if (jr++, jr === r.length) return; + Kr = 0; + } + gt(jr, Kr), We += ar.length; + } else if (We < lt(de).length) + gt(de, We + 1); + else if (de < f) + gt(de + 1, 0); + else + return; + } + return gt(f, lt(f).length), ve; + function lt(jt) { + return jt < f ? r[jt] : G; + } + function gt(jt, ar) { + const jr = jt === de ? H_(lt(jt).slice(We, ar)) : wT( + [r[de].slice(We), ...r.slice(de + 1, jt), lt(jt).slice(0, ar)], + a.slice(de, jt) + ); + ve.push(jr), de = jt, We = ar; + } + } + function uh(r, a, l, f = 0, d = !1) { + let y = !1, x, I = 2048, J, z, G, ve = 0; + de(a, l); + function de(Dr, Br) { + if (!(!N1(Br) || LE(Br))) { + if (Dr === pt || Dr === Ct) { + const xi = x; + x = Dr, de(Br, Br), x = xi; + return; + } + if (Dr.aliasSymbol && Dr.aliasSymbol === Br.aliasSymbol) { + if (Dr.aliasTypeArguments) { + const xi = Pn(Dr.aliasSymbol).typeParameters, en = gg(xi), us = ty(Dr.aliasTypeArguments, xi, en, an(Dr.aliasSymbol.valueDeclaration)), Ga = ty(Br.aliasTypeArguments, xi, en, an(Dr.aliasSymbol.valueDeclaration)); + jr(us, Ga, ZNe(Dr.aliasSymbol)); + } + return; + } + if (Dr === Br && Dr.flags & 3145728) { + for (const xi of Dr.types) + de(xi, xi); + return; + } + if (Br.flags & 1048576) { + const [xi, en] = ar(Dr.flags & 1048576 ? Dr.types : [Dr], Br.types, fit), [us, Ga] = ar(xi, en, pit); + if (Ga.length === 0) + return; + if (Br = Xn(Ga), us.length === 0) { + We( + Dr, + Br, + 1 + /* NakedTypeVariable */ + ); + return; + } + Dr = Xn(us); + } else if (Br.flags & 2097152 && !Ni(Br.types, p$) && !(Dr.flags & 1048576)) { + const [xi, en] = ar(Dr.flags & 2097152 ? Dr.types : [Dr], Br.types, lh); + if (xi.length === 0 || en.length === 0) + return; + Dr = sa(xi), Br = sa(en); + } + if (Br.flags & 41943040) { + if (LE(Br)) + return; + Br = Kh(Br); + } + if (Br.flags & 8650752) { + if (vAe(Dr)) + return; + const xi = ir(Br); + if (xi) { + if (Dn(Dr) & 262144 || Dr === rn) + return; + if (!xi.isFixed) { + const us = x || Dr; + if (us === Ct) + return; + (xi.priority === void 0 || f < xi.priority) && (xi.candidates = void 0, xi.contraCandidates = void 0, xi.topLevel = !0, xi.priority = f), f === xi.priority && (d && !y ? ms(xi.contraCandidates, us) || (xi.contraCandidates = Er(xi.contraCandidates, us), M$(r)) : ms(xi.candidates, us) || (xi.candidates = Er(xi.candidates, us), M$(r))), !(f & 128) && Br.flags & 262144 && xi.topLevel && !hI(l, Br) && (xi.topLevel = !1, M$(r)); + } + I = Math.min(I, f); + return; + } + const en = Zh( + Br, + /*writing*/ + !1 + ); + if (en !== Br) + de(Dr, en); + else if (Br.flags & 8388608) { + const us = Zh( + Br.indexType, + /*writing*/ + !1 + ); + if (us.flags & 465829888) { + const Ga = bNe( + Zh( + Br.objectType, + /*writing*/ + !1 + ), + us, + /*writing*/ + !1 + ); + Ga && Ga !== Br && de(Dr, Ga); + } + } + } + if (Dn(Dr) & 4 && Dn(Br) & 4 && (Dr.target === Br.target || Ep(Dr) && Ep(Br)) && !(Dr.node && Br.node)) + jr(Ao(Dr), Ao(Br), jpe(Dr.target)); + else if (Dr.flags & 4194304 && Br.flags & 4194304) + Kr(Dr.type, Br.type); + else if ((fI(Dr) || Dr.flags & 4) && Br.flags & 4194304) { + const xi = nit(Dr); + lt( + xi, + Br.type, + 256 + /* LiteralKeyof */ + ); + } else if (Dr.flags & 8388608 && Br.flags & 8388608) + de(Dr.objectType, Br.objectType), de(Dr.indexType, Br.indexType); + else if (Dr.flags & 268435456 && Br.flags & 268435456) + Dr.symbol === Br.symbol && de(Dr.type, Br.type); + else if (Dr.flags & 33554432) + de(Dr.baseType, Br), We( + Zfe(Dr), + Br, + 4 + /* SubstituteSource */ + ); + else if (Br.flags & 16777216) + jt(Dr, Br, zn); + else if (Br.flags & 3145728) + Qn(Dr, Br.types, Br.flags); + else if (Dr.flags & 1048576) { + const xi = Dr.types; + for (const en of xi) + de(en, Br); + } else if (Br.flags & 134217728) + bi(Dr, Br); + else { + if (Dr = td(Dr), L_(Dr) && L_(Br) && jt(Dr, Br, ks), !(f & 512 && Dr.flags & 467927040)) { + const xi = e_(Dr); + if (xi !== Dr && !(xi.flags & 2621440)) + return de(xi, Br); + Dr = xi; + } + Dr.flags & 2621440 && jt(Dr, Br, Ua); + } + } + } + function We(Dr, Br, xi) { + const en = f; + f |= xi, de(Dr, Br), f = en; + } + function lt(Dr, Br, xi) { + const en = f; + f |= xi, Kr(Dr, Br), f = en; + } + function gt(Dr, Br, xi, en) { + const us = f; + f |= en, Qn(Dr, Br, xi), f = us; + } + function jt(Dr, Br, xi) { + const en = Dr.id + "," + Br.id, us = J && J.get(en); + if (us !== void 0) { + I = Math.min(I, us); + return; + } + (J || (J = /* @__PURE__ */ new Map())).set( + en, + -1 + /* Circularity */ + ); + const Ga = I; + I = 2048; + const Io = ve; + (z ?? (z = [])).push(Dr), (G ?? (G = [])).push(Br), aC(Dr, z, z.length, 2) && (ve |= 1), aC(Br, G, G.length, 2) && (ve |= 2), ve !== 3 ? xi(Dr, Br) : I = -1, G.pop(), z.pop(), ve = Io, J.set(en, I), I = Math.min(I, Ga); + } + function ar(Dr, Br, xi) { + let en, us; + for (const Ga of Br) + for (const Io of Dr) + xi(Io, Ga) && (de(Io, Ga), en = dh(en, Io), us = dh(us, Ga)); + return [ + en ? kn(Dr, (Ga) => !ms(en, Ga)) : Dr, + us ? kn(Br, (Ga) => !ms(us, Ga)) : Br + ]; + } + function jr(Dr, Br, xi) { + const en = Dr.length < Br.length ? Dr.length : Br.length; + for (let us = 0; us < en; us++) + us < xi.length && (xi[us] & 7) === 2 ? Kr(Dr[us], Br[us]) : de(Dr[us], Br[us]); + } + function Kr(Dr, Br) { + d = !d, de(Dr, Br), d = !d; + } + function or(Dr, Br) { + V || f & 1024 ? Kr(Dr, Br) : de(Dr, Br); + } + function ir(Dr) { + if (Dr.flags & 8650752) { + for (const Br of r) + if (Dr === Br.typeParameter) + return Br; + } + } + function nn(Dr) { + let Br; + for (const xi of Dr) { + const en = xi.flags & 2097152 && Nn(xi.types, (us) => !!ir(us)); + if (!en || Br && en !== Br) + return; + Br = en; + } + return Br; + } + function Qn(Dr, Br, xi) { + let en = 0; + if (xi & 1048576) { + let us; + const Ga = Dr.flags & 1048576 ? Dr.types : [Dr], Io = new Array(Ga.length); + let Jl = !1; + for (const Ta of Br) + if (ir(Ta)) + us = Ta, en++; + else + for (let Oc = 0; Oc < Ga.length; Oc++) { + const Uc = I; + I = 2048, de(Ga[Oc], Ta), I === f && (Io[Oc] = !0), Jl = Jl || I === -1, I = Math.min(I, Uc); + } + if (en === 0) { + const Ta = nn(Br); + Ta && We( + Dr, + Ta, + 1 + /* NakedTypeVariable */ + ); + return; + } + if (en === 1 && !Jl) { + const Ta = ka(Ga, (Oc, Uc) => Io[Uc] ? void 0 : Oc); + if (Ta.length) { + de(Xn(Ta), us); + return; + } + } + } else + for (const us of Br) + ir(us) ? en++ : de(Dr, us); + if (xi & 2097152 ? en === 1 : en > 0) + for (const us of Br) + ir(us) && We( + Dr, + us, + 1 + /* NakedTypeVariable */ + ); + } + function Ri(Dr, Br, xi) { + if (xi.flags & 1048576 || xi.flags & 2097152) { + let en = !1; + for (const us of xi.types) + en = Ri(Dr, Br, us) || en; + return en; + } + if (xi.flags & 4194304) { + const en = ir(xi.type); + if (en && !en.isFixed && !vAe(Dr)) { + const us = hAe(Dr, Br, xi); + us && We( + us, + en.typeParameter, + Dn(Dr) & 262144 ? 16 : 8 + /* HomomorphicMappedType */ + ); + } + return !0; + } + if (xi.flags & 262144) { + We( + jm( + Dr, + /*indexFlags*/ + Dr.pattern ? 2 : 0 + /* None */ + ), + xi, + 32 + /* MappedTypeConstraint */ + ); + const en = kT(xi); + if (en && Ri(Dr, Br, en)) + return !0; + const us = hr($a(Dr), Yr), Ga = hr(Su(Dr), (Io) => Io !== Li ? Io.type : nr); + return de(Xn(Bi(us, Ga)), sh(Br)), !0; + } + return !1; + } + function zn(Dr, Br) { + if (Dr.flags & 16777216) + de(Dr.checkType, Br.checkType), de(Dr.extendsType, Br.extendsType), de(E1(Dr), E1(Br)), de(D1(Dr), D1(Br)); + else { + const xi = [E1(Br), D1(Br)]; + gt(Dr, xi, Br.flags, d ? 64 : 0); + } + } + function bi(Dr, Br) { + const xi = TAe(Dr, Br), en = Br.types; + if (xi || Ni(Br.texts, (us) => us.length === 0)) + for (let us = 0; us < en.length; us++) { + const Ga = xi ? xi[us] : nr, Io = en[us]; + if (Ga.flags & 128 && Io.flags & 8650752) { + const Jl = ir(Io), Ta = Jl ? ou(Jl.typeParameter) : void 0; + if (Ta && !gn(Ta)) { + const Oc = Ta.flags & 1048576 ? Ta.types : [Ta]; + let Uc = Wu(Oc, (Xa, Yf) => Xa | Yf.flags, 0); + if (!(Uc & 4)) { + const Xa = Ga.value; + Uc & 296 && !bAe( + Xa, + /*roundTripOnly*/ + !0 + ) && (Uc &= -297), Uc & 2112 && !sF( + Xa, + /*roundTripOnly*/ + !0 + ) && (Uc &= -2113); + const Yf = Wu(Oc, ($o, wc) => wc.flags & Uc ? $o.flags & 4 ? $o : wc.flags & 4 ? Ga : $o.flags & 134217728 ? $o : wc.flags & 134217728 && B$(Ga, wc) ? Ga : $o.flags & 268435456 ? $o : wc.flags & 268435456 && Xa === gNe(wc.symbol, Xa) ? Ga : $o.flags & 128 ? $o : wc.flags & 128 && wc.value === Xa ? wc : $o.flags & 8 ? $o : wc.flags & 8 ? Xd(+Xa) : $o.flags & 32 ? $o : wc.flags & 32 ? Xd(+Xa) : $o.flags & 256 ? $o : wc.flags & 256 && wc.value === +Xa ? wc : $o.flags & 64 ? $o : wc.flags & 64 ? uit(Xa) : $o.flags & 2048 ? $o : wc.flags & 2048 && Ub(wc.value) === Xa ? wc : $o.flags & 16 ? $o : wc.flags & 16 ? Xa === "true" ? rt : Xa === "false" ? Rr : Nt : $o.flags & 512 ? $o : wc.flags & 512 && wc.intrinsicName === Xa ? wc : $o.flags & 32768 ? $o : wc.flags & 32768 && wc.intrinsicName === Xa ? wc : $o.flags & 65536 ? $o : wc.flags & 65536 && wc.intrinsicName === Xa ? wc : $o : $o, nr); + if (!(Yf.flags & 131072)) { + de(Yf, Io); + continue; + } + } + } + } + de(Ga, Io); + } + } + function ks(Dr, Br) { + de($f(Dr), $f(Br)), de(sh(Dr), sh(Br)); + const xi = K0(Dr), en = K0(Br); + xi && en && de(xi, en); + } + function Ua(Dr, Br) { + var xi, en; + if (Dn(Dr) & 4 && Dn(Br) & 4 && (Dr.target === Br.target || Ep(Dr) && Ep(Br))) { + jr(Ao(Dr), Ao(Br), jpe(Dr.target)); + return; + } + if (L_(Dr) && L_(Br) && ks(Dr, Br), Dn(Br) & 32 && !Br.declaration.nameType) { + const us = $f(Br); + if (Ri(Dr, Br, us)) + return; + } + if (!cit(Dr, Br)) { + if (ab(Dr)) { + if (Sa(Br)) { + const us = ry(Dr), Ga = ry(Br), Io = Ao(Br), Jl = Br.target.elementFlags; + if (Sa(Dr) && znt(Dr, Br)) { + for (let Uc = 0; Uc < Ga; Uc++) + de(Ao(Dr)[Uc], Io[Uc]); + return; + } + const Ta = Sa(Dr) ? Math.min(Dr.target.fixedLength, Br.target.fixedLength) : 0, Oc = Math.min(Sa(Dr) ? nI( + Dr.target, + 3 + /* Fixed */ + ) : 0, Br.target.combinedFlags & 12 ? nI( + Br.target, + 3 + /* Fixed */ + ) : 0); + for (let Uc = 0; Uc < Ta; Uc++) + de(Ao(Dr)[Uc], Io[Uc]); + if (!Sa(Dr) || us - Ta - Oc === 1 && Dr.target.elementFlags[Ta] & 4) { + const Uc = Ao(Dr)[Ta]; + for (let Xa = Ta; Xa < Ga - Oc; Xa++) + de(Jl[Xa] & 8 ? Tu(Uc) : Uc, Io[Xa]); + } else { + const Uc = Ga - Ta - Oc; + if (Uc === 2) { + if (Jl[Ta] & Jl[Ta + 1] & 8) { + const Xa = ir(Io[Ta]); + Xa && Xa.impliedArity !== void 0 && (de(dP(Dr, Ta, Oc + us - Xa.impliedArity), Io[Ta]), de(dP(Dr, Ta + Xa.impliedArity, Oc), Io[Ta + 1])); + } else if (Jl[Ta] & 8 && Jl[Ta + 1] & 4) { + const Xa = (xi = ir(Io[Ta])) == null ? void 0 : xi.typeParameter, Yf = Xa && ou(Xa); + if (Yf && Sa(Yf) && !(Yf.target.combinedFlags & 12)) { + const $o = Yf.target.fixedLength; + de(dP(Dr, Ta, us - (Ta + $o)), Io[Ta]), de(yP(Dr, Ta + $o, Oc), Io[Ta + 1]); + } + } else if (Jl[Ta] & 4 && Jl[Ta + 1] & 8) { + const Xa = (en = ir(Io[Ta + 1])) == null ? void 0 : en.typeParameter, Yf = Xa && ou(Xa); + if (Yf && Sa(Yf) && !(Yf.target.combinedFlags & 12)) { + const $o = Yf.target.fixedLength, wc = us - nI( + Br.target, + 3 + /* Fixed */ + ), Np = wc - $o, IP = hg( + Ao(Dr).slice(Np, wc), + Dr.target.elementFlags.slice(Np, wc), + /*readonly*/ + !1, + Dr.target.labeledElementDeclarations && Dr.target.labeledElementDeclarations.slice(Np, wc) + ); + de(yP(Dr, Ta, Oc + $o), Io[Ta]), de(IP, Io[Ta + 1]); + } + } + } else if (Uc === 1 && Jl[Ta] & 8) { + const Xa = Br.target.elementFlags[Ga - 1] & 2, Yf = dP(Dr, Ta, Oc); + We(Yf, Io[Ta], Xa ? 2 : 0); + } else if (Uc === 1 && Jl[Ta] & 4) { + const Xa = yP(Dr, Ta, Oc); + Xa && de(Xa, Io[Ta]); + } + } + for (let Uc = 0; Uc < Oc; Uc++) + de(Ao(Dr)[us - Uc - 1], Io[Ga - Uc - 1]); + return; + } + if (Ep(Br)) { + Bu(Dr, Br); + return; + } + } + Vi(Dr, Br), jo( + Dr, + Br, + 0 + /* Call */ + ), jo( + Dr, + Br, + 1 + /* Construct */ + ), Bu(Dr, Br); + } + } + function Vi(Dr, Br) { + const xi = ey(Br); + for (const en of xi) { + const us = Ys(Dr, en.escapedName); + us && !ot(us.declarations, rde) && de( + i0(Yr(us), !!(us.flags & 16777216)), + i0(Yr(en), !!(en.flags & 16777216)) + ); + } + } + function jo(Dr, Br, xi) { + const en = Is(Dr, xi), us = en.length; + if (us > 0) { + const Ga = Is(Br, xi), Io = Ga.length; + for (let Jl = 0; Jl < Io; Jl++) { + const Ta = Math.max(us - Io + Jl, 0); + Sc(mtt(en[Ta]), rI(Ga[Jl])); + } + } + } + function Sc(Dr, Br) { + if (!(Dr.flags & 64)) { + const xi = y, en = Br.declaration ? Br.declaration.kind : 0; + y = y || en === 175 || en === 174 || en === 177, Gpe(Dr, Br, or), y = xi; + } + $pe(Dr, Br, de); + } + function Bu(Dr, Br) { + const xi = Dn(Dr) & Dn(Br) & 32 ? 8 : 0, en = Su(Br); + if (F$(Dr)) + for (const us of en) { + const Ga = []; + for (const Io of $a(Dr)) + if (Kk(tC( + Io, + 8576 + /* StringOrNumberLiteralOrUnique */ + ), us.keyType)) { + const Jl = Yr(Io); + Ga.push(Io.flags & 16777216 ? I$(Jl) : Jl); + } + for (const Io of Su(Dr)) + Kk(Io.keyType, us.keyType) && Ga.push(Io.type); + Ga.length && We(Xn(Ga), us.type, xi); + } + for (const us of en) { + const Ga = Z8(Dr, us.keyType); + Ga && We(Ga.type, us.type, xi); + } + } + } + function fit(r, a) { + return a === ye ? r === a : lh(r, a) || !!(a.flags & 4 && r.flags & 128 || a.flags & 8 && r.flags & 256); + } + function pit(r, a) { + return !!(r.flags & 524288 && a.flags & 524288 && r.symbol && r.symbol === a.symbol || r.aliasSymbol && r.aliasTypeArguments && r.aliasSymbol === a.aliasSymbol); + } + function dit(r) { + const a = m_(r); + return !!a && Dc( + a.flags & 16777216 ? Mfe(a) : a, + 406978556 + /* StringMapping */ + ); + } + function sy(r) { + return !!(Dn(r) & 128); + } + function nde(r) { + return !!(Dn(r) & 16512); + } + function mit(r) { + if (r.length > 1) { + const a = kn(r, nde); + if (a.length) { + const l = Xn( + a, + 2 + /* Subtype */ + ); + return Bi(kn(r, (f) => !nde(f)), [l]); + } + } + return r; + } + function git(r) { + return r.priority & 416 ? sa(r.contraCandidates) : Ont(r.contraCandidates); + } + function hit(r, a) { + const l = mit(r.candidates), f = dit(r.typeParameter) || CT(r.typeParameter), d = !f && r.topLevel && (r.isFixed || !rit(a, r.typeParameter)), y = f ? Qc(l, t_) : d ? Qc(l, ob) : l, x = r.priority & 416 ? Xn( + y, + 2 + /* Subtype */ + ) : Int(y); + return Sf(x); + } + function ide(r, a) { + const l = r.inferences[a]; + if (!l.inferredType) { + let f, d; + if (r.signature) { + const x = l.candidates ? hit(l, r.signature) : void 0, I = l.contraCandidates ? git(l) : void 0; + if (x || I) { + const J = x && (!I || !(x.flags & 131073) && ot(l.contraCandidates, (z) => Ms(x, z)) && Ni(r.inferences, (z) => z !== l && m_(z.typeParameter) !== l.typeParameter || Ni(z.candidates, (G) => Ms(G, x)))); + f = J ? x : I, d = J ? I : x; + } else if (r.flags & 1) + f = kt; + else { + const J = A2(l.typeParameter); + J && (f = Mi(J, LNe(Vrt(r, a), r.nonFixingMapper))); + } + } else + f = yAe(l); + l.inferredType = f || sde(!!(r.flags & 2)); + const y = m_(l.typeParameter); + if (y) { + const x = Mi(y, r.nonFixingMapper); + (!f || !r.compareTypes(f, yf(x, f))) && (l.inferredType = d && r.compareTypes(d, yf(x, d)) ? d : x); + } + jst(); + } + return l.inferredType; + } + function sde(r) { + return r ? Le : yt; + } + function ade(r) { + const a = []; + for (let l = 0; l < r.inferences.length; l++) + a.push(ide(r, l)); + return a; + } + function kAe(r) { + switch (r.escapedText) { + case "document": + case "console": + return p.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom; + case "$": + return F.types ? p.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig : p.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery; + case "describe": + case "suite": + case "it": + case "test": + return F.types ? p.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig : p.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha; + case "process": + case "require": + case "Buffer": + case "module": + return F.types ? p.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig : p.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode; + case "Bun": + return F.types ? p.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_Bun_Try_npm_i_save_dev_types_Slashbun_and_then_add_bun_to_the_types_field_in_your_tsconfig : p.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_Bun_Try_npm_i_save_dev_types_Slashbun; + case "Map": + case "Set": + case "Promise": + case "Symbol": + case "WeakMap": + case "WeakSet": + case "Iterator": + case "AsyncIterator": + case "SharedArrayBuffer": + case "Atomics": + case "AsyncIterable": + case "AsyncIterableIterator": + case "AsyncGenerator": + case "AsyncGeneratorFunction": + case "BigInt": + case "Reflect": + case "BigInt64Array": + case "BigUint64Array": + return p.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_1_or_later; + case "await": + if (Ps(r.parent)) + return p.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function; + // falls through + default: + return r.parent.kind === 305 ? p.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer : p.Cannot_find_name_0; + } + } + function ju(r) { + const a = xn(r); + return a.resolvedSymbol || (a.resolvedSymbol = !lc(r) && st( + r, + r, + 1160127, + kAe(r), + !R5(r), + /*excludeGlobals*/ + !1 + ) || Y), a.resolvedSymbol; + } + function ode(r) { + return !!(r.flags & 33554432 || dr(r, (a) => Vl(a) || Wp(a) || a_(a))); + } + function kM(r, a, l, f) { + switch (r.kind) { + case 80: + if (!jb(r)) { + const x = ju(r); + return x !== Y ? `${f ? Ma(f) : "-1"}|${jl(a)}|${jl(l)}|${Xs(x)}` : void 0; + } + // falls through + case 110: + return `0|${f ? Ma(f) : "-1"}|${jl(a)}|${jl(l)}`; + case 236: + case 218: + return kM(r.expression, a, l, f); + case 167: + const d = kM(r.left, a, l, f); + return d && `${d}.${r.right.escapedText}`; + case 212: + case 213: + const y = MT(r); + if (y !== void 0) { + const x = kM(r.expression, a, l, f); + return x && `${x}.${y}`; + } + if (uo(r) && Me(r.argumentExpression)) { + const x = ju(r.argumentExpression); + if (oC(x) || bI(x) && !vI(x)) { + const I = kM(r.expression, a, l, f); + return I && `${I}.@${Xs(x)}`; + } + } + break; + case 207: + case 208: + case 263: + case 219: + case 220: + case 175: + return `${Ma(r)}#${jl(a)}`; + } + } + function Yl(r, a) { + switch (a.kind) { + case 218: + case 236: + return Yl(r, a.expression); + case 227: + return Nl(a) && Yl(r, a.left) || _n(a) && a.operatorToken.kind === 28 && Yl(r, a.right); + } + switch (r.kind) { + case 237: + return a.kind === 237 && r.keywordToken === a.keywordToken && r.name.escapedText === a.name.escapedText; + case 80: + case 81: + return jb(r) ? a.kind === 110 : a.kind === 80 && ju(r) === ju(a) || (ei(a) || ya(a)) && _t(ju(r)) === yn(a); + case 110: + return a.kind === 110; + case 108: + return a.kind === 108; + case 236: + case 218: + case 239: + return Yl(r.expression, a); + case 212: + case 213: + const l = MT(r); + if (l !== void 0) { + const f = To(a) ? MT(a) : void 0; + if (f !== void 0) + return f === l && Yl(r.expression, a.expression); + } + if (uo(r) && uo(a) && Me(r.argumentExpression) && Me(a.argumentExpression)) { + const f = ju(r.argumentExpression); + if (f === ju(a.argumentExpression) && (oC(f) || bI(f) && !vI(f))) + return Yl(r.expression, a.expression); + } + break; + case 167: + return To(a) && r.right.escapedText === MT(a) && Yl(r.left, a.expression); + case 227: + return _n(r) && r.operatorToken.kind === 28 && Yl(r.right, a); + } + return !1; + } + function MT(r) { + if (wn(r)) + return r.name.escapedText; + if (uo(r)) + return yit(r); + if (ya(r)) { + const a = X0(r); + return a ? tc(a) : void 0; + } + if (Ii(r)) + return "" + r.parent.parameters.indexOf(r); + } + function cde(r) { + return r.flags & 8192 ? r.escapedName : r.flags & 384 ? tc("" + r.value) : void 0; + } + function yit(r) { + return If(r.argumentExpression) ? tc(r.argumentExpression.text) : to(r.argumentExpression) ? vit(r.argumentExpression) : void 0; + } + function vit(r) { + const a = dc( + r, + 111551, + /*ignoreErrors*/ + !0 + ); + if (!a || !(oC(a) || a.flags & 8)) return; + const l = a.valueDeclaration; + if (l === void 0) return; + const f = x1(l); + if (f) { + const d = cde(f); + if (d !== void 0) + return d; + } + if (iS(l) && qh(l, r)) { + const d = j3(l); + if (d) { + const y = ws(l.parent) ? rh(l) : lu(d); + return y && cde(y); + } + if (Ph(l)) + return dx(l.name); + } + } + function CAe(r, a) { + for (; To(r); ) + if (r = r.expression, Yl(r, a)) + return !0; + return !1; + } + function RT(r, a) { + for (; Eu(r); ) + if (r = r.expression, Yl(r, a)) + return !0; + return !1; + } + function vP(r, a) { + if (r && r.flags & 1048576) { + const l = y3e(r, a); + if (l && uc(l) & 2) + return l.links.isDiscriminantProperty === void 0 && (l.links.isDiscriminantProperty = (l.links.checkFlags & 192) === 192 && !nb(Yr(l))), !!l.links.isDiscriminantProperty; + } + return !1; + } + function EAe(r, a) { + let l; + for (const f of r) + if (vP(a, f.escapedName)) { + if (l) { + l.push(f); + continue; + } + l = [f]; + } + return l; + } + function bit(r, a) { + const l = /* @__PURE__ */ new Map(); + let f = 0; + for (const d of r) + if (d.flags & 61603840) { + const y = rr(d, a); + if (y) { + if (!fI(y)) + return; + let x = !1; + BT(y, (I) => { + const J = jl(t_(I)), z = l.get(J); + z ? z !== yt && (l.set(J, yt), x = !0) : l.set(J, d); + }), x || f++; + } + } + return f >= 10 && f * 2 >= r.length ? l : void 0; + } + function CM(r) { + const a = r.types; + if (!(a.length < 10 || Dn(r) & 32768 || l0(a, (l) => !!(l.flags & 59506688)) < 10)) { + if (r.keyPropertyName === void 0) { + const l = lr(a, (d) => d.flags & 59506688 ? lr($a(d), (y) => Qd(Yr(y)) ? y.escapedName : void 0) : void 0), f = l && bit(a, l); + r.keyPropertyName = f ? l : "", r.constituentMap = f; + } + return r.keyPropertyName.length ? r.keyPropertyName : void 0; + } + } + function EM(r, a) { + var l; + const f = (l = r.constituentMap) == null ? void 0 : l.get(jl(t_(a))); + return f !== yt ? f : void 0; + } + function DAe(r, a) { + const l = CM(r), f = l && rr(a, l); + return f && EM(r, f); + } + function Sit(r, a) { + const l = CM(r), f = l && Nn(a.properties, (y) => y.symbol && y.kind === 304 && y.symbol.escapedName === l && LM(y.initializer)), d = f && tR(f.initializer); + return d && EM(r, d); + } + function wAe(r, a) { + return Yl(r, a) || CAe(r, a); + } + function PAe(r, a) { + if (r.arguments) { + for (const l of r.arguments) + if (wAe(a, l) || RT(l, a)) + return !0; + } + return !!(r.expression.kind === 212 && wAe(a, r.expression.expression)); + } + function lde(r) { + return r.id <= 0 && (r.id = W1e, W1e++), r.id; + } + function Tit(r, a) { + if (!(r.flags & 1048576)) + return Ms(r, a); + for (const l of r.types) + if (Ms(l, a)) + return !0; + return !1; + } + function xit(r, a) { + if (r === a) + return r; + if (a.flags & 131072) + return a; + const l = `A${jl(r)},${jl(a)}`; + return f_(l) ?? Yp(l, kit(r, a)); + } + function kit(r, a) { + const l = Xc(r, (d) => Tit(a, d)), f = a.flags & 512 && L2(a) ? Go(l, iC) : l; + return Ms(a, f) ? f : r; + } + function ude(r) { + if (Dn(r) & 256) + return !1; + const a = $d(r); + return !!(a.callSignatures.length || a.constructSignatures.length || a.members.get("bind") && R2(r, Mr)); + } + function BE(r, a) { + return _de(r, a) & a; + } + function Yd(r, a) { + return BE(r, a) !== 0; + } + function _de(r, a) { + r.flags & 467927040 && (r = ou(r) || yt); + const l = r.flags; + if (l & 268435460) + return K ? 16317953 : 16776705; + if (l & 134217856) { + const f = l & 128 && r.value === ""; + return K ? f ? 12123649 : 7929345 : f ? 12582401 : 16776705; + } + if (l & 40) + return K ? 16317698 : 16776450; + if (l & 256) { + const f = r.value === 0; + return K ? f ? 12123394 : 7929090 : f ? 12582146 : 16776450; + } + if (l & 64) + return K ? 16317188 : 16775940; + if (l & 2048) { + const f = lAe(r); + return K ? f ? 12122884 : 7928580 : f ? 12581636 : 16775940; + } + return l & 16 ? K ? 16316168 : 16774920 : l & 528 ? K ? r === Rr || r === Pr ? 12121864 : 7927560 : r === Rr || r === Pr ? 12580616 : 16774920 : l & 524288 ? (a & (K ? 83427327 : 83886079)) === 0 ? 0 : Dn(r) & 16 && t0(r) ? K ? 83427327 : 83886079 : ude(r) ? K ? 7880640 : 16728e3 : K ? 7888800 : 16736160 : l & 16384 ? 9830144 : l & 32768 ? 26607360 : l & 65536 ? 42917664 : l & 12288 ? K ? 7925520 : 16772880 : l & 67108864 ? K ? 7888800 : 16736160 : l & 131072 ? 0 : l & 1048576 ? Wu( + r.types, + (f, d) => f | _de(d, a), + 0 + /* None */ + ) : l & 2097152 ? Cit(r, a) : 83886079; + } + function Cit(r, a) { + const l = Dc( + r, + 402784252 + /* Primitive */ + ); + let f = 0, d = 134217727; + for (const y of r.types) + if (!(l && y.flags & 524288)) { + const x = _de(y, a); + f |= x, d &= x; + } + return f & 8256 | d & 134209471; + } + function Dp(r, a) { + return Xc(r, (l) => Yd(l, a)); + } + function jT(r, a) { + const l = fde(Dp(K && r.flags & 2 ? va : r, a)); + if (K) + switch (a) { + case 524288: + return NAe(l, 65536, 131072, 33554432, Mt); + case 1048576: + return NAe(l, 131072, 65536, 16777216, ue); + case 2097152: + case 4194304: + return Go(l, (f) => Yd( + f, + 262144 + /* EQUndefinedOrNull */ + ) ? Vnt(f) : f); + } + return l; + } + function NAe(r, a, l, f, d) { + const y = BE( + r, + 50528256 + /* IsNull */ + ); + if (!(y & a)) + return r; + const x = Xn([ta, d]); + return Go(r, (I) => Yd(I, a) ? sa([I, !(y & f) && Yd(I, l) ? x : ta]) : I); + } + function fde(r) { + return r === va ? yt : r; + } + function pde(r, a) { + return a ? Xn([Ka(r), lu(a)]) : r; + } + function AAe(r, a) { + var l; + const f = Yh(a); + if (!_p(f)) return qe; + const d = fp(f); + return rr(r, d) || yI((l = eC(r, d)) == null ? void 0 : l.type) || qe; + } + function IAe(r, a) { + return G_(r, hP) && Lnt(r, a) || yI(ay( + 65, + r, + ue, + /*errorNode*/ + void 0 + )) || qe; + } + function yI(r) { + return r && (F.noUncheckedIndexedAccess ? Xn([r, ye]) : r); + } + function FAe(r) { + return Tu(ay( + 65, + r, + ue, + /*errorNode*/ + void 0 + ) || qe); + } + function Eit(r) { + return r.parent.kind === 210 && dde(r.parent) || r.parent.kind === 304 && dde(r.parent.parent) ? pde(DM(r), r.right) : lu(r.right); + } + function dde(r) { + return r.parent.kind === 227 && r.parent.left === r || r.parent.kind === 251 && r.parent.initializer === r; + } + function Dit(r, a) { + return IAe(DM(r), r.elements.indexOf(a)); + } + function wit(r) { + return FAe(DM(r.parent)); + } + function OAe(r) { + return AAe(DM(r.parent), r.name); + } + function Pit(r) { + return pde(OAe(r), r.objectAssignmentInitializer); + } + function DM(r) { + const { parent: a } = r; + switch (a.kind) { + case 250: + return at; + case 251: + return cR(a) || qe; + case 227: + return Eit(a); + case 221: + return ue; + case 210: + return Dit(a, r); + case 231: + return wit(a); + case 304: + return OAe(a); + case 305: + return Pit(a); + } + return qe; + } + function Nit(r) { + const a = r.parent, l = MAe(a.parent), f = a.kind === 207 ? AAe(l, r.propertyName || r.name) : r.dotDotDotToken ? FAe(l) : IAe(l, a.elements.indexOf(r)); + return pde(f, r.initializer); + } + function LAe(r) { + return xn(r).resolvedType || lu(r); + } + function Ait(r) { + return r.initializer ? LAe(r.initializer) : r.parent.parent.kind === 250 ? at : r.parent.parent.kind === 251 && cR(r.parent.parent) || qe; + } + function MAe(r) { + return r.kind === 261 ? Ait(r) : Nit(r); + } + function Iit(r) { + return r.kind === 261 && r.initializer && Y0(r.initializer) || r.kind !== 209 && r.parent.kind === 227 && Y0(r.parent.right); + } + function B2(r) { + switch (r.kind) { + case 218: + return B2(r.expression); + case 227: + switch (r.operatorToken.kind) { + case 64: + case 76: + case 77: + case 78: + return B2(r.left); + case 28: + return B2(r.right); + } + } + return r; + } + function RAe(r) { + const { parent: a } = r; + return a.kind === 218 || a.kind === 227 && a.operatorToken.kind === 64 && a.left === r || a.kind === 227 && a.operatorToken.kind === 28 && a.right === r ? RAe(a) : r; + } + function Fit(r) { + return r.kind === 297 ? t_(lu(r.expression)) : nr; + } + function J$(r) { + const a = xn(r); + if (!a.switchTypes) { + a.switchTypes = []; + for (const l of r.caseBlock.clauses) + a.switchTypes.push(Fit(l)); + } + return a.switchTypes; + } + function jAe(r) { + if (ot(r.caseBlock.clauses, (l) => l.kind === 297 && !ja(l.expression))) + return; + const a = []; + for (const l of r.caseBlock.clauses) { + const f = l.kind === 297 ? l.expression.text : void 0; + a.push(f && !ms(a, f) ? f : void 0); + } + return a; + } + function Oit(r, a) { + return r.flags & 1048576 ? !lr(r.types, (l) => !ms(a, l)) : ms(a, r); + } + function bP(r, a) { + return !!(r === a || r.flags & 131072 || a.flags & 1048576 && Lit(r, a)); + } + function Lit(r, a) { + if (r.flags & 1048576) { + for (const l of r.types) + if (!ch(a.types, l)) + return !1; + return !0; + } + return r.flags & 1056 && $G(r) === a ? !0 : ch(a.types, r); + } + function BT(r, a) { + return r.flags & 1048576 ? lr(r.types, a) : a(r); + } + function wp(r, a) { + return r.flags & 1048576 ? ot(r.types, a) : a(r); + } + function G_(r, a) { + return r.flags & 1048576 ? Ni(r.types, a) : a(r); + } + function Mit(r, a) { + return r.flags & 3145728 ? Ni(r.types, a) : a(r); + } + function Xc(r, a) { + if (r.flags & 1048576) { + const l = r.types, f = kn(l, a); + if (f === l) + return r; + const d = r.origin; + let y; + if (d && d.flags & 1048576) { + const x = d.types, I = kn(x, (J) => !!(J.flags & 1048576) || a(J)); + if (x.length - I.length === l.length - f.length) { + if (I.length === 1) + return I[0]; + y = upe(1048576, I); + } + } + return fpe( + f, + r.objectFlags & 16809984, + /*aliasSymbol*/ + void 0, + /*aliasTypeArguments*/ + void 0, + y + ); + } + return r.flags & 131072 || a(r) ? r : nr; + } + function z$(r, a) { + return Xc(r, (l) => l !== a); + } + function Rit(r) { + return r.flags & 1048576 ? r.types.length : 1; + } + function Go(r, a, l) { + if (r.flags & 131072) + return r; + if (!(r.flags & 1048576)) + return a(r); + const f = r.origin, d = f && f.flags & 1048576 ? f.types : r.types; + let y, x = !1; + for (const I of d) { + const J = I.flags & 1048576 ? Go(I, a, l) : a(I); + x || (x = I !== J), J && (y ? y.push(J) : y = [J]); + } + return x ? y && Xn( + y, + l ? 0 : 1 + /* Literal */ + ) : r; + } + function BAe(r, a, l, f) { + return r.flags & 1048576 && l ? Xn(hr(r.types, a), 1, l, f) : Go(r, a); + } + function SP(r, a) { + return Xc(r, (l) => (l.flags & a) !== 0); + } + function JAe(r, a) { + return Dc( + r, + 134217804 + /* BigInt */ + ) && Dc( + a, + 402655616 + /* BigIntLiteral */ + ) ? Go(r, (l) => l.flags & 4 ? SP( + a, + 402653316 + /* StringMapping */ + ) : PT(l) && !Dc( + a, + 402653188 + /* StringMapping */ + ) ? SP( + a, + 128 + /* StringLiteral */ + ) : l.flags & 8 ? SP( + a, + 264 + /* NumberLiteral */ + ) : l.flags & 64 ? SP( + a, + 2112 + /* BigIntLiteral */ + ) : l) : r; + } + function JE(r) { + return r.flags === 0; + } + function JT(r) { + return r.flags === 0 ? r.type : r; + } + function zE(r, a) { + return a ? { flags: 0, type: r.flags & 131072 ? kt : r } : r; + } + function jit(r) { + const a = Wc( + 256 + /* EvolvingArray */ + ); + return a.elementType = r, a; + } + function mde(r) { + return Et[r.id] || (Et[r.id] = jit(r)); + } + function zAe(r, a) { + const l = mI(r0(tR(a))); + return bP(l, r.elementType) ? r : mde(Xn([r.elementType, l])); + } + function Bit(r) { + return r.flags & 131072 ? Ol : Tu( + r.flags & 1048576 ? Xn( + r.types, + 2 + /* Subtype */ + ) : r + ); + } + function Jit(r) { + return r.finalArrayType || (r.finalArrayType = Bit(r.elementType)); + } + function wM(r) { + return Dn(r) & 256 ? Jit(r) : r; + } + function zit(r) { + return Dn(r) & 256 ? r.elementType : nr; + } + function Wit(r) { + let a = !1; + for (const l of r) + if (!(l.flags & 131072)) { + if (!(Dn(l) & 256)) + return !1; + a = !0; + } + return a; + } + function WAe(r) { + const a = RAe(r), l = a.parent, f = wn(l) && (l.name.escapedText === "length" || l.parent.kind === 214 && Me(l.name) && zB(l.name)), d = l.kind === 213 && l.expression === a && l.parent.kind === 227 && l.parent.operatorToken.kind === 64 && l.parent.left === l && !Ly(l.parent) && cu( + lu(l.argumentExpression), + 296 + /* NumberLike */ + ); + return f || d; + } + function Uit(r) { + return (ei(r) || os(r) || $u(r) || Ii(r)) && !!(Kc(r) || an(r) && d0(r) && r.initializer && zy(r.initializer) && nf(r.initializer)); + } + function W$(r, a) { + if (r = zc(r), r.flags & 8752) + return Yr(r); + if (r.flags & 7) { + if (uc(r) & 262144) { + const f = r.links.syntheticOrigin; + if (f && W$(f)) + return Yr(r); + } + const l = r.valueDeclaration; + if (l) { + if (Uit(l)) + return Yr(r); + if (ei(l) && l.parent.parent.kind === 251) { + const f = l.parent.parent, d = PM( + f.expression, + /*diagnostic*/ + void 0 + ); + if (d) { + const y = f.awaitModifier ? 15 : 13; + return ay( + y, + d, + ue, + /*errorNode*/ + void 0 + ); + } + } + a && zs(a, sn(l, p._0_needs_an_explicit_type_annotation, Wi(r))); + } + } + } + function PM(r, a) { + if (!(r.flags & 67108864)) + switch (r.kind) { + case 80: + const l = _t(ju(r)); + return W$(l, a); + case 110: + return ust(r); + case 108: + return $$(r); + case 212: { + const f = PM(r.expression, a); + if (f) { + const d = r.name; + let y; + if (Ai(d)) { + if (!f.symbol) + return; + y = Ys(f, Z3(f.symbol, d.escapedText)); + } else + y = Ys(f, d.escapedText); + return y && W$(y, a); + } + return; + } + case 218: + return PM(r.expression, a); + } + } + function NM(r) { + const a = xn(r); + let l = a.effectsSignature; + if (l === void 0) { + let f; + if (_n(r)) { + const x = UE(r.right); + f = mme(x); + } else r.parent.kind === 245 ? f = PM( + r.expression, + /*diagnostic*/ + void 0 + ) : r.expression.kind !== 108 && (Eu(r) ? f = Jm( + pI(Hi(r.expression), r.expression), + r.expression + ) : f = UE(r.expression)); + const d = Is( + f && e_(f) || yt, + 0 + /* Call */ + ), y = d.length === 1 && !d[0].typeParameters ? d[0] : ot(d, UAe) ? qE(r) : void 0; + l = a.effectsSignature = y && UAe(y) ? y : Vn; + } + return l === Vn ? void 0 : l; + } + function UAe(r) { + return !!(kp(r) || r.declaration && (IE(r.declaration) || yt).flags & 131072); + } + function Vit(r, a) { + if (r.kind === 1 || r.kind === 3) + return a.arguments[r.parameterIndex]; + const l = Ba(a.expression); + return To(l) ? Ba(l.expression) : void 0; + } + function qit(r) { + const a = dr(r, Vj), l = xr(r), f = om(l, a.statements.pos); + Aa.add(ll(l, f.start, f.length, p.The_containing_function_or_module_body_is_too_large_for_control_flow_analysis)); + } + function AM(r) { + const a = U$( + r, + /*noCacheCheck*/ + !1 + ); + return Zn = r, ns = a, a; + } + function IM(r) { + const a = Ba( + r, + /*excludeJSDocTypeAssertions*/ + !0 + ); + return a.kind === 97 || a.kind === 227 && (a.operatorToken.kind === 56 && (IM(a.left) || IM(a.right)) || a.operatorToken.kind === 57 && IM(a.left) && IM(a.right)); + } + function U$(r, a) { + for (; ; ) { + if (r === Zn) + return ns; + const l = r.flags; + if (l & 4096) { + if (!a) { + const f = lde(r), d = Ak[f]; + return d !== void 0 ? d : Ak[f] = U$( + r, + /*noCacheCheck*/ + !0 + ); + } + a = !1; + } + if (l & 368) + r = r.antecedent; + else if (l & 512) { + const f = NM(r.node); + if (f) { + const d = kp(f); + if (d && d.kind === 3 && !d.type) { + const y = r.node.arguments[d.parameterIndex]; + if (y && IM(y)) + return !1; + } + if (Wa(f).flags & 131072) + return !1; + } + r = r.antecedent; + } else { + if (l & 4) + return ot(r.antecedent, (f) => U$( + f, + /*noCacheCheck*/ + !1 + )); + if (l & 8) { + const f = r.antecedent; + if (f === void 0 || f.length === 0) + return !1; + r = f[0]; + } else if (l & 128) { + const f = r.node; + if (f.clauseStart === f.clauseEnd && LIe(f.switchStatement)) + return !1; + r = r.antecedent; + } else if (l & 1024) { + Zn = void 0; + const f = r.node.target, d = f.antecedent; + f.antecedent = r.node.antecedents; + const y = U$( + r.antecedent, + /*noCacheCheck*/ + !1 + ); + return f.antecedent = d, y; + } else + return !(l & 1); + } + } + } + function V$(r, a) { + for (; ; ) { + const l = r.flags; + if (l & 4096) { + if (!a) { + const f = lde(r), d = h2[f]; + return d !== void 0 ? d : h2[f] = V$( + r, + /*noCacheCheck*/ + !0 + ); + } + a = !1; + } + if (l & 496) + r = r.antecedent; + else if (l & 512) { + if (r.node.expression.kind === 108) + return !0; + r = r.antecedent; + } else { + if (l & 4) + return Ni(r.antecedent, (f) => V$( + f, + /*noCacheCheck*/ + !1 + )); + if (l & 8) + r = r.antecedent[0]; + else if (l & 1024) { + const f = r.node.target, d = f.antecedent; + f.antecedent = r.node.antecedents; + const y = V$( + r.antecedent, + /*noCacheCheck*/ + !1 + ); + return f.antecedent = d, y; + } else + return !!(l & 1); + } + } + } + function gde(r) { + switch (r.kind) { + case 110: + return !0; + case 80: + if (!jb(r)) { + const l = ju(r); + return oC(l) || bI(l) && !vI(l) || !!l.valueDeclaration && yo(l.valueDeclaration); + } + break; + case 212: + case 213: + return gde(r.expression) && tm(xn(r).resolvedSymbol || Y); + case 207: + case 208: + const a = _m(r.parent); + return Ii(a) || Qee(a) ? !hde(a) : ei(a) && UI(a); + } + return !1; + } + function s0(r, a, l = a, f, d = ((y) => (y = Bn(r, HC)) == null ? void 0 : y.flowNode)()) { + let y, x = !1, I = 0; + if (hi) + return qe; + if (!d) + return a; + rs++; + const J = Vr, z = JT(de(d)); + Vr = J; + const G = Dn(z) & 256 && WAe(r) ? Ol : wM(z); + if (G === fr || r.parent && r.parent.kind === 236 && !(G.flags & 131072) && Dp( + G, + 2097152 + /* NEUndefinedOrNull */ + ).flags & 131072) + return a; + return G; + function ve() { + return x ? y : (x = !0, y = kM(r, a, l, f)); + } + function de(It) { + var gr; + if (I === 2e3) + return (gr = on) == null || gr.instant(on.Phase.CheckTypes, "getTypeAtFlowNode_DepthLimit", { flowId: It.id }), hi = !0, qit(r), qe; + I++; + let Fr; + for (; ; ) { + const Qr = It.flags; + if (Qr & 4096) { + for (let Kn = J; Kn < Vr; Kn++) + if (a1[Kn] === It) + return I--, Nk[Kn]; + Fr = It; + } + let Tn; + if (Qr & 16) { + if (Tn = lt(It), !Tn) { + It = It.antecedent; + continue; + } + } else if (Qr & 512) { + if (Tn = jt(It), !Tn) { + It = It.antecedent; + continue; + } + } else if (Qr & 96) + Tn = jr(It); + else if (Qr & 128) + Tn = Kr(It); + else if (Qr & 12) { + if (It.antecedent.length === 1) { + It = It.antecedent[0]; + continue; + } + Tn = Qr & 4 ? or(It) : ir(It); + } else if (Qr & 256) { + if (Tn = ar(It), !Tn) { + It = It.antecedent; + continue; + } + } else if (Qr & 1024) { + const Kn = It.node.target, aa = Kn.antecedent; + Kn.antecedent = It.node.antecedents, Tn = de(It.antecedent), Kn.antecedent = aa; + } else if (Qr & 2) { + const Kn = It.node; + if (Kn && Kn !== f && r.kind !== 212 && r.kind !== 213 && !(r.kind === 110 && Kn.kind !== 220)) { + It = Kn.flowNode; + continue; + } + Tn = l; + } else + Tn = BI(a); + return Fr && (a1[Vr] = Fr, Nk[Vr] = Tn, Vr++), I--, Tn; + } + } + function We(It) { + const gr = It.node; + return yde( + gr.kind === 261 || gr.kind === 209 ? MAe(gr) : DM(gr), + r + ); + } + function lt(It) { + const gr = It.node; + if (Yl(r, gr)) { + if (!AM(It)) + return fr; + if (Oy(gr) === 2) { + const Qr = de(It.antecedent); + return zE(r0(JT(Qr)), JE(Qr)); + } + if (a === mt || a === Ol) { + if (Iit(gr)) + return mde(nr); + const Qr = ob(We(It)); + return Ms(Qr, a) ? Qr : Gl; + } + const Fr = FB(gr) ? r0(a) : a; + return Fr.flags & 1048576 ? xit(Fr, We(It)) : Fr; + } + if (CAe(r, gr)) { + if (!AM(It)) + return fr; + if (ei(gr) && (an(gr) || UI(gr))) { + const Fr = zD(gr); + if (Fr && (Fr.kind === 219 || Fr.kind === 220)) + return de(It.antecedent); + } + return a; + } + if (ei(gr) && gr.parent.parent.kind === 250 && (Yl(r, gr.parent.parent.expression) || RT(gr.parent.parent.expression, r))) + return jde(wM(JT(de(It.antecedent)))); + } + function gt(It, gr) { + const Fr = Ba( + gr, + /*excludeJSDocTypeAssertions*/ + !0 + ); + if (Fr.kind === 97) + return fr; + if (Fr.kind === 227) { + if (Fr.operatorToken.kind === 56) + return gt(gt(It, Fr.left), Fr.right); + if (Fr.operatorToken.kind === 57) + return Xn([gt(It, Fr.left), gt(It, Fr.right)]); + } + return Pf( + It, + Fr, + /*assumeTrue*/ + !0 + ); + } + function jt(It) { + const gr = NM(It.node); + if (gr) { + const Fr = kp(gr); + if (Fr && (Fr.kind === 2 || Fr.kind === 3)) { + const Qr = de(It.antecedent), Tn = wM(JT(Qr)), Kn = Fr.type ? FP( + Tn, + Fr, + It.node, + /*assumeTrue*/ + !0 + ) : Fr.kind === 3 && Fr.parameterIndex >= 0 && Fr.parameterIndex < It.node.arguments.length ? gt(Tn, It.node.arguments[Fr.parameterIndex]) : Tn; + return Kn === Tn ? Qr : zE(Kn, JE(Qr)); + } + if (Wa(gr).flags & 131072) + return fr; + } + } + function ar(It) { + if (a === mt || a === Ol) { + const gr = It.node, Fr = gr.kind === 214 ? gr.expression.expression : gr.left.expression; + if (Yl(r, B2(Fr))) { + const Qr = de(It.antecedent), Tn = JT(Qr); + if (Dn(Tn) & 256) { + let Kn = Tn; + if (gr.kind === 214) + for (const aa of gr.arguments) + Kn = zAe(Kn, aa); + else { + const aa = tR(gr.left.argumentExpression); + cu( + aa, + 296 + /* NumberLike */ + ) && (Kn = zAe(Kn, gr.right)); + } + return Kn === Tn ? Qr : zE(Kn, JE(Qr)); + } + return Qr; + } + } + } + function jr(It) { + const gr = de(It.antecedent), Fr = JT(gr); + if (Fr.flags & 131072) + return gr; + const Qr = (It.flags & 32) !== 0, Tn = wM(Fr), Kn = Pf(Tn, It.node, Qr); + return Kn === Tn ? gr : zE(Kn, JE(gr)); + } + function Kr(It) { + const gr = Ba(It.node.switchStatement.expression), Fr = de(It.antecedent); + let Qr = JT(Fr); + if (Yl(r, gr)) + Qr = Io(Qr, It.node); + else if (gr.kind === 222 && Yl(r, gr.expression)) + Qr = Oc(Qr, It.node); + else if (gr.kind === 112) + Qr = Uc(Qr, It.node); + else { + K && (RT(gr, r) ? Qr = Ga(Qr, It.node, (Kn) => !(Kn.flags & 163840)) : gr.kind === 222 && RT(gr.expression, r) && (Qr = Ga(Qr, It.node, (Kn) => !(Kn.flags & 131072 || Kn.flags & 128 && Kn.value === "undefined")))); + const Tn = Ri(gr, Qr); + Tn && (Qr = ks(Qr, Tn, It.node)); + } + return zE(Qr, JE(Fr)); + } + function or(It) { + const gr = []; + let Fr = !1, Qr = !1, Tn; + for (const Kn of It.antecedent) { + if (!Tn && Kn.flags & 128 && Kn.node.clauseStart === Kn.node.clauseEnd) { + Tn = Kn; + continue; + } + const aa = de(Kn), ua = JT(aa); + if (ua === a && a === l) + return ua; + tp(gr, ua), bP(ua, l) || (Fr = !0), JE(aa) && (Qr = !0); + } + if (Tn) { + const Kn = de(Tn), aa = JT(Kn); + if (!(aa.flags & 131072) && !ms(gr, aa) && !LIe(Tn.node.switchStatement)) { + if (aa === a && a === l) + return aa; + gr.push(aa), bP(aa, l) || (Fr = !0), JE(Kn) && (Qr = !0); + } + } + return zE(nn( + gr, + Fr ? 2 : 1 + /* Literal */ + ), Qr); + } + function ir(It) { + const gr = lde(It), Fr = mE[gr] || (mE[gr] = /* @__PURE__ */ new Map()), Qr = ve(); + if (!Qr) + return a; + const Tn = Fr.get(Qr); + if (Tn) + return Tn; + for (let kl = dn; kl < Ir; kl++) + if (eT[kl] === It && Pk[kl] === Qr && g2[kl].length) + return zE( + nn( + g2[kl], + 1 + /* Literal */ + ), + /*incomplete*/ + !0 + ); + const Kn = []; + let aa = !1, ua; + for (const kl of It.antecedent) { + let Ju; + if (!ua) + Ju = ua = de(kl); + else { + eT[Ir] = It, Pk[Ir] = Qr, g2[Ir] = Kn, Ir++; + const fb = Pi; + Pi = void 0, Ju = de(kl), Pi = fb, Ir--; + const pb = Fr.get(Qr); + if (pb) + return pb; + } + const M_ = JT(Ju); + if (tp(Kn, M_), bP(M_, l) || (aa = !0), M_ === a) + break; + } + const mo = nn( + Kn, + aa ? 2 : 1 + /* Literal */ + ); + return JE(ua) ? zE( + mo, + /*incomplete*/ + !0 + ) : (Fr.set(Qr, mo), mo); + } + function nn(It, gr) { + if (Wit(It)) + return mde(Xn(hr(It, zit))); + const Fr = fde(Xn(Qc(It, wM), gr)); + return Fr !== a && Fr.flags & a.flags & 1048576 && Tf(Fr.types, a.types) ? a : Fr; + } + function Qn(It) { + if (ws(r) || zy(r) || Rp(r)) { + if (Me(It)) { + const gr = ju(It), Fr = _t(gr).valueDeclaration; + if (Fr && (ya(Fr) || Ii(Fr)) && r === Fr.parent && !Fr.initializer && !Fr.dotDotDotToken) + return Fr; + } + } else if (To(It)) { + if (Yl(r, It.expression)) + return It; + } else if (Me(It)) { + const gr = ju(It); + if (oC(gr)) { + const Fr = gr.valueDeclaration; + if (ei(Fr) && !Fr.type && Fr.initializer && To(Fr.initializer) && Yl(r, Fr.initializer.expression)) + return Fr.initializer; + if (ya(Fr) && !Fr.initializer) { + const Qr = Fr.parent.parent; + if (ei(Qr) && !Qr.type && Qr.initializer && (Me(Qr.initializer) || To(Qr.initializer)) && Yl(r, Qr.initializer)) + return Fr; + } + } + } + } + function Ri(It, gr) { + if (a.flags & 1048576 || gr.flags & 1048576) { + const Fr = Qn(It); + if (Fr) { + const Qr = MT(Fr); + if (Qr) { + const Tn = a.flags & 1048576 && bP(gr, a) ? a : gr; + if (vP(Tn, Qr)) + return Fr; + } + } + } + } + function zn(It, gr, Fr) { + const Qr = MT(gr); + if (Qr === void 0) + return It; + const Tn = Eu(gr), Kn = K && (Tn || Zee(gr)) && Dc( + It, + 98304 + /* Nullable */ + ); + let aa = rr(Kn ? Dp( + It, + 2097152 + /* NEUndefinedOrNull */ + ) : It, Qr); + if (!aa) + return It; + aa = Kn && Tn ? P1(aa) : aa; + const ua = Fr(aa); + return Xc(It, (mo) => { + const kl = Rn(mo, Qr) || yt; + return !(kl.flags & 131072) && !(ua.flags & 131072) && mM(ua, kl); + }); + } + function bi(It, gr, Fr, Qr, Tn) { + if ((Fr === 37 || Fr === 38) && It.flags & 1048576) { + const Kn = CM(It); + if (Kn && Kn === MT(gr)) { + const aa = EM(It, lu(Qr)); + if (aa) + return Fr === (Tn ? 37 : 38) ? aa : Qd(rr(aa, Kn) || yt) ? z$(It, aa) : It; + } + } + return zn(It, gr, (Kn) => xi(Kn, Fr, Qr, Tn)); + } + function ks(It, gr, Fr) { + if (Fr.clauseStart < Fr.clauseEnd && It.flags & 1048576 && CM(It) === MT(gr)) { + const Qr = J$(Fr.switchStatement).slice(Fr.clauseStart, Fr.clauseEnd), Tn = Xn(hr(Qr, (Kn) => EM(It, Kn) || yt)); + if (Tn !== yt) + return Tn; + } + return zn(It, gr, (Qr) => Io(Qr, Fr)); + } + function Ua(It, gr, Fr) { + if (Yl(r, gr)) + return jT( + It, + Fr ? 4194304 : 8388608 + /* Falsy */ + ); + K && Fr && RT(gr, r) && (It = jT( + It, + 2097152 + /* NEUndefinedOrNull */ + )); + const Qr = Ri(gr, It); + return Qr ? zn(It, Qr, (Tn) => Dp( + Tn, + Fr ? 4194304 : 8388608 + /* Falsy */ + )) : It; + } + function Vi(It, gr, Fr) { + const Qr = Ys(It, gr); + return Qr ? !!(Qr.flags & 16777216 || uc(Qr) & 48) || Fr : !!eC(It, gr) || !Fr; + } + function jo(It, gr, Fr) { + const Qr = fp(gr); + if (wp(It, (Kn) => Vi( + Kn, + Qr, + /*assumeTrue*/ + !0 + ))) + return Xc(It, (Kn) => Vi(Kn, Qr, Fr)); + if (Fr) { + const Kn = $tt(); + if (Kn) + return sa([It, OE(Kn, [gr, yt])]); + } + return It; + } + function Sc(It, gr, Fr, Qr, Tn) { + return Tn = Tn !== (Fr.kind === 112) != (Qr !== 38 && Qr !== 36), Pf(It, gr, Tn); + } + function Bu(It, gr, Fr) { + switch (gr.operatorToken.kind) { + case 64: + case 76: + case 77: + case 78: + return Ua(Pf(It, gr.right, Fr), gr.left, Fr); + case 35: + case 36: + case 37: + case 38: + const Qr = gr.operatorToken.kind, Tn = B2(gr.left), Kn = B2(gr.right); + if (Tn.kind === 222 && ja(Kn)) + return en(It, Tn, Qr, Kn, Fr); + if (Kn.kind === 222 && ja(Tn)) + return en(It, Kn, Qr, Tn, Fr); + if (Yl(r, Tn)) + return xi(It, Qr, Kn, Fr); + if (Yl(r, Kn)) + return xi(It, Qr, Tn, Fr); + K && (RT(Tn, r) ? It = Br(It, Qr, Kn, Fr) : RT(Kn, r) && (It = Br(It, Qr, Tn, Fr))); + const aa = Ri(Tn, It); + if (aa) + return bi(It, aa, Qr, Kn, Fr); + const ua = Ri(Kn, It); + if (ua) + return bi(It, ua, Qr, Tn, Fr); + if (Xa(Tn)) + return Yf(It, Qr, Kn, Fr); + if (Xa(Kn)) + return Yf(It, Qr, Tn, Fr); + if (DD(Kn) && !To(Tn)) + return Sc(It, Tn, Kn, Qr, Fr); + if (DD(Tn) && !To(Kn)) + return Sc(It, Kn, Tn, Qr, Fr); + break; + case 104: + return $o(It, gr, Fr); + case 103: + if (Ai(gr.left)) + return Dr(It, gr, Fr); + const mo = B2(gr.right); + if (dI(It) && To(r) && Yl(r.expression, mo)) { + const kl = lu(gr.left); + if (_p(kl) && MT(r) === fp(kl)) + return Dp( + It, + Fr ? 524288 : 65536 + /* EQUndefined */ + ); + } + if (Yl(r, mo)) { + const kl = lu(gr.left); + if (_p(kl)) + return jo(It, kl, Fr); + } + break; + case 28: + return Pf(It, gr.right, Fr); + // Ordinarily we won't see && and || expressions in control flow analysis because the Binder breaks those + // expressions down to individual conditional control flows. However, we may encounter them when analyzing + // aliased conditional expressions. + case 56: + return Fr ? Pf( + Pf( + It, + gr.left, + /*assumeTrue*/ + !0 + ), + gr.right, + /*assumeTrue*/ + !0 + ) : Xn([Pf( + It, + gr.left, + /*assumeTrue*/ + !1 + ), Pf( + It, + gr.right, + /*assumeTrue*/ + !1 + )]); + case 57: + return Fr ? Xn([Pf( + It, + gr.left, + /*assumeTrue*/ + !0 + ), Pf( + It, + gr.right, + /*assumeTrue*/ + !0 + )]) : Pf( + Pf( + It, + gr.left, + /*assumeTrue*/ + !1 + ), + gr.right, + /*assumeTrue*/ + !1 + ); + } + return It; + } + function Dr(It, gr, Fr) { + const Qr = B2(gr.right); + if (!Yl(r, Qr)) + return It; + E.assertNode(gr.left, Ai); + const Tn = oX(gr.left); + if (Tn === void 0) + return It; + const Kn = Tn.parent, aa = cl(E.checkDefined(Tn.valueDeclaration, "should always have a declaration")) ? Yr(Kn) : bo(Kn); + return Np( + It, + aa, + Fr, + /*checkDerived*/ + !0 + ); + } + function Br(It, gr, Fr, Qr) { + const Tn = gr === 35 || gr === 37, Kn = gr === 35 || gr === 36 ? 98304 : 32768, aa = lu(Fr); + return Tn !== Qr && G_(aa, (mo) => !!(mo.flags & Kn)) || Tn === Qr && G_(aa, (mo) => !(mo.flags & (3 | Kn))) ? jT( + It, + 2097152 + /* NEUndefinedOrNull */ + ) : It; + } + function xi(It, gr, Fr, Qr) { + if (It.flags & 1) + return It; + (gr === 36 || gr === 38) && (Qr = !Qr); + const Tn = lu(Fr), Kn = gr === 35 || gr === 36; + if (Tn.flags & 98304) { + if (!K) + return It; + const aa = Kn ? Qr ? 262144 : 2097152 : Tn.flags & 65536 ? Qr ? 131072 : 1048576 : Qr ? 65536 : 524288; + return jT(It, aa); + } + if (Qr) { + if (!Kn && (It.flags & 2 || wp(It, yg))) { + if (Tn.flags & 469893116 || yg(Tn)) + return Tn; + if (Tn.flags & 524288) + return vr; + } + const aa = Xc(It, (ua) => mM(ua, Tn) || Kn && qnt(ua, Tn)); + return JAe(aa, Tn); + } + return Qd(Tn) ? Xc(It, (aa) => !(sAe(aa) && mM(aa, Tn))) : It; + } + function en(It, gr, Fr, Qr, Tn) { + (Fr === 36 || Fr === 38) && (Tn = !Tn); + const Kn = B2(gr.expression); + if (!Yl(r, Kn)) { + K && RT(Kn, r) && Tn === (Qr.text !== "undefined") && (It = jT( + It, + 2097152 + /* NEUndefinedOrNull */ + )); + const aa = Ri(Kn, It); + return aa ? zn(It, aa, (ua) => us(ua, Qr, Tn)) : It; + } + return us(It, Qr, Tn); + } + function us(It, gr, Fr) { + return Fr ? Jl(It, gr.text) : jT( + It, + Cne.get(gr.text) || 32768 + /* TypeofNEHostObject */ + ); + } + function Ga(It, { switchStatement: gr, clauseStart: Fr, clauseEnd: Qr }, Tn) { + return Fr !== Qr && Ni(J$(gr).slice(Fr, Qr), Tn) ? Dp( + It, + 2097152 + /* NEUndefinedOrNull */ + ) : It; + } + function Io(It, { switchStatement: gr, clauseStart: Fr, clauseEnd: Qr }) { + const Tn = J$(gr); + if (!Tn.length) + return It; + const Kn = Tn.slice(Fr, Qr), aa = Fr === Qr || ms(Kn, nr); + if (It.flags & 2 && !aa) { + let Ju; + for (let M_ = 0; M_ < Kn.length; M_ += 1) { + const fb = Kn[M_]; + if (fb.flags & 469893116) + Ju !== void 0 && Ju.push(fb); + else if (fb.flags & 524288) + Ju === void 0 && (Ju = Kn.slice(0, M_)), Ju.push(vr); + else + return It; + } + return Xn(Ju === void 0 ? Kn : Ju); + } + const ua = Xn(Kn), mo = ua.flags & 131072 ? nr : JAe(Xc(It, (Ju) => mM(ua, Ju)), ua); + if (!aa) + return mo; + const kl = Xc(It, (Ju) => !(sAe(Ju) && ms(Tn, Ju.flags & 32768 ? ue : t_(Rnt(Ju))))); + return mo.flags & 131072 ? kl : Xn([mo, kl]); + } + function Jl(It, gr) { + switch (gr) { + case "string": + return Ta( + It, + at, + 1 + /* TypeofEQString */ + ); + case "number": + return Ta( + It, + wt, + 2 + /* TypeofEQNumber */ + ); + case "bigint": + return Ta( + It, + Zr, + 4 + /* TypeofEQBigInt */ + ); + case "boolean": + return Ta( + It, + Nt, + 8 + /* TypeofEQBoolean */ + ); + case "symbol": + return Ta( + It, + Jt, + 16 + /* TypeofEQSymbol */ + ); + case "object": + return It.flags & 1 ? It : Xn([Ta( + It, + vr, + 32 + /* TypeofEQObject */ + ), Ta( + It, + Mt, + 131072 + /* EQNull */ + )]); + case "function": + return It.flags & 1 ? It : Ta( + It, + Mr, + 64 + /* TypeofEQFunction */ + ); + case "undefined": + return Ta( + It, + ue, + 65536 + /* EQUndefined */ + ); + } + return Ta( + It, + vr, + 128 + /* TypeofEQHostObject */ + ); + } + function Ta(It, gr, Fr) { + return Go(It, (Qr) => ( + // We first check if a constituent is a subtype of the implied type. If so, we either keep or eliminate + // the constituent based on its type facts. We use the strict subtype relation because it treats `object` + // as a subtype of `{}`, and we need the type facts check because function types are subtypes of `object`, + // but are classified as "function" according to `typeof`. + Bm(Qr, gr, Ro) ? Yd(Qr, Fr) ? Qr : nr : ( + // We next check if the consituent is a supertype of the implied type. If so, we substitute the implied + // type. This handles top types like `unknown` and `{}`, and supertypes like `{ toString(): string }`. + R2(gr, Qr) ? gr : ( + // Neither the constituent nor the implied type is a subtype of the other, however their domains may still + // overlap. For example, an unconstrained type parameter and type `string`. If the type facts indicate + // possible overlap, we form an intersection. Otherwise, we eliminate the constituent. + Yd(Qr, Fr) ? sa([Qr, gr]) : nr + ) + ) + )); + } + function Oc(It, { switchStatement: gr, clauseStart: Fr, clauseEnd: Qr }) { + const Tn = jAe(gr); + if (!Tn) + return It; + const Kn = oc( + gr.caseBlock.clauses, + (mo) => mo.kind === 298 + /* DefaultClause */ + ); + if (Fr === Qr || Kn >= Fr && Kn < Qr) { + const mo = OIe(Fr, Qr, Tn); + return Xc(It, (kl) => BE(kl, mo) === mo); + } + const ua = Tn.slice(Fr, Qr); + return Xn(hr(ua, (mo) => mo ? Jl(It, mo) : nr)); + } + function Uc(It, { switchStatement: gr, clauseStart: Fr, clauseEnd: Qr }) { + const Tn = oc( + gr.caseBlock.clauses, + (ua) => ua.kind === 298 + /* DefaultClause */ + ), Kn = Fr === Qr || Tn >= Fr && Tn < Qr; + for (let ua = 0; ua < Fr; ua++) { + const mo = gr.caseBlock.clauses[ua]; + mo.kind === 297 && (It = Pf( + It, + mo.expression, + /*assumeTrue*/ + !1 + )); + } + if (Kn) { + for (let ua = Qr; ua < gr.caseBlock.clauses.length; ua++) { + const mo = gr.caseBlock.clauses[ua]; + mo.kind === 297 && (It = Pf( + It, + mo.expression, + /*assumeTrue*/ + !1 + )); + } + return It; + } + const aa = gr.caseBlock.clauses.slice(Fr, Qr); + return Xn(hr(aa, (ua) => ua.kind === 297 ? Pf( + It, + ua.expression, + /*assumeTrue*/ + !0 + ) : nr)); + } + function Xa(It) { + return (wn(It) && An(It.name) === "constructor" || uo(It) && ja(It.argumentExpression) && It.argumentExpression.text === "constructor") && Yl(r, It.expression); + } + function Yf(It, gr, Fr, Qr) { + if (Qr ? gr !== 35 && gr !== 37 : gr !== 36 && gr !== 38) + return It; + const Tn = lu(Fr); + if (!qme(Tn) && !Gd(Tn)) + return It; + const Kn = Ys(Tn, "prototype"); + if (!Kn) + return It; + const aa = Yr(Kn), ua = gn(aa) ? void 0 : aa; + if (!ua || ua === Ot || ua === Mr) + return It; + if (gn(It)) + return ua; + return Xc(It, (kl) => mo(kl, ua)); + function mo(kl, Ju) { + return kl.flags & 524288 && Dn(kl) & 1 || Ju.flags & 524288 && Dn(Ju) & 1 ? kl.symbol === Ju.symbol : R2(kl, Ju); + } + } + function $o(It, gr, Fr) { + const Qr = B2(gr.left); + if (!Yl(r, Qr)) + return Fr && K && RT(Qr, r) ? jT( + It, + 2097152 + /* NEUndefinedOrNull */ + ) : It; + const Tn = gr.right, Kn = lu(Tn); + if (!sb(Kn, Ot)) + return It; + const aa = NM(gr), ua = aa && kp(aa); + if (ua && ua.kind === 1 && ua.parameterIndex === 0) + return Np( + It, + ua.type, + Fr, + /*checkDerived*/ + !0 + ); + if (!sb(Kn, Mr)) + return It; + const mo = Go(Kn, wc); + return gn(It) && (mo === Ot || mo === Mr) || !Fr && !(mo.flags & 524288 && !yg(mo)) ? It : Np( + It, + mo, + Fr, + /*checkDerived*/ + !0 + ); + } + function wc(It) { + const gr = rr(It, "prototype"); + if (gr && !gn(gr)) + return gr; + const Fr = Is( + It, + 1 + /* Construct */ + ); + return Fr.length ? Xn(hr(Fr, (Qr) => Wa(rI(Qr)))) : ta; + } + function Np(It, gr, Fr, Qr) { + const Tn = It.flags & 1048576 ? `N${jl(It)},${jl(gr)},${(Fr ? 1 : 0) | (Qr ? 2 : 0)}` : void 0; + return f_(Tn) ?? Yp(Tn, IP(It, gr, Fr, Qr)); + } + function IP(It, gr, Fr, Qr) { + if (!Fr) { + if (It === gr) + return nr; + if (Qr) + return Xc(It, (mo) => !sb(mo, gr)); + It = It.flags & 2 ? va : It; + const ua = Np( + It, + gr, + /*assumeTrue*/ + !0, + /*checkDerived*/ + !1 + ); + return fde(Xc(It, (mo) => !bP(mo, ua))); + } + if (It.flags & 3 || It === gr) + return gr; + const Tn = Qr ? sb : R2, Kn = It.flags & 1048576 ? CM(It) : void 0, aa = Go(gr, (ua) => { + const mo = Kn && rr(ua, Kn), kl = mo && EM(It, mo), Ju = Go( + kl || It, + Qr ? (M_) => sb(M_, ua) ? M_ : sb(ua, M_) ? ua : nr : (M_) => mP(M_, ua) ? M_ : mP(ua, M_) ? ua : R2(M_, ua) ? M_ : R2(ua, M_) ? ua : nr + ); + return Ju.flags & 131072 ? Go(It, (M_) => Dc( + M_, + 465829888 + /* Instantiable */ + ) && Tn(ua, ou(M_) || yt) ? sa([M_, ua]) : nr) : Ju; + }); + return aa.flags & 131072 ? R2(gr, It) ? gr : Ms(It, gr) ? It : Ms(gr, It) ? gr : sa([It, gr]) : aa; + } + function VI(It, gr, Fr) { + if (PAe(gr, r)) { + const Qr = Fr || !K2(gr) ? NM(gr) : void 0, Tn = Qr && kp(Qr); + if (Tn && (Tn.kind === 0 || Tn.kind === 1)) + return FP(It, Tn, gr, Fr); + } + if (dI(It) && To(r) && wn(gr.expression)) { + const Qr = gr.expression; + if (Yl(r.expression, B2(Qr.expression)) && Me(Qr.name) && Qr.name.escapedText === "hasOwnProperty" && gr.arguments.length === 1) { + const Tn = gr.arguments[0]; + if (ja(Tn) && MT(r) === tc(Tn.text)) + return Dp( + It, + Fr ? 524288 : 65536 + /* EQUndefined */ + ); + } + } + return It; + } + function FP(It, gr, Fr, Qr) { + if (gr.type && !(gn(It) && (gr.type === Ot || gr.type === Mr))) { + const Tn = Vit(gr, Fr); + if (Tn) { + if (Yl(r, Tn)) + return Np( + It, + gr.type, + Qr, + /*checkDerived*/ + !1 + ); + K && RT(Tn, r) && (Qr && !Yd( + gr.type, + 65536 + /* EQUndefined */ + ) || !Qr && G_(gr.type, JM)) && (It = jT( + It, + 2097152 + /* NEUndefinedOrNull */ + )); + const Kn = Ri(Tn, It); + if (Kn) + return zn(It, Kn, (aa) => Np( + aa, + gr.type, + Qr, + /*checkDerived*/ + !1 + )); + } + } + return It; + } + function Pf(It, gr, Fr) { + if (x7(gr) || _n(gr.parent) && (gr.parent.operatorToken.kind === 61 || gr.parent.operatorToken.kind === 78) && gr.parent.left === gr) + return qI(It, gr, Fr); + switch (gr.kind) { + case 80: + if (!Yl(r, gr) && T < 5) { + const Qr = ju(gr); + if (oC(Qr)) { + const Tn = Qr.valueDeclaration; + if (Tn && ei(Tn) && !Tn.type && Tn.initializer && gde(r)) { + T++; + const Kn = Pf(It, Tn.initializer, Fr); + return T--, Kn; + } + } + } + // falls through + case 110: + case 108: + case 212: + case 213: + return Ua(It, gr, Fr); + case 214: + return VI(It, gr, Fr); + case 218: + case 236: + case 239: + return Pf(It, gr.expression, Fr); + case 227: + return Bu(It, gr, Fr); + case 225: + if (gr.operator === 54) + return Pf(It, gr.operand, !Fr); + break; + } + return It; + } + function qI(It, gr, Fr) { + if (Yl(r, gr)) + return jT( + It, + Fr ? 2097152 : 262144 + /* EQUndefinedOrNull */ + ); + const Qr = Ri(gr, It); + return Qr ? zn(It, Qr, (Tn) => Dp( + Tn, + Fr ? 2097152 : 262144 + /* EQUndefinedOrNull */ + )) : It; + } + } + function Hit(r, a) { + if (r = _t(r), (a.kind === 80 || a.kind === 81) && (r4(a) && (a = a.parent), Xm(a) && (!Ly(a) || Ex(a)))) { + const l = N$( + Ex(a) && a.kind === 212 ? aX( + a, + /*checkMode*/ + void 0, + /*writeOnly*/ + !0 + ) : lu(a) + ); + if (_t(xn(a).resolvedSymbol) === r) + return l; + } + return Qm(a) && am(a.parent) && P2(a.parent) ? UG(a.parent.symbol) : cJ(a) && Ex(a.parent) ? Z0(r) : Hd(r); + } + function TP(r) { + return dr( + r.parent, + (a) => Es(a) && !q1(a) || a.kind === 269 || a.kind === 308 || a.kind === 173 + /* PropertyDeclaration */ + ); + } + function Git(r) { + return (r.lastAssignmentPos !== void 0 || vI(r) && r.lastAssignmentPos !== void 0) && r.lastAssignmentPos < 0; + } + function vI(r) { + return !VAe( + r, + /*location*/ + void 0 + ); + } + function VAe(r, a) { + const l = dr(r.valueDeclaration, q$); + if (!l) + return !1; + const f = xn(l); + return f.flags & 131072 || (f.flags |= 131072, $it(l) || HAe(l)), !r.lastAssignmentPos || a && Math.abs(r.lastAssignmentPos) < a.pos; + } + function hde(r) { + return E.assert(ei(r) || Ii(r)), qAe(r.name); + } + function qAe(r) { + return r.kind === 80 ? vI(yn(r.parent)) : ot(r.elements, (a) => a.kind !== 233 && qAe(a.name)); + } + function $it(r) { + return !!dr(r.parent, (a) => q$(a) && !!(xn(a).flags & 131072)); + } + function q$(r) { + return io(r) || Di(r); + } + function HAe(r) { + switch (r.kind) { + case 80: + const a = Oy(r); + if (a !== 0) { + const d = ju(r), y = a === 1 || d.lastAssignmentPos !== void 0 && d.lastAssignmentPos < 0; + if (bI(d)) { + if (d.lastAssignmentPos === void 0 || Math.abs(d.lastAssignmentPos) !== Number.MAX_VALUE) { + const x = dr(r, q$), I = dr(d.valueDeclaration, q$); + d.lastAssignmentPos = x === I ? Xit(r, d.valueDeclaration) : Number.MAX_VALUE; + } + y && d.lastAssignmentPos > 0 && (d.lastAssignmentPos *= -1); + } + } + return; + case 282: + const l = r.parent.parent, f = r.propertyName || r.name; + if (!r.isTypeOnly && !l.isTypeOnly && !l.moduleSpecifier && f.kind !== 11) { + const d = dc( + f, + 111551, + /*ignoreErrors*/ + !0, + /*dontResolveAlias*/ + !0 + ); + if (d && bI(d)) { + const y = d.lastAssignmentPos !== void 0 && d.lastAssignmentPos < 0 ? -1 : 1; + d.lastAssignmentPos = y * Number.MAX_VALUE; + } + } + return; + case 265: + case 266: + case 267: + return; + } + li(r) || xs(r, HAe); + } + function Xit(r, a) { + let l = r.pos; + for (; r && r.pos > a.pos; ) { + switch (r.kind) { + case 244: + case 245: + case 246: + case 247: + case 248: + case 249: + case 250: + case 251: + case 255: + case 256: + case 259: + case 264: + l = r.end; + } + r = r.parent; + } + return l; + } + function oC(r) { + return r.flags & 3 && (Lde(r) & 6) !== 0; + } + function bI(r) { + const a = r.valueDeclaration && _m(r.valueDeclaration); + return !!a && (Ii(a) || ei(a) && (Zb(a.parent) || GAe(a))); + } + function GAe(r) { + return !!(r.parent.flags & 1) && !(J1(r) & 32 || r.parent.parent.kind === 244 && m0(r.parent.parent.parent)); + } + function Qit(r) { + const a = xn(r); + if (a.parameterInitializerContainsUndefined === void 0) { + if (!Lm( + r, + 8 + /* ParameterInitializerContainsUndefined */ + )) + return xT(r.symbol), !0; + const l = !!Yd( + kP( + r, + 0 + /* Normal */ + ), + 16777216 + /* IsUndefined */ + ); + if (!He()) + return xT(r.symbol), !0; + a.parameterInitializerContainsUndefined ?? (a.parameterInitializerContainsUndefined = l); + } + return a.parameterInitializerContainsUndefined; + } + function Yit(r, a) { + return K && a.kind === 170 && a.initializer && Yd( + r, + 16777216 + /* IsUndefined */ + ) && !Qit(a) ? Dp( + r, + 524288 + /* NEUndefined */ + ) : r; + } + function Zit(r, a) { + const l = a.parent; + return l.kind === 212 || l.kind === 167 || l.kind === 214 && l.expression === a || l.kind === 215 && l.expression === a || l.kind === 213 && l.expression === a && !(wp(r, XAe) && AT(lu(l.argumentExpression))); + } + function $Ae(r) { + return r.flags & 2097152 ? ot(r.types, $Ae) : !!(r.flags & 465829888 && Rm(r).flags & 1146880); + } + function XAe(r) { + return r.flags & 2097152 ? ot(r.types, XAe) : !!(r.flags & 465829888 && !Dc( + Rm(r), + 98304 + /* Nullable */ + )); + } + function Kit(r, a) { + const l = (Me(r) || wn(r) || uo(r)) && !((Id(r.parent) || NS(r.parent)) && r.parent.tagName === r) && (a && a & 32 ? g_( + r, + 8 + /* SkipBindingPatterns */ + ) : g_( + r, + /*contextFlags*/ + void 0 + )); + return l && !nb(l); + } + function yde(r, a, l) { + return LE(r) && (r = r.baseType), !(l && l & 2) && wp(r, $Ae) && (Zit(r, a) || Kit(a, l)) ? Go(r, Rm) : r; + } + function QAe(r) { + return !!dr(r, (a) => { + const l = a.parent; + return l === void 0 ? "quit" : Mo(l) ? l.expression === a && to(a) : Nu(l) ? l.name === a || l.propertyName === a : !1; + }); + } + function cC(r, a, l, f) { + if (Ce && !(r.flags & 33554432 && !$u(r) && !os(r))) + switch (a) { + case 1: + return H$(r); + case 2: + return YAe(r, l, f); + case 3: + return ZAe(r); + case 4: + return vde(r); + case 5: + return KAe(r); + case 6: + return e8e(r); + case 7: + return t8e(r); + case 8: + return r8e(r); + case 0: { + if (Me(r) && (Xm(r) || gu(r.parent) || _l(r.parent) && r.parent.moduleReference === r) && a8e(r)) { + if (f3(r.parent) && (wn(r.parent) ? r.parent.expression : r.parent.left) !== r) + return; + H$(r); + return; + } + if (f3(r)) { + let d = r; + for (; f3(d); ) { + if (lm(d)) return; + d = d.parent; + } + return YAe(r); + } + return Mo(r) ? ZAe(r) : wu(r) || ud(r) ? vde(r) : _l(r) ? cS(r) || IX(r) ? e8e(r) : void 0 : Nu(r) ? t8e(r) : ((io(r) || cd(r)) && KAe(r), !F.emitDecoratorMetadata || !e2(r) || !Ff(r) || !r.modifiers || !F3(U, r, r.parent, r.parent.parent) ? void 0 : r8e(r)); + } + default: + E.assertNever(a, `Unhandled reference hint: ${a}`); + } + } + function H$(r) { + const a = ju(r); + a && a !== ie && a !== Y && !jb(r) && FM(a, r); + } + function YAe(r, a, l) { + const f = wn(r) ? r.expression : r.left; + if (Ry(f) || !Me(f)) + return; + const d = ju(f); + if (!d || d === Y) + return; + if (zp(F) || By(F) && QAe(r)) { + FM(d, r); + return; + } + const y = l || mc(f); + if (gn(y) || y === kt) { + FM(d, r); + return; + } + let x = a; + if (!x && !l) { + const I = wn(r) ? r.name : r.right, J = Ai(I) && zM(I.escapedText, I), z = Oy(r), G = e_(z !== 0 || Bde(r) ? Sf(y) : y); + x = Ai(I) ? J && cX(G, J) || void 0 : Ys(G, I.escapedText); + } + x && (zI(x) || x.flags & 8 && r.parent.kind === 307) || FM(d, r); + } + function ZAe(r) { + if (Me(r.expression)) { + const a = r.expression, l = _t(dc( + a, + -1, + /*ignoreErrors*/ + !0, + /*dontResolveAlias*/ + !0, + r + )); + l && FM(l, a); + } + } + function vde(r) { + if (!iX(r)) { + const a = Aa && F.jsx === 2 ? p.This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found : void 0, l = pd(r), f = wu(r) ? r.tagName : r, d = F.jsx !== 1 && F.jsx !== 3; + let y; + if (ud(r) && l === "null" || (y = st( + f, + l, + d ? 111551 : 111167, + a, + /*isUse*/ + !0 + )), y && (y.isReferenced = -1, Ce && y.flags & 2097152 && !Vd(y) && G$(y)), ud(r)) { + const x = xr(r), I = Gme(x); + if (I) { + const J = i_(I).escapedText; + st( + f, + J, + d ? 111551 : 111167, + a, + /*isUse*/ + !0 + ); + } + } + } + } + function KAe(r) { + if (R < 2 && Mc(r) & 2) { + const a = nf(r); + est(a); + } + } + function e8e(r) { + Gn( + r, + 32 + /* Export */ + ) && n8e(r); + } + function t8e(r) { + if (!r.parent.parent.moduleSpecifier && !r.isTypeOnly && !r.parent.parent.isTypeOnly) { + const a = r.propertyName || r.name; + if (a.kind === 11) + return; + const l = st( + a, + a.escapedText, + 2998271, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !0 + ); + if (!(l && (l === ne || l === Se || l.declarations && m0(bt(l.declarations[0]))))) { + const f = l && (l.flags & 2097152 ? Rl(l) : l); + (!f || O_(f) & 111551) && (n8e(r), H$(a)); + } + return; + } + } + function r8e(r) { + if (F.emitDecoratorMetadata) { + const a = Nn(r.modifiers, ul); + if (!a) + return; + switch (xl( + a, + 16 + /* Metadata */ + ), r.kind) { + case 264: + const l = Mg(r); + if (l) + for (const x of l.parameters) + WE(CX(x)); + break; + case 178: + case 179: + const f = r.kind === 178 ? 179 : 178, d = Oo(yn(r), f); + WE(P2(r) || d && P2(d)); + break; + case 175: + for (const x of r.parameters) + WE(CX(x)); + WE(nf(r)); + break; + case 173: + WE(Kc(r)); + break; + case 170: + WE(CX(r)); + const y = r.parent; + for (const x of y.parameters) + WE(CX(x)); + WE(nf(y)); + break; + } + } + } + function FM(r, a) { + if (Ce && lT( + r, + /*excludes*/ + 111551 + /* Value */ + ) && !Tx(a)) { + const l = Rl(r); + O_( + r, + /*excludeTypeOnlyMeanings*/ + !0 + ) & 1160127 && (zp(F) || By(F) && QAe(a) || !zI(_t(l))) && G$(r); + } + } + function G$(r) { + E.assert(Ce); + const a = Pn(r); + if (!a.referenced) { + a.referenced = !0; + const l = F_(r); + if (!l) return E.fail(); + if (cS(l) && O_(zc(r)) & 111551) { + const f = i_(l.moduleReference); + H$(f); + } + } + } + function n8e(r) { + const a = yn(r), l = Rl(a); + l && (l === Y || O_( + a, + /*excludeTypeOnlyMeanings*/ + !0 + ) & 111551 && !zI(l)) && G$(a); + } + function i8e(r, a) { + if (!r) return; + const l = i_(r), f = (r.kind === 80 ? 788968 : 1920) | 2097152, d = st( + l, + l.escapedText, + f, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !0 + ); + if (d && d.flags & 2097152) { + if (Ce && ur(d) && !zI(Rl(d)) && !Vd(d)) + G$(d); + else if (a && zp(F) && Hu(F) >= 5 && !ur(d) && !ot(d.declarations, p0)) { + const y = ze(r, p.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled), x = Nn(d.declarations || Ge, U0); + x && zs(y, sn(x, p._0_was_imported_here, An(l))); + } + } + } + function est(r) { + i8e( + r && I3(r), + /*forDecoratorMetadata*/ + !1 + ); + } + function WE(r) { + const a = Cme(r); + a && r_(a) && i8e( + a, + /*forDecoratorMetadata*/ + !0 + ); + } + function tst(r, a) { + var l; + const f = Yr(r), d = r.valueDeclaration; + if (d) { + if (ya(d) && !d.initializer && !d.dotDotDotToken && d.parent.elements.length >= 2) { + const y = d.parent.parent, x = _m(y); + if (x.kind === 261 && U2(x) & 6 || x.kind === 170) { + const I = xn(y); + if (!(I.flags & 4194304)) { + I.flags |= 4194304; + const J = ii( + y, + 0 + /* Normal */ + ), z = J && Go(J, Rm); + if (I.flags &= -4194305, z && z.flags & 1048576 && !(x.kind === 170 && hde(x))) { + const G = d.parent, ve = s0( + G, + z, + z, + /*flowContainer*/ + void 0, + a.flowNode + ); + return ve.flags & 131072 ? nr : S1( + d, + ve, + /*noTupleBoundsCheck*/ + !0 + ); + } + } + } + } + if (Ii(d) && !d.type && !d.initializer && !d.dotDotDotToken) { + const y = d.parent; + if (y.parameters.length >= 2 && y$(y)) { + const x = TI(y); + if (x && x.parameters.length === 1 && Iu(x)) { + const I = cP(Mi(Yr(x.parameters[0]), (l = J2(y)) == null ? void 0 : l.nonFixingMapper)); + if (I.flags & 1048576 && G_(I, Sa) && !ot(y.parameters, hde)) { + const J = s0( + y, + I, + I, + /*flowContainer*/ + void 0, + a.flowNode + ), z = y.parameters.indexOf(d) - (Rb(y) ? 1 : 0); + return vf(J, Xd(z)); + } + } + } + } + } + return f; + } + function s8e(r, a) { + if (jb(r)) return; + if (a === ie) { + if (Wde( + r, + /*ignoreArrowFunctions*/ + !0 + )) { + ze(r, p.arguments_cannot_be_referenced_in_property_initializers_or_class_static_initialization_blocks); + return; + } + let y = Af(r); + if (y) + for (R < 2 && (y.kind === 220 ? ze(r, p.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES5_Consider_using_a_standard_function_expression) : Gn( + y, + 1024 + /* Async */ + ) && ze(r, p.The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES5_Consider_using_a_standard_function_or_method)), xn(y).flags |= 512; y && xo(y); ) + y = Af(y), y && (xn(y).flags |= 512); + return; + } + const l = _t(a), f = jme(l, r); + Zu(f) && mpe(r, f) && f.declarations && Zp(r, f.declarations, r.escapedText); + const d = l.valueDeclaration; + if (d && l.flags & 32 && $n(d) && d.name !== r) { + let y = qu( + r, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + for (; y.kind !== 308 && y.parent !== d; ) + y = qu( + y, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + y.kind !== 308 && (xn(d).flags |= 262144, xn(y).flags |= 262144, xn(r).flags |= 536870912); + } + ast(r, a); + } + function rst(r, a) { + if (jb(r)) + return OM(r); + const l = ju(r); + if (l === Y) + return qe; + if (s8e(r, l), l === ie) + return Wde(r) ? qe : Yr(l); + a8e(r) && cC( + r, + 1 + /* Identifier */ + ); + const f = _t(l); + let d = f.valueDeclaration; + const y = d; + if (d && d.kind === 209 && ms(Qp, d.parent) && dr(r, (ir) => ir === d.parent)) + return rn; + let x = tst(f, r); + const I = Oy(r); + if (I) { + if (!(f.flags & 3) && !(an(r) && f.flags & 512)) { + const ir = f.flags & 384 ? p.Cannot_assign_to_0_because_it_is_an_enum : f.flags & 32 ? p.Cannot_assign_to_0_because_it_is_a_class : f.flags & 1536 ? p.Cannot_assign_to_0_because_it_is_a_namespace : f.flags & 16 ? p.Cannot_assign_to_0_because_it_is_a_function : f.flags & 2097152 ? p.Cannot_assign_to_0_because_it_is_an_import : p.Cannot_assign_to_0_because_it_is_not_a_variable; + return ze(r, ir, Wi(l)), qe; + } + if (tm(f)) + return f.flags & 3 ? ze(r, p.Cannot_assign_to_0_because_it_is_a_constant, Wi(l)) : ze(r, p.Cannot_assign_to_0_because_it_is_a_read_only_property, Wi(l)), qe; + } + const J = f.flags & 2097152; + if (f.flags & 3) { + if (I === 1) + return FB(r) ? r0(x) : x; + } else if (J) + d = F_(l); + else + return x; + if (!d) + return x; + x = yde(x, r, a); + const z = _m(d).kind === 170, G = TP(d); + let ve = TP(r); + const de = ve !== G, We = r.parent && r.parent.parent && Vg(r.parent) && dde(r.parent.parent), lt = l.flags & 134217728, gt = x === mt || x === Ol, jt = gt && r.parent.kind === 236; + for (; ve !== G && (ve.kind === 219 || ve.kind === 220 || K7(ve)) && (oC(f) && x !== Ol || bI(f) && VAe(f, r)); ) + ve = TP(ve); + const ar = y && ei(y) && !y.initializer && !y.exclamationToken && GAe(y) && !Git(l), jr = z || J || de && !ar || We || lt || nst(r, d) || x !== mt && x !== Ol && (!K || (x.flags & 16387) !== 0 || Tx(r) || ode(r) || r.parent.kind === 282) || r.parent.kind === 236 || d.kind === 261 && d.exclamationToken || d.flags & 33554432, Kr = jt ? ue : jr ? z ? Yit(x, d) : x : gt ? ue : P1(x), or = jt ? n0(s0(r, x, Kr, ve)) : s0(r, x, Kr, ve); + if (!WAe(r) && (x === mt || x === Ol)) { + if (or === mt || or === Ol) + return fe && (ze(_s(d), p.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined, Wi(l), Wr(or)), ze(r, p.Variable_0_implicitly_has_an_1_type, Wi(l), Wr(or))), BI(or); + } else if (!jr && !jE(x) && jE(or)) + return ze(r, p.Variable_0_is_used_before_being_assigned, Wi(l)), x; + return I ? r0(or) : or; + } + function nst(r, a) { + if (ya(a)) { + const l = dr(r, ya); + return l && _m(l) === _m(a); + } + } + function a8e(r) { + var a; + const l = r.parent; + if (l) { + if (wn(l) && l.expression === r || Nu(l) && l.isTypeOnly) + return !1; + const f = (a = l.parent) == null ? void 0 : a.parent; + if (f && Bc(f) && f.isTypeOnly) + return !1; + } + return !0; + } + function ist(r, a) { + return !!dr(r, (l) => l === a ? "quit" : Es(l) || l.parent && os(l.parent) && !cl(l.parent) && l.parent.initializer === l); + } + function sst(r, a) { + return dr(r, (l) => l === a ? "quit" : l === a.initializer || l === a.condition || l === a.incrementor || l === a.statement); + } + function bde(r) { + return dr(r, (a) => !a || WB(a) ? "quit" : wy( + a, + /*lookInLabeledStatements*/ + !1 + )); + } + function ast(r, a) { + if (R >= 2 || (a.flags & 34) === 0 || !a.valueDeclaration || Di(a.valueDeclaration) || a.valueDeclaration.parent.kind === 300) + return; + const l = Dd(a.valueDeclaration), f = ist(r, l), d = bde(l); + if (d) { + if (f) { + let y = !0; + if (av(l)) { + const x = Q1( + a.valueDeclaration, + 262 + /* VariableDeclarationList */ + ); + if (x && x.parent === l) { + const I = sst(r.parent, l); + if (I) { + const J = xn(I); + J.flags |= 8192; + const z = J.capturedBlockScopeBindings || (J.capturedBlockScopeBindings = []); + tp(z, a), I === l.initializer && (y = !1); + } + } + } + y && (xn(d).flags |= 4096); + } + if (av(l)) { + const y = Q1( + a.valueDeclaration, + 262 + /* VariableDeclarationList */ + ); + y && y.parent === l && cst(r, l) && (xn(a.valueDeclaration).flags |= 65536); + } + xn(a.valueDeclaration).flags |= 32768; + } + f && (xn(a.valueDeclaration).flags |= 16384); + } + function ost(r, a) { + const l = xn(r); + return !!l && ms(l.capturedBlockScopeBindings, yn(a)); + } + function cst(r, a) { + let l = r; + for (; l.parent.kind === 218; ) + l = l.parent; + let f = !1; + if (Ly(l)) + f = !0; + else if (l.parent.kind === 225 || l.parent.kind === 226) { + const d = l.parent; + f = d.operator === 46 || d.operator === 47; + } + return f ? !!dr(l, (d) => d === a ? "quit" : d === a.statement) : !1; + } + function Sde(r, a) { + if (xn(r).flags |= 2, a.kind === 173 || a.kind === 177) { + const l = a.parent; + xn(l).flags |= 4; + } else + xn(a).flags |= 4; + } + function o8e(r) { + return oS(r) ? r : Es(r) ? void 0 : xs(r, o8e); + } + function Tde(r) { + const a = yn(r), l = bo(a); + return Xh(l) === ke; + } + function c8e(r, a, l) { + const f = a.parent; + Lb(f) && !Tde(f) && HC(r) && r.flowNode && !V$( + r.flowNode, + /*noCacheCheck*/ + !1 + ) && ze(r, l); + } + function lst(r, a) { + os(a) && cl(a) && U && a.initializer && KP(a.initializer, r.pos) && Ff(a.parent) && ze(r, p.Cannot_use_this_in_a_static_property_initializer_of_a_decorated_class); + } + function OM(r) { + const a = Tx(r); + let l = qu( + r, + /*includeArrowFunctions*/ + !0, + /*includeClassComputedPropertyName*/ + !0 + ), f = !1, d = !1; + for (l.kind === 177 && c8e(r, l, p.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class); ; ) { + if (l.kind === 220 && (l = qu( + l, + /*includeArrowFunctions*/ + !1, + !d + ), f = !0), l.kind === 168) { + l = qu( + l, + !f, + /*includeClassComputedPropertyName*/ + !1 + ), d = !0; + continue; + } + break; + } + if (lst(r, l), d) + ze(r, p.this_cannot_be_referenced_in_a_computed_property_name); + else + switch (l.kind) { + case 268: + ze(r, p.this_cannot_be_referenced_in_a_module_or_namespace_body); + break; + case 267: + ze(r, p.this_cannot_be_referenced_in_current_location); + break; + } + !a && f && R < 2 && Sde(r, l); + const y = xde( + r, + /*includeGlobalThis*/ + !0, + l + ); + if (he) { + const x = Yr(Se); + if (y === x && f) + ze(r, p.The_containing_arrow_function_captures_the_global_value_of_this); + else if (!y) { + const I = ze(r, p.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation); + if (!Di(l)) { + const J = xde(l); + J && J !== x && zs(I, sn(l, p.An_outer_value_of_this_is_shadowed_by_this_container)); + } + } + } + return y || Le; + } + function xde(r, a = !0, l = qu( + r, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + )) { + const f = an(r); + if (Es(l) && (!Ede(r) || Rb(l))) { + let d = WG(l) || f && fst(l); + if (!d) { + const y = _st(l); + if (f && y) { + const x = Hi(y).symbol; + x && x.members && x.flags & 16 && (d = bo(x).thisType); + } else zm(l) && (d = bo(Oa(l.symbol)).thisType); + d || (d = kde(l)); + } + if (d) + return s0(r, d); + } + if ($n(l.parent)) { + const d = yn(l.parent), y = Js(l) ? Yr(d) : bo(d).thisType; + return s0(r, y); + } + if (Di(l)) + if (l.commonJsModuleIndicator) { + const d = yn(l); + return d && Yr(d); + } else { + if (l.externalModuleIndicator) + return ue; + if (a) + return Yr(Se); + } + } + function ust(r) { + const a = qu( + r, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + if (Es(a)) { + const l = Xf(a); + if (l.thisParameter) + return W$(l.thisParameter); + } + if ($n(a.parent)) { + const l = yn(a.parent); + return Js(a) ? Yr(l) : bo(l).thisType; + } + } + function _st(r) { + if (r.kind === 219 && _n(r.parent) && Ac(r.parent) === 3) + return r.parent.left.expression.expression; + if (r.kind === 175 && r.parent.kind === 211 && _n(r.parent.parent) && Ac(r.parent.parent) === 6) + return r.parent.parent.left.expression; + if (r.kind === 219 && r.parent.kind === 304 && r.parent.parent.kind === 211 && _n(r.parent.parent.parent) && Ac(r.parent.parent.parent) === 6) + return r.parent.parent.parent.left.expression; + if (r.kind === 219 && rl(r.parent) && Me(r.parent.name) && (r.parent.name.escapedText === "value" || r.parent.name.escapedText === "get" || r.parent.name.escapedText === "set") && _a(r.parent.parent) && Ps(r.parent.parent.parent) && r.parent.parent.parent.arguments[2] === r.parent.parent && Ac(r.parent.parent.parent) === 9) + return r.parent.parent.parent.arguments[0].expression; + if (rc(r) && Me(r.name) && (r.name.escapedText === "value" || r.name.escapedText === "get" || r.name.escapedText === "set") && _a(r.parent) && Ps(r.parent.parent) && r.parent.parent.arguments[2] === r.parent && Ac(r.parent.parent) === 9) + return r.parent.parent.arguments[0].expression; + } + function fst(r) { + const a = v7(r); + if (a && a.typeExpression) + return Ci(a.typeExpression); + const l = uP(r); + if (l) + return tb(l); + } + function pst(r, a) { + return !!dr(r, (l) => io(l) ? "quit" : l.kind === 170 && l.parent === a); + } + function $$(r) { + const a = r.parent.kind === 214 && r.parent.expression === r, l = N3( + r, + /*stopOnFunctions*/ + !0 + ); + let f = l, d = !1, y = !1; + if (!a) { + for (; f && f.kind === 220; ) + Gn( + f, + 1024 + /* Async */ + ) && (y = !0), f = N3( + f, + /*stopOnFunctions*/ + !0 + ), d = R < 2; + f && Gn( + f, + 1024 + /* Async */ + ) && (y = !0); + } + let x = 0; + if (!f || !G(f)) { + const ve = dr( + r, + (de) => de === f ? "quit" : de.kind === 168 + /* ComputedPropertyName */ + ); + return ve && ve.kind === 168 ? ze(r, p.super_cannot_be_referenced_in_a_computed_property_name) : a ? ze(r, p.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors) : !f || !f.parent || !($n(f.parent) || f.parent.kind === 211) ? ze(r, p.super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions) : ze(r, p.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class), qe; + } + if (!a && l.kind === 177 && c8e(r, f, p.super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class), Js(f) || a ? (x = 32, !a && R >= 2 && R <= 8 && (os(f) || kc(f)) && sK(r.parent, (ve) => { + (!Di(ve) || tf(ve)) && (xn(ve).flags |= 2097152); + })) : x = 16, xn(r).flags |= x, f.kind === 175 && y && (j_(r.parent) && Ly(r.parent) ? xn(f).flags |= 256 : xn(f).flags |= 128), d && Sde(r.parent, f), f.parent.kind === 211) + return R < 2 ? (ze(r, p.super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher), qe) : Le; + const I = f.parent; + if (!Lb(I)) + return ze(r, p.super_can_only_be_referenced_in_a_derived_class), qe; + if (Tde(I)) + return a ? qe : ke; + const J = bo(yn(I)), z = J && bd(J)[0]; + if (!z) + return qe; + if (f.kind === 177 && pst(r, f)) + return ze(r, p.super_cannot_be_referenced_in_constructor_arguments), qe; + return x === 32 ? Xh(J) : yf(z, J.thisType); + function G(ve) { + return a ? ve.kind === 177 : $n(ve.parent) || ve.parent.kind === 211 ? Js(ve) ? ve.kind === 175 || ve.kind === 174 || ve.kind === 178 || ve.kind === 179 || ve.kind === 173 || ve.kind === 176 : ve.kind === 175 || ve.kind === 174 || ve.kind === 178 || ve.kind === 179 || ve.kind === 173 || ve.kind === 172 || ve.kind === 177 : !1; + } + } + function l8e(r) { + return (r.kind === 175 || r.kind === 178 || r.kind === 179) && r.parent.kind === 211 ? r.parent : r.kind === 219 && r.parent.kind === 304 ? r.parent.parent : void 0; + } + function u8e(r) { + return Dn(r) & 4 && r.target === Df ? Ao(r)[0] : void 0; + } + function dst(r) { + return Go(r, (a) => a.flags & 2097152 ? lr(a.types, u8e) : u8e(a)); + } + function _8e(r, a) { + let l = r, f = a; + for (; f; ) { + const d = dst(f); + if (d) + return d; + if (l.parent.kind !== 304) + break; + l = l.parent.parent, f = ub( + l, + /*contextFlags*/ + void 0 + ); + } + } + function kde(r) { + if (r.kind === 220) + return; + if (y$(r)) { + const l = TI(r); + if (l) { + const f = l.thisParameter; + if (f) + return Yr(f); + } + } + const a = an(r); + if (he || a) { + const l = l8e(r); + if (l) { + const d = ub( + l, + /*contextFlags*/ + void 0 + ), y = _8e(l, d); + return y ? Mi(y, Zpe(J2(l))) : Sf(d ? n0(d) : mc(l)); + } + const f = ad(r.parent); + if (Nl(f)) { + const d = f.left; + if (To(d)) { + const { expression: y } = d; + if (a && Me(y)) { + const x = xr(f); + if (x.commonJsModuleIndicator && ju(y) === x.symbol) + return; + } + return Sf(mc(y)); + } + } + } + } + function f8e(r) { + const a = r.parent; + if (!y$(a)) + return; + const l = q1(a); + if (l && l.arguments) { + const d = fX(l), y = a.parameters.indexOf(r); + if (r.dotDotDotToken) + return Qde( + d, + y, + d.length, + Le, + /*context*/ + void 0, + 0 + /* Normal */ + ); + const x = xn(l), I = x.resolvedSignature; + x.resolvedSignature = Hr; + const J = y < d.length ? ob(Hi(d[y])) : r.initializer ? void 0 : M; + return x.resolvedSignature = I, J; + } + const f = TI(a); + if (f) { + const d = a.parameters.indexOf(r) - (Rb(a) ? 1 : 0); + return r.dotDotDotToken && Do(a.parameters) === r ? $M(f, d) : W2(f, d); + } + } + function Cde(r, a) { + const l = Kc(r) || (an(r) ? lF(r) : void 0); + if (l) + return Ci(l); + switch (r.kind) { + case 170: + return f8e(r); + case 209: + return mst(r, a); + case 173: + if (Js(r)) + return gst(r, a); + } + } + function mst(r, a) { + const l = r.parent.parent, f = r.propertyName || r.name, d = Cde(l, a) || l.kind !== 209 && l.initializer && kP( + l, + r.dotDotDotToken ? 32 : 0 + /* Normal */ + ); + if (!d || ws(f) || x3(f)) return; + if (l.name.kind === 208) { + const x = MC(r.parent.elements, r); + return x < 0 ? void 0 : Ade(d, x); + } + const y = Yh(f); + if (_p(y)) { + const x = fp(y); + return rr(d, x); + } + } + function gst(r, a) { + const l = ut(r.parent) && g_(r.parent, a); + if (l) + return lb(l, yn(r).escapedName); + } + function hst(r, a) { + const l = r.parent; + if (d0(l) && r === l.initializer) { + const f = Cde(l, a); + if (f) + return f; + if (!(a & 8) && ws(l.name) && l.name.elements.length > 0) + return rP( + l.name, + /*includePatternInType*/ + !0, + /*reportErrors*/ + !1 + ); + } + } + function yst(r, a) { + const l = Af(r); + if (l) { + let f = X$(l, a); + if (f) { + const d = Mc(l); + if (d & 1) { + const y = (d & 2) !== 0; + f.flags & 1048576 && (f = Xc(f, (I) => !!oy(1, I, y))); + const x = oy(1, f, (d & 2) !== 0); + if (!x) + return; + f = x; + } + if (d & 2) { + const y = Go(f, a0); + return y && Xn([y, IIe(y)]); + } + return f; + } + } + } + function vst(r, a) { + const l = g_(r, a); + if (l) { + const f = a0(l); + return f && Xn([f, IIe(f)]); + } + } + function bst(r, a) { + const l = Af(r); + if (l) { + const f = Mc(l); + let d = X$(l, a); + if (d) { + const y = (f & 2) !== 0; + if (!r.asteriskToken && d.flags & 1048576 && (d = Xc(d, (x) => !!oy(1, x, y))), r.asteriskToken) { + const x = Mme(d, y), I = x?.yieldType ?? kt, J = g_(r, a) ?? kt, z = x?.nextType ?? yt, G = hX( + I, + J, + z, + /*isAsyncGenerator*/ + !1 + ); + if (y) { + const ve = hX( + I, + J, + z, + /*isAsyncGenerator*/ + !0 + ); + return Xn([G, ve]); + } + return G; + } + return oy(0, d, y); + } + } + } + function Ede(r) { + let a = !1; + for (; r.parent && !Es(r.parent); ) { + if (Ii(r.parent) && (a || r.parent.initializer === r)) + return !0; + ya(r.parent) && r.parent.initializer === r && (a = !0), r = r.parent; + } + return !1; + } + function p8e(r, a) { + const l = !!(Mc(a) & 2), f = X$( + a, + /*contextFlags*/ + void 0 + ); + if (f) + return oy(r, f, l) || void 0; + } + function X$(r, a) { + const l = IE(r); + if (l) + return l; + const f = eX(r); + if (f && !ZG(f)) { + const y = Wa(f), x = Mc(r); + return x & 1 ? Xc(y, (I) => !!(I.flags & 58998787) || bme( + I, + x, + /*errorNode*/ + void 0 + )) : x & 2 ? Xc(y, (I) => !!(I.flags & 58998787) || !!DP(I)) : y; + } + const d = q1(r); + if (d) + return g_(d, a); + } + function d8e(r, a) { + const f = fX(r).indexOf(a); + return f === -1 ? void 0 : Dde(r, f); + } + function Dde(r, a) { + if (T_(r)) + return a === 0 ? at : a === 1 ? V3e( + /*reportErrors*/ + !1 + ) : Le; + const l = xn(r).resolvedSignature === ln ? ln : qE(r); + if (wu(r) && a === 0) + return K$(l, r); + const f = l.parameters.length - 1; + return Iu(l) && a >= f ? vf( + Yr(l.parameters[f]), + Xd(a - f), + 256 + /* Contextual */ + ) : Kd(l, a); + } + function Sst(r) { + const a = ume(r); + return a ? ET(a) : void 0; + } + function Tst(r, a) { + if (r.parent.kind === 216) + return d8e(r.parent, a); + } + function xst(r, a) { + const l = r.parent, { left: f, operatorToken: d, right: y } = l; + switch (d.kind) { + case 64: + case 77: + case 76: + case 78: + return r === y ? Cst(l) : void 0; + case 57: + case 61: + const x = g_(l, a); + return r === y && (x && x.pattern || !x && !DK(l)) ? lu(f) : x; + case 56: + case 28: + return r === y ? g_(l, a) : void 0; + default: + return; + } + } + function kst(r) { + if (Ed(r) && r.symbol) + return r.symbol; + if (Me(r)) + return ju(r); + if (wn(r)) { + const l = lu(r.expression); + return Ai(r.name) ? a(l, r.name) : Ys(l, r.name.escapedText); + } + if (uo(r)) { + const l = mc(r.argumentExpression); + if (!_p(l)) + return; + const f = lu(r.expression); + return Ys(f, fp(l)); + } + return; + function a(l, f) { + const d = zM(f.escapedText, f); + return d && cX(l, d); + } + } + function Cst(r) { + var a, l; + const f = Ac(r); + switch (f) { + case 0: + case 4: + const d = kst(r.left), y = d && d.valueDeclaration; + if (y && (os(y) || $u(y))) { + const J = Kc(y); + return J && Mi(Ci(J), Pn(d).mapper) || (os(y) ? y.initializer && lu(r.left) : void 0); + } + return f === 0 ? lu(r.left) : m8e(r); + case 5: + if (Q$(r, f)) + return m8e(r); + if (!Ed(r.left) || !r.left.symbol) + return lu(r.left); + { + const J = r.left.symbol.valueDeclaration; + if (!J) + return; + const z = Us(r.left, To), G = Kc(J); + if (G) + return Ci(G); + if (Me(z.expression)) { + const ve = z.expression, de = st( + ve, + ve.escapedText, + 111551, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !0 + ); + if (de) { + const We = de.valueDeclaration && Kc(de.valueDeclaration); + if (We) { + const lt = Sh(z); + if (lt !== void 0) + return lb(Ci(We), lt); + } + return; + } + } + return an(J) || J === r.left ? void 0 : lu(r.left); + } + case 1: + case 6: + case 3: + case 2: + let x; + f !== 2 && (x = Ed(r.left) ? (a = r.left.symbol) == null ? void 0 : a.valueDeclaration : void 0), x || (x = (l = r.symbol) == null ? void 0 : l.valueDeclaration); + const I = x && Kc(x); + return I ? Ci(I) : void 0; + case 7: + case 8: + case 9: + return E.fail("Does not apply"); + default: + return E.assertNever(f); + } + } + function Q$(r, a = Ac(r)) { + if (a === 4) + return !0; + if (!an(r) || a !== 5 || !Me(r.left.expression)) + return !1; + const l = r.left.expression.escapedText, f = st( + r.left, + l, + 111551, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !0, + /*excludeGlobals*/ + !0 + ); + return i5(f?.valueDeclaration); + } + function m8e(r) { + if (!r.symbol) return lu(r.left); + if (r.symbol.valueDeclaration) { + const d = Kc(r.symbol.valueDeclaration); + if (d) { + const y = Ci(d); + if (y) + return y; + } + } + const a = Us(r.left, To); + if (!Rp(qu( + a.expression, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ))) + return; + const l = OM(a.expression), f = Sh(a); + return f !== void 0 && lb(l, f) || void 0; + } + function Est(r) { + return !!(uc(r) & 262144 && !r.links.type && X( + r, + 0 + /* Type */ + ) >= 0); + } + function wde(r, a) { + if (r.flags & 16777216) { + const l = r; + return !!(td(E1(l)).flags & 131072) && Kh(D1(l)) === Kh(l.checkType) && Ms(a, l.extendsType); + } + return r.flags & 2097152 ? ot(r.types, (l) => wde(l, a)) : !1; + } + function lb(r, a, l) { + return Go( + r, + (f) => { + if (f.flags & 2097152) { + let d, y, x = !1; + for (const I of f.types) { + if (!(I.flags & 524288)) + continue; + if (L_(I) && Y8(I) !== 2) { + const z = g8e(I, a, l); + d = Pde(d, z); + continue; + } + const J = h8e(I, a); + if (!J) { + x || (y = Er(y, I)); + continue; + } + x = !0, y = void 0, d = Pde(d, J); + } + if (y) + for (const I of y) { + const J = y8e(I, a, l); + d = Pde(d, J); + } + return d ? d.length === 1 ? d[0] : sa(d) : void 0; + } + if (f.flags & 524288) + return L_(f) && Y8(f) !== 2 ? g8e(f, a, l) : h8e(f, a) ?? y8e(f, a, l); + }, + /*noReductions*/ + !0 + ); + } + function Pde(r, a) { + return a ? Er(r, a.flags & 1 ? yt : a) : r; + } + function g8e(r, a, l) { + const f = l || H_(Si(a)), d = $f(r); + if (r.nameType && wde(r.nameType, f) || wde(d, f)) + return; + const y = ou(d) || d; + if (Ms(f, y)) + return f$(r, f); + } + function h8e(r, a) { + const l = Ys(r, a); + if (!(!l || Est(l))) + return i0(Yr(l), !!(l.flags & 16777216)); + } + function y8e(r, a, l) { + var f; + if (Sa(r) && zg(a) && +a >= 0) { + const d = yP( + r, + r.target.fixedLength, + /*endSkipCount*/ + 0, + /*writing*/ + !1, + /*noReductions*/ + !0 + ); + if (d) + return d; + } + return (f = Wfe(Ufe(r), l || H_(Si(a)))) == null ? void 0 : f.type; + } + function v8e(r, a) { + if (E.assert(Rp(r)), !(r.flags & 67108864)) + return Nde(r, a); + } + function Nde(r, a) { + const l = r.parent, f = rl(r) && Cde(r, a); + if (f) + return f; + const d = ub(l, a); + if (d) { + if (NE(r)) { + const y = yn(r); + return lb(d, y.escapedName, Pn(y).nameType); + } + if (Th(r)) { + const y = _s(r); + if (y && Gs(y)) { + const x = Hi(y.expression), I = _p(x) && lb(d, fp(x)); + if (I) + return I; + } + } + if (r.name) { + const y = Yh(r.name); + return Go( + d, + (x) => { + var I; + return (I = Wfe(Ufe(x), y)) == null ? void 0 : I.type; + }, + /*noReductions*/ + !0 + ); + } + } + } + function Dst(r) { + let a, l; + for (let f = 0; f < r.length; f++) + dp(r[f]) && (a ?? (a = f), l = f); + return { first: a, last: l }; + } + function Ade(r, a, l, f, d) { + return r && Go( + r, + (y) => { + if (Sa(y)) { + if ((f === void 0 || a < f) && a < y.target.fixedLength) + return i0(Ao(y)[a], !!y.target.elementFlags[a]); + const x = l !== void 0 && (d === void 0 || a > d) ? l - a : 0, I = x > 0 && y.target.combinedFlags & 12 ? nI( + y.target, + 3 + /* Fixed */ + ) : 0; + return x > 0 && x <= I ? Ao(y)[ry(y) - x] : yP( + y, + f === void 0 ? y.target.fixedLength : Math.min(y.target.fixedLength, f), + l === void 0 || d === void 0 ? I : Math.min(I, l - d), + /*writing*/ + !1, + /*noReductions*/ + !0 + ); + } + return (!f || a < f) && lb(y, "" + a) || Ame( + 1, + y, + ue, + /*errorNode*/ + void 0, + /*checkAssignability*/ + !1 + ); + }, + /*noReductions*/ + !0 + ); + } + function wst(r, a) { + const l = r.parent; + return r === l.whenTrue || r === l.whenFalse ? g_(l, a) : void 0; + } + function Pst(r, a, l) { + const f = ub(r.openingElement.attributes, l), d = jM(zT(r)); + if (!(f && !gn(f) && d && d !== "")) + return; + const y = QC(r.children), x = y.indexOf(a), I = lb(f, d); + return I && (y.length === 1 ? I : Go( + I, + (J) => iy(J) ? vf(J, Xd(x)) : J, + /*noReductions*/ + !0 + )); + } + function Nst(r, a) { + const l = r.parent; + return A7(l) ? g_(r, a) : Sm(l) ? Pst(l, r, a) : void 0; + } + function b8e(r, a) { + if (Tm(r)) { + const l = ub(r.parent, a); + return !l || gn(l) ? void 0 : lb(l, S4(r.name)); + } else + return g_(r.parent, a); + } + function LM(r) { + switch (r.kind) { + case 11: + case 9: + case 10: + case 15: + case 229: + case 112: + case 97: + case 106: + case 80: + case 157: + return !0; + case 212: + case 218: + return LM(r.expression); + case 295: + return !r.expression || LM(r.expression); + } + return !1; + } + function Ast(r, a) { + const l = `D${Ma(r)},${jl(a)}`; + return f_(l) ?? Yp( + l, + Sit(a, r) ?? Mpe( + a, + Bi( + hr( + kn(r.properties, (f) => f.symbol ? f.kind === 304 ? LM(f.initializer) && vP(a, f.symbol.escapedName) : f.kind === 305 ? vP(a, f.symbol.escapedName) : !1 : !1), + (f) => [() => tR(f.kind === 304 ? f.initializer : f.name), f.symbol.escapedName] + ), + hr( + kn($a(a), (f) => { + var d; + return !!(f.flags & 16777216) && !!((d = r?.symbol) != null && d.members) && !r.symbol.members.has(f.escapedName) && vP(a, f.escapedName); + }), + (f) => [() => ue, f.escapedName] + ) + ), + Ms + ) + ); + } + function Ist(r, a) { + const l = `D${Ma(r)},${jl(a)}`, f = f_(l); + if (f) return f; + const d = jM(zT(r)); + return Yp( + l, + Mpe( + a, + Bi( + hr( + kn(r.properties, (y) => !!y.symbol && y.kind === 292 && vP(a, y.symbol.escapedName) && (!y.initializer || LM(y.initializer))), + (y) => [y.initializer ? () => tR(y.initializer) : () => rt, y.symbol.escapedName] + ), + hr( + kn($a(a), (y) => { + var x; + if (!(y.flags & 16777216) || !((x = r?.symbol) != null && x.members)) + return !1; + const I = r.parent.parent; + return y.escapedName === d && Sm(I) && QC(I.children).length ? !1 : !r.symbol.members.has(y.escapedName) && vP(a, y.escapedName); + }), + (y) => [() => ue, y.escapedName] + ) + ), + Ms + ) + ); + } + function ub(r, a) { + const l = Rp(r) ? v8e(r, a) : g_(r, a), f = Y$(l, r, a); + if (f && !(a && a & 2 && f.flags & 8650752)) { + const d = Go( + f, + // When obtaining apparent type of *contextual* type we don't want to get apparent type of mapped types. + // That would evaluate mapped types with array or tuple type constraints too eagerly + // and thus it would prevent `getTypeOfPropertyOfContextualType` from obtaining per-position contextual type for elements of array literal expressions. + // Apparent type of other mapped types is already the mapped type itself so we can just avoid calling `getApparentType` here for all mapped types. + (y) => Dn(y) & 32 ? y : e_(y), + /*noReductions*/ + !0 + ); + return d.flags & 1048576 && _a(r) ? Ast(r, d) : d.flags & 1048576 && Yb(r) ? Ist(r, d) : d; + } + } + function Y$(r, a, l) { + if (r && Dc( + r, + 465829888 + /* Instantiable */ + )) { + const f = J2(a); + if (f && l & 1 && ot(f.inferences, wct)) + return Z$(r, f.nonFixingMapper); + if (f?.returnMapper) { + const d = Z$(r, f.returnMapper); + return d.flags & 1048576 && ch(d.types, Pr) && ch(d.types, vt) ? Xc(d, (y) => y !== Pr && y !== vt) : d; + } + } + return r; + } + function Z$(r, a) { + return r.flags & 465829888 ? Mi(r, a) : r.flags & 1048576 ? Xn( + hr(r.types, (l) => Z$(l, a)), + 0 + /* None */ + ) : r.flags & 2097152 ? sa(hr(r.types, (l) => Z$(l, a))) : r; + } + function g_(r, a) { + var l; + if (r.flags & 67108864) + return; + const f = T8e( + r, + /*includeCaches*/ + !a + ); + if (f >= 0) + return A_[f]; + const { parent: d } = r; + switch (d.kind) { + case 261: + case 170: + case 173: + case 172: + case 209: + return hst(r, a); + case 220: + case 254: + return yst(r, a); + case 230: + return bst(d, a); + case 224: + return vst(d, a); + case 214: + case 215: + return d8e(d, r); + case 171: + return Sst(d); + case 217: + case 235: + return nd(d.type) ? g_(d, a) : Ci(d.type); + case 227: + return xst(r, a); + case 304: + case 305: + return Nde(d, a); + case 306: + return g_(d.parent, a); + case 210: { + const y = d, x = ub(y, a), I = MC(y.elements, r), J = (l = xn(y)).spreadIndices ?? (l.spreadIndices = Dst(y.elements)); + return Ade(x, I, y.elements.length, J.first, J.last); + } + case 228: + return wst(r, a); + case 240: + return E.assert( + d.parent.kind === 229 + /* TemplateExpression */ + ), Tst(d.parent, r); + case 218: { + if (an(d)) { + if (UJ(d)) + return Ci(VJ(d)); + const y = z1(d); + if (y && !nd(y.typeExpression.type)) + return Ci(y.typeExpression.type); + } + return g_(d, a); + } + case 236: + return g_(d, a); + case 239: + return Ci(d.type); + case 278: + return x1(d); + case 295: + return Nst(d, a); + case 292: + case 294: + return b8e(d, a); + case 287: + case 286: + return Jst(d, a); + case 302: + return Bst(d); + } + } + function S8e(r) { + MM( + r, + g_( + r, + /*contextFlags*/ + void 0 + ), + /*isCache*/ + !0 + ); + } + function MM(r, a, l) { + Wo[$l] = r, A_[$l] = a, Xp[$l] = l, $l++; + } + function SI() { + $l--, Wo[$l] = void 0, A_[$l] = void 0, Xp[$l] = void 0; + } + function T8e(r, a) { + for (let l = $l - 1; l >= 0; l--) + if (r === Wo[l] && (a || !Xp[l])) + return l; + return -1; + } + function Fst(r, a) { + mf[Am] = r, wv[Am] = a, Am++; + } + function Ost() { + Am--, mf[Am] = void 0, wv[Am] = void 0; + } + function J2(r) { + for (let a = Am - 1; a >= 0; a--) + if (Ob(r, mf[a])) + return wv[a]; + } + function Lst(r) { + ag[og] = r, Pv[og] ?? (Pv[og] = /* @__PURE__ */ new Map()), og++; + } + function Mst() { + og--, ag[og] = void 0, Pv[og].clear(); + } + function Rst(r) { + for (let a = og - 1; a >= 0; a--) + if (r === ag[a]) + return a; + return -1; + } + function jst() { + for (let r = og - 1; r >= 0; r--) + Pv[r].clear(); + } + function Bst(r) { + return lb(tpe( + /*reportErrors*/ + !1 + ), uF(r)); + } + function Jst(r, a) { + if (Id(r) && a !== 4) { + const l = T8e( + r.parent, + /*includeCaches*/ + !a + ); + if (l >= 0) + return A_[l]; + } + return Dde(r, 0); + } + function K$(r, a) { + return ud(a) || aIe(a) !== 0 ? zst(r, a) : Vst(r, a); + } + function zst(r, a) { + let l = cme(r, yt); + l = x8e(a, zT(a), l); + const f = z2(Rf.IntrinsicAttributes, a); + return Gr(f) || (l = YL(f, l)), l; + } + function Wst(r, a) { + if (r.compositeSignatures) { + const f = []; + for (const d of r.compositeSignatures) { + const y = Wa(d); + if (gn(y)) + return y; + const x = rr(y, a); + if (!x) + return; + f.push(x); + } + return sa(f); + } + const l = Wa(r); + return gn(l) ? l : rr(l, a); + } + function Ust(r) { + if (ud(r)) return gIe(r); + if (uC(r.tagName)) { + const l = F8e(r), f = pX(r, l); + return ET(f); + } + const a = mc(r.tagName); + if (a.flags & 128) { + const l = I8e(a, r); + if (!l) + return qe; + const f = pX(r, l); + return ET(f); + } + return a; + } + function x8e(r, a, l) { + const f = pat(a); + if (f) { + const d = Ust(r), y = M8e(f, an(r), d, l); + if (y) + return y; + } + return l; + } + function Vst(r, a) { + const l = zT(a), f = mat(l); + let d = f === void 0 ? cme(r, yt) : f === "" ? Wa(r) : Wst(r, f); + if (!d) + return f && wr(a.attributes.properties) && ze(a, p.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property, Si(f)), yt; + if (d = x8e(a, l, d), gn(d)) + return d; + { + let y = d; + const x = z2(Rf.IntrinsicClassAttributes, a); + if (!Gr(x)) { + const J = ia(x.symbol), z = Wa(r); + let G; + if (J) { + const ve = ty([z], J, gg(J), an(a)); + G = Mi(x, bf(J, ve)); + } else G = x; + y = YL(G, y); + } + const I = z2(Rf.IntrinsicAttributes, a); + return Gr(I) || (y = YL(I, y)), y; + } + } + function qst(r) { + return du(F, "noImplicitAny") ? Wu( + r, + (a, l) => a === l || !a ? a : i3e(a.typeParameters, l.typeParameters) ? $st(a, l) : void 0 + ) : void 0; + } + function Hst(r, a, l) { + if (!r || !a) + return r || a; + const f = Xn([Yr(r), Mi(Yr(a), l)]); + return LT(r, f); + } + function Gst(r, a, l) { + const f = $_(r), d = $_(a), y = f >= d ? r : a, x = y === r ? a : r, I = y === r ? f : d, J = vg(r) || vg(a), z = J && !vg(y), G = new Array(I + (z ? 1 : 0)); + for (let ve = 0; ve < I; ve++) { + let de = W2(y, ve); + y === a && (de = Mi(de, l)); + let We = W2(x, ve) || yt; + x === a && (We = Mi(We, l)); + const lt = Xn([de, We]), gt = J && !z && ve === I - 1, jt = ve >= em(y) && ve >= em(x), ar = ve >= f ? void 0 : xP(r, ve), jr = ve >= d ? void 0 : xP(a, ve), Kr = ar === jr ? ar : ar ? jr ? void 0 : ar : jr, or = ga( + 1 | (jt && !gt ? 16777216 : 0), + Kr || `arg${ve}`, + gt ? 32768 : jt ? 16384 : 0 + ); + or.links.type = gt ? Tu(lt) : lt, G[ve] = or; + } + if (z) { + const ve = ga( + 1, + "args", + 32768 + /* RestParameter */ + ); + ve.links.type = Tu(Kd(x, I)), x === a && (ve.links.type = Mi(ve.links.type, l)), G[I] = ve; + } + return G; + } + function $st(r, a) { + const l = r.typeParameters || a.typeParameters; + let f; + r.typeParameters && a.typeParameters && (f = bf(a.typeParameters, r.typeParameters)); + let d = (r.flags | a.flags) & 166; + const y = r.declaration, x = Gst(r, a, f), I = Do(x); + I && uc(I) & 32768 && (d |= 1); + const J = Hst(r.thisParameter, a.thisParameter, f), z = Math.max(r.minArgumentCount, a.minArgumentCount), G = Mm( + y, + l, + J, + x, + /*resolvedReturnType*/ + void 0, + /*resolvedTypePredicate*/ + void 0, + z, + d + ); + return G.compositeKind = 2097152, G.compositeSignatures = Bi(r.compositeKind === 2097152 && r.compositeSignatures || [r], [a]), f && (G.mapper = r.compositeKind === 2097152 && r.mapper && r.compositeSignatures ? ib(r.mapper, f) : f), G; + } + function Ide(r, a) { + const l = Is( + r, + 0 + /* Call */ + ), f = kn(l, (d) => !Xst(d, a)); + return f.length === 1 ? f[0] : qst(f); + } + function Xst(r, a) { + let l = 0; + for (; l < a.parameters.length; l++) { + const f = a.parameters[l]; + if (f.initializer || f.questionToken || f.dotDotDotToken || cF(f)) + break; + } + return a.parameters.length && My(a.parameters[0]) && l--, !vg(r) && $_(r) < l; + } + function eX(r) { + return zy(r) || Rp(r) ? TI(r) : void 0; + } + function TI(r) { + E.assert(r.kind !== 175 || Rp(r)); + const a = uP(r); + if (a) + return a; + const l = ub( + r, + 1 + /* Signature */ + ); + if (!l) + return; + if (!(l.flags & 1048576)) + return Ide(l, r); + let f; + const d = l.types; + for (const y of d) { + const x = Ide(y, r); + if (x) + if (!f) + f = [x]; + else if (bM( + f[0], + x, + /*partialMatch*/ + !1, + /*ignoreThisTypes*/ + !0, + /*ignoreReturnTypes*/ + !0, + lI + )) + f.push(x); + else + return; + } + if (f) + return f.length === 1 ? f[0] : r3e(f[0], f); + } + function Qst(r) { + const a = xr(r); + if (!F1(a) && !r.isUnterminated) { + let l; + s ?? (s = Dg( + 99, + /*skipTrivia*/ + !0 + )), s.setScriptTarget(a.languageVersion), s.setLanguageVariant(a.languageVariant), s.setOnError((f, d, y) => { + const x = s.getTokenEnd(); + if (f.category === 3 && l && x === l.start && d === l.length) { + const I = wx(a.fileName, a.text, x, d, f, y); + zs(l, I); + } else (!l || x !== l.start) && (l = ll(a, x, d, f, y), Aa.add(l)); + }), s.setText(a.text, r.pos, r.end - r.pos); + try { + return s.scan(), E.assert(s.reScanSlashToken( + /*reportErrors*/ + !0 + ) === 14, "Expected scanner to rescan RegularExpressionLiteral"), !!l; + } finally { + s.setText(""), s.setOnError( + /*onError*/ + void 0 + ); + } + } + return !1; + } + function Yst(r) { + const a = xn(r); + return a.flags & 1 || (a.flags |= 1, n(() => Qst(r))), vc; + } + function Zst(r, a) { + R < El.SpreadElements && xl( + r, + F.downlevelIteration ? 1536 : 1024 + /* SpreadArray */ + ); + const l = Hi(r.expression, a); + return ay(33, l, ue, r.expression); + } + function Kst(r) { + return r.isSpread ? vf(r.type, wt) : r.type; + } + function lC(r) { + return r.kind === 209 && !!r.initializer || r.kind === 304 && lC(r.initializer) || r.kind === 305 && !!r.objectAssignmentInitializer || r.kind === 227 && r.operatorToken.kind === 64; + } + function eat(r) { + const a = ad(r.parent); + return dp(a) && sm(a.parent); + } + function k8e(r, a, l) { + const f = r.elements, d = f.length, y = [], x = []; + S8e(r); + const I = Ly(r), J = CP(r), z = ub( + r, + /*contextFlags*/ + void 0 + ), G = eat(r) || !!z && wp(z, (de) => hP(de) || L_(de) && !de.nameType && !!oI(de.target || de)); + let ve = !1; + for (let de = 0; de < d; de++) { + const We = f[de]; + if (We.kind === 231) { + R < El.SpreadElements && xl( + We, + F.downlevelIteration ? 1536 : 1024 + /* SpreadArray */ + ); + const lt = Hi(We.expression, a, l); + if (iy(lt)) + y.push(lt), x.push( + 8 + /* Variadic */ + ); + else if (I) { + const gt = eb(lt, wt) || Ame( + 65, + lt, + ue, + /*errorNode*/ + void 0, + /*checkAssignability*/ + !1 + ) || yt; + y.push(gt), x.push( + 4 + /* Rest */ + ); + } else + y.push(ay(33, lt, ue, We.expression)), x.push( + 4 + /* Rest */ + ); + } else if (be && We.kind === 233) + ve = !0, y.push(Q), x.push( + 2 + /* Optional */ + ); + else { + const lt = EP(We, a, l); + if (y.push(Ru( + lt, + /*isProperty*/ + !0, + ve + )), x.push( + ve ? 2 : 1 + /* Required */ + ), G && a && a & 2 && !(a & 4) && Qf(We)) { + const gt = J2(r); + E.assert(gt), Qpe(gt, We, lt); + } + } + } + return SI(), I ? hg(y, x) : C8e(l || J || G ? hg( + y, + x, + /*readonly*/ + J && !(z && wp(z, zpe)) + ) : Tu( + y.length ? Xn( + Qc(y, (de, We) => x[We] & 8 ? C1(de, wt) || Le : de), + 2 + /* Subtype */ + ) : K ? cr : M, + J + )); + } + function C8e(r) { + if (!(Dn(r) & 4)) + return r; + let a = r.literalType; + return a || (a = r.literalType = A3e(r), a.objectFlags |= 147456), a; + } + function tat(r) { + switch (r.kind) { + case 168: + return rat(r); + case 80: + return zg(r.escapedText); + case 9: + case 11: + return zg(r.text); + default: + return !1; + } + } + function rat(r) { + return cu( + Td(r), + 296 + /* NumberLike */ + ); + } + function Td(r) { + const a = xn(r.expression); + if (!a.resolvedType) { + if ((a_(r.parent.parent) || $n(r.parent.parent) || Vl(r.parent.parent)) && _n(r.expression) && r.expression.operatorToken.kind === 103 && r.parent.kind !== 178 && r.parent.kind !== 179) + return a.resolvedType = qe; + if (a.resolvedType = Hi(r.expression), os(r.parent) && !cl(r.parent) && Rc(r.parent.parent)) { + const l = Dd(r.parent.parent), f = bde(l); + f && (xn(f).flags |= 4096, xn(r).flags |= 32768, xn(r.parent.parent).flags |= 32768); + } + (a.resolvedType.flags & 98304 || !cu( + a.resolvedType, + 402665900 + /* ESSymbolLike */ + ) && !Ms(a.resolvedType, oi)) && ze(r, p.A_computed_property_name_must_be_of_type_string_number_symbol_or_any); + } + return a.resolvedType; + } + function nat(r) { + var a; + const l = (a = r.declarations) == null ? void 0 : a[0]; + return zg(r.escapedName) || l && wl(l) && tat(l.name); + } + function E8e(r) { + var a; + const l = (a = r.declarations) == null ? void 0 : a[0]; + return QD(r) || l && wl(l) && Gs(l.name) && cu( + Td(l.name), + 4096 + /* ESSymbol */ + ); + } + function iat(r) { + var a; + const l = (a = r.declarations) == null ? void 0 : a[0]; + return l && wl(l) && Gs(l.name); + } + function xI(r, a, l, f) { + var d; + const y = []; + let x; + for (let J = a; J < l.length; J++) { + const z = l[J]; + (f === at && !E8e(z) || f === wt && nat(z) || f === Jt && E8e(z)) && (y.push(Yr(l[J])), iat(l[J]) && (x = Er(x, (d = l[J].declarations) == null ? void 0 : d[0]))); + } + const I = y.length ? Xn( + y, + 2 + /* Subtype */ + ) : ue; + return oh( + f, + I, + r, + /*declaration*/ + void 0, + x + ); + } + function tX(r) { + E.assert((r.flags & 2097152) !== 0, "Should only get Alias here."); + const a = Pn(r); + if (!a.immediateTarget) { + const l = F_(r); + if (!l) return E.fail(); + a.immediateTarget = qv( + l, + /*dontRecursivelyResolve*/ + !0 + ); + } + return a.immediateTarget; + } + function sat(r, a = 0) { + const l = Ly(r); + yft(r, l); + const f = K ? Bs() : void 0; + let d = Bs(), y = [], x = ta; + S8e(r); + const I = ub( + r, + /*contextFlags*/ + void 0 + ), J = I && I.pattern && (I.pattern.kind === 207 || I.pattern.kind === 211), z = CP(r), G = z ? 8 : 0, ve = an(r) && !c5(r), de = ve ? Lj(r) : void 0, We = !I && ve && !de; + let lt = 8192, gt = !1, jt = !1, ar = !1, jr = !1; + for (const ir of r.properties) + ir.name && Gs(ir.name) && Td(ir.name); + let Kr = 0; + for (const ir of r.properties) { + let nn = yn(ir); + const Qn = ir.name && ir.name.kind === 168 ? Td(ir.name) : void 0; + if (ir.kind === 304 || ir.kind === 305 || Rp(ir)) { + let Ri = ir.kind === 304 ? GIe(ir, a) : ( + // avoid resolving the left side of the ShorthandPropertyAssignment outside of the destructuring + // for error recovery purposes. For example, if a user wrote `{ a = 100 }` instead of `{ a: 100 }`. + // we don't want to say "could not find 'a'". + ir.kind === 305 ? EP(!l && ir.objectAssignmentInitializer ? ir.objectAssignmentInitializer : ir.name, a) : $Ie(ir, a) + ); + if (ve) { + const ks = Ra(ir); + ks ? (xu(Ri, ks, ir), Ri = ks) : de && de.typeExpression && xu(Ri, Ci(de.typeExpression), ir); + } + lt |= Dn(Ri) & 458752; + const zn = Qn && _p(Qn) ? Qn : void 0, bi = zn ? ga( + 4 | nn.flags, + fp(zn), + G | 4096 + /* Late */ + ) : ga(4 | nn.flags, nn.escapedName, G); + if (zn && (bi.links.nameType = zn), l && lC(ir)) + bi.flags |= 16777216; + else if (J && !(Dn(I) & 512)) { + const ks = Ys(I, nn.escapedName); + ks ? bi.flags |= ks.flags & 16777216 : ah(I, at) || ze(ir.name, p.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, Wi(nn), Wr(I)); + } + if (bi.declarations = nn.declarations, bi.parent = nn.parent, nn.valueDeclaration && (bi.valueDeclaration = nn.valueDeclaration), bi.links.type = Ri, bi.links.target = nn, nn = bi, f?.set(bi.escapedName, bi), I && a & 2 && !(a & 4) && (ir.kind === 304 || ir.kind === 175) && Qf(ir)) { + const ks = J2(r); + E.assert(ks); + const Ua = ir.kind === 304 ? ir.initializer : ir; + Qpe(ks, Ua, Ri); + } + } else if (ir.kind === 306) { + R < El.ObjectAssign && xl( + ir, + 2 + /* Assign */ + ), y.length > 0 && (x = O2(x, or(), r.symbol, lt, z), y = [], d = Bs(), jt = !1, ar = !1, jr = !1); + const Ri = td(Hi( + ir.expression, + a & 2 + /* Inferential */ + )); + if (RM(Ri)) { + const zn = Spe(Ri, z); + if (f && P8e(zn, f, ir), Kr = y.length, Gr(x)) + continue; + x = O2(x, zn, r.symbol, lt, z); + } else + ze(ir, p.Spread_types_may_only_be_created_from_object_types), x = qe; + continue; + } else + E.assert( + ir.kind === 178 || ir.kind === 179 + /* SetAccessor */ + ), fC(ir); + Qn && !(Qn.flags & 8576) ? Ms(Qn, oi) && (Ms(Qn, wt) ? ar = !0 : Ms(Qn, Jt) ? jr = !0 : jt = !0, l && (gt = !0)) : d.set(nn.escapedName, nn), y.push(nn); + } + if (SI(), Gr(x)) + return qe; + if (x !== ta) + return y.length > 0 && (x = O2(x, or(), r.symbol, lt, z), y = [], d = Bs(), jt = !1, ar = !1), Go(x, (ir) => ir === ta ? or() : ir); + return or(); + function or() { + const ir = [], nn = CP(r); + jt && ir.push(xI(nn, Kr, y, at)), ar && ir.push(xI(nn, Kr, y, wt)), jr && ir.push(xI(nn, Kr, y, Jt)); + const Qn = Ho(r.symbol, d, Ge, Ge, ir); + return Qn.objectFlags |= lt | 128 | 131072, We && (Qn.objectFlags |= 4096), gt && (Qn.objectFlags |= 512), l && (Qn.pattern = r), Qn; + } + } + function RM(r) { + const a = uAe(Go(r, Rm)); + return !!(a.flags & 126615553 || a.flags & 3145728 && Ni(a.types, RM)); + } + function aat(r) { + Ode(r); + } + function oat(r, a) { + return fC(r), BM(r) || Le; + } + function cat(r) { + Ode(r.openingElement), uC(r.closingElement.tagName) ? nX(r.closingElement) : Hi(r.closingElement.tagName), rX(r); + } + function lat(r, a) { + return fC(r), BM(r) || Le; + } + function uat(r) { + Ode(r.openingFragment); + const a = xr(r); + G5(F) && (F.jsxFactory || a.pragmas.has("jsx")) && !F.jsxFragmentFactory && !a.pragmas.has("jsxfrag") && ze( + r, + F.jsxFactory ? p.The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_compiler_option : p.An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments + ), rX(r); + const l = BM(r); + return Gr(l) ? Le : l; + } + function Fde(r) { + return r.includes("-"); + } + function uC(r) { + return Me(r) && YC(r.escapedText) || Fd(r); + } + function D8e(r, a) { + return r.initializer ? EP(r.initializer, a) : rt; + } + function w8e(r, a = 0) { + const l = K ? Bs() : void 0; + let f = Bs(), d = Ec, y = !1, x, I = !1, J = 2048; + const z = jM(zT(r)), G = ud(r); + let ve, de = r; + if (!G) { + const gt = r.attributes; + ve = gt.symbol, de = gt; + const jt = g_( + gt, + 0 + /* None */ + ); + for (const ar of gt.properties) { + const jr = ar.symbol; + if (Tm(ar)) { + const Kr = D8e(ar, a); + J |= Dn(Kr) & 458752; + const or = ga(4 | jr.flags, jr.escapedName); + if (or.declarations = jr.declarations, or.parent = jr.parent, jr.valueDeclaration && (or.valueDeclaration = jr.valueDeclaration), or.links.type = Kr, or.links.target = jr, f.set(or.escapedName, or), l?.set(or.escapedName, or), S4(ar.name) === z && (I = !0), jt) { + const ir = Ys(jt, jr.escapedName); + ir && ir.declarations && Zu(ir) && Me(ar.name) && Zp(ar.name, ir.declarations, ar.name.escapedText); + } + if (jt && a & 2 && !(a & 4) && Qf(ar)) { + const ir = J2(gt); + E.assert(ir); + const nn = ar.initializer.expression; + Qpe(ir, nn, Kr); + } + } else { + E.assert( + ar.kind === 294 + /* JsxSpreadAttribute */ + ), f.size > 0 && (d = O2( + d, + lt(), + gt.symbol, + J, + /*readonly*/ + !1 + ), f = Bs()); + const Kr = td(Hi( + ar.expression, + a & 2 + /* Inferential */ + )); + gn(Kr) && (y = !0), RM(Kr) ? (d = O2( + d, + Kr, + gt.symbol, + J, + /*readonly*/ + !1 + ), l && P8e(Kr, l, ar)) : (ze(ar.expression, p.Spread_types_may_only_be_created_from_object_types), x = x ? sa([x, Kr]) : Kr); + } + } + y || f.size > 0 && (d = O2( + d, + lt(), + gt.symbol, + J, + /*readonly*/ + !1 + )); + } + const We = r.parent; + if ((Sm(We) && We.openingElement === r || cv(We) && We.openingFragment === r) && QC(We.children).length > 0) { + const gt = rX(We, a); + if (!y && z && z !== "") { + I && ze(de, p._0_are_specified_twice_The_attribute_named_0_will_be_overwritten, Si(z)); + const jt = Id(r) ? ub( + r.attributes, + /*contextFlags*/ + void 0 + ) : void 0, ar = jt && lb(jt, z), jr = ga(4, z); + jr.links.type = gt.length === 1 ? gt[0] : ar && wp(ar, hP) ? hg(gt) : Tu(Xn(gt)), jr.valueDeclaration = N.createPropertySignature( + /*modifiers*/ + void 0, + Si(z), + /*questionToken*/ + void 0, + /*type*/ + void 0 + ), za(jr.valueDeclaration, de), jr.valueDeclaration.symbol = jr; + const Kr = Bs(); + Kr.set(z, jr), d = O2( + d, + Ho(ve, Kr, Ge, Ge, Ge), + ve, + J, + /*readonly*/ + !1 + ); + } + } + if (y) + return Le; + if (x && d !== Ec) + return sa([x, d]); + return x || (d === Ec ? lt() : d); + function lt() { + return J |= 8192, _at(J, ve, f); + } + } + function _at(r, a, l) { + const f = Ho(a, l, Ge, Ge, Ge); + return f.objectFlags |= r | 8192 | 128 | 131072, f; + } + function rX(r, a) { + const l = []; + for (const f of r.children) + if (f.kind === 12) + f.containsOnlyTriviaWhiteSpaces || l.push(at); + else { + if (f.kind === 295 && !f.expression) + continue; + l.push(EP(f, a)); + } + return l; + } + function P8e(r, a, l) { + for (const f of $a(r)) + if (!(f.flags & 16777216)) { + const d = a.get(f.escapedName); + if (d) { + const y = ze(d.valueDeclaration, p._0_is_specified_more_than_once_so_this_usage_will_be_overwritten, Si(d.escapedName)); + zs(y, sn(l, p.This_spread_always_overwrites_this_property)); + } + } + } + function fat(r, a) { + return w8e(r.parent, a); + } + function z2(r, a) { + const l = zT(a), f = l && gf(l), d = f && Xl( + f, + r, + 788968 + /* Type */ + ); + return d ? bo(d) : qe; + } + function nX(r) { + const a = xn(r); + if (!a.resolvedSymbol) { + const l = z2(Rf.IntrinsicElements, r); + if (Gr(l)) + return fe && ze(r, p.JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists, Si(Rf.IntrinsicElements)), a.resolvedSymbol = Y; + { + if (!Me(r.tagName) && !Fd(r.tagName)) return E.fail(); + const f = Fd(r.tagName) ? Lx(r.tagName) : r.tagName.escapedText, d = Ys(l, f); + if (d) + return a.jsxFlags |= 1, a.resolvedSymbol = d; + const y = t5e(l, H_(Si(f))); + return y ? (a.jsxFlags |= 2, a.resolvedSymbol = y) : Rn(l, f) ? (a.jsxFlags |= 2, a.resolvedSymbol = l.symbol) : (ze(r, p.Property_0_does_not_exist_on_type_1, qJ(r.tagName), "JSX." + Rf.IntrinsicElements), a.resolvedSymbol = Y); + } + } + return a.resolvedSymbol; + } + function iX(r) { + const a = r && xr(r), l = a && xn(a); + if (l && l.jsxImplicitImportContainer === !1) + return; + if (l && l.jsxImplicitImportContainer) + return l.jsxImplicitImportContainer; + const f = $5(yN(F, a), F); + if (!f) + return; + const y = Pu(F) === 1 ? p.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option : p.This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed, x = $ft(a, f), I = _T(x || r, f, y, r), J = I && I !== Y ? Oa(zc(I)) : void 0; + return l && (l.jsxImplicitImportContainer = J || !1), J; + } + function zT(r) { + const a = r && xn(r); + if (a && a.jsxNamespace) + return a.jsxNamespace; + if (!a || a.jsxNamespace !== !1) { + let f = iX(r); + if (!f || f === Y) { + const d = pd(r); + f = st( + r, + d, + 1920, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + ); + } + if (f) { + const d = zc(Xl( + gf(zc(f)), + Rf.JSX, + 1920 + /* Namespace */ + )); + if (d && d !== Y) + return a && (a.jsxNamespace = d), d; + } + a && (a.jsxNamespace = !1); + } + const l = zc(ME( + Rf.JSX, + 1920, + /*diagnostic*/ + void 0 + )); + if (l !== Y) + return l; + } + function N8e(r, a) { + const l = a && Xl( + a.exports, + r, + 788968 + /* Type */ + ), f = l && bo(l), d = f && $a(f); + if (d) { + if (d.length === 0) + return ""; + if (d.length === 1) + return d[0].escapedName; + d.length > 1 && l.declarations && ze(l.declarations[0], p.The_global_type_JSX_0_may_not_have_more_than_one_property, Si(r)); + } + } + function pat(r) { + return r && Xl( + r.exports, + Rf.LibraryManagedAttributes, + 788968 + /* Type */ + ); + } + function dat(r) { + return r && Xl( + r.exports, + Rf.ElementType, + 788968 + /* Type */ + ); + } + function mat(r) { + return N8e(Rf.ElementAttributesPropertyNameContainer, r); + } + function jM(r) { + return F.jsx === 4 || F.jsx === 5 ? "children" : N8e(Rf.ElementChildrenAttributeNameContainer, r); + } + function A8e(r, a) { + if (r.flags & 4) + return [Hr]; + if (r.flags & 128) { + const d = I8e(r, a); + return d ? [pX(a, d)] : (ze(a, p.Property_0_does_not_exist_on_type_1, r.value, "JSX." + Rf.IntrinsicElements), Ge); + } + const l = e_(r); + let f = Is( + l, + 1 + /* Construct */ + ); + return f.length === 0 && (f = Is( + l, + 0 + /* Call */ + )), f.length === 0 && l.flags & 1048576 && (f = Ife(hr(l.types, (d) => A8e(d, a)))), f; + } + function I8e(r, a) { + const l = z2(Rf.IntrinsicElements, a); + if (!Gr(l)) { + const f = r.value, d = Ys(l, tc(f)); + if (d) + return Yr(d); + const y = eb(l, at); + return y || void 0; + } + return Le; + } + function gat(r, a, l) { + if (r === 1) { + const d = L8e(l); + d && Cp(a, d, yu, l.tagName, p.Its_return_type_0_is_not_a_valid_JSX_element, f); + } else if (r === 0) { + const d = O8e(l); + d && Cp(a, d, yu, l.tagName, p.Its_instance_type_0_is_not_a_valid_JSX_element, f); + } else { + const d = L8e(l), y = O8e(l); + if (!d || !y) + return; + const x = Xn([d, y]); + Cp(a, x, yu, l.tagName, p.Its_element_type_0_is_not_a_valid_JSX_element, f); + } + function f() { + const d = Qo(l.tagName); + return Ts( + /*details*/ + void 0, + p._0_cannot_be_used_as_a_JSX_component, + d + ); + } + } + function F8e(r) { + var a; + E.assert(uC(r.tagName)); + const l = xn(r); + if (!l.resolvedJsxElementAttributesType) { + const f = nX(r); + if (l.jsxFlags & 1) + return l.resolvedJsxElementAttributesType = Yr(f) || qe; + if (l.jsxFlags & 2) { + const d = Fd(r.tagName) ? Lx(r.tagName) : r.tagName.escapedText; + return l.resolvedJsxElementAttributesType = ((a = eC(z2(Rf.IntrinsicElements, r), d)) == null ? void 0 : a.type) || qe; + } else + return l.resolvedJsxElementAttributesType = qe; + } + return l.resolvedJsxElementAttributesType; + } + function O8e(r) { + const a = z2(Rf.ElementClass, r); + if (!Gr(a)) + return a; + } + function BM(r) { + return z2(Rf.Element, r); + } + function L8e(r) { + const a = BM(r); + if (a) + return Xn([a, Mt]); + } + function hat(r) { + const a = zT(r); + if (!a) return; + const l = dat(a); + if (!l) return; + const f = M8e(l, an(r)); + if (!(!f || Gr(f))) + return f; + } + function M8e(r, a, ...l) { + const f = bo(r); + if (r.flags & 524288) { + const d = Pn(r).typeParameters; + if (wr(d) >= l.length) { + const y = ty(l, d, l.length, a); + return wr(y) === 0 ? f : OE(r, y); + } + } + if (wr(f.typeParameters) >= l.length) { + const d = ty(l, f.typeParameters, l.length, a); + return Qh(f, d); + } + } + function yat(r) { + const a = z2(Rf.IntrinsicElements, r); + return a ? $a(a) : Ge; + } + function vat(r) { + (F.jsx || 0) === 0 && ze(r, p.Cannot_use_JSX_unless_the_jsx_flag_is_provided), BM(r) === void 0 && fe && ze(r, p.JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist); + } + function Ode(r) { + const a = wu(r); + a && vft(r), vat(r), vde(r); + const l = qE(r); + if (mX(l, r), a) { + const f = r, d = hat(f); + if (d !== void 0) { + const y = f.tagName, x = uC(y) ? H_(qJ(y)) : Hi(y); + Cp(x, d, yu, y, p.Its_type_0_is_not_a_valid_JSX_element_type, () => { + const I = Qo(y); + return Ts( + /*details*/ + void 0, + p._0_cannot_be_used_as_a_JSX_component, + I + ); + }); + } else + gat(aIe(f), Wa(l), f); + } + } + function sX(r, a, l) { + if (r.flags & 524288 && (N2(r, a) || eC(r, a) || X8(a) && ah(r, at) || l && Fde(a))) + return !0; + if (r.flags & 33554432) + return sX(r.baseType, a, l); + if (r.flags & 3145728 && kI(r)) { + for (const f of r.types) + if (sX(f, a, l)) + return !0; + } + return !1; + } + function kI(r) { + return !!(r.flags & 524288 && !(Dn(r) & 512) || r.flags & 67108864 || r.flags & 33554432 && kI(r.baseType) || r.flags & 1048576 && ot(r.types, kI) || r.flags & 2097152 && Ni(r.types, kI)); + } + function bat(r, a) { + if (Sft(r), r.expression) { + const l = Hi(r.expression, a); + return r.dotDotDotToken && l !== Le && !Ep(l) && ze(r, p.JSX_spread_child_must_be_an_array_type), l; + } else + return qe; + } + function Lde(r) { + return r.valueDeclaration ? U2(r.valueDeclaration) : 0; + } + function Mde(r) { + if (r.flags & 8192 || uc(r) & 4) + return !0; + if (an(r.valueDeclaration)) { + const a = r.valueDeclaration.parent; + return a && _n(a) && Ac(a) === 3; + } + } + function Rde(r, a, l, f, d, y = !0) { + const x = y ? r.kind === 167 ? r.right : r.kind === 206 ? r : r.kind === 209 && r.propertyName ? r.propertyName : r.name : void 0; + return R8e(r, a, l, f, d, x); + } + function R8e(r, a, l, f, d, y) { + var x; + const I = up(d, l); + if (a) { + if (R < 2 && j8e(d)) + return y && ze(y, p.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword), !1; + if (I & 64) + return y && ze(y, p.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression, Wi(d), Wr(sC(d))), !1; + if (!(I & 256) && ((x = d.declarations) != null && x.some(kZ))) + return y && ze(y, p.Class_field_0_defined_by_the_parent_class_is_not_accessible_in_the_child_class_via_super, Wi(d)), !1; + } + if (I & 64 && j8e(d) && (A3(r) || kK(r) || Of(r.parent) && i5(r.parent.parent))) { + const z = Eh(Tl(d)); + if (z && h_t(r)) + return y && ze(y, p.Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor, Wi(d), op(z.name)), !1; + } + if (!(I & 6)) + return !0; + if (I & 2) { + const z = Eh(Tl(d)); + return Wme(r, z) ? !0 : (y && ze(y, p.Property_0_is_private_and_only_accessible_within_class_1, Wi(d), Wr(sC(d))), !1); + } + if (a) + return !0; + let J = K7e(r, (z) => { + const G = bo(yn(z)); + return eAe(G, d, l); + }); + return !J && (J = Sat(r), J = J && eAe(J, d, l), I & 256 || !J) ? (y && ze(y, p.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, Wi(d), Wr(sC(d) || f)), !1) : I & 256 ? !0 : (f.flags & 262144 && (f = f.isThisType ? m_(f) : ou(f)), !f || !En(f, J) ? (y && ze(y, p.Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_This_is_an_instance_of_class_2, Wi(d), Wr(J), Wr(f)), !1) : !0); + } + function Sat(r) { + const a = Tat(r); + let l = a?.type && Ci(a.type); + if (l) + l.flags & 262144 && (l = m_(l)); + else { + const f = qu( + r, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + Es(f) && (l = kde(f)); + } + if (l && Dn(l) & 7) + return Cr(l); + } + function Tat(r) { + const a = qu( + r, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + return a && Es(a) ? Rb(a) : void 0; + } + function j8e(r) { + return !!vM(r, (a) => !(a.flags & 8192)); + } + function UE(r) { + return Jm(Hi(r), r); + } + function JM(r) { + return Yd( + r, + 50331648 + /* IsUndefinedOrNull */ + ); + } + function jde(r) { + return JM(r) ? n0(r) : r; + } + function xat(r, a) { + const l = to(r) ? ef(r) : void 0; + if (r.kind === 106) { + ze(r, p.The_value_0_cannot_be_used_here, "null"); + return; + } + if (l !== void 0 && l.length < 100) { + if (Me(r) && l === "undefined") { + ze(r, p.The_value_0_cannot_be_used_here, "undefined"); + return; + } + ze( + r, + a & 16777216 ? a & 33554432 ? p._0_is_possibly_null_or_undefined : p._0_is_possibly_undefined : p._0_is_possibly_null, + l + ); + } else + ze( + r, + a & 16777216 ? a & 33554432 ? p.Object_is_possibly_null_or_undefined : p.Object_is_possibly_undefined : p.Object_is_possibly_null + ); + } + function kat(r, a) { + ze( + r, + a & 16777216 ? a & 33554432 ? p.Cannot_invoke_an_object_which_is_possibly_null_or_undefined : p.Cannot_invoke_an_object_which_is_possibly_undefined : p.Cannot_invoke_an_object_which_is_possibly_null + ); + } + function B8e(r, a, l) { + if (K && r.flags & 2) { + if (to(a)) { + const d = ef(a); + if (d.length < 100) + return ze(a, p._0_is_of_type_unknown, d), qe; + } + return ze(a, p.Object_is_of_type_unknown), qe; + } + const f = BE( + r, + 50331648 + /* IsUndefinedOrNull */ + ); + if (f & 50331648) { + l(a, f); + const d = n0(r); + return d.flags & 229376 ? qe : d; + } + return r; + } + function Jm(r, a) { + return B8e(r, a, xat); + } + function J8e(r, a) { + const l = Jm(r, a); + if (l.flags & 16384) { + if (to(a)) { + const f = ef(a); + if (Me(a) && f === "undefined") + return ze(a, p.The_value_0_cannot_be_used_here, f), l; + if (f.length < 100) + return ze(a, p._0_is_possibly_undefined, f), l; + } + ze(a, p.Object_is_possibly_undefined); + } + return l; + } + function aX(r, a, l) { + return r.flags & 64 ? Cat(r, a) : Jde(r, r.expression, UE(r.expression), r.name, a, l); + } + function Cat(r, a) { + const l = Hi(r.expression), f = pI(l, r.expression); + return A$(Jde(r, r.expression, Jm(f, r.expression), r.name, a), r, f !== l); + } + function z8e(r, a) { + const l = o5(r) && Ry(r.left) ? Jm(OM(r.left), r.left) : UE(r.left); + return Jde(r, r.left, l, r.right, a); + } + function Bde(r) { + for (; r.parent.kind === 218; ) + r = r.parent; + return sm(r.parent) && r.parent.expression === r; + } + function zM(r, a) { + for (let l = r5(a); l; l = Wl(l)) { + const { symbol: f } = l, d = Z3(f, r), y = f.members && f.members.get(d) || f.exports && f.exports.get(d); + if (y) + return y; + } + } + function Eat(r) { + if (!Wl(r)) + return mr(r, p.Private_identifiers_are_not_allowed_outside_class_bodies); + if (!PF(r.parent)) { + if (!Xm(r)) + return mr(r, p.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression); + const a = _n(r.parent) && r.parent.operatorToken.kind === 103; + if (!oX(r) && !a) + return mr(r, p.Cannot_find_name_0, An(r)); + } + return !1; + } + function Dat(r) { + Eat(r); + const a = oX(r); + return a && UM( + a, + /*nodeForCheckWriteOnly*/ + void 0, + /*isSelfTypeAccess*/ + !1 + ), Le; + } + function oX(r) { + if (!Xm(r)) + return; + const a = xn(r); + return a.resolvedSymbol === void 0 && (a.resolvedSymbol = zM(r.escapedText, r)), a.resolvedSymbol; + } + function cX(r, a) { + return Ys(r, a.escapedName); + } + function wat(r, a, l) { + let f; + const d = $a(r); + d && lr(d, (x) => { + const I = x.valueDeclaration; + if (I && wl(I) && Ai(I.name) && I.name.escapedText === a.escapedText) + return f = x, !0; + }); + const y = U_(a); + if (f) { + const x = E.checkDefined(f.valueDeclaration), I = E.checkDefined(Wl(x)); + if (l?.valueDeclaration) { + const J = l.valueDeclaration, z = Wl(J); + if (E.assert(!!z), dr(z, (G) => I === G)) { + const G = ze( + a, + p.The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_private_identifier_with_the_same_spelling, + y, + Wr(r) + ); + return zs( + G, + sn( + J, + p.The_shadowing_declaration_of_0_is_defined_here, + y + ), + sn( + x, + p.The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here, + y + ) + ), !0; + } + } + return ze( + a, + p.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier, + y, + U_(I.name || DW) + ), !0; + } + return !1; + } + function W8e(r, a) { + return (nh(a) || A3(r) && pg(a)) && qu( + r, + /*includeArrowFunctions*/ + !0, + /*includeClassComputedPropertyName*/ + !1 + ) === tn(a); + } + function Jde(r, a, l, f, d, y) { + const x = xn(a).resolvedSymbol, I = Oy(r), J = e_(I !== 0 || Bde(r) ? Sf(l) : l), z = gn(J) || J === kt; + let G; + if (Ai(f)) { + (R < El.PrivateNamesAndClassStaticBlocks || R < El.ClassAndClassElementDecorators || !$) && (I !== 0 && xl( + r, + 1048576 + /* ClassPrivateFieldSet */ + ), I !== 1 && xl( + r, + 524288 + /* ClassPrivateFieldGet */ + )); + const de = zM(f.escapedText, f); + if (I && de && de.valueDeclaration && rc(de.valueDeclaration) && mr(f, p.Cannot_assign_to_private_method_0_Private_methods_are_not_writable, An(f)), z) { + if (de) + return Gr(J) ? qe : J; + if (r5(f) === void 0) + return mr(f, p.Private_identifiers_are_not_allowed_outside_class_bodies), Le; + } + if (G = de && cX(l, de), G === void 0) { + if (wat(l, f, de)) + return qe; + const We = r5(f); + We && AD(xr(We), F.checkJs) && mr(f, p.Private_field_0_must_be_declared_in_an_enclosing_class, An(f)); + } else + G.flags & 65536 && !(G.flags & 32768) && I !== 1 && ze(r, p.Private_accessor_was_defined_without_a_getter); + } else { + if (z) + return Me(a) && x && cC( + r, + 2, + /*propSymbol*/ + void 0, + l + ), Gr(J) ? qe : J; + G = Ys( + J, + f.escapedText, + /*skipObjectFunctionPropertyAugment*/ + vX(J), + /*includeTypeOnlyMembers*/ + r.kind === 167 + /* QualifiedName */ + ); + } + cC(r, 2, G, l); + let ve; + if (G) { + const de = jme(G, f); + if (Zu(de) && mpe(r, de) && de.declarations && Zp(f, de.declarations, f.escapedText), Pat(G, r, f), UM(G, r, Q8e(a, x)), xn(r).resolvedSymbol = G, Rde(r, a.kind === 108, Ex(r), J, G), jIe(r, G, I)) + return ze(f, p.Cannot_assign_to_0_because_it_is_a_read_only_property, An(f)), qe; + ve = W8e(r, G) ? mt : y || R5(r) ? Z0(G) : Yr(G); + } else { + const de = !Ai(f) && (I === 0 || !NT(l) || b4(l)) ? eC(J, f.escapedText) : void 0; + if (!(de && de.type)) { + const We = zde( + r, + l.symbol, + /*excludeClasses*/ + !0 + ); + return !We && iI(l) ? Le : l.symbol === Se ? (Se.exports.has(f.escapedText) && Se.exports.get(f.escapedText).flags & 418 ? ze(f, p.Property_0_does_not_exist_on_type_1, Si(f.escapedText), Wr(l)) : fe && ze(f, p.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature, Wr(l)), Le) : (f.escapedText && !u1(r) && V8e(f, b4(l) ? J : l, We), qe); + } + de.isReadonly && (Ly(r) || OB(r)) && ze(r, p.Index_signature_in_type_0_only_permits_reading, Wr(J)), ve = de.type, F.noUncheckedIndexedAccess && Oy(r) !== 1 && (ve = Xn([ve, ye])), F.noPropertyAccessFromIndexSignature && wn(r) && ze(f, p.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0, Si(f.escapedText)), de.declaration && Wd(de.declaration) && Zp(f, [de.declaration], f.escapedText); + } + return U8e(r, G, ve, f, d); + } + function zde(r, a, l) { + var f; + const d = xr(r); + if (d && F.checkJs === void 0 && d.checkJsDirective === void 0 && (d.scriptKind === 1 || d.scriptKind === 2)) { + const y = lr(a?.declarations, xr), x = !a?.valueDeclaration || !$n(a.valueDeclaration) || ((f = a.valueDeclaration.heritageClauses) == null ? void 0 : f.length) || g0( + /*useLegacyDecorators*/ + !1, + a.valueDeclaration + ); + return !(d !== y && y && m0(y)) && !(l && a && a.flags & 32 && x) && !(r && l && wn(r) && r.expression.kind === 110 && x); + } + return !1; + } + function U8e(r, a, l, f, d) { + const y = Oy(r); + if (y === 1) + return i0(l, !!(a && a.flags & 16777216)); + if (a && !(a.flags & 98311) && !(a.flags & 8192 && l.flags & 1048576) && !MX(a.declarations)) + return l; + if (l === mt) + return oe(r, a); + l = yde(l, r, d); + let x = !1; + if (K && se && To(r) && r.expression.kind === 110) { + const J = a && a.valueDeclaration; + if (J && J7e(J) && !Js(J)) { + const z = TP(r); + z.kind === 177 && z.parent === J.parent && !(J.flags & 33554432) && (x = !0); + } + } else K && a && a.valueDeclaration && wn(a.valueDeclaration) && z3(a.valueDeclaration) && TP(r) === TP(a.valueDeclaration) && (x = !0); + const I = s0(r, l, x ? P1(l) : l); + return x && !jE(l) && jE(I) ? (ze(f, p.Property_0_is_used_before_being_assigned, Wi(a)), l) : y ? r0(I) : I; + } + function Pat(r, a, l) { + const { valueDeclaration: f } = r; + if (!f || xr(a).isDeclarationFile) + return; + let d; + const y = An(l); + Wde(a) && !stt(f) && !(To(a) && To(a.expression)) && !qh(f, l) && !(rc(f) && HX(f) & 256) && ($ || !Nat(r)) ? d = ze(l, p.Property_0_is_used_before_its_initialization, y) : f.kind === 264 && a.parent.kind !== 184 && !(f.flags & 33554432) && !qh(f, l) && (d = ze(l, p.Class_0_used_before_its_declaration, y)), d && zs(d, sn(f, p._0_is_declared_here, y)); + } + function Wde(r, a) { + return !!dr(r, (l) => { + switch (l.kind) { + case 173: + case 176: + return !0; + case 187: + case 288: + return "quit"; + case 220: + return a ? !1 : "quit"; + case 242: + return io(l.parent) && l.parent.kind !== 220 ? "quit" : !1; + default: + return !1; + } + }); + } + function Nat(r) { + if (!(r.parent.flags & 32)) + return !1; + let a = Yr(r.parent); + for (; ; ) { + if (a = a.symbol && Aat(a), !a) + return !1; + const l = Ys(a, r.escapedName); + if (l && l.valueDeclaration) + return !0; + } + } + function Aat(r) { + const a = bd(r); + if (a.length !== 0) + return sa(a); + } + function V8e(r, a, l) { + const f = xn(r), d = f.nonExistentPropCheckCache || (f.nonExistentPropCheckCache = /* @__PURE__ */ new Set()), y = `${jl(a)}|${l}`; + if (d.has(y)) + return; + d.add(y); + let x, I; + if (!Ai(r) && a.flags & 1048576 && !(a.flags & 402784252)) { + for (const z of a.types) + if (!Ys(z, r.escapedText) && !eC(z, r.escapedText)) { + x = Ts(x, p.Property_0_does_not_exist_on_type_1, co(r), Wr(z)); + break; + } + } + if (q8e(r.escapedText, a)) { + const z = co(r), G = Wr(a); + x = Ts(x, p.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead, z, G, G + "." + z); + } else { + const z = LI(a); + if (z && Ys(z, r.escapedText)) + x = Ts(x, p.Property_0_does_not_exist_on_type_1, co(r), Wr(a)), I = sn(r, p.Did_you_forget_to_use_await); + else { + const G = co(r), ve = Wr(a), de = Oat(G, a); + if (de !== void 0) + x = Ts(x, p.Property_0_does_not_exist_on_type_1_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2_or_later, G, ve, de); + else { + const We = Ude(r, a); + if (We !== void 0) { + const lt = cc(We), gt = l ? p.Property_0_may_not_exist_on_type_1_Did_you_mean_2 : p.Property_0_does_not_exist_on_type_1_Did_you_mean_2; + x = Ts(x, gt, G, ve, lt), I = We.valueDeclaration && sn(We.valueDeclaration, p._0_is_declared_here, lt); + } else { + const lt = Iat(a) ? p.Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom : p.Property_0_does_not_exist_on_type_1; + x = Ts(zfe(x, a), lt, G, ve); + } + } + } + } + const J = Fg(xr(r), r, x); + I && zs(J, I), Qg(!l || x.code !== p.Property_0_may_not_exist_on_type_1_Did_you_mean_2.code, J); + } + function Iat(r) { + return F.lib && !F.lib.includes("lib.dom.d.ts") && Mit(r, (a) => a.symbol && /^(?:EventTarget|Node|(?:HTML[a-zA-Z]*)?Element)$/.test(Si(a.symbol.escapedName))) && t0(r); + } + function q8e(r, a) { + const l = a.symbol && Ys(Yr(a.symbol), r); + return l !== void 0 && !!l.valueDeclaration && Js(l.valueDeclaration); + } + function Fat(r) { + const a = U_(r), f = oB().get(a); + return f && IR(f.keys()); + } + function Oat(r, a) { + const l = e_(a).symbol; + if (!l) + return; + const f = cc(l), y = oB().get(f); + if (y) { + for (const [x, I] of y) + if (ms(I, r)) + return x; + } + } + function H8e(r, a) { + return WM( + r, + $a(a), + 106500 + /* ClassMember */ + ); + } + function Ude(r, a) { + let l = $a(a); + if (typeof r != "string") { + const f = r.parent; + wn(f) && (l = kn(l, (d) => Y8e(f, a, d))), r = An(r); + } + return WM( + r, + l, + 111551 + /* Value */ + ); + } + function G8e(r, a) { + const l = gs(r) ? r : An(r), f = $a(a); + return (l === "for" ? Nn(f, (y) => cc(y) === "htmlFor") : l === "class" ? Nn(f, (y) => cc(y) === "className") : void 0) ?? WM( + l, + f, + 111551 + /* Value */ + ); + } + function $8e(r, a) { + const l = Ude(r, a); + return l && cc(l); + } + function Lat(r, a, l) { + const f = Xl(r, a, l); + if (f) return f; + let d; + return r === Ye ? d = Fi( + ["string", "number", "boolean", "object", "bigint", "symbol"], + (x) => r.has(x.charAt(0).toUpperCase() + x.slice(1)) ? ga(524288, x) : void 0 + ).concat(is(r.values())) : d = is(r.values()), WM(Si(a), d, l); + } + function X8e(r, a, l) { + return E.assert(a !== void 0, "outername should always be defined"), Wt( + r, + a, + l, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1, + /*excludeGlobals*/ + !1 + ); + } + function Vde(r, a) { + return a.exports && WM( + An(r), + Wk(a), + 2623475 + /* ModuleMember */ + ); + } + function Mat(r, a, l) { + function f(x) { + const I = N2(r, x); + if (I) { + const J = UT(Yr(I)); + return !!J && em(J) >= 1 && Ms(l, Kd(J, 0)); + } + return !1; + } + const d = Ly(a) ? "set" : "get"; + if (!f(d)) + return; + let y = cN(a.expression); + return y === void 0 ? y = d : y += "." + d, y; + } + function Rat(r, a) { + const l = a.types.filter((f) => !!(f.flags & 128)); + return Sb(r.value, l, (f) => f.value); + } + function WM(r, a, l) { + return Sb(r, a, f); + function f(d) { + const y = cc(d); + if (!Ui(y, '"')) { + if (d.flags & l) + return y; + if (d.flags & 2097152) { + const x = jk(d); + if (x && x.flags & l) + return y; + } + } + } + } + function UM(r, a, l) { + const f = r && r.flags & 106500 && r.valueDeclaration; + if (!f) + return; + const d = sf( + f, + 2 + /* Private */ + ), y = r.valueDeclaration && wl(r.valueDeclaration) && Ai(r.valueDeclaration.name); + if (!(!d && !y) && !(a && R5(a) && !(r.flags & 65536))) { + if (l) { + const x = dr(a, io); + if (x && x.symbol === r) + return; + } + (uc(r) & 1 ? Pn(r).target : r).isReferenced = -1; + } + } + function Q8e(r, a) { + return r.kind === 110 || !!a && to(r) && a === ju(i_(r)); + } + function jat(r, a) { + switch (r.kind) { + case 212: + return qde(r, r.expression.kind === 108, a, Sf(Hi(r.expression))); + case 167: + return qde( + r, + /*isSuper*/ + !1, + a, + Sf(Hi(r.left)) + ); + case 206: + return qde( + r, + /*isSuper*/ + !1, + a, + Ci(r) + ); + } + } + function Y8e(r, a, l) { + return Hde( + r, + r.kind === 212 && r.expression.kind === 108, + /*isWrite*/ + !1, + a, + l + ); + } + function qde(r, a, l, f) { + if (gn(f)) + return !0; + const d = Ys(f, l); + return !!d && Hde( + r, + a, + /*isWrite*/ + !1, + f, + d + ); + } + function Hde(r, a, l, f, d) { + if (gn(f)) + return !0; + if (d.valueDeclaration && Du(d.valueDeclaration)) { + const y = Wl(d.valueDeclaration); + return !Eu(r) && !!dr(r, (x) => x === y); + } + return R8e(r, a, l, f, d); + } + function Bat(r) { + const a = r.initializer; + if (a.kind === 262) { + const l = a.declarations[0]; + if (l && !ws(l.name)) + return yn(l); + } else if (a.kind === 80) + return ju(a); + } + function Jat(r) { + return Su(r).length === 1 && !!ah(r, wt); + } + function zat(r) { + const a = Ba(r); + if (a.kind === 80) { + const l = ju(a); + if (l.flags & 3) { + let f = r, d = r.parent; + for (; d; ) { + if (d.kind === 250 && f === d.statement && Bat(d) === l && Jat(lu(d.expression))) + return !0; + f = d, d = d.parent; + } + } + } + return !1; + } + function Wat(r, a) { + return r.flags & 64 ? Uat(r, a) : Z8e(r, UE(r.expression), a); + } + function Uat(r, a) { + const l = Hi(r.expression), f = pI(l, r.expression); + return A$(Z8e(r, Jm(f, r.expression), a), r, f !== l); + } + function Z8e(r, a, l) { + const f = Oy(r) !== 0 || Bde(r) ? Sf(a) : a, d = r.argumentExpression, y = Hi(d); + if (Gr(f) || f === kt) + return f; + if (vX(f) && !ja(d)) + return ze(d, p.A_const_enum_member_can_only_be_accessed_using_a_string_literal), qe; + const x = zat(d) ? wt : y, I = Oy(r); + let J; + I === 0 ? J = 32 : (J = 4 | (NT(f) && !b4(f) ? 2 : 0), I === 2 && (J |= 32)); + const z = C1(f, x, J, r) || qe; + return o7e(U8e(r, xn(r).resolvedSymbol, z, d, l), r); + } + function K8e(r) { + return sm(r) || nv(r) || wu(r); + } + function WT(r) { + return K8e(r) && lr(r.typeArguments, la), r.kind === 216 ? Hi(r.template) : wu(r) ? Hi(r.attributes) : _n(r) ? Hi(r.left) : sm(r) && lr(r.arguments, (a) => { + Hi(a); + }), Hr; + } + function Zd(r) { + return WT(r), Vn; + } + function Vat(r, a, l) { + let f, d, y = 0, x, I = -1, J; + E.assert(!a.length); + for (const z of r) { + const G = z.declaration && yn(z.declaration), ve = z.declaration && z.declaration.parent; + !d || G === d ? f && ve === f ? x = x + 1 : (f = ve, x = y) : (x = y = a.length, f = ve), d = G, G1e(z) ? (I++, J = I, y++) : J = x, a.splice(J, 0, l ? Det(z, l) : z); + } + } + function lX(r) { + return !!r && (r.kind === 231 || r.kind === 238 && r.isSpread); + } + function Gde(r) { + return oc(r, lX); + } + function eIe(r) { + return !!(r.flags & 16384); + } + function qat(r) { + return !!(r.flags & 49155); + } + function uX(r, a, l, f = !1) { + if (ud(r)) return !0; + let d, y = !1, x = $_(l), I = em(l); + if (r.kind === 216) + if (d = a.length, r.template.kind === 229) { + const J = pa(r.template.templateSpans); + y = lc(J.literal) || !!J.literal.isUnterminated; + } else { + const J = r.template; + E.assert( + J.kind === 15 + /* NoSubstitutionTemplateLiteral */ + ), y = !!J.isUnterminated; + } + else if (r.kind === 171) + d = cIe(r, l); + else if (r.kind === 227) + d = 1; + else if (wu(r)) { + if (y = r.attributes.end === r.end, y) + return !0; + d = I === 0 ? a.length : 1, x = a.length === 0 ? x : 1, I = Math.min(I, 1); + } else if (r.arguments) { + d = f ? a.length + 1 : a.length, y = r.arguments.end === r.end; + const J = Gde(a); + if (J >= 0) + return J >= em(l) && (vg(l) || J < $_(l)); + } else + return E.assert( + r.kind === 215 + /* NewExpression */ + ), em(l) === 0; + if (!vg(l) && d > x) + return !1; + if (y || d >= I) + return !0; + for (let J = d; J < I; J++) { + const z = Kd(l, J); + if (Xc(z, an(r) && !K ? qat : eIe).flags & 131072) + return !1; + } + return !0; + } + function $de(r, a) { + const l = wr(r.typeParameters), f = gg(r.typeParameters); + return !ot(a) || a.length >= f && a.length <= l; + } + function tIe(r, a) { + let l; + return !!(r.target && (l = W2(r.target, a)) && nb(l)); + } + function UT(r) { + return CI( + r, + 0, + /*allowMembers*/ + !1 + ); + } + function rIe(r) { + return CI( + r, + 0, + /*allowMembers*/ + !1 + ) || CI( + r, + 1, + /*allowMembers*/ + !1 + ); + } + function CI(r, a, l) { + if (r.flags & 524288) { + const f = $d(r); + if (l || f.properties.length === 0 && f.indexInfos.length === 0) { + if (a === 0 && f.callSignatures.length === 1 && f.constructSignatures.length === 0) + return f.callSignatures[0]; + if (a === 1 && f.constructSignatures.length === 1 && f.callSignatures.length === 0) + return f.constructSignatures[0]; + } + } + } + function nIe(r, a, l, f) { + const d = gI(D3e(r), r, 0, f), y = wI(a), x = l && (y && y.flags & 262144 ? l.nonFixingMapper : l.mapper), I = x ? FT(a, x) : a; + return Gpe(I, r, (J, z) => { + uh(d.inferences, J, z); + }), l || $pe(a, r, (J, z) => { + uh( + d.inferences, + J, + z, + 128 + /* ReturnType */ + ); + }), tI(r, ade(d), an(a.declaration)); + } + function Hat(r, a, l, f) { + const d = K$(a, r), y = HE(r.attributes, d, f, l); + return uh(f.inferences, y, d), ade(f); + } + function iIe(r) { + if (!r) + return _r; + const a = Hi(r); + return aee(r) ? a : SD(r.parent) ? n0(a) : Eu(r.parent) ? N$(a) : a; + } + function Xde(r, a, l, f, d) { + if (wu(r)) + return Hat(r, a, f, d); + if (r.kind !== 171 && r.kind !== 227) { + const J = Ni(a.typeParameters, (G) => !!A2(G)), z = g_( + r, + J ? 8 : 0 + /* None */ + ); + if (z) { + const G = Wa(a); + if (N1(G)) { + const ve = J2(r); + if (!(!J && g_( + r, + 8 + /* SkipBindingPatterns */ + ) !== z)) { + const gt = Zpe(dAe( + ve, + 1 + /* NoDefault */ + )), jt = Mi(z, gt), ar = UT(jt), jr = ar && ar.typeParameters ? ET(Gfe(ar, ar.typeParameters)) : jt; + uh( + d.inferences, + jr, + G, + 128 + /* ReturnType */ + ); + } + const We = gI(a.typeParameters, a, d.flags), lt = Mi(z, ve && qrt(ve)); + uh(We.inferences, lt, G), d.returnMapper = ot(We.inferences, GE) ? Zpe(tit(We)) : void 0; + } + } + } + const y = PI(a), x = y ? Math.min($_(a) - 1, l.length) : l.length; + if (y && y.flags & 262144) { + const J = Nn(d.inferences, (z) => z.typeParameter === y); + J && (J.impliedArity = oc(l, lX, x) < 0 ? l.length - x : void 0); + } + const I = tb(a); + if (I && N1(I)) { + const J = oIe(r); + uh(d.inferences, iIe(J), I); + } + for (let J = 0; J < x; J++) { + const z = l[J]; + if (z.kind !== 233) { + const G = Kd(a, J); + if (N1(G)) { + const ve = HE(z, G, d, f); + uh(d.inferences, ve, G); + } + } + } + if (y && N1(y)) { + const J = Qde(l, x, l.length, y, d, f); + uh(d.inferences, J, y); + } + return ade(d); + } + function sIe(r) { + return r.flags & 1048576 ? Go(r, sIe) : r.flags & 1 || SM(ou(r) || r) ? r : Sa(r) ? hg( + F2(r), + r.target.elementFlags, + /*readonly*/ + !1, + r.target.labeledElementDeclarations + ) : hg([r], [ + 8 + /* Variadic */ + ]); + } + function Qde(r, a, l, f, d, y) { + const x = CT(f); + if (a >= l - 1) { + const G = r[l - 1]; + if (lX(G)) { + const ve = G.kind === 238 ? G.type : HE(G.expression, f, d, y); + return iy(ve) ? sIe(ve) : Tu(ay(33, ve, ue, G.kind === 231 ? G.expression : G), x); + } + } + const I = [], J = [], z = []; + for (let G = a; G < l; G++) { + const ve = r[G]; + if (lX(ve)) { + const de = ve.kind === 238 ? ve.type : Hi(ve.expression); + iy(de) ? (I.push(de), J.push( + 8 + /* Variadic */ + )) : (I.push(ay(33, de, ue, ve.kind === 231 ? ve.expression : ve)), J.push( + 4 + /* Rest */ + )); + } else { + const de = Sa(f) ? Ade(f, G - a, l - a) || yt : vf( + f, + Xd(G - a), + 256 + /* Contextual */ + ), We = HE(ve, de, d, y), lt = x || Dc( + de, + 406978556 + /* StringMapping */ + ); + I.push(lt ? t_(We) : ob(We)), J.push( + 1 + /* Required */ + ); + } + ve.kind === 238 && ve.tupleNameSource ? z.push(ve.tupleNameSource) : z.push(void 0); + } + return hg(I, J, x && !wp(f, zpe), z); + } + function Yde(r, a, l, f) { + const d = an(r.declaration), y = r.typeParameters, x = ty(hr(a, Ci), y, gg(y), d); + let I; + for (let J = 0; J < a.length; J++) { + E.assert(y[J] !== void 0, "Should not call checkTypeArguments with too many type arguments"); + const z = m_(y[J]); + if (z) { + const G = l && f ? () => Ts( + /*details*/ + void 0, + p.Type_0_does_not_satisfy_the_constraint_1 + ) : void 0, ve = f || p.Type_0_does_not_satisfy_the_constraint_1; + I || (I = bf(y, x)); + const de = x[J]; + if (!xu( + de, + yf(Mi(z, I), de), + l ? a[J] : void 0, + ve, + G + )) + return; + } + } + return x; + } + function aIe(r) { + if (uC(r.tagName)) + return 2; + const a = e_(Hi(r.tagName)); + return wr(Is( + a, + 1 + /* Construct */ + )) ? 0 : wr(Is( + a, + 0 + /* Call */ + )) ? 1 : 2; + } + function Gat(r, a, l, f, d, y, x) { + const I = K$(a, r), J = ud(r) ? w8e(r) : HE( + r.attributes, + I, + /*inferenceContext*/ + void 0, + f + ), z = f & 4 ? mI(J) : J; + return G() && Ape( + z, + I, + l, + d ? ud(r) ? r : r.tagName : void 0, + ud(r) ? void 0 : r.attributes, + /*headMessage*/ + void 0, + y, + x + ); + function G() { + var ve; + if (iX(r)) + return !0; + const de = (Id(r) || NS(r)) && !(uC(r.tagName) || Fd(r.tagName)) ? Hi(r.tagName) : void 0; + if (!de) + return !0; + const We = Is( + de, + 0 + /* Call */ + ); + if (!wr(We)) + return !0; + const lt = Gme(r); + if (!lt) + return !0; + const gt = dc( + lt, + 111551, + /*ignoreErrors*/ + !0, + /*dontResolveAlias*/ + !1, + r + ); + if (!gt) + return !0; + const jt = Yr(gt), ar = Is( + jt, + 0 + /* Call */ + ); + if (!wr(ar)) + return !0; + let jr = !1, Kr = 0; + for (const ir of ar) { + const nn = Kd(ir, 0), Qn = Is( + nn, + 0 + /* Call */ + ); + if (wr(Qn)) + for (const Ri of Qn) { + if (jr = !0, vg(Ri)) + return !0; + const zn = $_(Ri); + zn > Kr && (Kr = zn); + } + } + if (!jr) + return !0; + let or = 1 / 0; + for (const ir of We) { + const nn = em(ir); + nn < or && (or = nn); + } + if (or <= Kr) + return !0; + if (d) { + const ir = r.tagName, nn = sn(ir, p.Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3, ef(ir), or, ef(lt), Kr), Qn = (ve = Pp(ir)) == null ? void 0 : ve.valueDeclaration; + Qn && zs(nn, sn(Qn, p._0_is_declared_here, ef(ir))), x && x.skipLogging && (x.errors || (x.errors = [])).push(nn), x.skipLogging || Aa.add(nn); + } + return !1; + } + } + function _X(r) { + const a = an(r) ? -2147483615 : 33; + return hc(r, a); + } + function VM(r, a, l, f, d, y, x) { + const I = { errors: void 0, skipLogging: !0 }; + if (jZ(r)) + return Gat(r, l, f, d, y, x, I) ? void 0 : (E.assert(!y || !!I.errors, "jsx should have errors when reporting errors"), I.errors || Ge); + const J = tb(l); + if (J && J !== _r && !(Xb(r) || Ps(r) && j_(r.expression))) { + const We = oIe(r), lt = iIe(We), gt = y ? We || r : void 0, jt = p.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1; + if (!Cp(lt, J, f, gt, jt, x, I)) + return E.assert(!y || !!I.errors, "this parameter should have errors when reporting errors"), I.errors || Ge; + } + const z = p.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1, G = PI(l), ve = G ? Math.min($_(l) - 1, a.length) : a.length; + for (let We = 0; We < ve; We++) { + const lt = a[We]; + if (lt.kind !== 233) { + const gt = Kd(l, We), jt = HE( + lt, + gt, + /*inferenceContext*/ + void 0, + d + ), ar = d & 4 ? mI(jt) : jt, jr = _X(lt); + if (!Ape(ar, gt, f, y ? jr : void 0, jr, z, x, I)) + return E.assert(!y || !!I.errors, "parameter should have errors when reporting errors"), de(lt, ar, gt), I.errors || Ge; + } + } + if (G) { + const We = Qde( + a, + ve, + a.length, + G, + /*context*/ + void 0, + d + ), lt = a.length - ve, gt = y ? lt === 0 ? r : lt === 1 ? _X(a[ve]) : Ad(EI(r, We), a[ve].pos, a[a.length - 1].end) : void 0; + if (!Cp( + We, + G, + f, + gt, + z, + /*containingMessageChain*/ + void 0, + I + )) + return E.assert(!y || !!I.errors, "rest parameter should have errors when reporting errors"), de(gt, We, G), I.errors || Ge; + } + return; + function de(We, lt, gt) { + if (We && y && I.errors && I.errors.length) { + if (DP(gt)) + return; + const jt = DP(lt); + jt && Bm(jt, gt, f) && zs(I.errors[0], sn(We, p.Did_you_forget_to_use_await)); + } + } + } + function oIe(r) { + if (r.kind === 227) + return r.right; + const a = r.kind === 214 ? r.expression : r.kind === 216 ? r.tag : r.kind === 171 && !U ? r.expression : void 0; + if (a) { + const l = hc(a); + if (To(l)) + return l.expression; + } + } + function EI(r, a, l, f) { + const d = fv.createSyntheticExpression(a, l, f); + return ct(d, r), za(d, r), d; + } + function fX(r) { + if (ud(r)) + return [EI(r, zf)]; + if (r.kind === 216) { + const f = r.template, d = [EI(f, Ttt())]; + return f.kind === 229 && lr(f.templateSpans, (y) => { + d.push(y.expression); + }), d; + } + if (r.kind === 171) + return $at(r); + if (r.kind === 227) + return [r.left]; + if (wu(r)) + return r.attributes.properties.length > 0 || Id(r) && r.parent.children.length > 0 ? [r.attributes] : Ge; + const a = r.arguments || Ge, l = Gde(a); + if (l >= 0) { + const f = a.slice(0, l); + for (let d = l; d < a.length; d++) { + const y = a[d], x = y.kind === 231 && (Ir ? Hi(y.expression) : mc(y.expression)); + x && Sa(x) ? lr(F2(x), (I, J) => { + var z; + const G = x.target.elementFlags[J], ve = EI(y, G & 4 ? Tu(I) : I, !!(G & 12), (z = x.target.labeledElementDeclarations) == null ? void 0 : z[J]); + f.push(ve); + }) : f.push(y); + } + return f; + } + return a; + } + function $at(r) { + const a = r.expression, l = ume(r); + if (l) { + const f = []; + for (const d of l.parameters) { + const y = Yr(d); + f.push(EI(a, y)); + } + return f; + } + return E.fail(); + } + function cIe(r, a) { + return F.experimentalDecorators ? Xat(r, a) : ( + // Allow the runtime to oversupply arguments to an ES decorator as long as there's at least one parameter. + Math.min(Math.max($_(a), 1), 2) + ); + } + function Xat(r, a) { + switch (r.parent.kind) { + case 264: + case 232: + return 1; + case 173: + return fm(r.parent) ? 3 : 2; + case 175: + case 178: + case 179: + return a.parameters.length <= 2 ? 2 : 3; + case 170: + return 3; + default: + return E.fail(); + } + } + function lIe(r) { + const a = xr(r), { start: l, length: f } = aS(a, wn(r.expression) ? r.expression.name : r.expression); + return { start: l, length: f, sourceFile: a }; + } + function DI(r, a, ...l) { + if (Ps(r)) { + const { sourceFile: f, start: d, length: y } = lIe(r); + return "message" in a ? ll(f, d, y, a, ...l) : yB(f, a); + } else + return "message" in a ? sn(r, a, ...l) : Fg(xr(r), r, a); + } + function Qat(r) { + return sm(r) ? wn(r.expression) ? r.expression.name : r.expression : nv(r) ? wn(r.tag) ? r.tag.name : r.tag : wu(r) ? r.tagName : r; + } + function Yat(r) { + if (!Ps(r) || !Me(r.expression)) return !1; + const a = st( + r.expression, + r.expression.escapedText, + 111551, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + ), l = a?.valueDeclaration; + if (!l || !Ii(l) || !zy(l.parent) || !Xb(l.parent.parent) || !Me(l.parent.parent.expression)) + return !1; + const f = rpe( + /*reportErrors*/ + !1 + ); + return f ? Pp( + l.parent.parent.expression, + /*ignoreErrors*/ + !0 + ) === f : !1; + } + function uIe(r, a, l, f) { + var d; + const y = Gde(l); + if (y > -1) + return sn(l[y], p.A_spread_argument_must_either_have_a_tuple_type_or_be_passed_to_a_rest_parameter); + let x = Number.POSITIVE_INFINITY, I = Number.NEGATIVE_INFINITY, J = Number.NEGATIVE_INFINITY, z = Number.POSITIVE_INFINITY, G; + for (const gt of a) { + const jt = em(gt), ar = $_(gt); + jt < x && (x = jt, G = gt), I = Math.max(I, ar), jt < l.length && jt > J && (J = jt), l.length < ar && ar < z && (z = ar); + } + const ve = ot(a, vg), de = ve ? x : x < I ? x + "-" + I : x, We = !ve && de === 1 && l.length === 0 && Yat(r); + if (We && an(r)) + return DI(r, p.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments); + const lt = ul(r) ? ve ? p.The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_at_least_0 : p.The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_0 : ve ? p.Expected_at_least_0_arguments_but_got_1 : We ? p.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise : p.Expected_0_arguments_but_got_1; + if (x < l.length && l.length < I) { + if (f) { + let gt = Ts( + /*details*/ + void 0, + p.No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments, + l.length, + J, + z + ); + return gt = Ts(gt, f), DI(r, gt); + } + return DI(r, p.No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments, l.length, J, z); + } else if (l.length < x) { + let gt; + if (f) { + let ar = Ts( + /*details*/ + void 0, + lt, + de, + l.length + ); + ar = Ts(ar, f), gt = DI(r, ar); + } else + gt = DI(r, lt, de, l.length); + const jt = (d = G?.declaration) == null ? void 0 : d.parameters[G.thisParameter ? l.length + 1 : l.length]; + if (jt) { + const ar = ws(jt.name) ? [p.An_argument_matching_this_binding_pattern_was_not_provided] : Hm(jt) ? [p.Arguments_for_the_rest_parameter_0_were_not_provided, An(i_(jt.name))] : [p.An_argument_for_0_was_not_provided, jt.name ? An(i_(jt.name)) : l.length], jr = sn(jt, ...ar); + return zs(gt, jr); + } + return gt; + } else { + const gt = N.createNodeArray(l.slice(I)), jt = Ca(gt).pos; + let ar = pa(gt).end; + if (ar === jt && ar++, Ad(gt, jt, ar), f) { + let jr = Ts( + /*details*/ + void 0, + lt, + de, + l.length + ); + return jr = Ts(jr, f), k3(xr(r), gt, jr); + } + return jC(xr(r), gt, lt, de, l.length); + } + } + function Zat(r, a, l, f) { + const d = l.length; + if (a.length === 1) { + const I = a[0], J = gg(I.typeParameters), z = wr(I.typeParameters); + if (f) { + let G = Ts( + /*details*/ + void 0, + p.Expected_0_type_arguments_but_got_1, + J < z ? J + "-" + z : J, + d + ); + return G = Ts(G, f), k3(xr(r), l, G); + } + return jC(xr(r), l, p.Expected_0_type_arguments_but_got_1, J < z ? J + "-" + z : J, d); + } + let y = -1 / 0, x = 1 / 0; + for (const I of a) { + const J = gg(I.typeParameters), z = wr(I.typeParameters); + J > d ? x = Math.min(x, J) : z < d && (y = Math.max(y, z)); + } + if (y !== -1 / 0 && x !== 1 / 0) { + if (f) { + let I = Ts( + /*details*/ + void 0, + p.No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments, + d, + y, + x + ); + return I = Ts(I, f), k3(xr(r), l, I); + } + return jC(xr(r), l, p.No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments, d, y, x); + } + if (f) { + let I = Ts( + /*details*/ + void 0, + p.Expected_0_type_arguments_but_got_1, + y === -1 / 0 ? x : y, + d + ); + return I = Ts(I, f), k3(xr(r), l, I); + } + return jC(xr(r), l, p.Expected_0_type_arguments_but_got_1, y === -1 / 0 ? x : y, d); + } + function VE(r, a, l, f, d, y) { + const x = r.kind === 216, I = r.kind === 171, J = wu(r), z = ud(r), G = r.kind === 227, ve = !P && !l; + let de, We, lt, gt, jt = 0, ar = [], jr; + if (!I && !G && !oS(r) && !z && (jr = r.typeArguments, (x || J || r.expression.kind !== 108) && lr(jr, la)), ar = l || [], Vat(a, ar, d), !z && !ar.length) + return ve && Aa.add(DI(r, p.Call_target_does_not_contain_any_signatures)), Zd(r); + const Kr = fX(r), or = ar.length === 1 && !ar[0].typeParameters; + !I && !or && ot(Kr, Qf) && (jt = 4); + const ir = !!(f & 16) && r.kind === 214 && r.arguments.hasTrailingComma; + ar.length > 1 && (gt = Ri(ar, cg, or, ir)), gt || (gt = Ri(ar, yu, or, ir)); + const nn = xn(r); + if (nn.resolvedSignature !== ln && !l) + return E.assert(nn.resolvedSignature), nn.resolvedSignature; + if (gt) + return gt; + if (gt = Kat(r, ar, Kr, !!l, f), nn.resolvedSignature = gt, ve) { + if (!y && G && (y = p.The_left_hand_side_of_an_instanceof_expression_must_be_assignable_to_the_first_argument_of_the_right_hand_side_s_Symbol_hasInstance_method), de) + if (de.length === 1 || de.length > 3) { + const zn = de[de.length - 1]; + let bi; + de.length > 3 && (bi = Ts(bi, p.The_last_overload_gave_the_following_error), bi = Ts(bi, p.No_overload_matches_this_call)), y && (bi = Ts(bi, y)); + const ks = VM( + r, + Kr, + zn, + yu, + 0, + /*reportErrors*/ + !0, + () => bi + ); + if (ks) + for (const Ua of ks) + zn.declaration && de.length > 3 && zs(Ua, sn(zn.declaration, p.The_last_overload_is_declared_here)), Qn(zn, Ua), Aa.add(Ua); + else + E.fail("No error for last overload signature"); + } else { + const zn = []; + let bi = 0, ks = Number.MAX_VALUE, Ua = 0, Vi = 0; + for (const Br of de) { + const en = VM( + r, + Kr, + Br, + yu, + 0, + /*reportErrors*/ + !0, + () => Ts( + /*details*/ + void 0, + p.Overload_0_of_1_2_gave_the_following_error, + Vi + 1, + ar.length, + b1(Br) + ) + ); + en ? (en.length <= ks && (ks = en.length, Ua = Vi), bi = Math.max(bi, en.length), zn.push(en)) : E.fail("No error for 3 or fewer overload signatures"), Vi++; + } + const jo = bi > 1 ? zn[Ua] : Ip(zn); + E.assert(jo.length > 0, "No errors reported for 3 or fewer overload signatures"); + let Sc = Ts( + hr(jo, cK), + p.No_overload_matches_this_call + ); + y && (Sc = Ts(Sc, y)); + const Bu = [...ka(jo, (Br) => Br.relatedInformation)]; + let Dr; + if (Ni(jo, (Br) => Br.start === jo[0].start && Br.length === jo[0].length && Br.file === jo[0].file)) { + const { file: Br, start: xi, length: en } = jo[0]; + Dr = { file: Br, start: xi, length: en, code: Sc.code, category: Sc.category, messageText: Sc, relatedInformation: Bu }; + } else + Dr = Fg(xr(r), Qat(r), Sc, Bu); + Qn(de[0], Dr), Aa.add(Dr); + } + else if (We) + Aa.add(uIe(r, [We], Kr, y)); + else if (lt) + Yde( + lt, + r.typeArguments, + /*reportErrors*/ + !0, + y + ); + else if (!z) { + const zn = kn(a, (bi) => $de(bi, jr)); + zn.length === 0 ? Aa.add(Zat(r, a, jr, y)) : Aa.add(uIe(r, zn, Kr, y)); + } + } + return gt; + function Qn(zn, bi) { + var ks, Ua; + const Vi = de, jo = We, Sc = lt, Bu = ((Ua = (ks = zn.declaration) == null ? void 0 : ks.symbol) == null ? void 0 : Ua.declarations) || Ge, Br = Bu.length > 1 ? Nn(Bu, (xi) => io(xi) && Mp(xi.body)) : void 0; + if (Br) { + const xi = Xf(Br), en = !xi.typeParameters; + Ri([xi], yu, en) && zs(bi, sn(Br, p.The_call_would_have_succeeded_against_this_implementation_but_implementation_signatures_of_overloads_are_not_externally_visible)); + } + de = Vi, We = jo, lt = Sc; + } + function Ri(zn, bi, ks, Ua = !1) { + if (de = void 0, We = void 0, lt = void 0, ks) { + const Vi = zn[0]; + if (ot(jr) || !uX(r, Kr, Vi, Ua)) + return; + if (VM( + r, + Kr, + Vi, + bi, + 0, + /*reportErrors*/ + !1, + /*containingMessageChain*/ + void 0 + )) { + de = [Vi]; + return; + } + return Vi; + } + for (let Vi = 0; Vi < zn.length; Vi++) { + const jo = zn[Vi]; + if (!$de(jo, jr) || !uX(r, Kr, jo, Ua)) + continue; + let Sc, Bu; + if (jo.typeParameters) { + let Dr; + if (ot(jr)) { + if (Dr = Yde( + jo, + jr, + /*reportErrors*/ + !1 + ), !Dr) { + lt = jo; + continue; + } + } else + Bu = gI( + jo.typeParameters, + jo, + /*flags*/ + an(r) ? 2 : 0 + /* None */ + ), Dr = Xde(r, jo, Kr, jt | 8, Bu), jt |= Bu.flags & 4 ? 8 : 0; + if (Sc = tI(jo, Dr, an(jo.declaration), Bu && Bu.inferredTypeParameters), PI(jo) && !uX(r, Kr, Sc, Ua)) { + We = Sc; + continue; + } + } else + Sc = jo; + if (VM( + r, + Kr, + Sc, + bi, + jt, + /*reportErrors*/ + !1, + /*containingMessageChain*/ + void 0 + )) { + (de || (de = [])).push(Sc); + continue; + } + if (jt) { + if (jt = 0, Bu) { + const Dr = Xde(r, jo, Kr, jt, Bu); + if (Sc = tI(jo, Dr, an(jo.declaration), Bu.inferredTypeParameters), PI(jo) && !uX(r, Kr, Sc, Ua)) { + We = Sc; + continue; + } + } + if (VM( + r, + Kr, + Sc, + bi, + jt, + /*reportErrors*/ + !1, + /*containingMessageChain*/ + void 0 + )) { + (de || (de = [])).push(Sc); + continue; + } + } + return zn[Vi] = Sc, Sc; + } + } + } + function Kat(r, a, l, f, d) { + return E.assert(a.length > 0), fC(r), f || a.length === 1 || a.some((y) => !!y.typeParameters) ? rot(r, a, l, d) : eot(a); + } + function eot(r) { + const a = Fi(r, (J) => J.thisParameter); + let l; + a.length && (l = _Ie(a, a.map(GM))); + const { min: f, max: d } = Wee(r, tot), y = []; + for (let J = 0; J < d; J++) { + const z = Fi(r, (G) => Iu(G) ? J < G.parameters.length - 1 ? G.parameters[J] : pa(G.parameters) : J < G.parameters.length ? G.parameters[J] : void 0); + E.assert(z.length !== 0), y.push(_Ie(z, Fi(r, (G) => W2(G, J)))); + } + const x = Fi(r, (J) => Iu(J) ? pa(J.parameters) : void 0); + let I = 128; + if (x.length !== 0) { + const J = Tu(Xn( + Fi(r, E3e), + 2 + /* Subtype */ + )); + y.push(fIe(x, J)), I |= 1; + } + return r.some(G1e) && (I |= 2), Mm( + r[0].declaration, + /*typeParameters*/ + void 0, + // Before calling this we tested for `!candidates.some(c => !!c.typeParameters)`. + l, + y, + /*resolvedReturnType*/ + sa(r.map(Wa)), + /*resolvedTypePredicate*/ + void 0, + f, + I + ); + } + function tot(r) { + const a = r.parameters.length; + return Iu(r) ? a - 1 : a; + } + function _Ie(r, a) { + return fIe(r, Xn( + a, + 2 + /* Subtype */ + )); + } + function fIe(r, a) { + return LT(Ca(r), a); + } + function rot(r, a, l, f) { + const d = sot(a, Ve === void 0 ? l.length : Ve), y = a[d], { typeParameters: x } = y; + if (!x) + return y; + const I = K8e(r) ? r.typeArguments : void 0, J = I ? KG(y, not(I, x, an(r))) : iot(r, x, y, l, f); + return a[d] = J, J; + } + function not(r, a, l) { + const f = r.map(pC); + for (; f.length > a.length; ) + f.pop(); + for (; f.length < a.length; ) + f.push(A2(a[f.length]) || m_(a[f.length]) || sde(l)); + return f; + } + function iot(r, a, l, f, d) { + const y = gI( + a, + l, + /*flags*/ + an(r) ? 2 : 0 + /* None */ + ), x = Xde(r, l, f, d | 4 | 8, y); + return KG(l, x); + } + function sot(r, a) { + let l = -1, f = -1; + for (let d = 0; d < r.length; d++) { + const y = r[d], x = $_(y); + if (vg(y) || x >= a) + return d; + x > f && (f = x, l = d); + } + return l; + } + function aot(r, a, l) { + if (r.expression.kind === 108) { + const J = $$(r.expression); + if (gn(J)) { + for (const z of r.arguments) + Hi(z); + return Hr; + } + if (!Gr(J)) { + const z = wd(Wl(r)); + if (z) { + const G = ih(J, z.typeArguments, z); + return VE( + r, + G, + a, + l, + 0 + /* None */ + ); + } + } + return WT(r); + } + let f, d = Hi(r.expression); + if (K2(r)) { + const J = pI(d, r.expression); + f = J === d ? 0 : TD(r) ? 16 : 8, d = J; + } else + f = 0; + if (d = B8e( + d, + r.expression, + kat + ), d === kt) + return kr; + const y = e_(d); + if (Gr(y)) + return Zd(r); + const x = Is( + y, + 0 + /* Call */ + ), I = Is( + y, + 1 + /* Construct */ + ).length; + if (qM(d, y, x.length, I)) + return !Gr(d) && r.typeArguments && ze(r, p.Untyped_function_calls_may_not_accept_type_arguments), WT(r); + if (!x.length) { + if (I) + ze(r, p.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, Wr(d)); + else { + let J; + if (r.arguments.length === 1) { + const z = xr(r).text; + Cu(z.charCodeAt(oa( + z, + r.expression.end, + /*stopAfterLineBreak*/ + !0 + ) - 1)) && (J = sn(r.expression, p.Are_you_missing_a_semicolon)); + } + Kde(r.expression, y, 0, J); + } + return Zd(r); + } + return l & 8 && !r.typeArguments && x.some(oot) ? (QIe(r, l), ln) : x.some((J) => an(J.declaration) && !!Fj(J.declaration)) ? (ze(r, p.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, Wr(d)), Zd(r)) : VE(r, x, a, l, f); + } + function oot(r) { + return !!(r.typeParameters && qme(Wa(r))); + } + function qM(r, a, l, f) { + return gn(r) || gn(a) && !!(r.flags & 262144) || !l && !f && !(a.flags & 1048576) && !(td(a).flags & 131072) && Ms(r, Mr); + } + function cot(r, a, l) { + let f = UE(r.expression); + if (f === kt) + return kr; + if (f = e_(f), Gr(f)) + return Zd(r); + if (gn(f)) + return r.typeArguments && ze(r, p.Untyped_function_calls_may_not_accept_type_arguments), WT(r); + const d = Is( + f, + 1 + /* Construct */ + ); + if (d.length) { + if (!lot(r, d[0])) + return Zd(r); + if (pIe(d, (I) => !!(I.flags & 4))) + return ze(r, p.Cannot_create_an_instance_of_an_abstract_class), Zd(r); + const x = f.symbol && Eh(f.symbol); + return x && Gn( + x, + 64 + /* Abstract */ + ) ? (ze(r, p.Cannot_create_an_instance_of_an_abstract_class), Zd(r)) : VE( + r, + d, + a, + l, + 0 + /* None */ + ); + } + const y = Is( + f, + 0 + /* Call */ + ); + if (y.length) { + const x = VE( + r, + y, + a, + l, + 0 + /* None */ + ); + return fe || (x.declaration && !zm(x.declaration) && Wa(x) !== _r && ze(r, p.Only_a_void_function_can_be_called_with_the_new_keyword), tb(x) === _r && ze(r, p.A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void)), x; + } + return Kde( + r.expression, + f, + 1 + /* Construct */ + ), Zd(r); + } + function pIe(r, a) { + return as(r) ? ot(r, (l) => pIe(l, a)) : r.compositeKind === 1048576 ? ot(r.compositeSignatures, a) : a(r); + } + function Zde(r, a) { + const l = bd(a); + if (!wr(l)) + return !1; + const f = l[0]; + if (f.flags & 2097152) { + const d = f.types, y = a3e(d); + let x = 0; + for (const I of f.types) { + if (!y[x] && Dn(I) & 3 && (I.symbol === r || Zde(r, I))) + return !0; + x++; + } + return !1; + } + return f.symbol === r ? !0 : Zde(r, f); + } + function lot(r, a) { + if (!a || !a.declaration) + return !0; + const l = a.declaration, f = xx( + l, + 6 + /* NonPublicAccessibilityModifier */ + ); + if (!f || l.kind !== 177) + return !0; + const d = Eh(l.parent.symbol), y = bo(l.parent.symbol); + if (!Wme(r, d)) { + const x = Wl(r); + if (x && f & 4) { + const I = pC(x); + if (Zde(l.parent.symbol, I)) + return !0; + } + return f & 2 && ze(r, p.Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration, Wr(y)), f & 4 && ze(r, p.Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration, Wr(y)), !1; + } + return !0; + } + function dIe(r, a, l) { + let f; + const d = l === 0, y = _C(a), x = y && Is(y, l).length > 0; + if (a.flags & 1048576) { + const J = a.types; + let z = !1; + for (const G of J) + if (Is(G, l).length !== 0) { + if (z = !0, f) + break; + } else if (f || (f = Ts( + f, + d ? p.Type_0_has_no_call_signatures : p.Type_0_has_no_construct_signatures, + Wr(G) + ), f = Ts( + f, + d ? p.Not_all_constituents_of_type_0_are_callable : p.Not_all_constituents_of_type_0_are_constructable, + Wr(a) + )), z) + break; + z || (f = Ts( + /*details*/ + void 0, + d ? p.No_constituent_of_type_0_is_callable : p.No_constituent_of_type_0_is_constructable, + Wr(a) + )), f || (f = Ts( + f, + d ? p.Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_other : p.Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_with_each_other, + Wr(a) + )); + } else + f = Ts( + f, + d ? p.Type_0_has_no_call_signatures : p.Type_0_has_no_construct_signatures, + Wr(a) + ); + let I = d ? p.This_expression_is_not_callable : p.This_expression_is_not_constructable; + if (Ps(r.parent) && r.parent.arguments.length === 0) { + const { resolvedSymbol: J } = xn(r); + J && J.flags & 32768 && (I = p.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without); + } + return { + messageChain: Ts(f, I), + relatedMessage: x ? p.Did_you_forget_to_use_await : void 0 + }; + } + function Kde(r, a, l, f) { + const { messageChain: d, relatedMessage: y } = dIe(r, a, l), x = Fg(xr(r), r, d); + if (y && zs(x, sn(r, y)), Ps(r.parent)) { + const { start: I, length: J } = lIe(r.parent); + x.start = I, x.length = J; + } + Aa.add(x), mIe(a, l, f ? zs(x, f) : x); + } + function mIe(r, a, l) { + if (!r.symbol) + return; + const f = Pn(r.symbol).originatingImport; + if (f && !T_(f)) { + const d = Is(Yr(Pn(r.symbol).target), a); + if (!d || !d.length) return; + zs(l, sn(f, p.Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead)); + } + } + function uot(r, a, l) { + const f = Hi(r.tag), d = e_(f); + if (Gr(d)) + return Zd(r); + const y = Is( + d, + 0 + /* Call */ + ), x = Is( + d, + 1 + /* Construct */ + ).length; + if (qM(f, d, y.length, x)) + return WT(r); + if (!y.length) { + if (nu(r.parent)) { + const I = sn(r.tag, p.It_is_likely_that_you_are_missing_a_comma_to_separate_these_two_template_expressions_They_form_a_tagged_template_expression_which_cannot_be_invoked); + return Aa.add(I), Zd(r); + } + return Kde( + r.tag, + d, + 0 + /* Call */ + ), Zd(r); + } + return VE( + r, + y, + a, + l, + 0 + /* None */ + ); + } + function _ot(r) { + switch (r.parent.kind) { + case 264: + case 232: + return p.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression; + case 170: + return p.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression; + case 173: + return p.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression; + case 175: + case 178: + case 179: + return p.Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression; + default: + return E.fail(); + } + } + function fot(r, a, l) { + const f = Hi(r.expression), d = e_(f); + if (Gr(d)) + return Zd(r); + const y = Is( + d, + 0 + /* Call */ + ), x = Is( + d, + 1 + /* Construct */ + ).length; + if (qM(f, d, y.length, x)) + return WT(r); + if (mot(r, y) && !o_(r.expression)) { + const J = Qo( + r.expression, + /*includeTrivia*/ + !1 + ); + return ze(r, p._0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0, J), Zd(r); + } + const I = _ot(r); + if (!y.length) { + const J = dIe( + r.expression, + d, + 0 + /* Call */ + ), z = Ts(J.messageChain, I), G = Fg(xr(r.expression), r.expression, z); + return J.relatedMessage && zs(G, sn(r.expression, J.relatedMessage)), Aa.add(G), mIe(d, 0, G), Zd(r); + } + return VE(r, y, a, l, 0, I); + } + function pX(r, a) { + const l = zT(r), f = l && gf(l), d = f && Xl( + f, + Rf.Element, + 788968 + /* Type */ + ), y = d && pe.symbolToEntityName(d, 788968, r), x = N.createFunctionTypeNode( + /*typeParameters*/ + void 0, + [N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "props", + /*questionToken*/ + void 0, + pe.typeToTypeNode(a, r) + )], + y ? N.createTypeReferenceNode( + y, + /*typeArguments*/ + void 0 + ) : N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ) + ), I = ga(1, "props"); + return I.links.type = a, Mm( + x, + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + [I], + d ? bo(d) : qe, + /*resolvedTypePredicate*/ + void 0, + 1, + 0 + /* None */ + ); + } + function gIe(r) { + const a = xn(xr(r)); + if (a.jsxFragmentType !== void 0) return a.jsxFragmentType; + const l = pd(r); + if (!((F.jsx === 2 || F.jsxFragmentFactory !== void 0) && l !== "null")) return a.jsxFragmentType = Le; + const d = F.jsx !== 1 && F.jsx !== 3, y = Aa ? p.Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found : void 0, x = iX(r) ?? st( + r, + l, + d ? 111551 : 111167, + /*nameNotFoundMessage*/ + y, + /*isUse*/ + !0 + ); + if (x === void 0) return a.jsxFragmentType = qe; + if (x.escapedName === FW.Fragment) return a.jsxFragmentType = Yr(x); + const I = (x.flags & 2097152) === 0 ? x : Rl(x), J = x && gf(I), z = J && Xl( + J, + FW.Fragment, + 2 + /* BlockScopedVariable */ + ), G = z && Yr(z); + return a.jsxFragmentType = G === void 0 ? qe : G; + } + function pot(r, a, l) { + const f = ud(r); + let d; + if (f) + d = gIe(r); + else { + if (uC(r.tagName)) { + const I = F8e(r), J = pX(r, I); + return j2(HE( + r.attributes, + K$(J, r), + /*inferenceContext*/ + void 0, + 0 + /* Normal */ + ), I, r.tagName, r.attributes), wr(r.typeArguments) && (lr(r.typeArguments, la), Aa.add(jC(xr(r), r.typeArguments, p.Expected_0_type_arguments_but_got_1, 0, wr(r.typeArguments)))), J; + } + d = Hi(r.tagName); + } + const y = e_(d); + if (Gr(y)) + return Zd(r); + const x = A8e(d, r); + return qM( + d, + y, + x.length, + /*constructSignatures*/ + 0 + ) ? WT(r) : x.length === 0 ? (f ? ze(r, p.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, Qo(r)) : ze(r.tagName, p.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, Qo(r.tagName)), Zd(r)) : VE( + r, + x, + a, + l, + 0 + /* None */ + ); + } + function dot(r, a, l) { + const f = Hi(r.right); + if (!gn(f)) { + const d = mme(f); + if (d) { + const y = e_(d); + if (Gr(y)) + return Zd(r); + const x = Is( + y, + 0 + /* Call */ + ), I = Is( + y, + 1 + /* Construct */ + ); + if (qM(d, y, x.length, I.length)) + return WT(r); + if (x.length) + return VE( + r, + x, + a, + l, + 0 + /* None */ + ); + } else if (!(BX(f) || R2(f, Mr))) + return ze(r.right, p.The_right_hand_side_of_an_instanceof_expression_must_be_either_of_type_any_a_class_function_or_other_type_assignable_to_the_Function_interface_type_or_an_object_type_with_a_Symbol_hasInstance_method), Zd(r); + } + return Hr; + } + function mot(r, a) { + return a.length && Ni(a, (l) => l.minArgumentCount === 0 && !Iu(l) && l.parameters.length < cIe(r, l)); + } + function got(r, a, l) { + switch (r.kind) { + case 214: + return aot(r, a, l); + case 215: + return cot(r, a, l); + case 216: + return uot(r, a, l); + case 171: + return fot(r, a, l); + case 290: + case 287: + case 286: + return pot(r, a, l); + case 227: + return dot(r, a, l); + } + E.assertNever(r, "Branch in 'resolveSignature' should be unreachable."); + } + function qE(r, a, l) { + const f = xn(r), d = f.resolvedSignature; + if (d && d !== ln && !a) + return d; + const y = R0; + d || (R0 = Xg.length), f.resolvedSignature = ln; + const x = got( + r, + a, + l || 0 + /* Normal */ + ); + return R0 = y, x !== ln && (f.resolvedSignature = dn === Ir ? x : d), x; + } + function zm(r) { + var a; + if (!r || !an(r)) + return !1; + const l = Cc(r) || yo(r) ? r : (ei(r) || rl(r)) && r.initializer && yo(r.initializer) ? r.initializer : void 0; + if (l) { + if (Fj(r)) return !0; + if (rl(ad(l.parent))) return !1; + const f = yn(l); + return !!((a = f?.members) != null && a.size); + } + return !1; + } + function eme(r, a) { + var l, f; + if (a) { + const d = Pn(a); + if (!d.inferredClassSymbol || !d.inferredClassSymbol.has(Xs(r))) { + const y = Ng(r) ? r : v2(r); + return y.exports = y.exports || Bs(), y.members = y.members || Bs(), y.flags |= a.flags & 32, (l = a.exports) != null && l.size && Im(y.exports, a.exports), (f = a.members) != null && f.size && Im(y.members, a.members), (d.inferredClassSymbol || (d.inferredClassSymbol = /* @__PURE__ */ new Map())).set(Xs(y), y), y; + } + return d.inferredClassSymbol.get(Xs(r)); + } + } + function hot(r) { + var a; + const l = r && dX( + r, + /*allowDeclaration*/ + !0 + ), f = (a = l?.exports) == null ? void 0 : a.get("prototype"), d = f?.valueDeclaration && yot(f.valueDeclaration); + return d ? yn(d) : void 0; + } + function dX(r, a) { + if (!r.parent) + return; + let l, f; + if (ei(r.parent) && r.parent.initializer === r) { + if (!an(r) && !(UI(r.parent) && io(r))) + return; + l = r.parent.name, f = r.parent; + } else if (_n(r.parent)) { + const d = r.parent, y = r.parent.operatorToken.kind; + if (y === 64 && (a || d.right === r)) + l = d.left, f = l; + else if ((y === 57 || y === 61) && (ei(d.parent) && d.parent.initializer === d ? (l = d.parent.name, f = d.parent) : _n(d.parent) && d.parent.operatorToken.kind === 64 && (a || d.parent.right === d) && (l = d.parent.left, f = l), !l || !_S(l) || !VC(l, d.left))) + return; + } else a && Cc(r) && (l = r.name, f = r); + if (!(!f || !l || !a && !G1(r, jy(l)))) + return Hf(f); + } + function yot(r) { + if (!r.parent) + return !1; + let a = r.parent; + for (; a && a.kind === 212; ) + a = a.parent; + if (a && _n(a) && jy(a.left) && a.operatorToken.kind === 64) { + const l = PB(a); + return _a(l) && l; + } + } + function vot(r, a) { + var l, f, d; + dR(r, r.typeArguments); + const y = qE( + r, + /*candidatesOutArray*/ + void 0, + a + ); + if (y === ln) + return kt; + if (mX(y, r), r.expression.kind === 108) + return _r; + if (r.kind === 215) { + const I = y.declaration; + if (I && I.kind !== 177 && I.kind !== 181 && I.kind !== 186 && !(w0(I) && ((f = (l = GC(I)) == null ? void 0 : l.parent) == null ? void 0 : f.kind) === 177) && !vx(I) && !zm(I)) + return fe && ze(r, p.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type), Le; + } + if (an(r) && bIe(r)) + return k3e(r.arguments[0]); + const x = Wa(y); + if (x.flags & 12288 && hIe(r)) + return xpe(ad(r.parent)); + if (r.kind === 214 && !r.questionDotToken && r.parent.kind === 245 && x.flags & 16384 && kp(y)) { + if (!aN(r.expression)) + ze(r.expression, p.Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name); + else if (!NM(r)) { + const I = ze(r.expression, p.Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation); + PM(r.expression, I); + } + } + if (an(r)) { + const I = dX( + r, + /*allowDeclaration*/ + !1 + ); + if ((d = I?.exports) != null && d.size) { + const J = Ho(I, I.exports, Ge, Ge, Ge); + return J.objectFlags |= 4096, sa([x, J]); + } + } + return x; + } + function mX(r, a) { + if (!(r.flags & 128) && r.declaration && r.declaration.flags & 536870912) { + const l = HM(a), f = cN(s5(a)); + Rv(l, r.declaration, f, b1(r)); + } + } + function HM(r) { + switch (r = Ba(r), r.kind) { + case 214: + case 171: + case 215: + return HM(r.expression); + case 216: + return HM(r.tag); + case 287: + case 286: + return HM(r.tagName); + case 213: + return r.argumentExpression; + case 212: + return r.name; + case 184: + const a = r; + return s_(a.typeName) ? a.typeName.right : a; + default: + return r; + } + } + function hIe(r) { + if (!Ps(r)) return !1; + let a = r.expression; + if (wn(a) && a.name.escapedText === "for" && (a = a.expression), !Me(a) || a.escapedText !== "Symbol") + return !1; + const l = q3e( + /*reportErrors*/ + !1 + ); + return l ? l === st( + a, + "Symbol", + 111551, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + ) : !1; + } + function bot(r) { + if (Wft(r), r.arguments.length === 0) + return YM(r, Le); + const a = r.arguments[0], l = mc(a), f = r.arguments.length > 1 ? mc(r.arguments[1]) : void 0; + for (let y = 2; y < r.arguments.length; ++y) + mc(r.arguments[y]); + if ((l.flags & 32768 || l.flags & 65536 || !Ms(l, at)) && ze(a, p.Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0, Wr(l)), f) { + const y = V3e( + /*reportErrors*/ + !0 + ); + y !== ta && xu(f, xM( + y, + 32768 + /* Undefined */ + ), r.arguments[1]); + } + const d = Mu(r, a); + if (d) { + const y = th( + d, + a, + /*dontResolveAlias*/ + !0, + /*suppressInteropError*/ + !1 + ); + if (y) + return YM( + r, + yIe(Yr(y), y, d, a) || vIe(Yr(y), y, d, a) + ); + } + return YM(r, Le); + } + function tme(r, a, l) { + const f = Bs(), d = ga( + 2097152, + "default" + /* Default */ + ); + return d.parent = a, d.links.nameType = H_("default"), d.links.aliasTarget = zc(r), f.set("default", d), Ho(l, f, Ge, Ge, Ge); + } + function yIe(r, a, l, f) { + if (d1(f) && r && !Gr(r)) { + const y = r; + if (!y.defaultOnlyType) { + const x = tme(a, l); + y.defaultOnlyType = x; + } + return y.defaultOnlyType; + } + } + function vIe(r, a, l, f) { + var d; + if (_e && r && !Gr(r)) { + const y = r; + if (!y.syntheticType) { + const x = (d = l.declarations) == null ? void 0 : d.find(Di); + if (Wv( + x, + l, + /*dontResolveAlias*/ + !1, + f + )) { + const J = ga( + 2048, + "__type" + /* Type */ + ), z = tme(a, l, J); + J.links.type = z, y.syntheticType = RM(r) ? O2( + r, + z, + J, + /*objectFlags*/ + 0, + /*readonly*/ + !1 + ) : z; + } else + y.syntheticType = r; + } + return y.syntheticType; + } + return r; + } + function bIe(r) { + if (!x_( + r, + /*requireStringLiteralLikeArgument*/ + !0 + )) + return !1; + if (!Me(r.expression)) return E.fail(); + const a = st( + r.expression, + r.expression.escapedText, + 111551, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !0 + ); + if (a === Ne) + return !0; + if (a.flags & 2097152) + return !1; + const l = a.flags & 16 ? 263 : a.flags & 3 ? 261 : 0; + if (l !== 0) { + const f = Oo(a, l); + return !!f && !!(f.flags & 33554432); + } + return !1; + } + function Sot(r) { + mft(r) || dR(r, r.typeArguments), R < El.TaggedTemplates && xl( + r, + 262144 + /* MakeTemplateObject */ + ); + const a = qE(r); + return mX(a, r), Wa(a); + } + function Tot(r, a) { + if (r.kind === 217) { + const l = xr(r); + if (l && xc(l.fileName, [ + ".cts", + ".mts" + /* Mts */ + ]) && mr(r, p.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead), F.erasableSyntaxOnly) { + const f = oa(l.text, r.pos), d = r.expression.pos; + Aa.add(ll(l, f, d - f, p.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled)); + } + } + return SIe(r, a); + } + function rme(r) { + switch (r.kind) { + case 11: + case 15: + case 9: + case 10: + case 112: + case 97: + case 210: + case 211: + case 229: + return !0; + case 218: + return rme(r.expression); + case 225: + const a = r.operator, l = r.operand; + return a === 41 && (l.kind === 9 || l.kind === 10) || a === 40 && l.kind === 9; + case 212: + case 213: + const f = Ba(r.expression), d = to(f) ? dc( + f, + 111551, + /*ignoreErrors*/ + !0 + ) : void 0; + return !!(d && d.flags & 384); + } + return !1; + } + function SIe(r, a) { + const { type: l, expression: f } = TIe(r), d = Hi(f, a); + if (nd(l)) + return rme(f) || ze(f, p.A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals), t_(d); + const y = xn(r); + return y.assertionExpressionType = d, la(l), fC(r), Ci(l); + } + function TIe(r) { + let a, l; + switch (r.kind) { + case 235: + case 217: + a = r.type, l = r.expression; + break; + case 218: + a = x6(r), l = r.expression; + break; + } + return { type: a, expression: l }; + } + function xot(r) { + const { type: a } = TIe(r), l = o_(r) ? a : r, f = xn(r); + E.assertIsDefined(f.assertionExpressionType); + const d = mI(r0(f.assertionExpressionType)), y = Ci(a); + Gr(y) || n(() => { + const x = Sf(d); + v$(y, x) || GNe(d, y, l, p.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first); + }); + } + function kot(r) { + const a = Hi(r.expression), l = pI(a, r.expression); + return A$(n0(l), r, l !== a); + } + function Cot(r) { + return r.flags & 64 ? kot(r) : n0(Hi(r.expression)); + } + function xIe(r) { + if (m5e(r), lr(r.typeArguments, la), r.kind === 234) { + const l = ad(r.parent); + l.kind === 227 && l.operatorToken.kind === 104 && Ob(r, l.right) && ze(r, p.The_right_hand_side_of_an_instanceof_expression_must_not_be_an_instantiation_expression); + } + const a = r.kind === 234 ? Hi(r.expression) : Ry(r.exprName) ? OM(r.exprName) : Hi(r.exprName); + return kIe(a, r); + } + function kIe(r, a) { + const l = a.typeArguments; + if (r === kt || Gr(r) || !ot(l)) + return r; + const f = xn(a); + if (f.instantiationExpressionTypes || (f.instantiationExpressionTypes = /* @__PURE__ */ new Map()), f.instantiationExpressionTypes.has(r.id)) + return f.instantiationExpressionTypes.get(r.id); + let d = !1, y; + const x = J(r); + f.instantiationExpressionTypes.set(r.id, x); + const I = d ? y : r; + return I && Aa.add(jC(xr(a), l, p.Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable, Wr(I))), x; + function J(G) { + let ve = !1, de = !1; + const We = lt(G); + return d || (d = de), ve && !de && (y ?? (y = G)), We; + function lt(gt) { + if (gt.flags & 524288) { + const jt = $d(gt), ar = z(jt.callSignatures), jr = z(jt.constructSignatures); + if (ve || (ve = jt.callSignatures.length !== 0 || jt.constructSignatures.length !== 0), de || (de = ar.length !== 0 || jr.length !== 0), ar !== jt.callSignatures || jr !== jt.constructSignatures) { + const Kr = Ho(ga( + 0, + "__instantiationExpression" + /* InstantiationExpression */ + ), jt.members, ar, jr, jt.indexInfos); + return Kr.objectFlags |= 8388608, Kr.node = a, Kr; + } + } else if (gt.flags & 58982400) { + const jt = ou(gt); + if (jt) { + const ar = lt(jt); + if (ar !== jt) + return ar; + } + } else { + if (gt.flags & 1048576) + return Go(gt, J); + if (gt.flags & 2097152) + return sa(Qc(gt.types, lt)); + } + return gt; + } + } + function z(G) { + const ve = kn(G, (de) => !!de.typeParameters && $de(de, l)); + return Qc(ve, (de) => { + const We = Yde( + de, + l, + /*reportErrors*/ + !0 + ); + return We ? tI(de, We, an(de.declaration)) : de; + }); + } + } + function Eot(r) { + return la(r.type), nme(r.expression, r.type); + } + function nme(r, a, l) { + const f = Hi(r, l), d = Ci(a); + if (Gr(d)) + return d; + const y = dr( + a.parent, + (x) => x.kind === 239 || x.kind === 351 + /* JSDocSatisfiesTag */ + ); + return j2(f, d, y, r, p.Type_0_does_not_satisfy_the_expected_type_1), f; + } + function Dot(r) { + return Aft(r), r.keywordToken === 105 ? ime(r) : r.keywordToken === 102 ? r.name.escapedText === "defer" ? (E.assert(!Ps(r.parent) || r.parent.expression !== r, "Trying to get the type of `import.defer` in `import.defer(...)`"), qe) : wot(r) : E.assertNever(r.keywordToken); + } + function CIe(r) { + switch (r.keywordToken) { + case 102: + return U3e(); + case 105: + const a = ime(r); + return Gr(a) ? qe : qot(a); + default: + E.assertNever(r.keywordToken); + } + } + function ime(r) { + const a = xK(r); + if (a) + if (a.kind === 177) { + const l = yn(a.parent); + return Yr(l); + } else { + const l = yn(a); + return Yr(l); + } + else return ze(r, p.Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor, "new.target"), qe; + } + function wot(r) { + 100 <= B && B <= 199 ? xr(r).impliedNodeFormat !== 99 && ze(r, p.The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output) : B < 6 && B !== 4 && ze(r, p.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_node18_node20_or_nodenext); + const a = xr(r); + return E.assert(!!(a.flags & 8388608), "Containing file is missing import meta node flag."), r.name.escapedText === "meta" ? W3e() : qe; + } + function GM(r) { + const a = r.valueDeclaration; + return Ru( + Yr(r), + /*isProperty*/ + !1, + /*isOptional*/ + !!a && (d0(a) || Ox(a)) + ); + } + function sme(r, a, l) { + switch (r.name.kind) { + case 80: { + const f = r.name.escapedText; + return r.dotDotDotToken ? l & 12 ? f : `${f}_${a}` : l & 3 ? f : `${f}_n`; + } + case 208: { + if (r.dotDotDotToken) { + const f = r.name.elements, d = Bn(Do(f), ya), y = f.length - (d?.dotDotDotToken ? 1 : 0); + if (a < y) { + const x = f[a]; + if (ya(x)) + return sme(x, a, l); + } else if (d?.dotDotDotToken) + return sme(d, a - y, l); + } + break; + } + } + return `arg_${a}`; + } + function ame(r, a = 0, l = 3, f) { + if (!r) { + const d = Bn(f?.valueDeclaration, Ii); + return d ? sme(d, a, l) : `${f?.escapedName ?? "arg"}_${a}`; + } + return E.assert(Me(r.name)), r.name.escapedText; + } + function xP(r, a, l) { + var f; + const d = r.parameters.length - (Iu(r) ? 1 : 0); + if (a < d) + return r.parameters[a].escapedName; + const y = r.parameters[d] || Y, x = l || Yr(y); + if (Sa(x)) { + const I = x.target, J = a - d, z = (f = I.labeledElementDeclarations) == null ? void 0 : f[J], G = I.elementFlags[J]; + return ame(z, J, G, y); + } + return y.escapedName; + } + function Pot(r, a) { + var l; + if (((l = r.declaration) == null ? void 0 : l.kind) === 318) + return; + const f = r.parameters.length - (Iu(r) ? 1 : 0); + if (a < f) { + const I = r.parameters[a], J = EIe(I); + return J ? { + parameter: J, + parameterName: I.escapedName, + isRestParameter: !1 + } : void 0; + } + const d = r.parameters[f] || Y, y = EIe(d); + if (!y) + return; + const x = Yr(d); + if (Sa(x)) { + const I = x.target.labeledElementDeclarations, J = a - f, z = I?.[J], G = !!z?.dotDotDotToken; + return z ? (E.assert(Me(z.name)), { parameter: z.name, parameterName: z.name.escapedText, isRestParameter: G }) : void 0; + } + if (a === f) + return { parameter: y, parameterName: d.escapedName, isRestParameter: !0 }; + } + function EIe(r) { + return r.valueDeclaration && Ii(r.valueDeclaration) && Me(r.valueDeclaration.name) && r.valueDeclaration.name; + } + function DIe(r) { + return r.kind === 203 || Ii(r) && r.name && Me(r.name); + } + function Not(r, a) { + const l = r.parameters.length - (Iu(r) ? 1 : 0); + if (a < l) { + const y = r.parameters[a].valueDeclaration; + return y && DIe(y) ? y : void 0; + } + const f = r.parameters[l] || Y, d = Yr(f); + if (Sa(d)) { + const y = d.target.labeledElementDeclarations, x = a - l; + return y && y[x]; + } + return f.valueDeclaration && DIe(f.valueDeclaration) ? f.valueDeclaration : void 0; + } + function Kd(r, a) { + return W2(r, a) || Le; + } + function W2(r, a) { + const l = r.parameters.length - (Iu(r) ? 1 : 0); + if (a < l) + return GM(r.parameters[a]); + if (Iu(r)) { + const f = Yr(r.parameters[l]), d = a - l; + if (!Sa(f) || f.target.combinedFlags & 12 || d < f.target.fixedLength) + return vf(f, Xd(d)); + } + } + function $M(r, a, l) { + const f = $_(r), d = em(r), y = wI(r); + if (y && a >= f - 1) + return a === f - 1 ? y : Tu(vf(y, wt)); + const x = [], I = [], J = []; + for (let z = a; z < f; z++) + !y || z < f - 1 ? (x.push(Kd(r, z)), I.push( + z < d ? 1 : 2 + /* Optional */ + )) : (x.push(y), I.push( + 8 + /* Variadic */ + )), J.push(Not(r, z)); + return hg(x, I, l, J); + } + function wIe(r, a) { + const l = $M(r, a), f = l && TM(l); + return f && gn(f) ? Le : l; + } + function $_(r) { + const a = r.parameters.length; + if (Iu(r)) { + const l = Yr(r.parameters[a - 1]); + if (Sa(l)) + return a + l.target.fixedLength - (l.target.combinedFlags & 12 ? 0 : 1); + } + return a; + } + function em(r, a) { + const l = a & 1, f = a & 2; + if (f || r.resolvedMinArgumentCount === void 0) { + let d; + if (Iu(r)) { + const y = Yr(r.parameters[r.parameters.length - 1]); + if (Sa(y)) { + const x = oc(y.target.elementFlags, (J) => !(J & 1)), I = x < 0 ? y.target.fixedLength : x; + I > 0 && (d = r.parameters.length - 1 + I); + } + } + if (d === void 0) { + if (!l && r.flags & 32) + return 0; + d = r.minArgumentCount; + } + if (f) + return d; + for (let y = d - 1; y >= 0; y--) { + const x = Kd(r, y); + if (Xc(x, eIe).flags & 131072) + break; + d = y; + } + r.resolvedMinArgumentCount = d; + } + return r.resolvedMinArgumentCount; + } + function vg(r) { + if (Iu(r)) { + const a = Yr(r.parameters[r.parameters.length - 1]); + return !Sa(a) || !!(a.target.combinedFlags & 12); + } + return !1; + } + function wI(r) { + if (Iu(r)) { + const a = Yr(r.parameters[r.parameters.length - 1]); + if (!Sa(a)) + return gn(a) ? Gl : a; + if (a.target.combinedFlags & 12) + return dP(a, a.target.fixedLength); + } + } + function PI(r) { + const a = wI(r); + return a && !Ep(a) && !gn(a) ? a : void 0; + } + function ome(r) { + return cme(r, nr); + } + function cme(r, a) { + return r.parameters.length > 0 ? Kd(r, 0) : a; + } + function PIe(r, a, l) { + const f = r.parameters.length - (Iu(r) ? 1 : 0); + for (let y = 0; y < f; y++) { + const x = r.parameters[y].valueDeclaration, I = Kc(x); + if (I) { + const J = Ru( + Ci(I), + /*isProperty*/ + !1, + Ox(x) + ), z = Kd(a, y); + uh(l.inferences, J, z); + } + } + const d = r.declaration && nf(r.declaration); + if (d) { + const y = Ci(d), x = Wa(a); + uh(l.inferences, y, x); + } + } + function Aot(r, a) { + if (a.typeParameters) + if (!r.typeParameters) + r.typeParameters = a.typeParameters; + else + return; + if (a.thisParameter) { + const f = r.thisParameter; + (!f || f.valueDeclaration && !f.valueDeclaration.type) && (f || (r.thisParameter = LT( + a.thisParameter, + /*type*/ + void 0 + )), XM(r.thisParameter, Yr(a.thisParameter))); + } + const l = r.parameters.length - (Iu(r) ? 1 : 0); + for (let f = 0; f < l; f++) { + const d = r.parameters[f], y = d.valueDeclaration; + if (!Kc(y)) { + let x = W2(a, f); + if (x && y.initializer) { + let I = kP( + y, + 0 + /* Normal */ + ); + !Ms(I, x) && Ms(x, I = hme(y, I)) && (x = I); + } + XM(d, x); + } + } + if (Iu(r)) { + const f = pa(r.parameters); + if (f.valueDeclaration ? !Kc(f.valueDeclaration) : uc(f) & 65536) { + const d = $M(a, l); + XM(f, d); + } + } + } + function Iot(r) { + r.thisParameter && XM(r.thisParameter); + for (const a of r.parameters) + XM(a); + } + function XM(r, a) { + const l = Pn(r); + if (l.type) + a && E.assertEqual(l.type, a, "Parameter symbol already has a cached type which differs from newly assigned type"); + else { + const f = r.valueDeclaration; + l.type = Ru( + a || (f ? Yk( + f, + /*reportErrors*/ + !0 + ) : Yr(r)), + /*isProperty*/ + !1, + /*isOptional*/ + !!f && !f.initializer && Ox(f) + ), f && f.name.kind !== 80 && (l.type === yt && (l.type = rP(f.name)), NIe(f.name, l.type)); + } + } + function NIe(r, a) { + for (const l of r.elements) + if (!vl(l)) { + const f = S1( + l, + a, + /*noTupleBoundsCheck*/ + !1 + ); + l.name.kind === 80 ? Pn(yn(l)).type = f : NIe(l.name, f); + } + } + function Fot(r) { + return FE(Btt( + /*reportErrors*/ + !0 + ), [r]); + } + function Oot(r, a) { + return FE(Jtt( + /*reportErrors*/ + !0 + ), [r, a]); + } + function Lot(r, a) { + return FE(ztt( + /*reportErrors*/ + !0 + ), [r, a]); + } + function Mot(r, a) { + return FE(Wtt( + /*reportErrors*/ + !0 + ), [r, a]); + } + function Rot(r, a) { + return FE(Utt( + /*reportErrors*/ + !0 + ), [r, a]); + } + function jot(r, a) { + return FE(Htt( + /*reportErrors*/ + !0 + ), [r, a]); + } + function Bot(r, a, l) { + const f = `${a ? "p" : "P"}${l ? "s" : "S"}${r.id}`; + let d = bs.get(f); + if (!d) { + const y = Bs(); + y.set("name", z0("name", r)), y.set("private", z0("private", a ? rt : Rr)), y.set("static", z0("static", l ? rt : Rr)), d = Ho( + /*symbol*/ + void 0, + y, + Ge, + Ge, + Ge + ), bs.set(f, d); + } + return d; + } + function AIe(r, a, l) { + const f = cl(r), d = Ai(r.name), y = d ? H_(An(r.name)) : Yh(r.name), x = rc(r) ? Oot(a, l) : pp(r) ? Lot(a, l) : z_(r) ? Mot(a, l) : b_(r) ? Rot(a, l) : os(r) ? jot(a, l) : E.failBadSyntaxKind(r), I = Bot(y, d, f); + return sa([x, I]); + } + function Jot(r, a) { + return FE(Vtt( + /*reportErrors*/ + !0 + ), [r, a]); + } + function zot(r, a) { + return FE(qtt( + /*reportErrors*/ + !0 + ), [r, a]); + } + function Wot(r, a) { + const l = Vf("this", r), f = Vf("value", a); + return kme( + /*typeParameters*/ + void 0, + l, + [f], + a, + /*typePredicate*/ + void 0, + 1 + ); + } + function lme(r, a, l) { + const f = Vf("target", r), d = Vf("context", a), y = Xn([l, _r]); + return MI( + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + [f, d], + y + ); + } + function Uot(r) { + const { parent: a } = r, l = xn(a); + if (!l.decoratorSignature) + switch (l.decoratorSignature = Hr, a.kind) { + case 264: + case 232: { + const d = Yr(yn(a)), y = Fot(d); + l.decoratorSignature = lme(d, y, d); + break; + } + case 175: + case 178: + case 179: { + const f = a; + if (!$n(f.parent)) break; + const d = rc(f) ? ET(Xf(f)) : pC(f), y = cl(f) ? Yr(yn(f.parent)) : xp(yn(f.parent)), x = pp(f) ? u7e(d) : z_(f) ? _7e(d) : d, I = AIe(f, y, d), J = pp(f) ? u7e(d) : z_(f) ? _7e(d) : d; + l.decoratorSignature = lme(x, I, J); + break; + } + case 173: { + const f = a; + if (!$n(f.parent)) break; + const d = pC(f), y = cl(f) ? Yr(yn(f.parent)) : xp(yn(f.parent)), x = fm(f) ? Jot(y, d) : ue, I = AIe(f, y, d), J = fm(f) ? zot(y, d) : Wot(y, d); + l.decoratorSignature = lme(x, I, J); + break; + } + } + return l.decoratorSignature === Hr ? void 0 : l.decoratorSignature; + } + function Vot(r) { + const { parent: a } = r, l = xn(a); + if (!l.decoratorSignature) + switch (l.decoratorSignature = Hr, a.kind) { + case 264: + case 232: { + const d = Yr(yn(a)), y = Vf("target", d); + l.decoratorSignature = MI( + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + [y], + Xn([d, _r]) + ); + break; + } + case 170: { + const f = a; + if (!nc(f.parent) && !(rc(f.parent) || z_(f.parent) && $n(f.parent.parent)) || Rb(f.parent) === f) + break; + const d = Rb(f.parent) ? f.parent.parameters.indexOf(f) - 1 : f.parent.parameters.indexOf(f); + E.assert(d >= 0); + const y = nc(f.parent) ? Yr(yn(f.parent.parent)) : n5e(f.parent), x = nc(f.parent) ? ue : i5e(f.parent), I = Xd(d), J = Vf("target", y), z = Vf("propertyKey", x), G = Vf("parameterIndex", I); + l.decoratorSignature = MI( + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + [J, z, G], + _r + ); + break; + } + case 175: + case 178: + case 179: + case 173: { + const f = a; + if (!$n(f.parent)) break; + const d = n5e(f), y = Vf("target", d), x = i5e(f), I = Vf("propertyKey", x), J = os(f) ? _r : Z3e(pC(f)); + if (!os(a) || fm(a)) { + const G = Z3e(pC(f)), ve = Vf("descriptor", G); + l.decoratorSignature = MI( + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + [y, I, ve], + Xn([J, _r]) + ); + } else + l.decoratorSignature = MI( + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + [y, I], + Xn([J, _r]) + ); + break; + } + } + return l.decoratorSignature === Hr ? void 0 : l.decoratorSignature; + } + function ume(r) { + return U ? Vot(r) : Uot(r); + } + function QM(r) { + const a = sM( + /*reportErrors*/ + !0 + ); + return a !== zt ? (r = a0(wP(r)) || yt, Qh(a, [r])) : yt; + } + function IIe(r) { + const a = G3e( + /*reportErrors*/ + !0 + ); + return a !== zt ? (r = a0(wP(r)) || yt, Qh(a, [r])) : yt; + } + function YM(r, a) { + const l = QM(a); + return l === yt ? (ze( + r, + T_(r) ? p.A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option : p.An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option + ), qe) : (rpe( + /*reportErrors*/ + !0 + ) || ze( + r, + T_(r) ? p.A_dynamic_import_call_in_ES5_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option : p.An_async_function_or_method_in_ES5_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option + ), l); + } + function qot(r) { + const a = ga(0, "NewTargetExpression"), l = ga( + 4, + "target", + 8 + /* Readonly */ + ); + l.parent = a, l.links.type = r; + const f = Bs([l]); + return a.members = f, Ho(a, f, Ge, Ge, Ge); + } + function gX(r, a) { + if (!r.body) + return qe; + const l = Mc(r), f = (l & 2) !== 0, d = (l & 1) !== 0; + let y, x, I, J = _r; + if (r.body.kind !== 242) + y = mc( + r.body, + a && a & -9 + /* SkipGenericFunctions */ + ), f && (y = wP(nR( + y, + /*withAlias*/ + !1, + /*errorNode*/ + r, + p.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member + ))); + else if (d) { + const z = MIe(r, a); + z ? z.length > 0 && (y = Xn( + z, + 2 + /* Subtype */ + )) : J = nr; + const { yieldTypes: G, nextTypes: ve } = Hot(r, a); + x = ot(G) ? Xn( + G, + 2 + /* Subtype */ + ) : void 0, I = ot(ve) ? sa(ve) : void 0; + } else { + const z = MIe(r, a); + if (!z) + return l & 2 ? YM(r, nr) : nr; + if (z.length === 0) { + const G = X$( + r, + /*contextFlags*/ + void 0 + ), ve = G && (lR(G, l) || _r).flags & 32768 ? ue : _r; + return l & 2 ? YM(r, ve) : ( + // Async function + ve + ); + } + y = Xn( + z, + 2 + /* Subtype */ + ); + } + if (y || x || I) { + if (x && L$( + r, + x, + 3 + /* GeneratorYield */ + ), y && L$( + r, + y, + 1 + /* FunctionReturn */ + ), I && L$( + r, + I, + 2 + /* GeneratorNext */ + ), y && Qd(y) || x && Qd(x) || I && Qd(I)) { + const z = eX(r), G = z ? z === Xf(r) ? d ? void 0 : y : Y$( + Wa(z), + r, + /*contextFlags*/ + void 0 + ) : void 0; + d ? (x = qpe(x, G, 0, f), y = qpe(y, G, 1, f), I = qpe(I, G, 2, f)) : y = Bnt(y, G, f); + } + x && (x = Sf(x)), y && (y = Sf(y)), I && (I = Sf(I)); + } + return d ? hX( + x || nr, + y || J, + I || p8e(2, r) || yt, + f + ) : f ? QM(y || J) : y || J; + } + function hX(r, a, l, f) { + const d = f ? Jc : vo, y = d.getGlobalGeneratorType( + /*reportErrors*/ + !1 + ); + if (r = d.resolveIterationType( + r, + /*errorNode*/ + void 0 + ) || yt, a = d.resolveIterationType( + a, + /*errorNode*/ + void 0 + ) || yt, y === zt) { + const x = d.getGlobalIterableIteratorType( + /*reportErrors*/ + !1 + ); + return x !== zt ? pP(x, [r, a, l]) : (d.getGlobalIterableIteratorType( + /*reportErrors*/ + !0 + ), ta); + } + return pP(y, [r, a, l]); + } + function Hot(r, a) { + const l = [], f = [], d = (Mc(r) & 2) !== 0; + return pK(r.body, (y) => { + const x = y.expression ? Hi(y.expression, a) : M; + tp(l, FIe(y, x, Le, d)); + let I; + if (y.asteriskToken) { + const J = PX( + x, + d ? 19 : 17, + y.expression + ); + I = J && J.nextType; + } else + I = g_( + y, + /*contextFlags*/ + void 0 + ); + I && tp(f, I); + }), { yieldTypes: l, nextTypes: f }; + } + function FIe(r, a, l, f) { + if (a === kt) + return kt; + const d = r.expression || r, y = r.asteriskToken ? ay(f ? 19 : 17, a, l, d) : a; + return f ? _C( + y, + d, + r.asteriskToken ? p.Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member : p.Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member + ) : y; + } + function OIe(r, a, l) { + let f = 0; + for (let d = 0; d < l.length; d++) { + const y = d < r || d >= a ? l[d] : void 0; + f |= y !== void 0 ? Cne.get(y) || 32768 : 0; + } + return f; + } + function LIe(r) { + const a = xn(r); + if (a.isExhaustive === void 0) { + a.isExhaustive = 0; + const l = Got(r); + a.isExhaustive === 0 && (a.isExhaustive = l); + } else a.isExhaustive === 0 && (a.isExhaustive = !1); + return a.isExhaustive; + } + function Got(r) { + if (r.expression.kind === 222) { + const f = jAe(r); + if (!f) + return !1; + const d = Rm(mc(r.expression.expression)), y = OIe(0, 0, f); + return d.flags & 3 ? (556800 & y) === 556800 : !wp(d, (x) => BE(x, y) === y); + } + const a = Rm(mc(r.expression)); + if (!fI(a)) + return !1; + const l = J$(r); + return !l.length || ot(l, Mnt) ? !1 : Oit(Go(a, t_), l); + } + function _me(r) { + return r.endFlowNode && AM(r.endFlowNode); + } + function MIe(r, a) { + const l = Mc(r), f = []; + let d = _me(r), y = !1; + if (Fy(r.body, (x) => { + let I = x.expression; + if (I) { + if (I = Ba( + I, + /*excludeJSDocTypeAssertions*/ + !0 + ), l & 2 && I.kind === 224 && (I = Ba( + I.expression, + /*excludeJSDocTypeAssertions*/ + !0 + )), I.kind === 214 && I.expression.kind === 80 && mc(I.expression).symbol === Oa(r.symbol) && (!zy(r.symbol.valueDeclaration) || gde(I.expression))) { + y = !0; + return; + } + let J = mc( + I, + a && a & -9 + /* SkipGenericFunctions */ + ); + l & 2 && (J = wP(nR( + J, + /*withAlias*/ + !1, + r, + p.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member + ))), J.flags & 131072 && (y = !0), tp(f, J); + } else + d = !0; + }), !(f.length === 0 && !d && (y || $ot(r)))) + return K && f.length && d && !(zm(r) && f.some((x) => x.symbol === r.symbol)) && tp(f, ue), f; + } + function $ot(r) { + switch (r.kind) { + case 219: + case 220: + return !0; + case 175: + return r.parent.kind === 211; + default: + return !1; + } + } + function Xot(r) { + switch (r.kind) { + case 177: + case 178: + case 179: + return; + } + if (Mc(r) !== 0) return; + let l; + if (r.body && r.body.kind !== 242) + l = r.body; + else if (Fy(r.body, (d) => { + if (l || !d.expression) return !0; + l = d.expression; + }) || !l || _me(r)) return; + return Qot(r, l); + } + function Qot(r, a) { + if (a = Ba( + a, + /*excludeJSDocTypeAssertions*/ + !0 + ), !!(mc(a).flags & 16)) + return lr(r.parameters, (f, d) => { + const y = Yr(f.symbol); + if (!y || y.flags & 16 || !Me(f.name) || vI(f.symbol) || Hm(f)) + return; + const x = Yot(r, a, f, y); + if (x) + return eI(1, Si(f.name.escapedText), d, x); + }); + } + function Yot(r, a, l, f) { + const d = HC(a) && a.flowNode || a.parent.kind === 254 && a.parent.flowNode || tg( + 2, + /*node*/ + void 0, + /*antecedent*/ + void 0 + ), y = tg(32, a, d), x = s0(l.name, f, f, r, y); + if (x === f) return; + const I = tg(64, a, d); + return td(s0(l.name, f, x, r, I)).flags & 131072 ? x : void 0; + } + function fme(r, a) { + n(l); + return; + function l() { + const f = Mc(r), d = a && lR(a, f); + if (d && (Dc( + d, + 16384 + /* Void */ + ) || d.flags & 32769) || r.kind === 174 || lc(r.body) || r.body.kind !== 242 || !_me(r)) + return; + const y = r.flags & 1024, x = nf(r) || r; + if (d && d.flags & 131072) + ze(x, p.A_function_returning_never_cannot_have_a_reachable_end_point); + else if (d && !y) + ze(x, p.A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value); + else if (d && K && !Ms(ue, d)) + ze(x, p.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined); + else if (F.noImplicitReturns) { + if (!d) { + if (!y) + return; + const I = Wa(Xf(r)); + if (N7e(r, I)) + return; + } + ze(x, p.Not_all_code_paths_return_a_value); + } + } + } + function RIe(r, a) { + if (E.assert(r.kind !== 175 || Rp(r)), fC(r), yo(r) && PP(r, r.name), a && a & 4 && Qf(r)) { + if (!nf(r) && !aF(r)) { + const f = TI(r); + if (f && N1(Wa(f))) { + const d = xn(r); + if (d.contextFreeType) + return d.contextFreeType; + const y = gX(r, a), x = Mm( + /*declaration*/ + void 0, + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + Ge, + y, + /*resolvedTypePredicate*/ + void 0, + 0, + 64 + /* IsNonInferrable */ + ), I = Ho(r.symbol, A, [x], Ge, Ge); + return I.objectFlags |= 262144, d.contextFreeType = I; + } + } + return Za; + } + return !UX(r) && r.kind === 219 && Qme(r), Zot(r, a), Yr(yn(r)); + } + function Zot(r, a) { + const l = xn(r); + if (!(l.flags & 64)) { + const f = TI(r); + if (!(l.flags & 64)) { + l.flags |= 64; + const d = Yc(Is( + Yr(yn(r)), + 0 + /* Call */ + )); + if (!d) + return; + if (Qf(r)) + if (f) { + const y = J2(r); + let x; + if (a && a & 2) { + PIe(d, f, y); + const I = wI(f); + I && I.flags & 262144 && (x = FT(f, y.nonFixingMapper)); + } + x || (x = y ? FT(f, y.mapper) : f), Aot(d, x); + } else + Iot(d); + else if (f && !r.typeParameters && f.parameters.length > r.parameters.length) { + const y = J2(r); + a && a & 2 && PIe(d, f, y); + } + if (f && !IE(r) && !d.resolvedReturnType) { + const y = gX(r, a); + d.resolvedReturnType || (d.resolvedReturnType = y); + } + II(r); + } + } + } + function Kot(r) { + E.assert(r.kind !== 175 || Rp(r)); + const a = Mc(r), l = IE(r); + if (fme(r, l), r.body) + if (nf(r) || Wa(Xf(r)), r.body.kind === 242) + la(r.body); + else { + const f = Hi(r.body), d = l && lR(l, a); + d && NX(r, d, r.body, r.body, f); + } + } + function yX(r, a, l, f = !1) { + if (!Ms(a, Fs)) { + const d = f && DP(a); + return J0( + r, + !!d && Ms(d, Fs), + l + ), !1; + } + return !0; + } + function ect(r) { + if (!Ps(r) || !uS(r)) + return !1; + const a = mc(r.arguments[2]); + if (rr(a, "value")) { + const d = Ys(a, "writable"), y = d && Yr(d); + if (!y || y === Rr || y === Pr) + return !0; + if (d && d.valueDeclaration && rl(d.valueDeclaration)) { + const x = d.valueDeclaration.initializer, I = Hi(x); + if (I === Rr || I === Pr) + return !0; + } + return !1; + } + return !Ys(a, "set"); + } + function tm(r) { + return !!(uc(r) & 8 || r.flags & 4 && up(r) & 8 || r.flags & 3 && Lde(r) & 6 || r.flags & 98304 && !(r.flags & 65536) || r.flags & 8 || ot(r.declarations, ect)); + } + function jIe(r, a, l) { + var f, d; + if (l === 0) + return !1; + if (tm(a)) { + if (a.flags & 4 && To(r) && r.expression.kind === 110) { + const y = TP(r); + if (!(y && (y.kind === 177 || zm(y)))) + return !0; + if (a.valueDeclaration) { + const x = _n(a.valueDeclaration), I = y.parent === a.valueDeclaration.parent, J = y === a.valueDeclaration.parent, z = x && ((f = a.parent) == null ? void 0 : f.valueDeclaration) === y.parent, G = x && ((d = a.parent) == null ? void 0 : d.valueDeclaration) === y; + return !(I || J || z || G); + } + } + return !0; + } + if (To(r)) { + const y = Ba(r.expression); + if (y.kind === 80) { + const x = xn(y).resolvedSymbol; + if (x.flags & 2097152) { + const I = F_(x); + return !!I && I.kind === 275; + } + } + } + return !1; + } + function NI(r, a, l) { + const f = hc( + r, + 39 + /* Parentheses */ + ); + return f.kind !== 80 && !To(f) ? (ze(r, a), !1) : f.flags & 64 ? (ze(r, l), !1) : !0; + } + function tct(r) { + Hi(r.expression); + const a = Ba(r.expression); + if (!To(a)) + return ze(a, p.The_operand_of_a_delete_operator_must_be_a_property_reference), Nt; + wn(a) && Ai(a.name) && ze(a, p.The_operand_of_a_delete_operator_cannot_be_a_private_identifier); + const l = xn(a), f = _t(l.resolvedSymbol); + return f && (tm(f) ? ze(a, p.The_operand_of_a_delete_operator_cannot_be_a_read_only_property) : rct(a, f)), Nt; + } + function rct(r, a) { + const l = Yr(a); + K && !(l.flags & 131075) && !(be ? a.flags & 16777216 : Yd( + l, + 16777216 + /* IsUndefined */ + )) && ze(r, p.The_operand_of_a_delete_operator_must_be_optional); + } + function nct(r) { + return Hi(r.expression), gE; + } + function ict(r) { + return fC(r), M; + } + function BIe(r) { + let a = !1; + const l = t5(r); + if (l && kc(l)) { + const f = Hy(r) ? p.await_expression_cannot_be_used_inside_a_class_static_block : p.await_using_statements_cannot_be_used_inside_a_class_static_block; + ze(r, f), a = !0; + } else if (!(r.flags & 65536)) + if (n5(r)) { + const f = xr(r); + if (!F1(f)) { + let d; + if (!RC(f, F)) { + d ?? (d = om(f, r.pos)); + const y = Hy(r) ? p.await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module : p.await_using_statements_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module, x = ll(f, d.start, d.length, y); + Aa.add(x), a = !0; + } + switch (B) { + case 100: + case 101: + case 102: + case 199: + if (f.impliedNodeFormat === 1) { + d ?? (d = om(f, r.pos)), Aa.add( + ll(f, d.start, d.length, p.The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level) + ), a = !0; + break; + } + // fallthrough + case 7: + case 99: + case 200: + case 4: + if (R >= 4) + break; + // fallthrough + default: + d ?? (d = om(f, r.pos)); + const y = Hy(r) ? p.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher : p.Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher; + Aa.add(ll(f, d.start, d.length, y)), a = !0; + break; + } + } + } else { + const f = xr(r); + if (!F1(f)) { + const d = om(f, r.pos), y = Hy(r) ? p.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules : p.await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules, x = ll(f, d.start, d.length, y); + if (l && l.kind !== 177 && (Mc(l) & 2) === 0) { + const I = sn(l, p.Did_you_mean_to_mark_this_function_as_async); + zs(x, I); + } + Aa.add(x), a = !0; + } + } + return Hy(r) && Ede(r) && (ze(r, p.await_expressions_cannot_be_used_in_a_parameter_initializer), a = !0), a; + } + function sct(r) { + n(() => BIe(r)); + const a = Hi(r.expression), l = nR( + a, + /*withAlias*/ + !0, + r, + p.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member + ); + return l === a && !Gr(l) && !(a.flags & 3) && Qg( + /*isError*/ + !1, + sn(r, p.await_has_no_effect_on_the_type_of_this_expression) + ), l; + } + function act(r) { + const a = Hi(r.operand); + if (a === kt) + return kt; + switch (r.operand.kind) { + case 9: + switch (r.operator) { + case 41: + return iC(Xd(-r.operand.text)); + case 40: + return iC(Xd(+r.operand.text)); + } + break; + case 10: + if (r.operator === 41) + return iC(_M({ + negative: !0, + base10Value: g4(r.operand.text) + })); + } + switch (r.operator) { + case 40: + case 41: + case 55: + return Jm(a, r.operand), ZM( + a, + 12288 + /* ESSymbolLike */ + ) && ze(r.operand, p.The_0_operator_cannot_be_applied_to_type_symbol, qs(r.operator)), r.operator === 40 ? (ZM( + a, + 2112 + /* BigIntLike */ + ) && ze(r.operand, p.Operator_0_cannot_be_applied_to_type_1, qs(r.operator), Wr(r0(a))), wt) : pme(a); + case 54: + Pme(a, r.operand); + const l = BE( + a, + 12582912 + /* Falsy */ + ); + return l === 4194304 ? Rr : l === 8388608 ? rt : Nt; + case 46: + case 47: + return yX(r.operand, Jm(a, r.operand), p.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type) && NI( + r.operand, + p.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access, + p.The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access + ), pme(a); + } + return qe; + } + function oct(r) { + const a = Hi(r.operand); + return a === kt ? kt : (yX( + r.operand, + Jm(a, r.operand), + p.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type + ) && NI( + r.operand, + p.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access, + p.The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access + ), pme(a)); + } + function pme(r) { + return Dc( + r, + 2112 + /* BigIntLike */ + ) ? cu( + r, + 3 + /* AnyOrUnknown */ + ) || Dc( + r, + 296 + /* NumberLike */ + ) ? Fs : Zr : wt; + } + function ZM(r, a) { + if (Dc(r, a)) + return !0; + const l = Rm(r); + return !!l && Dc(l, a); + } + function Dc(r, a) { + if (r.flags & a) + return !0; + if (r.flags & 3145728) { + const l = r.types; + for (const f of l) + if (Dc(f, a)) + return !0; + } + return !1; + } + function cu(r, a, l) { + return r.flags & a ? !0 : l && r.flags & 114691 ? !1 : !!(a & 296) && Ms(r, wt) || !!(a & 2112) && Ms(r, Zr) || !!(a & 402653316) && Ms(r, at) || !!(a & 528) && Ms(r, Nt) || !!(a & 16384) && Ms(r, _r) || !!(a & 131072) && Ms(r, nr) || !!(a & 65536) && Ms(r, Mt) || !!(a & 32768) && Ms(r, ue) || !!(a & 4096) && Ms(r, Jt) || !!(a & 67108864) && Ms(r, vr); + } + function AI(r, a, l) { + return r.flags & 1048576 ? Ni(r.types, (f) => AI(f, a, l)) : cu(r, a, l); + } + function vX(r) { + return !!(Dn(r) & 16) && !!r.symbol && dme(r.symbol); + } + function dme(r) { + return (r.flags & 128) !== 0; + } + function mme(r) { + const a = E7e("hasInstance"); + if (AI( + r, + 67108864 + /* NonPrimitive */ + )) { + const l = Ys(r, a); + if (l) { + const f = Yr(l); + if (f && Is( + f, + 0 + /* Call */ + ).length !== 0) + return f; + } + } + } + function cct(r, a, l, f, d) { + if (l === kt || f === kt) + return kt; + !gn(l) && AI( + l, + 402784252 + /* Primitive */ + ) && ze(r, p.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter), E.assert(F5(r.parent)); + const y = qE( + r.parent, + /*candidatesOutArray*/ + void 0, + d + ); + if (y === ln) + return kt; + const x = Wa(y); + return xu(x, Nt, a, p.An_object_s_Symbol_hasInstance_method_must_return_a_boolean_value_for_it_to_be_used_on_the_right_hand_side_of_an_instanceof_expression), Nt; + } + function lct(r) { + return wp(r, (a) => a === Fa || !!(a.flags & 2097152) && yg(Rm(a))); + } + function uct(r, a, l, f) { + if (l === kt || f === kt) + return kt; + if (Ai(r)) { + if ((R < El.PrivateNamesAndClassStaticBlocks || R < El.ClassAndClassElementDecorators || !$) && xl( + r, + 2097152 + /* ClassPrivateFieldIn */ + ), !xn(r).resolvedSymbol && Wl(r)) { + const d = zde( + r, + f.symbol, + /*excludeClasses*/ + !0 + ); + V8e(r, f, d); + } + } else + xu(Jm(l, r), oi, r); + return xu(Jm(f, a), vr, a) && lct(f) && ze(a, p.Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operator, Wr(f)), Nt; + } + function _ct(r, a, l) { + const f = r.properties; + if (K && f.length === 0) + return Jm(a, r); + for (let d = 0; d < f.length; d++) + JIe(r, a, d, f, l); + return a; + } + function JIe(r, a, l, f, d = !1) { + const y = r.properties, x = y[l]; + if (x.kind === 304 || x.kind === 305) { + const I = x.name, J = Yh(I); + if (_p(J)) { + const ve = fp(J), de = Ys(a, ve); + de && (UM(de, x, d), Rde( + x, + /*isSuper*/ + !1, + /*writing*/ + !0, + a, + de + )); + } + const z = vf(a, J, 32 | (lC(x) ? 16 : 0), I), G = La(x, z); + return VT(x.kind === 305 ? x : x.initializer, G); + } else if (x.kind === 306) + if (l < y.length - 1) + ze(x, p.A_rest_element_must_be_last_in_a_destructuring_pattern); + else { + R < El.ObjectSpreadRest && xl( + x, + 4 + /* Rest */ + ); + const I = []; + if (f) + for (const z of f) + Vg(z) || I.push(z.name); + const J = ji(a, I, a.symbol); + return mC(f, p.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma), VT(x.expression, J); + } + else + ze(x, p.Property_assignment_expected); + } + function fct(r, a, l) { + const f = r.elements; + R < El.DestructuringAssignment && F.downlevelIteration && xl( + r, + 512 + /* Read */ + ); + const d = ay(193, a, ue, r) || qe; + let y = F.noUncheckedIndexedAccess ? void 0 : d; + for (let x = 0; x < f.length; x++) { + let I = d; + r.elements[x].kind === 231 && (I = y = y ?? (ay(65, a, ue, r) || qe)), zIe(r, a, x, I, l); + } + return a; + } + function zIe(r, a, l, f, d) { + const y = r.elements, x = y[l]; + if (x.kind !== 233) { + if (x.kind !== 231) { + const I = Xd(l); + if (iy(a)) { + const J = 32 | (lC(x) ? 16 : 0), z = C1(a, I, J, EI(x, I)) || qe, G = lC(x) ? Dp( + z, + 524288 + /* NEUndefined */ + ) : z, ve = La(x, G); + return VT(x, ve, d); + } + return VT(x, f, d); + } + if (l < y.length - 1) + ze(x, p.A_rest_element_must_be_last_in_a_destructuring_pattern); + else { + const I = x.expression; + if (I.kind === 227 && I.operatorToken.kind === 64) + ze(I.operatorToken, p.A_rest_element_cannot_have_an_initializer); + else { + mC(r.elements, p.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma); + const J = G_(a, Sa) ? Go(a, (z) => dP(z, l)) : Tu(f); + return VT(I, J, d); + } + } + } + } + function VT(r, a, l, f) { + let d; + if (r.kind === 305) { + const y = r; + y.objectAssignmentInitializer && (K && !Yd( + Hi(y.objectAssignmentInitializer), + 16777216 + /* IsUndefined */ + ) && (a = Dp( + a, + 524288 + /* NEUndefined */ + )), vct(y.name, y.equalsToken, y.objectAssignmentInitializer, l)), d = r.name; + } else + d = r; + return d.kind === 227 && d.operatorToken.kind === 64 && (me(d, l), d = d.left, K && (a = Dp( + a, + 524288 + /* NEUndefined */ + ))), d.kind === 211 ? _ct(d, a, f) : d.kind === 210 ? fct(d, a, l) : pct(d, a, l); + } + function pct(r, a, l) { + const f = Hi(r, l), d = r.parent.kind === 306 ? p.The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access : p.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access, y = r.parent.kind === 306 ? p.The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access : p.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access; + return NI(r, d, y) && j2(a, f, r, r), AC(r) && xl( + r.parent, + 1048576 + /* ClassPrivateFieldSet */ + ), a; + } + function KM(r) { + switch (r = Ba(r), r.kind) { + case 80: + case 11: + case 14: + case 216: + case 229: + case 15: + case 9: + case 10: + case 112: + case 97: + case 106: + case 157: + case 219: + case 232: + case 220: + case 210: + case 211: + case 222: + case 236: + case 286: + case 285: + return !0; + case 228: + return KM(r.whenTrue) && KM(r.whenFalse); + case 227: + return kh(r.operatorToken.kind) ? !1 : KM(r.left) && KM(r.right); + case 225: + case 226: + switch (r.operator) { + case 54: + case 40: + case 41: + case 55: + return !0; + } + return !1; + // Some forms listed here for clarity + case 223: + // Explicit opt-out + case 217: + // Not SEF, but can produce useful type warnings + case 235: + // Not SEF, but can produce useful type warnings + default: + return !1; + } + } + function gme(r, a) { + return (a.flags & 98304) !== 0 || v$(r, a); + } + function dct() { + const r = WF(a, l, f, d, y, x); + return (de, We) => { + const lt = r(de, We); + return E.assertIsDefined(lt), lt; + }; + function a(de, We, lt) { + return We ? (We.stackIndex++, We.skip = !1, z( + We, + /*type*/ + void 0 + ), ve( + We, + /*type*/ + void 0 + )) : We = { + checkMode: lt, + skip: !1, + stackIndex: 0, + typeStack: [void 0, void 0] + }, an(de) && mx(de) ? (We.skip = !0, ve(We, Hi(de.right, lt)), We) : (mct(de), de.operatorToken.kind === 64 && (de.left.kind === 211 || de.left.kind === 210) && (We.skip = !0, ve(We, VT( + de.left, + Hi(de.right, lt), + lt, + de.right.kind === 110 + /* ThisKeyword */ + ))), We); + } + function l(de, We, lt) { + if (!We.skip) + return I(We, de); + } + function f(de, We, lt) { + if (!We.skip) { + const gt = G(We); + E.assertIsDefined(gt), z(We, gt), ve( + We, + /*type*/ + void 0 + ); + const jt = de.kind; + if (A5(jt)) { + let ar = lt.parent; + for (; ar.kind === 218 || sN(ar); ) + ar = ar.parent; + (jt === 56 || sv(ar)) && wme(lt.left, gt, sv(ar) ? ar.thenStatement : void 0), iN(jt) && Pme(gt, lt.left); + } + } + } + function d(de, We, lt) { + if (!We.skip) + return I(We, de); + } + function y(de, We) { + let lt; + if (We.skip) + lt = G(We); + else { + const gt = J(We); + E.assertIsDefined(gt); + const jt = G(We); + E.assertIsDefined(jt), lt = WIe(de.left, de.operatorToken, de.right, gt, jt, We.checkMode, de); + } + return We.skip = !1, z( + We, + /*type*/ + void 0 + ), ve( + We, + /*type*/ + void 0 + ), We.stackIndex--, lt; + } + function x(de, We, lt) { + return ve(de, We), de; + } + function I(de, We) { + if (_n(We)) + return We; + ve(de, Hi(We, de.checkMode)); + } + function J(de) { + return de.typeStack[de.stackIndex]; + } + function z(de, We) { + de.typeStack[de.stackIndex] = We; + } + function G(de) { + return de.typeStack[de.stackIndex + 1]; + } + function ve(de, We) { + de.typeStack[de.stackIndex + 1] = We; + } + } + function mct(r) { + if (r.operatorToken.kind === 61) { + if (_n(r.parent)) { + const { left: a, operatorToken: l } = r.parent; + _n(a) && l.kind === 57 && mr(a, p._0_and_1_operations_cannot_be_mixed_without_parentheses, qs( + 61 + /* QuestionQuestionToken */ + ), qs(l.kind)); + } else if (_n(r.left)) { + const { operatorToken: a } = r.left; + (a.kind === 57 || a.kind === 56) && mr(r.left, p._0_and_1_operations_cannot_be_mixed_without_parentheses, qs(a.kind), qs( + 61 + /* QuestionQuestionToken */ + )); + } else if (_n(r.right)) { + const { operatorToken: a } = r.right; + a.kind === 56 && mr(r.right, p._0_and_1_operations_cannot_be_mixed_without_parentheses, qs( + 61 + /* QuestionQuestionToken */ + ), qs(a.kind)); + } + gct(r), hct(r); + } + } + function gct(r) { + const a = hc( + r.left, + 63 + /* All */ + ), l = eR(a); + l !== 3 && (l === 1 ? ze(a, p.This_expression_is_always_nullish) : ze(a, p.Right_operand_of_is_unreachable_because_the_left_operand_is_never_nullish)); + } + function hct(r) { + const a = hc( + r.right, + 63 + /* All */ + ), l = eR(a); + yct(r) || (l === 1 ? ze(a, p.This_expression_is_always_nullish) : l === 2 && ze(a, p.This_expression_is_never_nullish)); + } + function yct(r) { + return !_n(r.parent) || r.parent.operatorToken.kind !== 61; + } + function eR(r) { + switch (r = hc(r), r.kind) { + case 224: + case 214: + case 216: + case 213: + case 237: + case 215: + case 212: + case 230: + case 110: + return 3; + case 227: + switch (r.operatorToken.kind) { + case 64: + case 61: + case 78: + case 57: + case 76: + case 56: + case 77: + return 3; + case 28: + return eR(r.right); + } + return 2; + case 228: + return eR(r.whenTrue) | eR(r.whenFalse); + case 106: + return 1; + case 80: + return ju(r) === ne ? 1 : 3; + } + return 2; + } + function vct(r, a, l, f, d) { + const y = a.kind; + if (y === 64 && (r.kind === 211 || r.kind === 210)) + return VT( + r, + Hi(l, f), + f, + l.kind === 110 + /* ThisKeyword */ + ); + let x; + iN(y) ? x = JI(r, f) : x = Hi(r, f); + const I = Hi(l, f); + return WIe(r, a, l, x, I, f, d); + } + function WIe(r, a, l, f, d, y, x) { + const I = a.kind; + switch (I) { + case 42: + case 43: + case 67: + case 68: + case 44: + case 69: + case 45: + case 70: + case 41: + case 66: + case 48: + case 71: + case 49: + case 72: + case 50: + case 73: + case 52: + case 75: + case 53: + case 79: + case 51: + case 74: + if (f === kt || d === kt) + return kt; + f = Jm(f, r), d = Jm(d, l); + let or; + if (f.flags & 528 && d.flags & 528 && (or = de(a.kind)) !== void 0) + return ze(x || a, p.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, qs(a.kind), qs(or)), wt; + { + const Qn = yX( + r, + f, + p.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type, + /*isAwaitValid*/ + !0 + ), Ri = yX( + l, + d, + p.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type, + /*isAwaitValid*/ + !0 + ); + let zn; + if (cu( + f, + 3 + /* AnyOrUnknown */ + ) && cu( + d, + 3 + /* AnyOrUnknown */ + ) || // Or, if neither could be bigint, implicit coercion results in a number result + !(Dc( + f, + 2112 + /* BigIntLike */ + ) || Dc( + d, + 2112 + /* BigIntLike */ + ))) + zn = wt; + else if (J(f, d)) { + switch (I) { + case 50: + case 73: + jt(); + break; + case 43: + case 68: + R < 3 && ze(x, p.Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_later); + } + zn = Zr; + } else + jt(J), zn = qe; + if (Qn && Ri) + switch (We(zn), I) { + case 48: + case 71: + case 49: + case 72: + case 50: + case 73: + const bi = Fe(l); + typeof bi.value == "number" && Math.abs(bi.value) >= 32 && dd( + Ph(ad(l.parent.parent)), + // elevate from suggestion to error within an enum member + x || a, + p.This_operation_can_be_simplified_This_shift_is_identical_to_0_1_2, + Qo(r), + qs(I), + bi.value % 32 + ); + break; + } + return zn; + } + case 40: + case 65: + if (f === kt || d === kt) + return kt; + !cu( + f, + 402653316 + /* StringLike */ + ) && !cu( + d, + 402653316 + /* StringLike */ + ) && (f = Jm(f, r), d = Jm(d, l)); + let ir; + return cu( + f, + 296, + /*strict*/ + !0 + ) && cu( + d, + 296, + /*strict*/ + !0 + ) ? ir = wt : cu( + f, + 2112, + /*strict*/ + !0 + ) && cu( + d, + 2112, + /*strict*/ + !0 + ) ? ir = Zr : cu( + f, + 402653316, + /*strict*/ + !0 + ) || cu( + d, + 402653316, + /*strict*/ + !0 + ) ? ir = at : (gn(f) || gn(d)) && (ir = Gr(f) || Gr(d) ? qe : Le), ir && !ve(I) ? ir : ir ? (I === 65 && We(ir), ir) : (jt( + (Ri, zn) => cu(Ri, 402655727) && cu(zn, 402655727) + ), Le); + case 30: + case 32: + case 33: + case 34: + return ve(I) && (f = Upe(Jm(f, r)), d = Upe(Jm(d, l)), gt((Qn, Ri) => { + if (gn(Qn) || gn(Ri)) + return !0; + const zn = Ms(Qn, Fs), bi = Ms(Ri, Fs); + return zn && bi || !zn && !bi && mM(Qn, Ri); + })), Nt; + case 35: + case 36: + case 37: + case 38: + if (!(y && y & 64)) { + if ((zj(r) || zj(l)) && // only report for === and !== in JS, not == or != + (!an(r) || I === 37 || I === 38)) { + const Qn = I === 35 || I === 37; + ze(x, p.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value, Qn ? "false" : "true"); + } + jr(x, I, r, l), gt((Qn, Ri) => gme(Qn, Ri) || gme(Ri, Qn)); + } + return Nt; + case 104: + return cct(r, l, f, d, y); + case 103: + return uct(r, l, f, d); + case 56: + case 77: { + const Qn = Yd( + f, + 4194304 + /* Truthy */ + ) ? Xn([Wnt(K ? f : r0(d)), d]) : f; + return I === 77 && We(d), Qn; + } + case 57: + case 76: { + const Qn = Yd( + f, + 8388608 + /* Falsy */ + ) ? Xn( + [n0(uAe(f)), d], + 2 + /* Subtype */ + ) : f; + return I === 76 && We(d), Qn; + } + case 61: + case 78: { + const Qn = Yd( + f, + 262144 + /* EQUndefinedOrNull */ + ) ? Xn( + [n0(f), d], + 2 + /* Subtype */ + ) : f; + return I === 78 && We(d), Qn; + } + case 64: + const nn = _n(r.parent) ? Ac(r.parent) : 0; + return z(nn, d), lt(nn) ? ((!(d.flags & 524288) || nn !== 2 && nn !== 6 && !t0(d) && !ude(d) && !(Dn(d) & 1)) && We(d), f) : (We(d), d); + case 28: + if (!F.allowUnreachableCode && KM(r) && !G(r.parent)) { + const Qn = xr(r), Ri = Qn.text, zn = oa(Ri, r.pos); + Qn.parseDiagnostics.some((ks) => ks.code !== p.JSX_expressions_must_have_one_parent_element.code ? !1 : Dj(ks, zn)) || ze(r, p.Left_side_of_comma_operator_is_unused_and_has_no_side_effects); + } + return d; + default: + return E.fail(); + } + function J(or, ir) { + return cu( + or, + 2112 + /* BigIntLike */ + ) && cu( + ir, + 2112 + /* BigIntLike */ + ); + } + function z(or, ir) { + if (or === 2) + for (const nn of ey(ir)) { + const Qn = Yr(nn); + if (Qn.symbol && Qn.symbol.flags & 32) { + const Ri = nn.escapedName, zn = st( + nn.valueDeclaration, + Ri, + 788968, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + ); + zn?.declarations && zn.declarations.some(IS) && (Yg(zn, p.Duplicate_identifier_0, Si(Ri), nn), Yg(nn, p.Duplicate_identifier_0, Si(Ri), zn)); + } + } + } + function G(or) { + return or.parent.kind === 218 && E_(or.left) && or.left.text === "0" && (Ps(or.parent.parent) && or.parent.parent.expression === or.parent || or.parent.parent.kind === 216) && // special-case for "eval" because it's the only non-access case where an indirect call actually affects behavior. + (To(or.right) || Me(or.right) && or.right.escapedText === "eval"); + } + function ve(or) { + const ir = ZM( + f, + 12288 + /* ESSymbolLike */ + ) ? r : ZM( + d, + 12288 + /* ESSymbolLike */ + ) ? l : void 0; + return ir ? (ze(ir, p.The_0_operator_cannot_be_applied_to_type_symbol, qs(or)), !1) : !0; + } + function de(or) { + switch (or) { + case 52: + case 75: + return 57; + case 53: + case 79: + return 38; + case 51: + case 74: + return 56; + default: + return; + } + } + function We(or) { + kh(I) && n(ir); + function ir() { + let nn = f; + if (Z4(a.kind) && r.kind === 212 && (nn = aX( + r, + /*checkMode*/ + void 0, + /*writeOnly*/ + !0 + )), NI(r, p.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access, p.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access)) { + let Qn; + if (be && wn(r) && Dc( + or, + 32768 + /* Undefined */ + )) { + const Ri = rr(lu(r.expression), r.name.escapedText); + S$(or, Ri) && (Qn = p.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target); + } + j2(or, nn, r, l, Qn); + } + } + } + function lt(or) { + var ir; + switch (or) { + case 2: + return !0; + case 1: + case 5: + case 6: + case 3: + case 4: + const nn = Hf(r), Qn = mx(l); + return !!Qn && _a(Qn) && !!((ir = nn?.exports) != null && ir.size); + default: + return !1; + } + } + function gt(or) { + return or(f, d) ? !1 : (jt(or), !0); + } + function jt(or) { + let ir = !1; + const nn = x || a; + if (or) { + const ks = a0(f), Ua = a0(d); + ir = !(ks === f && Ua === d) && !!(ks && Ua) && or(ks, Ua); + } + let Qn = f, Ri = d; + !ir && or && ([Qn, Ri] = bct(f, d, or)); + const [zn, bi] = Kw(Qn, Ri); + ar(nn, ir, zn, bi) || J0( + nn, + ir, + p.Operator_0_cannot_be_applied_to_types_1_and_2, + qs(a.kind), + zn, + bi + ); + } + function ar(or, ir, nn, Qn) { + switch (a.kind) { + case 37: + case 35: + case 38: + case 36: + return J0( + or, + ir, + p.This_comparison_appears_to_be_unintentional_because_the_types_0_and_1_have_no_overlap, + nn, + Qn + ); + default: + return; + } + } + function jr(or, ir, nn, Qn) { + const Ri = Kr(Ba(nn)), zn = Kr(Ba(Qn)); + if (Ri || zn) { + const bi = ze(or, p.This_condition_will_always_return_0, qs( + ir === 37 || ir === 35 ? 97 : 112 + /* TrueKeyword */ + )); + if (Ri && zn) return; + const ks = ir === 38 || ir === 36 ? qs( + 54 + /* ExclamationToken */ + ) : "", Ua = Ri ? Qn : nn, Vi = Ba(Ua); + zs(bi, sn(Ua, p.Did_you_mean_0, `${ks}Number.isNaN(${to(Vi) ? ef(Vi) : "..."})`)); + } + } + function Kr(or) { + if (Me(or) && or.escapedText === "NaN") { + const ir = Gtt(); + return !!ir && ir === ju(or); + } + return !1; + } + } + function bct(r, a, l) { + let f = r, d = a; + const y = r0(r), x = r0(a); + return l(y, x) || (f = y, d = x), [f, d]; + } + function Sct(r) { + n(ve); + const a = Af(r); + if (!a) return Le; + const l = Mc(a); + if (!(l & 1)) + return Le; + const f = (l & 2) !== 0; + r.asteriskToken && (f && R < El.AsyncGenerators && xl( + r, + 26624 + /* AsyncDelegatorIncludes */ + ), !f && R < El.Generators && F.downlevelIteration && xl( + r, + 256 + /* Values */ + )); + let d = IE(a); + d && d.flags & 1048576 && (d = Xc(d, (de) => bme( + de, + l, + /*errorNode*/ + void 0 + ))); + const y = d && Mme(d, f), x = y && y.yieldType || Le, I = y && y.nextType || Le, J = r.expression ? Hi(r.expression) : M, z = FIe(r, J, I, f); + if (d && z && j2(z, x, r.expression || r, r.expression), r.asteriskToken) + return Ime(f ? 19 : 17, 1, J, r.expression) || Le; + if (d) + return oy(2, d, f) || Le; + let G = p8e(2, a); + return G || (G = Le, n(() => { + if (fe && !$ee(r)) { + const de = g_( + r, + /*contextFlags*/ + void 0 + ); + (!de || gn(de)) && ze(r, p.yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation); + } + })), G; + function ve() { + r.flags & 16384 || Bl(r, p.A_yield_expression_is_only_allowed_in_a_generator_body), Ede(r) && ze(r, p.yield_expressions_cannot_be_used_in_a_parameter_initializer); + } + } + function Tct(r, a) { + const l = JI(r.condition, a); + wme(r.condition, l, r.whenTrue); + const f = Hi(r.whenTrue, a), d = Hi(r.whenFalse, a); + return Xn( + [f, d], + 2 + /* Subtype */ + ); + } + function UIe(r) { + const a = r.parent; + return o_(a) && UIe(a) || uo(a) && a.argumentExpression === r; + } + function xct(r) { + const a = [r.head.text], l = []; + for (const d of r.templateSpans) { + const y = Hi(d.expression); + ZM( + y, + 12288 + /* ESSymbolLike */ + ) && ze(d.expression, p.Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String), a.push(d.literal.text), l.push(Ms(y, Rs) ? y : at); + } + const f = r.parent.kind !== 216 && Fe(r).value; + return f ? iC(H_(f)) : CP(r) || UIe(r) || wp(g_( + r, + /*contextFlags*/ + void 0 + ) || yt, kct) ? wT(a, l) : at; + } + function kct(r) { + return !!(r.flags & 134217856 || r.flags & 58982400 && Dc( + ou(r) || yt, + 402653316 + /* StringLike */ + )); + } + function Cct(r) { + return Yb(r) && !NS(r.parent) ? r.parent.parent : r; + } + function HE(r, a, l, f) { + const d = Cct(r); + MM( + d, + a, + /*isCache*/ + !1 + ), Fst(d, l); + const y = Hi(r, f | 1 | (l ? 2 : 0)); + l && l.intraExpressionInferenceSites && (l.intraExpressionInferenceSites = void 0); + const x = Dc( + y, + 2944 + /* Literal */ + ) && bX(y, Y$( + a, + r, + /*contextFlags*/ + void 0 + )) ? t_(y) : y; + return Ost(), SI(), x; + } + function mc(r, a) { + if (a) + return Hi(r, a); + const l = xn(r); + if (!l.resolvedType) { + const f = dn, d = Pi; + dn = Ir, Pi = void 0, l.resolvedType = Hi(r, a), Pi = d, dn = f; + } + return l.resolvedType; + } + function VIe(r) { + return r = Ba( + r, + /*excludeJSDocTypeAssertions*/ + !0 + ), r.kind === 217 || r.kind === 235 || Kb(r); + } + function kP(r, a, l) { + const f = j3(r); + if (an(r)) { + const y = lF(r); + if (y) + return nme(f, y, a); + } + const d = vme(f) || (l ? HE( + f, + l, + /*inferenceContext*/ + void 0, + a || 0 + /* Normal */ + ) : mc(f, a)); + if (Ii(ya(r) ? Y2(r) : r)) { + if (r.name.kind === 207 && sy(d)) + return Ect(d, r.name); + if (r.name.kind === 208 && Sa(d)) + return Dct(d, r.name); + } + return d; + } + function Ect(r, a) { + let l; + for (const y of a.elements) + if (y.initializer) { + const x = qIe(y); + x && !Ys(r, x) && (l = Er(l, y)); + } + if (!l) + return r; + const f = Bs(); + for (const y of ey(r)) + f.set(y.escapedName, y); + for (const y of l) { + const x = ga(16777220, qIe(y)); + x.links.type = qd( + y, + /*includePatternInType*/ + !1, + /*reportErrors*/ + !1 + ), f.set(x.escapedName, x); + } + const d = Ho(r.symbol, f, Ge, Ge, Su(r)); + return d.objectFlags = r.objectFlags, d; + } + function qIe(r) { + const a = Yh(r.propertyName || r.name); + return _p(a) ? fp(a) : void 0; + } + function Dct(r, a) { + if (r.target.combinedFlags & 12 || ry(r) >= a.elements.length) + return r; + const l = a.elements, f = F2(r).slice(), d = r.target.elementFlags.slice(); + for (let y = ry(r); y < l.length; y++) { + const x = l[y]; + (y < l.length - 1 || !(x.kind === 209 && x.dotDotDotToken)) && (f.push(!vl(x) && lC(x) ? qd( + x, + /*includePatternInType*/ + !1, + /*reportErrors*/ + !1 + ) : Le), d.push( + 2 + /* Optional */ + ), !vl(x) && !lC(x) && cb(x, Le)); + } + return hg(f, d, r.target.readonly); + } + function hme(r, a) { + const l = HIe(r, a); + if (an(r)) { + if (iAe(l)) + return cb(r, Le), Le; + if (D$(l)) + return cb(r, Gl), Gl; + } + return l; + } + function HIe(r, a) { + return U2(r) & 6 || C3(r) ? a : ob(a); + } + function bX(r, a) { + if (a) { + if (a.flags & 3145728) { + const l = a.types; + return ot(l, (f) => bX(r, f)); + } + if (a.flags & 58982400) { + const l = ou(a) || yt; + return Dc( + l, + 4 + /* String */ + ) && Dc( + r, + 128 + /* StringLiteral */ + ) || Dc( + l, + 8 + /* Number */ + ) && Dc( + r, + 256 + /* NumberLiteral */ + ) || Dc( + l, + 64 + /* BigInt */ + ) && Dc( + r, + 2048 + /* BigIntLiteral */ + ) || Dc( + l, + 4096 + /* ESSymbol */ + ) && Dc( + r, + 8192 + /* UniqueESSymbol */ + ) || bX(r, l); + } + return !!(a.flags & 406847616 && Dc( + r, + 128 + /* StringLiteral */ + ) || a.flags & 256 && Dc( + r, + 256 + /* NumberLiteral */ + ) || a.flags & 2048 && Dc( + r, + 2048 + /* BigIntLiteral */ + ) || a.flags & 512 && Dc( + r, + 512 + /* BooleanLiteral */ + ) || a.flags & 8192 && Dc( + r, + 8192 + /* UniqueESSymbol */ + )); + } + return !1; + } + function CP(r) { + const a = r.parent; + return Eb(a) && nd(a.type) || Kb(a) && nd(x6(a)) || rme(r) && CT(g_( + r, + 0 + /* None */ + )) || (o_(a) || nu(a) || dp(a)) && CP(a) || (rl(a) || gu(a) || g6(a)) && CP(a.parent); + } + function EP(r, a, l) { + const f = Hi(r, a, l); + return CP(r) || mK(r) ? t_(f) : VIe(r) ? f : Vpe(f, Y$( + g_( + r, + /*contextFlags*/ + void 0 + ), + r, + /*contextFlags*/ + void 0 + )); + } + function GIe(r, a) { + return r.name.kind === 168 && Td(r.name), EP(r.initializer, a); + } + function $Ie(r, a) { + y5e(r), r.name.kind === 168 && Td(r.name); + const l = RIe(r, a); + return XIe(r, l, a); + } + function XIe(r, a, l) { + if (l && l & 10) { + const f = CI( + a, + 0, + /*allowMembers*/ + !0 + ), d = CI( + a, + 1, + /*allowMembers*/ + !0 + ), y = f || d; + if (y && y.typeParameters) { + const x = ub( + r, + 2 + /* NoConstraints */ + ); + if (x) { + const I = CI( + n0(x), + f ? 0 : 1, + /*allowMembers*/ + !1 + ); + if (I && !I.typeParameters) { + if (l & 8) + return QIe(r, l), Za; + const J = J2(r), z = J.signature && Wa(J.signature), G = z && rIe(z); + if (G && !G.typeParameters && !Ni(J.inferences, GE)) { + const ve = Act(J, y.typeParameters), de = Gfe(y, ve), We = hr(J.inferences, (lt) => Ype(lt.typeParameter)); + if (Gpe(de, I, (lt, gt) => { + uh( + We, + lt, + gt, + /*priority*/ + 0, + /*contravariant*/ + !0 + ); + }), ot(We, GE) && ($pe(de, I, (lt, gt) => { + uh(We, lt, gt); + }), !Pct(J.inferences, We))) + return Nct(J.inferences, We), J.inferredTypeParameters = Bi(J.inferredTypeParameters, ve), ET(de); + } + return ET(nIe(y, I, J)); + } + } + } + } + return a; + } + function QIe(r, a) { + if (a & 2) { + const l = J2(r); + l.flags |= 4; + } + } + function GE(r) { + return !!(r.candidates || r.contraCandidates); + } + function wct(r) { + return !!(r.candidates || r.contraCandidates || d3e(r.typeParameter)); + } + function Pct(r, a) { + for (let l = 0; l < r.length; l++) + if (GE(r[l]) && GE(a[l])) + return !0; + return !1; + } + function Nct(r, a) { + for (let l = 0; l < r.length; l++) + !GE(r[l]) && GE(a[l]) && (r[l] = a[l]); + } + function Act(r, a) { + const l = []; + let f, d; + for (const y of a) { + const x = y.symbol.escapedName; + if (yme(r.inferredTypeParameters, x) || yme(l, x)) { + const I = Ict(Bi(r.inferredTypeParameters, l), x), J = ga(262144, I), z = p_(J); + z.target = y, f = Er(f, y), d = Er(d, z), l.push(z); + } else + l.push(y); + } + if (d) { + const y = bf(f, d); + for (const x of d) + x.mapper = y; + } + return l; + } + function yme(r, a) { + return ot(r, (l) => l.symbol.escapedName === a); + } + function Ict(r, a) { + let l = a.length; + for (; l > 1 && a.charCodeAt(l - 1) >= 48 && a.charCodeAt(l - 1) <= 57; ) l--; + const f = a.slice(0, l); + for (let d = 1; ; d++) { + const y = f + d; + if (!yme(r, y)) + return y; + } + } + function YIe(r) { + const a = UT(r); + if (a && !a.typeParameters) + return Wa(a); + } + function Fct(r) { + const a = Hi(r.expression), l = pI(a, r.expression), f = YIe(a); + return f && A$(f, r, l !== a); + } + function lu(r) { + const a = vme(r); + if (a) + return a; + if (r.flags & 268435456 && Pi) { + const d = Pi[Ma(r)]; + if (d) + return d; + } + const l = rs, f = Hi( + r, + 64 + /* TypeOnly */ + ); + if (rs !== l) { + const d = Pi || (Pi = []); + d[Ma(r)] = f, Gee( + r, + r.flags | 268435456 + /* TypeCached */ + ); + } + return f; + } + function vme(r) { + let a = Ba( + r, + /*excludeJSDocTypeAssertions*/ + !0 + ); + if (Kb(a)) { + const l = x6(a); + if (!nd(l)) + return Ci(l); + } + if (a = Ba(r), Hy(a)) { + const l = vme(a.expression); + return l ? _C(l) : void 0; + } + if (Ps(a) && a.expression.kind !== 108 && !x_( + a, + /*requireStringLiteralLikeArgument*/ + !0 + ) && !hIe(a) && !T_(a)) + return K2(a) ? Fct(a) : YIe(UE(a.expression)); + if (Eb(a) && !nd(a.type)) + return Ci(a.type); + if (eS(r) || DD(r)) + return Hi(r); + } + function tR(r) { + const a = xn(r); + if (a.contextFreeType) + return a.contextFreeType; + MM( + r, + Le, + /*isCache*/ + !1 + ); + const l = a.contextFreeType = Hi( + r, + 4 + /* SkipContextSensitive */ + ); + return SI(), l; + } + function Hi(r, a, l) { + var f, d; + (f = on) == null || f.push(on.Phase.Check, "checkExpression", { kind: r.kind, pos: r.pos, end: r.end, path: r.tracingPath }); + const y = k; + k = r, h = 0; + const x = Mct(r, a, l), I = XIe(r, x, a); + return vX(I) && Oct(r, I), k = y, (d = on) == null || d.pop(), I; + } + function Oct(r, a) { + var l; + const f = r.parent.kind === 212 && r.parent.expression === r || r.parent.kind === 213 && r.parent.expression === r || (r.kind === 80 || r.kind === 167) && RX(r) || r.parent.kind === 187 && r.parent.exprName === r || r.parent.kind === 282; + if (f || ze(r, p.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query), F.isolatedModules || F.verbatimModuleSyntax && f && !st( + r, + i_(r), + 2097152, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1, + /*excludeGlobals*/ + !0 + )) { + E.assert(!!(a.symbol.flags & 128)); + const d = a.symbol.valueDeclaration, y = (l = e.getRedirectFromOutput(xr(d).resolvedPath)) == null ? void 0 : l.resolvedRef; + d.flags & 33554432 && !K1(r) && (!y || !By(y.commandLine.options)) && ze(r, p.Cannot_access_ambient_const_enums_when_0_is_enabled, Ee); + } + } + function Lct(r, a) { + if (kf(r)) { + if (UJ(r)) + return nme(r.expression, VJ(r), a); + if (Kb(r)) + return SIe(r, a); + } + return Hi(r.expression, a); + } + function Mct(r, a, l) { + const f = r.kind; + if (i) + switch (f) { + case 232: + case 219: + case 220: + i.throwIfCancellationRequested(); + } + switch (f) { + case 80: + return rst(r, a); + case 81: + return Dat(r); + case 110: + return OM(r); + case 108: + return $$(r); + case 106: + return ke; + case 15: + case 11: + return rde(r) ? Ct : iC(H_(r.text)); + case 9: + return k5e(r), iC(Xd(+r.text)); + case 10: + return jft(r), iC(_M({ + negative: !1, + base10Value: g4(r.text) + })); + case 112: + return rt; + case 97: + return Rr; + case 229: + return xct(r); + case 14: + return Yst(r); + case 210: + return k8e(r, a, l); + case 211: + return sat(r, a); + case 212: + return aX(r, a); + case 167: + return z8e(r, a); + case 213: + return Wat(r, a); + case 214: + if (T_(r)) + return bot(r); + // falls through + case 215: + return vot(r, a); + case 216: + return Sot(r); + case 218: + return Lct(r, a); + case 232: + return Eut(r); + case 219: + case 220: + return RIe(r, a); + case 222: + return nct(r); + case 217: + case 235: + return Tot(r, a); + case 236: + return Cot(r); + case 234: + return xIe(r); + case 239: + return Eot(r); + case 237: + return Dot(r); + case 221: + return tct(r); + case 223: + return ict(r); + case 224: + return sct(r); + case 225: + return act(r); + case 226: + return oct(r); + case 227: + return me(r, a); + case 228: + return Tct(r, a); + case 231: + return Zst(r, a); + case 233: + return M; + case 230: + return Sct(r); + case 238: + return Kst(r); + case 295: + return bat(r, a); + case 285: + return lat(r); + case 286: + return oat(r); + case 289: + return uat(r); + case 293: + return fat(r, a); + case 287: + E.fail("Shouldn't ever directly check a JsxOpeningElement"); + } + return qe; + } + function ZIe(r) { + fh(r), r.expression && Bl(r.expression, p.Type_expected), la(r.constraint), la(r.default); + const a = Zv(yn(r)); + ou(a), Zet(a) || ze(r.default, p.Type_parameter_0_has_a_circular_default, Wr(a)); + const l = m_(a), f = A2(a); + l && f && xu(f, yf(Mi(l, M2(a, f)), f), r.default, p.Type_0_does_not_satisfy_the_constraint_1), fC(r), n(() => NP(r.name, p.Type_parameter_name_cannot_be_0)); + } + function Rct(r) { + var a, l; + if (Vl(r.parent) || $n(r.parent) || Wp(r.parent)) { + const f = Zv(yn(r)), d = Bpe(f) & 24576; + if (d) { + const y = yn(r.parent); + if (Wp(r.parent) && !(Dn(bo(y)) & 48)) + ze(r, p.Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types); + else if (d === 8192 || d === 16384) { + (a = on) == null || a.push(on.Phase.CheckTypes, "checkTypeParameterDeferred", { parent: jl(bo(y)), id: jl(f) }); + const x = yM(y, f, d === 16384 ? Ft : tt), I = yM(y, f, d === 16384 ? tt : Ft), J = f; + D = f, xu(x, I, r, p.Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation), D = J, (l = on) == null || l.pop(); + } + } + } + } + function KIe(r) { + fh(r), oR(r); + const a = Af(r); + Gn( + r, + 31 + /* ParameterPropertyModifier */ + ) && (F.erasableSyntaxOnly && ze(r, p.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled), a.kind === 177 && Mp(a.body) || ze(r, p.A_parameter_property_is_only_allowed_in_a_constructor_implementation), a.kind === 177 && Me(r.name) && r.name.escapedText === "constructor" && ze(r.name, p.constructor_cannot_be_used_as_a_parameter_property_name)), !r.initializer && Ox(r) && ws(r.name) && a.body && ze(r, p.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature), r.name && Me(r.name) && (r.name.escapedText === "this" || r.name.escapedText === "new") && (a.parameters.indexOf(r) !== 0 && ze(r, p.A_0_parameter_must_be_the_first_parameter, r.name.escapedText), (a.kind === 177 || a.kind === 181 || a.kind === 186) && ze(r, p.A_constructor_cannot_have_a_this_parameter), a.kind === 220 && ze(r, p.An_arrow_function_cannot_have_a_this_parameter), (a.kind === 178 || a.kind === 179) && ze(r, p.get_and_set_accessors_cannot_declare_this_parameters)), r.dotDotDotToken && !ws(r.name) && !Ms(td(Yr(r.symbol)), pf) && ze(r, p.A_rest_parameter_must_be_of_an_array_type); + } + function jct(r) { + const a = Bct(r); + if (!a) { + ze(r, p.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); + return; + } + const l = Xf(a), f = kp(l); + if (!f) + return; + la(r.type); + const { parameterName: d } = r; + if (f.kind !== 0 && f.kind !== 2) { + if (f.parameterIndex >= 0) { + if (Iu(l) && f.parameterIndex === l.parameters.length - 1) + ze(d, p.A_type_predicate_cannot_reference_a_rest_parameter); + else if (f.type) { + const y = () => Ts( + /*details*/ + void 0, + p.A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type + ); + xu( + f.type, + Yr(l.parameters[f.parameterIndex]), + r.type, + /*headMessage*/ + void 0, + y + ); + } + } else if (d) { + let y = !1; + for (const { name: x } of a.parameters) + if (ws(x) && e7e(x, d, f.parameterName)) { + y = !0; + break; + } + y || ze(r.parameterName, p.Cannot_find_parameter_0, f.parameterName); + } + } + } + function Bct(r) { + switch (r.parent.kind) { + case 220: + case 180: + case 263: + case 219: + case 185: + case 175: + case 174: + const a = r.parent; + if (r === a.type) + return a; + } + } + function e7e(r, a, l) { + for (const f of r.elements) { + if (vl(f)) + continue; + const d = f.name; + if (d.kind === 80 && d.escapedText === l) + return ze(a, p.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern, l), !0; + if ((d.kind === 208 || d.kind === 207) && e7e( + d, + a, + l + )) + return !0; + } + } + function II(r) { + r.kind === 182 ? pft(r) : (r.kind === 185 || r.kind === 263 || r.kind === 186 || r.kind === 180 || r.kind === 177 || r.kind === 181) && UX(r); + const a = Mc(r); + a & 4 || ((a & 3) === 3 && R < El.AsyncGenerators && xl( + r, + 6144 + /* AsyncGeneratorIncludes */ + ), (a & 3) === 2 && R < El.AsyncFunctions && xl( + r, + 64 + /* Awaiter */ + ), (a & 3) !== 0 && R < El.Generators && xl( + r, + 128 + /* Generator */ + )), uR(xy(r)), xut(r), lr(r.parameters, KIe), r.type && la(r.type), n(l); + function l() { + jlt(r); + let f = nf(r), d = f; + if (an(r)) { + const y = z1(r); + if (y && y.typeExpression && of(y.typeExpression.type)) { + const x = UT(Ci(y.typeExpression)); + x && x.declaration && (f = nf(x.declaration), d = y.typeExpression.type); + } + } + if (fe && !f) + switch (r.kind) { + case 181: + ze(r, p.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); + break; + case 180: + ze(r, p.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); + break; + } + if (f && d) { + const y = Mc(r); + if ((y & 5) === 1) { + const x = Ci(f); + x === _r ? ze(d, p.A_generator_cannot_have_a_void_type_annotation) : bme(x, y, d); + } else (y & 3) === 2 && glt(r, f, d); + } + r.kind !== 182 && r.kind !== 318 && A1(r); + } + } + function bme(r, a, l) { + const f = oy(0, r, (a & 2) !== 0) || Le, d = oy(1, r, (a & 2) !== 0) || f, y = oy(2, r, (a & 2) !== 0) || yt, x = hX(f, d, y, !!(a & 2)); + return xu(x, r, l); + } + function Jct(r) { + const a = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(); + for (const y of r.members) + if (y.kind === 177) + for (const x of y.parameters) + K_(x, y) && !ws(x.name) && d( + a, + x.name, + x.name.escapedText, + 3 + /* GetOrSetAccessor */ + ); + else { + const x = Js(y), I = y.name; + if (!I) + continue; + const J = Ai(I), z = J && x ? 16 : 0, G = J ? f : x ? l : a, ve = I && ege(I); + if (ve) + switch (y.kind) { + case 178: + d(G, I, ve, 1 | z); + break; + case 179: + d(G, I, ve, 2 | z); + break; + case 173: + d(G, I, ve, 3 | z); + break; + case 175: + d(G, I, ve, 8 | z); + break; + } + } + function d(y, x, I, J) { + const z = y.get(I); + if (z) + if ((z & 16) !== (J & 16)) + ze(x, p.Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name, Qo(x)); + else { + const G = !!(z & 8), ve = !!(J & 8); + G || ve ? G !== ve && ze(x, p.Duplicate_identifier_0, Qo(x)) : z & J & -17 ? ze(x, p.Duplicate_identifier_0, Qo(x)) : y.set(I, z | J); + } + else + y.set(I, J); + } + } + function zct(r) { + for (const a of r.members) { + const l = a.name; + if (Js(a) && l) { + const d = ege(l); + switch (d) { + case "name": + case "length": + case "caller": + case "arguments": + if ($) + break; + // fall through + case "prototype": + const y = p.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1, x = Yv(yn(r)); + ze(l, y, d, x); + break; + } + } + } + } + function t7e(r) { + const a = /* @__PURE__ */ new Map(); + for (const l of r.members) + if (l.kind === 172) { + let f; + const d = l.name; + switch (d.kind) { + case 11: + case 9: + f = d.text; + break; + case 80: + f = An(d); + break; + default: + continue; + } + a.get(f) ? (ze(_s(l.symbol.valueDeclaration), p.Duplicate_identifier_0, f), ze(l.name, p.Duplicate_identifier_0, f)) : a.set(f, !0); + } + } + function Sme(r) { + if (r.kind === 265) { + const l = yn(r); + if (l.declarations && l.declarations.length > 0 && l.declarations[0] !== r) + return; + } + const a = e$(yn(r)); + if (a?.declarations) { + const l = /* @__PURE__ */ new Map(); + for (const f of a.declarations) + qy(f) && f.parameters.length === 1 && f.parameters[0].type && BT(Ci(f.parameters[0].type), (d) => { + const y = l.get(jl(d)); + y ? y.declarations.push(f) : l.set(jl(d), { type: d, declarations: [f] }); + }); + l.forEach((f) => { + if (f.declarations.length > 1) + for (const d of f.declarations) + ze(d, p.Duplicate_index_signature_for_type_0, Wr(f.type)); + }); + } + } + function r7e(r) { + !fh(r) && !Lft(r) && VX(r.name), oR(r), SX(r), Gn( + r, + 64 + /* Abstract */ + ) && r.kind === 173 && r.initializer && ze(r, p.Property_0_cannot_have_an_initializer_because_it_is_marked_abstract, co(r.name)); + } + function Wct(r) { + return Ai(r.name) && ze(r, p.Private_identifiers_are_not_allowed_outside_class_bodies), r7e(r); + } + function Uct(r) { + y5e(r) || VX(r.name), rc(r) && r.asteriskToken && Me(r.name) && An(r.name) === "constructor" && ze(r.name, p.Class_constructor_may_not_be_a_generator), d7e(r), Gn( + r, + 64 + /* Abstract */ + ) && r.kind === 175 && r.body && ze(r, p.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, co(r.name)), Ai(r.name) && !Wl(r) && ze(r, p.Private_identifiers_are_not_allowed_outside_class_bodies), SX(r); + } + function SX(r) { + if (Ai(r.name) && (R < El.PrivateNamesAndClassStaticBlocks || R < El.ClassAndClassElementDecorators || !$)) { + for (let a = Dd(r); a; a = Dd(a)) + xn(a).flags |= 1048576; + if (Rc(r.parent)) { + const a = bde(r.parent); + a && (xn(r.name).flags |= 32768, xn(a).flags |= 4096); + } + } + } + function Vct(r) { + fh(r), xs(r, la); + } + function qct(r) { + II(r), Fft(r) || Oft(r), la(r.body); + const a = yn(r), l = Oo(a, r.kind); + if (r === l && xX(a), lc(r.body)) + return; + n(d); + return; + function f(y) { + return Du(y) ? !0 : y.kind === 173 && !Js(y) && !!y.initializer; + } + function d() { + const y = r.parent; + if (Lb(y)) { + Sde(r.parent, y); + const x = Tde(y), I = o8e(r.body); + if (I) { + if (x && ze(I, p.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null), !W && (ot(r.parent.members, f) || ot(r.parameters, (z) => Gn( + z, + 31 + /* ParameterPropertyModifier */ + )))) + if (!Hct(I, r.body)) + ze(I, p.A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_initialized_properties_parameter_properties_or_private_identifiers); + else { + let z; + for (const G of r.body.statements) { + if (Al(G) && oS(hc(G.expression))) { + z = G; + break; + } + if (n7e(G)) + break; + } + z === void 0 && ze(r, p.A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_class_contains_initialized_properties_parameter_properties_or_private_identifiers); + } + } else x || ze(r, p.Constructors_for_derived_classes_must_contain_a_super_call); + } + } + } + function Hct(r, a) { + const l = ad(r.parent); + return Al(l) && l.parent === a; + } + function n7e(r) { + return r.kind === 108 || r.kind === 110 ? !0 : TK(r) ? !1 : !!xs(r, n7e); + } + function i7e(r) { + Me(r.name) && An(r.name) === "constructor" && $n(r.parent) && ze(r.name, p.Class_constructor_may_not_be_an_accessor), n(a), la(r.body), SX(r); + function a() { + if (!UX(r) && !Tft(r) && VX(r.name), iR(r), II(r), r.kind === 178 && !(r.flags & 33554432) && Mp(r.body) && r.flags & 512 && (r.flags & 1024 || ze(r.name, p.A_get_accessor_must_return_a_value)), r.name.kind === 168 && Td(r.name), NE(r)) { + const f = yn(r), d = Oo( + f, + 178 + /* GetAccessor */ + ), y = Oo( + f, + 179 + /* SetAccessor */ + ); + if (d && y && !(dC(d) & 1)) { + xn(d).flags |= 1; + const x = pu(d), I = pu(y); + (x & 64) !== (I & 64) && (ze(d.name, p.Accessors_must_both_be_abstract_or_non_abstract), ze(y.name, p.Accessors_must_both_be_abstract_or_non_abstract)), (x & 4 && !(I & 6) || x & 2 && !(I & 2)) && (ze(d.name, p.A_get_accessor_must_be_at_least_as_accessible_as_the_setter), ze(y.name, p.A_get_accessor_must_be_at_least_as_accessible_as_the_setter)); + } + } + const l = iP(yn(r)); + r.kind === 178 && fme(r, l); + } + } + function Gct(r) { + iR(r); + } + function $ct(r, a, l) { + return r.typeArguments && l < r.typeArguments.length ? Ci(r.typeArguments[l]) : TX(r, a)[l]; + } + function TX(r, a) { + return ty(hr(r.typeArguments, Ci), a, gg(a), an(r)); + } + function s7e(r, a) { + let l, f, d = !0; + for (let y = 0; y < a.length; y++) { + const x = m_(a[y]); + x && (l || (l = TX(r, a), f = bf(a, l)), d = d && xu( + l[y], + Mi(x, f), + r.typeArguments[y], + p.Type_0_does_not_satisfy_the_constraint_1 + )); + } + return d; + } + function Xct(r, a) { + if (!Gr(r)) + return a.flags & 524288 && Pn(a).typeParameters || (Dn(r) & 4 ? r.target.localTypeParameters : void 0); + } + function Tme(r) { + const a = Ci(r); + if (!Gr(a)) { + const l = xn(r).resolvedSymbol; + if (l) + return Xct(a, l); + } + } + function xme(r) { + if (dR(r, r.typeArguments), r.kind === 184 && !an(r) && !BD(r) && r.typeArguments && r.typeName.end !== r.typeArguments.pos) { + const a = xr(r); + _K(a, r.typeName.end) === 25 && _b(r, oa(a.text, r.typeName.end), 1, p.JSDoc_types_can_only_be_used_inside_documentation_comments); + } + lr(r.typeArguments, la), a7e(r); + } + function a7e(r) { + const a = Ci(r); + if (!Gr(a)) { + r.typeArguments && n(() => { + const f = Tme(r); + f && s7e(r, f); + }); + const l = xn(r).resolvedSymbol; + l && ot(l.declarations, (f) => Fx(f) && !!(f.flags & 536870912)) && Zp( + HM(r), + l.declarations, + l.escapedName + ); + } + } + function Qct(r) { + const a = Bn(r.parent, L7); + if (!a) return; + const l = Tme(a); + if (!l) return; + const f = m_(l[a.typeArguments.indexOf(r)]); + return f && Mi(f, bf(l, TX(a, l))); + } + function Yct(r) { + B3e(r); + } + function Zct(r) { + lr(r.members, la), n(a); + function a() { + const l = PNe(r); + AX(l, l.symbol), Sme(r), t7e(r); + } + } + function Kct(r) { + la(r.elementType); + } + function elt(r) { + let a = !1, l = !1; + for (const f of r.elements) { + let d = spe(f); + if (d & 8) { + const y = Ci(f.type); + if (!iy(y)) { + ze(f, p.A_rest_element_type_must_be_an_array_type); + break; + } + (Ep(y) || Sa(y) && y.target.combinedFlags & 4) && (d |= 4); + } + if (d & 4) { + if (l) { + mr(f, p.A_rest_element_cannot_follow_another_rest_element); + break; + } + l = !0; + } else if (d & 2) { + if (l) { + mr(f, p.An_optional_element_cannot_follow_a_rest_element); + break; + } + a = !0; + } else if (d & 1 && a) { + mr(f, p.A_required_element_cannot_follow_an_optional_element); + break; + } + } + lr(r.elements, la), Ci(r); + } + function tlt(r) { + lr(r.types, la), Ci(r); + } + function o7e(r, a) { + if (!(r.flags & 8388608)) + return r; + const l = r.objectType, f = r.indexType, d = L_(l) && Y8(l) === 2 ? pNe( + l, + 0 + /* None */ + ) : jm( + l, + 0 + /* None */ + ), y = !!ah(l, wt); + if (G_(f, (x) => Ms(x, d) || y && Kk(x, wt))) + return a.kind === 213 && Ly(a) && Dn(l) & 32 && mg(l) & 1 && ze(a, p.Index_signature_in_type_0_only_permits_reading, Wr(l)), r; + if (NT(l)) { + const x = _$(f, a); + if (x) { + const I = BT(e_(l), (J) => Ys(J, x)); + if (I && up(I) & 6) + return ze(a, p.Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter, Si(x)), qe; + } + } + return ze(a, p.Type_0_cannot_be_used_to_index_type_1, Wr(f), Wr(l)), qe; + } + function rlt(r) { + la(r.objectType), la(r.indexType), o7e(xNe(r), r); + } + function nlt(r) { + ilt(r), la(r.typeParameter), la(r.nameType), la(r.type), r.type || cb(r, Le); + const a = hpe(r), l = K0(a); + if (l) + xu(l, oi, r.nameType); + else { + const f = $f(a); + xu(f, oi, PC(r.typeParameter)); + } + } + function ilt(r) { + var a; + if ((a = r.members) != null && a.length) + return mr(r.members[0], p.A_mapped_type_may_not_declare_properties_or_methods); + } + function slt(r) { + kpe(r); + } + function alt(r) { + kft(r), la(r.type); + } + function olt(r) { + xs(r, la); + } + function clt(r) { + dr(r, (l) => l.parent && l.parent.kind === 195 && l.parent.extendsType === l) || mr(r, p.infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type), la(r.typeParameter); + const a = yn(r.typeParameter); + if (a.declarations && a.declarations.length > 1) { + const l = Pn(a); + if (!l.typeParametersChecked) { + l.typeParametersChecked = !0; + const f = Zv(a), d = WZ( + a, + 169 + /* TypeParameter */ + ); + if (!F7e(d, [f], (y) => [y])) { + const y = Wi(a); + for (const x of d) + ze(x.name, p.All_declarations_of_0_must_have_identical_constraints, y); + } + } + } + A1(r); + } + function llt(r) { + for (const a of r.templateSpans) { + la(a.type); + const l = Ci(a.type); + xu(l, Rs, a.type); + } + Ci(r); + } + function ult(r) { + la(r.argument), r.attributes && R6(r.attributes, mr), a7e(r); + } + function _lt(r) { + r.dotDotDotToken && r.questionToken && mr(r, p.A_tuple_member_cannot_be_both_optional_and_rest), r.type.kind === 191 && mr(r.type, p.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type), r.type.kind === 192 && mr(r.type, p.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type), la(r.type), Ci(r); + } + function rR(r) { + return (sf( + r, + 2 + /* Private */ + ) || Du(r)) && !!(r.flags & 33554432); + } + function FI(r, a) { + let l = HX(r); + if (r.parent.kind !== 265 && r.parent.kind !== 264 && r.parent.kind !== 232 && r.flags & 33554432) { + const f = G7(r); + f && f.flags & 128 && !(l & 128) && !(vm(r.parent) && jc(r.parent.parent) && $m(r.parent.parent)) && (l |= 32), l |= 128; + } + return l & a; + } + function xX(r) { + n(() => flt(r)); + } + function flt(r) { + function a(or, ir) { + return ir !== void 0 && ir.parent === or[0].parent ? ir : or[0]; + } + function l(or, ir, nn, Qn, Ri) { + if ((Qn ^ Ri) !== 0) { + const bi = FI(a(or, ir), nn); + yC(or, (ks) => xr(ks).fileName).forEach((ks) => { + const Ua = FI(a(ks, ir), nn); + for (const Vi of ks) { + const jo = FI(Vi, nn) ^ bi, Sc = FI(Vi, nn) ^ Ua; + Sc & 32 ? ze(_s(Vi), p.Overload_signatures_must_all_be_exported_or_non_exported) : Sc & 128 ? ze(_s(Vi), p.Overload_signatures_must_all_be_ambient_or_non_ambient) : jo & 6 ? ze(_s(Vi) || Vi, p.Overload_signatures_must_all_be_public_private_or_protected) : jo & 64 && ze(_s(Vi), p.Overload_signatures_must_all_be_abstract_or_non_abstract); + } + }); + } + } + function f(or, ir, nn, Qn) { + if (nn !== Qn) { + const Ri = yx(a(or, ir)); + lr(or, (zn) => { + yx(zn) !== Ri && ze(_s(zn), p.Overload_signatures_must_all_be_optional_or_required); + }); + } + } + const d = 230; + let y = 0, x = d, I = !1, J = !0, z = !1, G, ve, de; + const We = r.declarations, lt = (r.flags & 16384) !== 0; + function gt(or) { + if (or.name && lc(or.name)) + return; + let ir = !1; + const nn = xs(or.parent, (Ri) => { + if (ir) + return Ri; + ir = Ri === or; + }); + if (nn && nn.pos === or.end && nn.kind === or.kind) { + const Ri = nn.name || nn, zn = nn.name; + if (or.name && zn && // both are private identifiers + (Ai(or.name) && Ai(zn) && or.name.escapedText === zn.escapedText || // Both are computed property names + Gs(or.name) && Gs(zn) && lh(Td(or.name), Td(zn)) || // Both are literal property names that are the same. + um(or.name) && um(zn) && XD(or.name) === XD(zn))) { + if ((or.kind === 175 || or.kind === 174) && Js(or) !== Js(nn)) { + const ks = Js(or) ? p.Function_overload_must_be_static : p.Function_overload_must_not_be_static; + ze(Ri, ks); + } + return; + } + if (Mp(nn.body)) { + ze(Ri, p.Function_implementation_name_must_be_0, co(or.name)); + return; + } + } + const Qn = or.name || or; + lt ? ze(Qn, p.Constructor_implementation_is_missing) : Gn( + or, + 64 + /* Abstract */ + ) ? ze(Qn, p.All_declarations_of_an_abstract_method_must_be_consecutive) : ze(Qn, p.Function_implementation_is_missing_or_not_immediately_following_the_declaration); + } + let jt = !1, ar = !1, jr = !1; + const Kr = []; + if (We) + for (const or of We) { + const ir = or, nn = ir.flags & 33554432, Qn = ir.parent && (ir.parent.kind === 265 || ir.parent.kind === 188) || nn; + if (Qn && (de = void 0), (ir.kind === 264 || ir.kind === 232) && !nn && (jr = !0), ir.kind === 263 || ir.kind === 175 || ir.kind === 174 || ir.kind === 177) { + Kr.push(ir); + const Ri = FI(ir, d); + y |= Ri, x &= Ri, I = I || yx(ir), J = J && yx(ir); + const zn = Mp(ir.body); + zn && G ? lt ? ar = !0 : jt = !0 : de?.parent === ir.parent && de.end !== ir.pos && gt(de), zn ? G || (G = ir) : z = !0, de = ir, Qn || (ve = ir); + } + an(or) && Es(or) && or.jsDoc && (z = wr(IB(or)) > 0); + } + if (ar && lr(Kr, (or) => { + ze(or, p.Multiple_constructor_implementations_are_not_allowed); + }), jt && lr(Kr, (or) => { + ze(_s(or) || or, p.Duplicate_function_implementation); + }), jr && !lt && r.flags & 16 && We) { + const or = kn( + We, + (ir) => ir.kind === 264 + /* ClassDeclaration */ + ).map((ir) => sn(ir, p.Consider_adding_a_declare_modifier_to_this_class)); + lr(We, (ir) => { + const nn = ir.kind === 264 ? p.Class_declaration_cannot_implement_overload_list_for_0 : ir.kind === 263 ? p.Function_with_bodies_can_only_merge_with_classes_that_are_ambient : void 0; + nn && zs( + ze(_s(ir) || ir, nn, cc(r)), + ...or + ); + }); + } + if (ve && !ve.body && !Gn( + ve, + 64 + /* Abstract */ + ) && !ve.questionToken && gt(ve), z && (We && (l(We, G, d, y, x), f(We, G, I, J)), G)) { + const or = I2(r), ir = Xf(G); + for (const nn of or) + if (!dnt(ir, nn)) { + const Qn = nn.declaration && w0(nn.declaration) ? nn.declaration.parent.tagName : nn.declaration; + zs( + ze(Qn, p.This_overload_signature_is_not_compatible_with_its_implementation_signature), + sn(G, p.The_implementation_signature_is_declared_here) + ); + break; + } + } + } + function OI(r) { + n(() => plt(r)); + } + function plt(r) { + let a = r.localSymbol; + if (!a && (a = yn(r), !a.exportSymbol) || Oo(a, r.kind) !== r) + return; + let l = 0, f = 0, d = 0; + for (const z of a.declarations) { + const G = J(z), ve = FI( + z, + 2080 + /* Default */ + ); + ve & 32 ? ve & 2048 ? d |= G : l |= G : f |= G; + } + const y = l | f, x = l & f, I = d & y; + if (x || I) + for (const z of a.declarations) { + const G = J(z), ve = _s(z); + G & I ? ze(ve, p.Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead, co(ve)) : G & x && ze(ve, p.Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local, co(ve)); + } + function J(z) { + let G = z; + switch (G.kind) { + case 265: + case 266: + // A jsdoc typedef and callback are, by definition, type aliases. + // falls through + case 347: + case 339: + case 341: + return 2; + case 268: + return Vu(G) || Ah(G) !== 0 ? 5 : 4; + case 264: + case 267: + case 307: + return 3; + case 308: + return 7; + case 278: + case 227: + const ve = G, de = Mo(ve) ? ve.expression : ve.right; + if (!to(de)) + return 1; + G = de; + // The below options all declare an Alias, which is allowed to merge with other values within the importing module. + // falls through + case 272: + case 275: + case 274: + let We = 0; + const lt = Rl(yn(G)); + return lr(lt.declarations, (gt) => { + We |= J(gt); + }), We; + case 261: + case 209: + case 263: + case 277: + // https://github.com/Microsoft/TypeScript/pull/7591 + case 80: + return 1; + case 174: + case 172: + return 2; + default: + return E.failBadSyntaxKind(G); + } + } + } + function DP(r, a, l, ...f) { + const d = LI(r, a); + return d && _C(d, a, l, ...f); + } + function LI(r, a, l) { + if (gn(r)) + return; + const f = r; + if (f.promisedTypeOfPromise) + return f.promisedTypeOfPromise; + if (hf(r, sM( + /*reportErrors*/ + !1 + ))) + return f.promisedTypeOfPromise = Ao(r)[0]; + if (AI( + Rm(r), + 402915324 + /* Never */ + )) + return; + const d = rr(r, "then"); + if (gn(d)) + return; + const y = d ? Is( + d, + 0 + /* Call */ + ) : Ge; + if (y.length === 0) { + a && ze(a, p.A_promise_must_have_a_then_method); + return; + } + let x, I; + for (const G of y) { + const ve = tb(G); + ve && ve !== _r && !Bm(r, ve, cg) ? x = ve : I = Er(I, G); + } + if (!I) { + E.assertIsDefined(x), l && (l.value = x), a && ze(a, p.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1, Wr(r), Wr(x)); + return; + } + const J = Dp( + Xn(hr(I, ome)), + 2097152 + /* NEUndefinedOrNull */ + ); + if (gn(J)) + return; + const z = Is( + J, + 0 + /* Call */ + ); + if (z.length === 0) { + a && ze(a, p.The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback); + return; + } + return f.promisedTypeOfPromise = Xn( + hr(z, ome), + 2 + /* Subtype */ + ); + } + function nR(r, a, l, f, ...d) { + return (a ? _C(r, l, f, ...d) : a0(r, l, f, ...d)) || qe; + } + function c7e(r) { + if (AI( + Rm(r), + 402915324 + /* Never */ + )) + return !1; + const a = rr(r, "then"); + return !!a && Is( + Dp( + a, + 2097152 + /* NEUndefinedOrNull */ + ), + 0 + /* Call */ + ).length > 0; + } + function kX(r) { + var a; + if (r.flags & 16777216) { + const l = ipe( + /*reportErrors*/ + !1 + ); + return !!l && r.aliasSymbol === l && ((a = r.aliasTypeArguments) == null ? void 0 : a.length) === 1; + } + return !1; + } + function wP(r) { + return r.flags & 1048576 ? Go(r, wP) : kX(r) ? r.aliasTypeArguments[0] : r; + } + function l7e(r) { + if (gn(r) || kX(r)) + return !1; + if (NT(r)) { + const a = ou(r); + if (a ? a.flags & 3 || t0(a) || wp(a, c7e) : Dc( + r, + 8650752 + /* TypeVariable */ + )) + return !0; + } + return !1; + } + function dlt(r) { + const a = ipe( + /*reportErrors*/ + !0 + ); + if (a) + return OE(a, [wP(r)]); + } + function mlt(r) { + return l7e(r) ? dlt(r) ?? r : (E.assert(kX(r) || LI(r) === void 0, "type provided should not be a non-generic 'promise'-like."), r); + } + function _C(r, a, l, ...f) { + const d = a0(r, a, l, ...f); + return d && mlt(d); + } + function a0(r, a, l, ...f) { + if (gn(r) || kX(r)) + return r; + const d = r; + if (d.awaitedTypeOfType) + return d.awaitedTypeOfType; + if (r.flags & 1048576) { + if (c1.lastIndexOf(r.id) >= 0) { + a && ze(a, p.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method); + return; + } + const I = a ? (z) => a0(z, a, l, ...f) : a0; + c1.push(r.id); + const J = Go(r, I); + return c1.pop(), d.awaitedTypeOfType = J; + } + if (l7e(r)) + return d.awaitedTypeOfType = r; + const y = { value: void 0 }, x = LI( + r, + /*errorNode*/ + void 0, + y + ); + if (x) { + if (r.id === x.id || c1.lastIndexOf(x.id) >= 0) { + a && ze(a, p.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method); + return; + } + c1.push(r.id); + const I = a0(x, a, l, ...f); + return c1.pop(), I ? d.awaitedTypeOfType = I : void 0; + } + if (c7e(r)) { + if (a) { + E.assertIsDefined(l); + let I; + y.value && (I = Ts(I, p.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1, Wr(r), Wr(y.value))), I = Ts(I, l, ...f), Aa.add(Fg(xr(a), a, I)); + } + return; + } + return d.awaitedTypeOfType = r; + } + function glt(r, a, l) { + const f = Ci(a); + if (R >= 2) { + if (Gr(f)) + return; + const y = sM( + /*reportErrors*/ + !0 + ); + if (y !== zt && !hf(f, y)) { + d(p.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0, a, l, Wr(a0(f) || _r)); + return; + } + } else { + if (cC( + r, + 5 + /* AsyncFunction */ + ), Gr(f)) + return; + const y = I3(a); + if (y === void 0) { + d(p.Type_0_is_not_a_valid_async_function_return_type_in_ES5_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, a, l, Wr(f)); + return; + } + const x = dc( + y, + 111551, + /*ignoreErrors*/ + !0 + ), I = x ? Yr(x) : qe; + if (Gr(I)) { + y.kind === 80 && y.escapedText === "Promise" && Cr(f) === sM( + /*reportErrors*/ + !1 + ) ? ze(l, p.An_async_function_or_method_in_ES5_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option) : d(p.Type_0_is_not_a_valid_async_function_return_type_in_ES5_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, a, l, ef(y)); + return; + } + const J = ktt( + /*reportErrors*/ + !0 + ); + if (J === ta) { + d(p.Type_0_is_not_a_valid_async_function_return_type_in_ES5_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, a, l, ef(y)); + return; + } + const z = p.Type_0_is_not_a_valid_async_function_return_type_in_ES5_because_it_does_not_refer_to_a_Promise_compatible_constructor_value; + if (!xu(I, J, l, z, () => a === l ? void 0 : Ts( + /*details*/ + void 0, + p.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type + ))) + return; + const ve = y && i_(y), de = Xl( + r.locals, + ve.escapedText, + 111551 + /* Value */ + ); + if (de) { + ze(de.valueDeclaration, p.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions, An(ve), ef(y)); + return; + } + } + nR( + f, + /*withAlias*/ + !1, + r, + p.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member + ); + function d(y, x, I, J) { + if (x === I) + ze(I, y, J); + else { + const z = ze(I, p.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type); + zs(z, sn(x, y, J)); + } + } + } + function hlt(r) { + const a = xr(r); + if (!F1(a)) { + let l = r.expression; + if (o_(l)) + return !1; + let f = !0, d; + for (; ; ) { + if (Dh(l) || $x(l)) { + l = l.expression; + continue; + } + if (Ps(l)) { + f || (d = l), l.questionDotToken && (d = l.questionDotToken), l = l.expression, f = !1; + continue; + } + if (wn(l)) { + l.questionDotToken && (d = l.questionDotToken), l = l.expression, f = !1; + continue; + } + Me(l) || (d = l); + break; + } + if (d) + return zs( + ze(r.expression, p.Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator), + sn(d, p.Invalid_syntax_in_decorator) + ), !0; + } + return !1; + } + function ylt(r) { + hlt(r); + const a = qE(r); + mX(a, r); + const l = Wa(a); + if (l.flags & 1) + return; + const f = ume(r); + if (!f?.resolvedReturnType) return; + let d; + const y = f.resolvedReturnType; + switch (r.parent.kind) { + case 264: + case 232: + d = p.Decorator_function_return_type_0_is_not_assignable_to_type_1; + break; + case 173: + if (!U) { + d = p.Decorator_function_return_type_0_is_not_assignable_to_type_1; + break; + } + // falls through + case 170: + d = p.Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any; + break; + case 175: + case 178: + case 179: + d = p.Decorator_function_return_type_0_is_not_assignable_to_type_1; + break; + default: + return E.failBadSyntaxKind(r.parent); + } + xu(l, y, r.expression, d); + } + function MI(r, a, l, f, d, y = l.length, x = 0) { + const I = N.createFunctionTypeNode( + /*typeParameters*/ + void 0, + Ge, + N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ) + ); + return Mm(I, r, a, l, f, d, y, x); + } + function kme(r, a, l, f, d, y, x) { + const I = MI(r, a, l, f, d, y, x); + return ET(I); + } + function u7e(r) { + return kme( + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + Ge, + r + ); + } + function _7e(r) { + const a = Vf("value", r); + return kme( + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + [a], + _r + ); + } + function Cme(r) { + if (r) + switch (r.kind) { + case 194: + case 193: + return f7e(r.types); + case 195: + return f7e([r.trueType, r.falseType]); + case 197: + case 203: + return Cme(r.type); + case 184: + return r.typeName; + } + } + function f7e(r) { + let a; + for (let l of r) { + for (; l.kind === 197 || l.kind === 203; ) + l = l.type; + if (l.kind === 146 || !K && (l.kind === 202 && l.literal.kind === 106 || l.kind === 157)) + continue; + const f = Cme(l); + if (!f) + return; + if (a) { + if (!Me(a) || !Me(f) || a.escapedText !== f.escapedText) + return; + } else + a = f; + } + return a; + } + function CX(r) { + const a = Kc(r); + return Hm(r) ? SB(a) : a; + } + function iR(r) { + if (!e2(r) || !Ff(r) || !r.modifiers || !F3(U, r, r.parent, r.parent.parent)) + return; + const a = Nn(r.modifiers, ul); + if (a) { + U ? (xl( + a, + 8 + /* Decorate */ + ), r.kind === 170 && xl( + a, + 32 + /* Param */ + )) : R < El.ClassAndClassElementDecorators && (xl( + a, + 8 + /* ESDecorateAndRunInitializers */ + ), tl(r) ? r.name ? O7e(r) && xl( + a, + 4194304 + /* SetFunctionName */ + ) : xl( + a, + 4194304 + /* SetFunctionName */ + ) : Rc(r) || (Ai(r.name) && (rc(r) || Dy(r) || b_(r)) && xl( + a, + 4194304 + /* SetFunctionName */ + ), Gs(r.name) && xl( + a, + 8388608 + /* PropKey */ + ))), cC( + r, + 8 + /* Decorator */ + ); + for (const l of r.modifiers) + ul(l) && ylt(l); + } + } + function vlt(r) { + n(a); + function a() { + d7e(r), Qme(r), PP(r, r.name); + } + } + function blt(r) { + r.typeExpression || ze(r.name, p.JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags), r.name && NP(r.name, p.Type_alias_name_cannot_be_0), la(r.typeExpression), uR(xy(r)); + } + function Slt(r) { + la(r.constraint); + for (const a of r.typeParameters) + la(a); + } + function Tlt(r) { + la(r.typeExpression); + } + function xlt(r) { + la(r.typeExpression); + const a = X1(r); + if (a) { + const l = S7(a, MF); + if (wr(l) > 1) + for (let f = 1; f < wr(l); f++) { + const d = l[f].tagName; + ze(d, p._0_tag_already_specified, An(d)); + } + } + } + function klt(r) { + r.name && fR( + r.name, + /*ignoreErrors*/ + !0 + ); + } + function Clt(r) { + la(r.typeExpression); + } + function Elt(r) { + la(r.typeExpression); + } + function Dlt(r) { + n(a), II(r); + function a() { + !r.type && !vx(r) && cb(r, Le); + } + } + function wlt(r) { + const a = X1(r); + a && xo(a) && ze(r.tagName, p.An_arrow_function_cannot_have_a_this_parameter); + } + function Plt(r) { + Bme(r); + } + function Nlt(r) { + const a = X1(r); + (!a || !tl(a) && !Rc(a)) && ze(a, p.JSDoc_0_is_not_attached_to_a_class, An(r.tagName)); + } + function Alt(r) { + const a = X1(r); + if (!a || !tl(a) && !Rc(a)) { + ze(a, p.JSDoc_0_is_not_attached_to_a_class, An(r.tagName)); + return; + } + const l = W1(a).filter(Yx); + E.assert(l.length > 0), l.length > 1 && ze(l[1], p.Class_declarations_cannot_have_more_than_one_augments_or_extends_tag); + const f = p7e(r.class.expression), d = Lb(a); + if (d) { + const y = p7e(d.expression); + y && f.escapedText !== y.escapedText && ze(f, p.JSDoc_0_1_does_not_match_the_extends_2_clause, An(r.tagName), An(f), An(y)); + } + } + function Ilt(r) { + const a = Fb(r); + a && Du(a) && ze(r, p.An_accessibility_modifier_cannot_be_used_with_a_private_identifier); + } + function p7e(r) { + switch (r.kind) { + case 80: + return r; + case 212: + return r.name; + default: + return; + } + } + function d7e(r) { + var a; + iR(r), II(r); + const l = Mc(r); + if (r.name && r.name.kind === 168 && Td(r.name), NE(r)) { + const y = yn(r), x = r.localSymbol || y, I = (a = x.declarations) == null ? void 0 : a.find( + // Get first non javascript function declaration + (J) => J.kind === r.kind && !(J.flags & 524288) + ); + r === I && xX(x), y.parent && xX(y); + } + const f = r.kind === 174 ? void 0 : r.body; + if (la(f), fme(r, IE(r)), n(d), an(r)) { + const y = z1(r); + y && y.typeExpression && !Ide(Ci(y.typeExpression), r) && ze(y.typeExpression.type, p.The_type_of_a_function_declaration_must_match_the_function_s_signature); + } + function d() { + nf(r) || (lc(f) && !rR(r) && cb(r, Le), l & 1 && Mp(f) && Wa(Xf(r))); + } + } + function A1(r) { + n(a); + function a() { + const l = xr(r); + let f = Or.get(l.path); + f || (f = [], Or.set(l.path, f)), f.push(r); + } + } + function m7e(r, a) { + for (const l of r) + switch (l.kind) { + case 264: + case 232: + Flt(l, a), Eme(l, a); + break; + case 308: + case 268: + case 242: + case 270: + case 249: + case 250: + case 251: + y7e(l, a); + break; + case 177: + case 219: + case 263: + case 220: + case 175: + case 178: + case 179: + l.body && y7e(l, a), Eme(l, a); + break; + case 174: + case 180: + case 181: + case 185: + case 186: + case 266: + case 265: + Eme(l, a); + break; + case 196: + Olt(l, a); + break; + default: + E.assertNever(l, "Node should not have been registered for unused identifiers check"); + } + } + function g7e(r, a, l) { + const f = _s(r) || r, d = Fx(r) ? p._0_is_declared_but_never_used : p._0_is_declared_but_its_value_is_never_read; + l(r, 0, sn(f, d, a)); + } + function RI(r) { + return Me(r) && An(r).charCodeAt(0) === 95; + } + function Flt(r, a) { + for (const l of r.members) + switch (l.kind) { + case 175: + case 173: + case 178: + case 179: + if (l.kind === 179 && l.symbol.flags & 32768) + break; + const f = yn(l); + !f.isReferenced && (sf( + l, + 2 + /* Private */ + ) || wl(l) && Ai(l.name)) && !(l.flags & 33554432) && a(l, 0, sn(l.name, p._0_is_declared_but_its_value_is_never_read, Wi(f))); + break; + case 177: + for (const d of l.parameters) + !d.symbol.isReferenced && Gn( + d, + 2 + /* Private */ + ) && a(d, 0, sn(d.name, p.Property_0_is_declared_but_its_value_is_never_read, cc(d.symbol))); + break; + case 182: + case 241: + case 176: + break; + default: + E.fail("Unexpected class member"); + } + } + function Olt(r, a) { + const { typeParameter: l } = r; + Dme(l) && a(r, 1, sn(r, p._0_is_declared_but_its_value_is_never_read, An(l.name))); + } + function Eme(r, a) { + const l = yn(r).declarations; + if (!l || pa(l) !== r) return; + const f = xy(r), d = /* @__PURE__ */ new Set(); + for (const y of f) { + if (!Dme(y)) continue; + const x = An(y.name), { parent: I } = y; + if (I.kind !== 196 && I.typeParameters.every(Dme)) { + if (u0(d, I)) { + const J = xr(I), z = Up(I) ? RJ(I) : jJ(J, I.typeParameters), ve = I.typeParameters.length === 1 ? [p._0_is_declared_but_its_value_is_never_read, x] : [p.All_type_parameters_are_unused]; + a(y, 1, ll(J, z.pos, z.end - z.pos, ...ve)); + } + } else + a(y, 1, sn(y, p._0_is_declared_but_its_value_is_never_read, x)); + } + } + function Dme(r) { + return !(Oa(r.symbol).isReferenced & 262144) && !RI(r.name); + } + function sR(r, a, l, f) { + const d = String(f(a)), y = r.get(d); + y ? y[1].push(l) : r.set(d, [a, [l]]); + } + function h7e(r) { + return Bn(_m(r), Ii); + } + function Llt(r) { + return ya(r) ? Of(r.parent) ? !!(r.propertyName && RI(r.name)) : RI(r.name) : Vu(r) || (ei(r) && nS(r.parent.parent) || v7e(r)) && RI(r.name); + } + function y7e(r, a) { + const l = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(); + r.locals.forEach((y) => { + if (!(y.flags & 262144 ? !(y.flags & 3 && !(y.isReferenced & 3)) : y.isReferenced || y.exportSymbol) && y.declarations) { + for (const x of y.declarations) + if (!Llt(x)) + if (v7e(x)) + sR(l, Rlt(x), x, Ma); + else if (ya(x) && Of(x.parent)) { + const I = pa(x.parent.elements); + (x === I || !pa(x.parent.elements).dotDotDotToken) && sR(f, x.parent, x, Ma); + } else if (ei(x)) { + const I = U2(x) & 7, J = _s(x); + (I !== 4 && I !== 6 || !J || !RI(J)) && sR(d, x.parent, x, Ma); + } else { + const I = y.valueDeclaration && h7e(y.valueDeclaration), J = y.valueDeclaration && _s(y.valueDeclaration); + I && J ? !K_(I, I.parent) && !My(I) && !RI(J) && (ya(x) && D0(x.parent) ? sR(f, x.parent, x, Ma) : a(I, 1, sn(J, p._0_is_declared_but_its_value_is_never_read, cc(y)))) : g7e(x, cc(y), a); + } + } + }), l.forEach(([y, x]) => { + const I = y.parent; + if ((y.name ? 1 : 0) + (y.namedBindings ? y.namedBindings.kind === 275 ? 1 : y.namedBindings.elements.length : 0) === x.length) + a( + I, + 0, + x.length === 1 ? sn(I, p._0_is_declared_but_its_value_is_never_read, An(Ca(x).name)) : sn(I, p.All_imports_in_import_declaration_are_unused) + ); + else + for (const z of x) g7e(z, An(z.name), a); + }), f.forEach(([y, x]) => { + const I = h7e(y.parent) ? 1 : 0; + if (y.elements.length === x.length) + x.length === 1 && y.parent.kind === 261 && y.parent.parent.kind === 262 ? sR(d, y.parent.parent, y.parent, Ma) : a( + y, + I, + x.length === 1 ? sn(y, p._0_is_declared_but_its_value_is_never_read, aR(Ca(x).name)) : sn(y, p.All_destructured_elements_are_unused) + ); + else + for (const J of x) + a(J, I, sn(J, p._0_is_declared_but_its_value_is_never_read, aR(J.name))); + }), d.forEach(([y, x]) => { + if (y.declarations.length === x.length) + a( + y, + 0, + x.length === 1 ? sn(Ca(x).name, p._0_is_declared_but_its_value_is_never_read, aR(Ca(x).name)) : sn(y.parent.kind === 244 ? y.parent : y, p.All_variables_are_unused) + ); + else + for (const I of x) + a(I, 0, sn(I, p._0_is_declared_but_its_value_is_never_read, aR(I.name))); + }); + } + function Mlt() { + var r; + for (const a of zh) + if (!((r = yn(a)) != null && r.isReferenced)) { + const l = Y2(a); + E.assert(Y1(l), "Only parameter declaration should be checked here"); + const f = sn(a.name, p._0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation, co(a.name), co(a.propertyName)); + l.type || zs( + f, + ll(xr(l), l.end, 0, p.We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here, co(a.propertyName)) + ), Aa.add(f); + } + } + function aR(r) { + switch (r.kind) { + case 80: + return An(r); + case 208: + case 207: + return aR(Us(Ca(r.elements), ya).name); + default: + return E.assertNever(r); + } + } + function v7e(r) { + return r.kind === 274 || r.kind === 277 || r.kind === 275; + } + function Rlt(r) { + return r.kind === 274 ? r : r.kind === 275 ? r.parent : r.parent.parent; + } + function EX(r) { + if (r.kind === 242 && o0(r), Vj(r)) { + const a = hi; + lr(r.statements, la), hi = a; + } else + lr(r.statements, la); + r.locals && A1(r); + } + function jlt(r) { + R >= 2 || !Zj(r) || r.flags & 33554432 || lc(r.body) || lr(r.parameters, (a) => { + a.name && !ws(a.name) && a.name.escapedText === ie.escapedName && B0("noEmit", a, p.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters); + }); + } + function jI(r, a, l) { + if (a?.escapedText !== l || r.kind === 173 || r.kind === 172 || r.kind === 175 || r.kind === 174 || r.kind === 178 || r.kind === 179 || r.kind === 304 || r.flags & 33554432 || (ld(r) || _l(r) || Xu(r)) && p0(r)) + return !1; + const f = _m(r); + return !(Ii(f) && lc(f.parent.body)); + } + function Blt(r) { + dr(r, (a) => dC(a) & 4 ? (r.kind !== 80 ? ze(_s(r), p.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference) : ze(r, p.Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference), !0) : !1); + } + function Jlt(r) { + dr(r, (a) => dC(a) & 8 ? (r.kind !== 80 ? ze(_s(r), p.Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_meta_property_reference) : ze(r, p.Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta_property_reference), !0) : !1); + } + function zlt(r, a) { + if (e.getEmitModuleFormatOfFile(xr(r)) >= 5 || !a || !jI(r, a, "require") && !jI(r, a, "exports") || jc(r) && Ah(r) !== 1) + return; + const l = bt(r); + l.kind === 308 && tf(l) && B0("noEmit", a, p.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module, co(a), co(a)); + } + function Wlt(r, a) { + if (!a || R >= 4 || !jI(r, a, "Promise") || jc(r) && Ah(r) !== 1) + return; + const l = bt(r); + l.kind === 308 && tf(l) && l.flags & 4096 && B0("noEmit", a, p.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions, co(a), co(a)); + } + function Ult(r, a) { + R <= 8 && (jI(r, a, "WeakMap") || jI(r, a, "WeakSet")) && Bh.push(r); + } + function Vlt(r) { + const a = Dd(r); + dC(a) & 1048576 && (E.assert(wl(r) && Me(r.name) && typeof r.name.escapedText == "string", "The target of a WeakMap/WeakSet collision check should be an identifier"), B0("noEmit", r, p.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel, r.name.escapedText)); + } + function qlt(r, a) { + a && R >= 2 && R <= 8 && jI(r, a, "Reflect") && Jh.push(r); + } + function Hlt(r) { + let a = !1; + if (Rc(r)) { + for (const l of r.members) + if (dC(l) & 2097152) { + a = !0; + break; + } + } else if (yo(r)) + dC(r) & 2097152 && (a = !0); + else { + const l = Dd(r); + l && dC(l) & 2097152 && (a = !0); + } + a && (E.assert(wl(r) && Me(r.name), "The target of a Reflect collision check should be an identifier"), B0("noEmit", r, p.Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializers, co(r.name), "Reflect")); + } + function PP(r, a) { + a && (zlt(r, a), Wlt(r, a), Ult(r, a), qlt(r, a), $n(r) ? (NP(a, p.Class_name_cannot_be_0), r.flags & 33554432 || Tut(a)) : ov(r) && NP(a, p.Enum_name_cannot_be_0)); + } + function Glt(r) { + if ((U2(r) & 7) !== 0 || Y1(r)) + return; + const a = yn(r); + if (a.flags & 1) { + if (!Me(r.name)) return E.fail(); + const l = st( + r, + r.name.escapedText, + 3, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + ); + if (l && l !== a && l.flags & 2 && Lde(l) & 7) { + const f = Q1( + l.valueDeclaration, + 262 + /* VariableDeclarationList */ + ), d = f.parent.kind === 244 && f.parent.parent ? f.parent.parent : void 0; + if (!(d && (d.kind === 242 && Es(d.parent) || d.kind === 269 || d.kind === 268 || d.kind === 308))) { + const x = Wi(l); + ze(r, p.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, x, x); + } + } + } + } + function BI(r) { + return r === mt ? Le : r === Ol ? Gl : r; + } + function oR(r) { + var a; + if (iR(r), ya(r) || la(r.type), !r.name) + return; + if (r.name.kind === 168 && (Td(r.name), iS(r) && r.initializer && mc(r.initializer)), ya(r)) { + if (r.propertyName && Me(r.name) && Y1(r) && lc(Af(r).body)) { + zh.push(r); + return; + } + Of(r.parent) && r.dotDotDotToken && R < El.ObjectSpreadRest && xl( + r, + 4 + /* Rest */ + ), r.propertyName && r.propertyName.kind === 168 && Td(r.propertyName); + const d = r.parent.parent, y = r.dotDotDotToken ? 32 : 0, x = ii(d, y), I = r.propertyName || r.name; + if (x && !ws(I)) { + const J = Yh(I); + if (_p(J)) { + const z = fp(J), G = Ys(x, z); + G && (UM( + G, + /*nodeForCheckWriteOnly*/ + void 0, + /*isSelfTypeAccess*/ + !1 + ), Rde( + r, + !!d.initializer && d.initializer.kind === 108, + /*writing*/ + !1, + x, + G + )); + } + } + } + if (ws(r.name) && (r.name.kind === 208 && R < El.BindingPatterns && F.downlevelIteration && xl( + r, + 512 + /* Read */ + ), lr(r.name.elements, la)), r.initializer && Y1(r) && lc(Af(r).body)) { + ze(r, p.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation); + return; + } + if (ws(r.name)) { + if (ode(r)) + return; + const d = iS(r) && r.initializer && r.parent.parent.kind !== 250, y = !ot(r.name.elements, KI(vl)); + if (d || y) { + const x = Yk(r); + if (d) { + const I = mc(r.initializer); + K && y ? J8e(I, r) : j2(I, Yk(r), r, r.initializer); + } + y && (D0(r.name) ? ay(65, x, ue, r) : K && J8e(x, r)); + } + return; + } + const l = yn(r); + if (l.flags & 2097152 && (Ab(r) || EK(r))) { + OX(r); + return; + } + r.name.kind === 10 && ze(r.name, p.A_bigint_literal_cannot_be_used_as_a_property_name); + const f = BI(Yr(l)); + if (r === l.valueDeclaration) { + const d = iS(r) && j3(r); + if (d && !(an(r) && _a(d) && (d.properties.length === 0 || jy(r.name)) && !!((a = l.exports) != null && a.size)) && r.parent.parent.kind !== 250) { + const x = mc(d); + j2( + x, + f, + r, + d, + /*headMessage*/ + void 0 + ); + const I = U2(r) & 7; + if (I === 6) { + const J = Ltt( + /*reportErrors*/ + !0 + ), z = Q3e( + /*reportErrors*/ + !0 + ); + if (J !== ta && z !== ta) { + const G = Xn([J, z, Mt, ue]); + xu(G8(x, r), G, d, p.The_initializer_of_an_await_using_declaration_must_be_either_an_object_with_a_Symbol_asyncDispose_or_Symbol_dispose_method_or_be_null_or_undefined); + } + } else if (I === 4) { + const J = Q3e( + /*reportErrors*/ + !0 + ); + if (J !== ta) { + const z = Xn([J, Mt, ue]); + xu(G8(x, r), z, d, p.The_initializer_of_a_using_declaration_must_be_either_an_object_with_a_Symbol_dispose_method_or_be_null_or_undefined); + } + } + } + l.declarations && l.declarations.length > 1 && ot(l.declarations, (y) => y !== r && OD(y) && !S7e(y, r)) && ze(r.name, p.All_declarations_of_0_must_have_identical_modifiers, co(r.name)); + } else { + const d = BI(Yk(r)); + !Gr(f) && !Gr(d) && !lh(f, d) && !(l.flags & 67108864) && b7e(l.valueDeclaration, f, r, d), iS(r) && r.initializer && j2( + mc(r.initializer), + d, + r, + r.initializer, + /*headMessage*/ + void 0 + ), l.valueDeclaration && !S7e(r, l.valueDeclaration) && ze(r.name, p.All_declarations_of_0_must_have_identical_modifiers, co(r.name)); + } + r.kind !== 173 && r.kind !== 172 && (OI(r), (r.kind === 261 || r.kind === 209) && Glt(r), PP(r, r.name)); + } + function b7e(r, a, l, f) { + const d = _s(l), y = l.kind === 173 || l.kind === 172 ? p.Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2 : p.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2, x = co(d), I = ze( + d, + y, + x, + Wr(a), + Wr(f) + ); + r && zs(I, sn(r, p._0_was_also_declared_here, x)); + } + function S7e(r, a) { + if (r.kind === 170 && a.kind === 261 || r.kind === 261 && a.kind === 170) + return !0; + if (yx(r) !== yx(a)) + return !1; + const l = 1358; + return xx(r, l) === xx(a, l); + } + function $lt(r) { + var a, l; + (a = on) == null || a.push(on.Phase.Check, "checkVariableDeclaration", { kind: r.kind, pos: r.pos, end: r.end, path: r.tracingPath }), Pft(r), oR(r), (l = on) == null || l.pop(); + } + function Xlt(r) { + return Eft(r), oR(r); + } + function DX(r) { + const a = yh(r) & 7; + (a === 4 || a === 6) && R < El.UsingAndAwaitUsing && xl( + r, + 16777216 + /* AddDisposableResourceAndDisposeResources */ + ), lr(r.declarations, la); + } + function Qlt(r) { + !fh(r) && !Kme(r.declarationList) && Nft(r), DX(r.declarationList); + } + function Ylt(r) { + o0(r), Hi(r.expression); + } + function Zlt(r) { + o0(r); + const a = JI(r.expression); + wme(r.expression, a, r.thenStatement), la(r.thenStatement), r.thenStatement.kind === 243 && ze(r.thenStatement, p.The_body_of_an_if_statement_cannot_be_the_empty_statement), la(r.elseStatement); + } + function wme(r, a, l) { + if (!K) return; + f(r, l); + function f(y, x) { + for (y = Ba(y), d(y, x); _n(y) && (y.operatorToken.kind === 57 || y.operatorToken.kind === 61); ) + y = Ba(y.left), d(y, x); + } + function d(y, x) { + const I = sN(y) ? Ba(y.right) : y; + if (Lg(I)) + return; + if (sN(I)) { + f(I, x); + return; + } + const J = I === y ? a : Hi(I); + if (J.flags & 1024 && wn(I) && (xn(I.expression).resolvedSymbol ?? Y).flags & 384) { + ze(I, p.This_condition_will_always_return_0, J.value ? "true" : "false"); + return; + } + const z = wn(I) && VIe(I.expression); + if (!Yd( + J, + 4194304 + /* Truthy */ + ) || z) return; + const G = Is( + J, + 0 + /* Call */ + ), ve = !!DP(J); + if (G.length === 0 && !ve) + return; + const de = Me(I) ? I : wn(I) ? I.name : void 0, We = de && Pp(de); + if (!We && !ve) + return; + We && _n(y.parent) && eut(y.parent, We) || We && x && Klt(y, x, de, We) || (ve ? J0( + I, + /*maybeMissingAwait*/ + !0, + p.This_condition_will_always_return_true_since_this_0_is_always_defined, + kE(J) + ) : ze(I, p.This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead)); + } + } + function Klt(r, a, l, f) { + return !!xs(a, function d(y) { + if (Me(y)) { + const x = Pp(y); + if (x && x === f) { + if (Me(r) || Me(l) && _n(l.parent)) + return !0; + let I = l.parent, J = y.parent; + for (; I && J; ) { + if (Me(I) && Me(J) || I.kind === 110 && J.kind === 110) + return Pp(I) === Pp(J); + if (wn(I) && wn(J)) { + if (Pp(I.name) !== Pp(J.name)) + return !1; + J = J.expression, I = I.expression; + } else if (Ps(I) && Ps(J)) + J = J.expression, I = I.expression; + else + return !1; + } + } + } + return xs(y, d); + }); + } + function eut(r, a) { + for (; _n(r) && r.operatorToken.kind === 56; ) { + if (xs(r.right, function f(d) { + if (Me(d)) { + const y = Pp(d); + if (y && y === a) + return !0; + } + return xs(d, f); + })) + return !0; + r = r.parent; + } + return !1; + } + function tut(r) { + o0(r), la(r.statement), JI(r.expression); + } + function rut(r) { + o0(r), JI(r.expression), la(r.statement); + } + function Pme(r, a) { + if (r.flags & 16384) + ze(a, p.An_expression_of_type_void_cannot_be_tested_for_truthiness); + else { + const l = Nme(a); + l !== 3 && ze( + a, + l === 1 ? p.This_kind_of_expression_is_always_truthy : p.This_kind_of_expression_is_always_falsy + ); + } + return r; + } + function Nme(r) { + switch (r = hc(r), r.kind) { + case 9: + return r.text === "0" || r.text === "1" ? 3 : 1; + case 210: + case 220: + case 10: + case 232: + case 219: + case 285: + case 286: + case 211: + case 14: + return 1; + case 223: + case 106: + return 2; + case 15: + case 11: + return r.text ? 1 : 2; + case 228: + return Nme(r.whenTrue) | Nme(r.whenFalse); + case 80: + return ju(r) === ne ? 2 : 3; + } + return 3; + } + function JI(r, a) { + return Pme(Hi(r, a), r); + } + function nut(r) { + o0(r) || r.initializer && r.initializer.kind === 262 && Kme(r.initializer), r.initializer && (r.initializer.kind === 262 ? DX(r.initializer) : Hi(r.initializer)), r.condition && JI(r.condition), r.incrementor && Hi(r.incrementor), la(r.statement), r.locals && A1(r); + } + function iut(r) { + h5e(r); + const a = t5(r); + if (r.awaitModifier ? a && kc(a) ? mr(r.awaitModifier, p.for_await_loops_cannot_be_used_inside_a_class_static_block) : (Mc(a) & 6) === 2 && R < El.ForAwaitOf && xl( + r, + 16384 + /* ForAwaitOfIncludes */ + ) : F.downlevelIteration && R < El.ForOf && xl( + r, + 256 + /* ForOfIncludes */ + ), r.initializer.kind === 262) + DX(r.initializer); + else { + const l = r.initializer, f = cR(r); + if (l.kind === 210 || l.kind === 211) + VT(l, f || qe); + else { + const d = Hi(l); + NI( + l, + p.The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access, + p.The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access + ), f && j2(f, d, l, r.expression); + } + } + la(r.statement), r.locals && A1(r); + } + function sut(r) { + h5e(r); + const a = jde(Hi(r.expression)); + if (r.initializer.kind === 262) { + const l = r.initializer.declarations[0]; + l && ws(l.name) && ze(l.name, p.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern), DX(r.initializer); + } else { + const l = r.initializer, f = Hi(l); + l.kind === 210 || l.kind === 211 ? ze(l, p.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern) : Ms(Trt(a), f) ? NI( + l, + p.The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access, + p.The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access + ) : ze(l, p.The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any); + } + (a === nr || !cu( + a, + 126091264 + /* InstantiableNonPrimitive */ + )) && ze(r.expression, p.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0, Wr(a)), la(r.statement), r.locals && A1(r); + } + function cR(r) { + const a = r.awaitModifier ? 15 : 13; + return ay(a, UE(r.expression), ue, r.expression); + } + function ay(r, a, l, f) { + return gn(a) ? a : Ame( + r, + a, + l, + f, + /*checkAssignability*/ + !0 + ) || Le; + } + function Ame(r, a, l, f, d) { + const y = (r & 2) !== 0; + if (a === nr) { + f && Ome(f, a, y); + return; + } + const x = R >= 2, I = !x && F.downlevelIteration, J = F.noUncheckedIndexedAccess && !!(r & 128); + if (x || I || y) { + const We = PX(a, r, x ? f : void 0); + if (d && We) { + const lt = r & 8 ? p.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0 : r & 32 ? p.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0 : r & 64 ? p.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0 : r & 16 ? p.Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0 : void 0; + lt && xu(l, We.nextType, f, lt); + } + if (We || x) + return J ? yI(We && We.yieldType) : We && We.yieldType; + } + let z = a, G = !1; + if (r & 4) { + if (z.flags & 1048576) { + const We = a.types, lt = kn(We, (gt) => !(gt.flags & 402653316)); + lt !== We && (z = Xn( + lt, + 2 + /* Subtype */ + )); + } else z.flags & 402653316 && (z = nr); + if (G = z !== a, G && z.flags & 131072) + return J ? yI(at) : at; + } + if (!iy(z)) { + if (f) { + const We = !!(r & 4) && !G, [lt, gt] = de(We, I); + J0( + f, + gt && !!DP(z), + lt, + Wr(z) + ); + } + return G ? J ? yI(at) : at : void 0; + } + const ve = eb(z, wt); + if (G && ve) + return ve.flags & 402653316 && !F.noUncheckedIndexedAccess ? at : Xn( + J ? [ve, at, ue] : [ve, at], + 2 + /* Subtype */ + ); + return r & 128 ? yI(ve) : ve; + function de(We, lt) { + var gt; + return lt ? We ? [p.Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator, !0] : [p.Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator, !0] : Ime( + r, + 0, + a, + /*errorNode*/ + void 0 + ) ? [p.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher, !1] : aut((gt = a.symbol) == null ? void 0 : gt.escapedName) ? [p.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher, !0] : We ? [p.Type_0_is_not_an_array_type_or_a_string_type, !0] : [p.Type_0_is_not_an_array_type, !0]; + } + } + function aut(r) { + switch (r) { + case "Float32Array": + case "Float64Array": + case "Int16Array": + case "Int32Array": + case "Int8Array": + case "NodeList": + case "Uint16Array": + case "Uint32Array": + case "Uint8Array": + case "Uint8ClampedArray": + return !0; + } + return !1; + } + function Ime(r, a, l, f) { + if (gn(l)) + return; + const d = PX(l, r, f); + return d && d[H1e(a)]; + } + function I1(r = nr, a = nr, l = yt) { + if (r.flags & 67359327 && a.flags & 180227 && l.flags & 180227) { + const f = rd([r, a, l]); + let d = no.get(f); + return d || (d = { yieldType: r, returnType: a, nextType: l }, no.set(f, d)), d; + } + return { yieldType: r, returnType: a, nextType: l }; + } + function T7e(r) { + let a, l, f; + for (const d of r) + if (!(d === void 0 || d === ra)) { + if (d === Eo) + return Eo; + a = Er(a, d.yieldType), l = Er(l, d.returnType), f = Er(f, d.nextType); + } + return a || l || f ? I1( + a && Xn(a), + l && Xn(l), + f && sa(f) + ) : ra; + } + function wX(r, a) { + return r[a]; + } + function _h(r, a, l) { + return r[a] = l; + } + function PX(r, a, l) { + var f, d; + if (r === kt) + return $c; + if (gn(r)) + return Eo; + if (!(r.flags & 1048576)) { + const z = l ? { errors: void 0, skipLogging: !0 } : void 0, G = x7e(r, a, l, z); + if (G === ra) { + if (l) { + const ve = Ome(l, r, !!(a & 2)); + z?.errors && zs(ve, ...z.errors); + } + return; + } else if ((f = z?.errors) != null && f.length) + for (const ve of z.errors) + Aa.add(ve); + return G; + } + const y = a & 2 ? "iterationTypesOfAsyncIterable" : "iterationTypesOfIterable", x = wX(r, y); + if (x) return x === ra ? void 0 : x; + let I; + for (const z of r.types) { + const G = l ? { errors: void 0 } : void 0, ve = x7e(z, a, l, G); + if (ve === ra) { + if (l) { + const de = Ome(l, r, !!(a & 2)); + G?.errors && zs(de, ...G.errors); + } + _h(r, y, ra); + return; + } else if ((d = G?.errors) != null && d.length) + for (const de of G.errors) + Aa.add(de); + I = Er(I, ve); + } + const J = I ? T7e(I) : ra; + return _h(r, y, J), J === ra ? void 0 : J; + } + function Fme(r, a) { + if (r === ra) return ra; + if (r === Eo) return Eo; + const { yieldType: l, returnType: f, nextType: d } = r; + return a && ipe( + /*reportErrors*/ + !0 + ), I1( + _C(l, a) || Le, + _C(f, a) || Le, + d + ); + } + function x7e(r, a, l, f) { + if (gn(r)) + return Eo; + let d = !1; + if (a & 2) { + const y = k7e(r, Jc) || C7e(r, Jc); + if (y) + if (y === ra && l) + d = !0; + else + return a & 8 ? Fme(y, l) : y; + } + if (a & 1) { + let y = k7e(r, vo) || C7e(r, vo); + if (y) + if (y === ra && l) + d = !0; + else if (a & 2) { + if (y !== ra) + return y = Fme(y, l), d ? y : _h(r, "iterationTypesOfAsyncIterable", y); + } else + return y; + } + if (a & 2) { + const y = D7e(r, Jc, l, f, d); + if (y !== ra) + return y; + } + if (a & 1) { + let y = D7e(r, vo, l, f, d); + if (y !== ra) + return a & 2 ? (y = Fme(y, l), d ? y : _h(r, "iterationTypesOfAsyncIterable", y)) : y; + } + return ra; + } + function k7e(r, a) { + return wX(r, a.iterableCacheKey); + } + function C7e(r, a) { + if (hf(r, a.getGlobalIterableType( + /*reportErrors*/ + !1 + )) || hf(r, a.getGlobalIteratorObjectType( + /*reportErrors*/ + !1 + )) || hf(r, a.getGlobalIterableIteratorType( + /*reportErrors*/ + !1 + )) || hf(r, a.getGlobalGeneratorType( + /*reportErrors*/ + !1 + ))) { + const [l, f, d] = Ao(r); + return _h(r, a.iterableCacheKey, I1(a.resolveIterationType( + l, + /*errorNode*/ + void 0 + ) || l, a.resolveIterationType( + f, + /*errorNode*/ + void 0 + ) || f, d)); + } + if (GG(r, a.getGlobalBuiltinIteratorTypes())) { + const [l] = Ao(r), f = npe(), d = yt; + return _h(r, a.iterableCacheKey, I1(a.resolveIterationType( + l, + /*errorNode*/ + void 0 + ) || l, a.resolveIterationType( + f, + /*errorNode*/ + void 0 + ) || f, d)); + } + } + function E7e(r) { + const a = q3e( + /*reportErrors*/ + !1 + ), l = a && rr(Yr(a), tc(r)); + return l && _p(l) ? fp(l) : `__@${r}`; + } + function D7e(r, a, l, f, d) { + const y = Ys(r, E7e(a.iteratorSymbolName)), x = y && !(y.flags & 16777216) ? Yr(y) : void 0; + if (gn(x)) + return d ? Eo : _h(r, a.iterableCacheKey, Eo); + const I = x ? Is( + x, + 0 + /* Call */ + ) : void 0, J = kn(I, (ve) => em(ve) === 0); + if (!ot(J)) + return l && ot(I) && xu( + r, + a.getGlobalIterableType( + /*reportErrors*/ + !0 + ), + l, + /*headMessage*/ + void 0, + /*containingMessageChain*/ + void 0, + f + ), d ? ra : _h(r, a.iterableCacheKey, ra); + const z = sa(hr(J, Wa)), G = w7e(z, a, l, f, d) ?? ra; + return d ? G : _h(r, a.iterableCacheKey, G); + } + function Ome(r, a, l) { + const f = l ? p.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator : p.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator, d = ( + // for (const x of Promise<...>) or [...Promise<...>] + !!DP(a) || !l && JN(r.parent) && r.parent.expression === r && aM( + /*reportErrors*/ + !1 + ) !== zt && Ms(a, pP(aM( + /*reportErrors*/ + !1 + ), [Le, Le, Le])) + ); + return J0(r, d, f, Wr(a)); + } + function out(r, a, l, f) { + return w7e( + r, + a, + l, + f, + /*noCache*/ + !1 + ); + } + function w7e(r, a, l, f, d) { + if (gn(r)) + return Eo; + let y = cut(r, a) || lut(r, a); + return y === ra && l && (y = void 0, d = !0), y ?? (y = put(r, a, l, f, d)), y === ra ? void 0 : y; + } + function cut(r, a) { + return wX(r, a.iteratorCacheKey); + } + function lut(r, a) { + if (hf(r, a.getGlobalIterableIteratorType( + /*reportErrors*/ + !1 + )) || hf(r, a.getGlobalIteratorType( + /*reportErrors*/ + !1 + )) || hf(r, a.getGlobalIteratorObjectType( + /*reportErrors*/ + !1 + )) || hf(r, a.getGlobalGeneratorType( + /*reportErrors*/ + !1 + ))) { + const [l, f, d] = Ao(r); + return _h(r, a.iteratorCacheKey, I1(l, f, d)); + } + if (GG(r, a.getGlobalBuiltinIteratorTypes())) { + const [l] = Ao(r), f = npe(), d = yt; + return _h(r, a.iteratorCacheKey, I1(l, f, d)); + } + } + function P7e(r, a) { + const l = rr(r, "done") || Rr; + return Ms(a === 0 ? Rr : rt, l); + } + function uut(r) { + return P7e( + r, + 0 + /* Yield */ + ); + } + function _ut(r) { + return P7e( + r, + 1 + /* Return */ + ); + } + function fut(r) { + if (gn(r)) + return Eo; + const a = wX(r, "iterationTypesOfIteratorResult"); + if (a) + return a; + if (hf(r, Ftt( + /*reportErrors*/ + !1 + ))) { + const x = Ao(r)[0]; + return _h(r, "iterationTypesOfIteratorResult", I1( + x, + /*returnType*/ + void 0, + /*nextType*/ + void 0 + )); + } + if (hf(r, Ott( + /*reportErrors*/ + !1 + ))) { + const x = Ao(r)[0]; + return _h(r, "iterationTypesOfIteratorResult", I1( + /*yieldType*/ + void 0, + x, + /*nextType*/ + void 0 + )); + } + const l = Xc(r, uut), f = l !== nr ? rr(l, "value") : void 0, d = Xc(r, _ut), y = d !== nr ? rr(d, "value") : void 0; + return !f && !y ? _h(r, "iterationTypesOfIteratorResult", ra) : _h(r, "iterationTypesOfIteratorResult", I1( + f, + y || _r, + /*nextType*/ + void 0 + )); + } + function Lme(r, a, l, f, d) { + var y, x, I, J; + const z = Ys(r, l); + if (!z && l !== "next") + return; + const G = z && !(l === "next" && z.flags & 16777216) ? l === "next" ? Yr(z) : Dp( + Yr(z), + 2097152 + /* NEUndefinedOrNull */ + ) : void 0; + if (gn(G)) + return Eo; + const ve = G ? Is( + G, + 0 + /* Call */ + ) : Ge; + if (ve.length === 0) { + if (f) { + const or = l === "next" ? a.mustHaveANextMethodDiagnostic : a.mustBeAMethodDiagnostic; + d ? (d.errors ?? (d.errors = []), d.errors.push(sn(f, or, l))) : ze(f, or, l); + } + return l === "next" ? ra : void 0; + } + if (G?.symbol && ve.length === 1) { + const or = a.getGlobalGeneratorType( + /*reportErrors*/ + !1 + ), ir = a.getGlobalIteratorType( + /*reportErrors*/ + !1 + ), nn = ((x = (y = or.symbol) == null ? void 0 : y.members) == null ? void 0 : x.get(l)) === G.symbol, Qn = !nn && ((J = (I = ir.symbol) == null ? void 0 : I.members) == null ? void 0 : J.get(l)) === G.symbol; + if (nn || Qn) { + const Ri = nn ? or : ir, { mapper: zn } = G; + return I1( + ny(Ri.typeParameters[0], zn), + ny(Ri.typeParameters[1], zn), + l === "next" ? ny(Ri.typeParameters[2], zn) : void 0 + ); + } + } + let de, We; + for (const or of ve) + l !== "throw" && ot(or.parameters) && (de = Er(de, Kd(or, 0))), We = Er(We, Wa(or)); + let lt, gt; + if (l !== "throw") { + const or = de ? Xn(de) : yt; + if (l === "next") + gt = or; + else if (l === "return") { + const ir = a.resolveIterationType(or, f) || Le; + lt = Er(lt, ir); + } + } + let jt; + const ar = We ? sa(We) : nr, jr = a.resolveIterationType(ar, f) || Le, Kr = fut(jr); + return Kr === ra ? (f && (d ? (d.errors ?? (d.errors = []), d.errors.push(sn(f, a.mustHaveAValueDiagnostic, l))) : ze(f, a.mustHaveAValueDiagnostic, l)), jt = Le, lt = Er(lt, Le)) : (jt = Kr.yieldType, lt = Er(lt, Kr.returnType)), I1(jt, Xn(lt), gt); + } + function put(r, a, l, f, d) { + const y = T7e([ + Lme(r, a, "next", l, f), + Lme(r, a, "return", l, f), + Lme(r, a, "throw", l, f) + ]); + return d ? y : _h(r, a.iteratorCacheKey, y); + } + function oy(r, a, l) { + if (gn(a)) + return; + const f = Mme(a, l); + return f && f[H1e(r)]; + } + function Mme(r, a) { + if (gn(r)) + return Eo; + const l = a ? 2 : 1, f = a ? Jc : vo; + return PX( + r, + l, + /*errorNode*/ + void 0 + ) || out( + r, + f, + /*errorNode*/ + void 0, + /*errorOutputContainer*/ + void 0 + ); + } + function dut(r) { + o0(r) || Cft(r); + } + function lR(r, a) { + const l = !!(a & 1), f = !!(a & 2); + if (l) { + const d = oy(1, r, f); + return d ? f ? a0(wP(d)) : d : qe; + } + return f ? a0(r) || qe : r; + } + function N7e(r, a) { + const l = lR(a, Mc(r)); + return !!(l && (Dc( + l, + 16384 + /* Void */ + ) || l.flags & 32769)); + } + function mut(r) { + if (o0(r)) + return; + const a = t5(r); + if (a && kc(a)) { + Bl(r, p.A_return_statement_cannot_be_used_inside_a_class_static_block); + return; + } + if (!a) { + Bl(r, p.A_return_statement_can_only_be_used_within_a_function_body); + return; + } + const l = Xf(a), f = Wa(l); + if (K || r.expression || f.flags & 131072) { + const d = r.expression ? mc(r.expression) : ue; + if (a.kind === 179) + r.expression && ze(r, p.Setters_cannot_return_a_value); + else if (a.kind === 177) { + const y = r.expression ? mc(r.expression) : ue; + r.expression && !j2(y, f, r, r.expression) && ze(r, p.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class); + } else if (IE(a)) { + const y = lR(f, Mc(a)) ?? f; + NX(a, y, r, r.expression, d); + } + } else a.kind !== 177 && F.noImplicitReturns && !N7e(a, f) && ze(r, p.Not_all_code_paths_return_a_value); + } + function NX(r, a, l, f, d, y = !1) { + const x = an(l), I = Mc(r); + if (f) { + const de = Ba(f, x); + if (ES(de)) { + NX( + r, + a, + l, + de.whenTrue, + Hi(de.whenTrue), + /*inConditionalExpression*/ + !0 + ), NX( + r, + a, + l, + de.whenFalse, + Hi(de.whenFalse), + /*inConditionalExpression*/ + !0 + ); + return; + } + } + const J = l.kind === 254, z = I & 2 ? nR( + d, + /*withAlias*/ + !1, + l, + p.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member + ) : d, G = f && _X(f); + j2(z, a, J && !y ? l : G, G); + } + function gut(r) { + o0(r) || r.flags & 65536 && Bl(r, p.with_statements_are_not_allowed_in_an_async_function_block), Hi(r.expression); + const a = xr(r); + if (!F1(a)) { + const l = om(a, r.pos).start, f = r.statement.pos; + _b(a, l, f - l, p.The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any); + } + } + function hut(r) { + o0(r); + let a, l = !1; + const f = Hi(r.expression); + lr(r.caseBlock.clauses, (d) => { + d.kind === 298 && !l && (a === void 0 ? a = d : (mr(d, p.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement), l = !0)), d.kind === 297 && n(y(d)), lr(d.statements, la), F.noFallthroughCasesInSwitch && d.fallthroughFlowNode && AM(d.fallthroughFlowNode) && ze(d, p.Fallthrough_case_in_switch); + function y(x) { + return () => { + const I = Hi(x.expression); + gme(f, I) || GNe( + I, + f, + x.expression, + /*headMessage*/ + void 0 + ); + }; + } + }), r.caseBlock.locals && A1(r.caseBlock); + } + function yut(r) { + o0(r) || dr(r.parent, (a) => Es(a) ? "quit" : a.kind === 257 && a.label.escapedText === r.label.escapedText ? (mr(r.label, p.Duplicate_label_0, Qo(r.label)), !0) : !1), la(r.statement); + } + function vut(r) { + o0(r) || Me(r.expression) && !r.expression.escapedText && Bft(r, p.Line_break_not_permitted_here), r.expression && Hi(r.expression); + } + function but(r) { + o0(r), EX(r.tryBlock); + const a = r.catchClause; + if (a) { + if (a.variableDeclaration) { + const l = a.variableDeclaration; + oR(l); + const f = Kc(l); + if (f) { + const d = Ci(f); + d && !(d.flags & 3) && Bl(f, p.Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified); + } else if (l.initializer) + Bl(l.initializer, p.Catch_clause_variable_cannot_have_an_initializer); + else { + const d = a.block.locals; + d && Ag(a.locals, (y) => { + const x = d.get(y); + x?.valueDeclaration && (x.flags & 2) !== 0 && mr(x.valueDeclaration, p.Cannot_redeclare_identifier_0_in_catch_clause, Si(y)); + }); + } + } + EX(a.block); + } + r.finallyBlock && EX(r.finallyBlock); + } + function AX(r, a, l) { + const f = Su(r); + if (f.length === 0) + return; + for (const y of ey(r)) + l && y.flags & 4194304 || A7e(r, y, tC( + y, + 8576, + /*includeNonPublic*/ + !0 + ), Hd(y)); + const d = a.valueDeclaration; + if (d && $n(d)) { + for (const y of d.members) + if ((!l && !Js(y) || l && Js(y)) && !NE(y)) { + const x = yn(y); + A7e(r, x, lu(y.name.expression), Hd(x)); + } + } + if (f.length > 1) + for (const y of f) + Sut(r, y); + } + function A7e(r, a, l, f) { + const d = a.valueDeclaration, y = _s(d); + if (y && Ai(y)) + return; + const x = Vfe(r, l), I = Dn(r) & 2 ? Oo( + r.symbol, + 265 + /* InterfaceDeclaration */ + ) : void 0, J = d && d.kind === 227 || y && y.kind === 168 ? d : void 0, z = Tl(a) === r.symbol ? d : void 0; + for (const G of x) { + const ve = G.declaration && Tl(yn(G.declaration)) === r.symbol ? G.declaration : void 0, de = z || ve || (I && !ot(bd(r), (We) => !!N2(We, a.escapedName) && !!eb(We, G.keyType)) ? I : void 0); + if (de && !Ms(f, G.type)) { + const We = y2(de, p.Property_0_of_type_1_is_not_assignable_to_2_index_type_3, Wi(a), Wr(f), Wr(G.keyType), Wr(G.type)); + J && de !== J && zs(We, sn(J, p._0_is_declared_here, Wi(a))), Aa.add(We); + } + } + } + function Sut(r, a) { + const l = a.declaration, f = Vfe(r, a.keyType), d = Dn(r) & 2 ? Oo( + r.symbol, + 265 + /* InterfaceDeclaration */ + ) : void 0, y = l && Tl(yn(l)) === r.symbol ? l : void 0; + for (const x of f) { + if (x === a) continue; + const I = x.declaration && Tl(yn(x.declaration)) === r.symbol ? x.declaration : void 0, J = y || I || (d && !ot(bd(r), (z) => !!ah(z, a.keyType) && !!eb(z, x.keyType)) ? d : void 0); + J && !Ms(a.type, x.type) && ze(J, p._0_index_type_1_is_not_assignable_to_2_index_type_3, Wr(a.keyType), Wr(a.type), Wr(x.keyType), Wr(x.type)); + } + } + function NP(r, a) { + switch (r.escapedText) { + case "any": + case "unknown": + case "never": + case "number": + case "bigint": + case "boolean": + case "string": + case "symbol": + case "void": + case "object": + case "undefined": + ze(r, a, r.escapedText); + } + } + function Tut(r) { + R >= 1 && r.escapedText === "Object" && e.getEmitModuleFormatOfFile(xr(r)) < 5 && ze(r, p.Class_name_cannot_be_Object_when_targeting_ES5_and_above_with_module_0, TC[B]); + } + function xut(r) { + const a = kn(W1(r), Lf); + if (!wr(a)) return; + const l = an(r), f = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set(); + if (lr(r.parameters, ({ name: x }, I) => { + Me(x) && f.add(x.escapedText), ws(x) && d.add(I); + }), Hfe(r)) { + const x = a.length - 1, I = a[x]; + l && I && Me(I.name) && I.typeExpression && I.typeExpression.type && !f.has(I.name.escapedText) && !d.has(x) && !Ep(Ci(I.typeExpression.type)) && ze(I.name, p.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type, An(I.name)); + } else + lr(a, ({ name: x, isNameFirst: I }, J) => { + d.has(J) || Me(x) && f.has(x.escapedText) || (s_(x) ? l && ze(x, p.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1, ef(x), ef(x.left)) : I || dd(l, x, p.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, An(x))); + }); + } + function uR(r) { + let a = !1; + if (r) + for (let f = 0; f < r.length; f++) { + const d = r[f]; + ZIe(d), n(l(d, f)); + } + function l(f, d) { + return () => { + f.default ? (a = !0, kut(f.default, r, d)) : a && ze(f, p.Required_type_parameters_may_not_follow_optional_type_parameters); + for (let y = 0; y < d; y++) + r[y].symbol === f.symbol && ze(f.name, p.Duplicate_identifier_0, co(f.name)); + }; + } + } + function kut(r, a, l) { + f(r); + function f(d) { + if (d.kind === 184) { + const y = c$(d); + if (y.flags & 262144) + for (let x = l; x < a.length; x++) + y.symbol === yn(a[x]) && ze(d, p.Type_parameter_defaults_can_only_reference_previously_declared_type_parameters); + } + xs(d, f); + } + } + function I7e(r) { + if (r.declarations && r.declarations.length === 1) + return; + const a = Pn(r); + if (!a.typeParametersChecked) { + a.typeParametersChecked = !0; + const l = Iut(r); + if (!l || l.length <= 1) + return; + const f = bo(r); + if (!F7e(l, f.localTypeParameters, xy)) { + const d = Wi(r); + for (const y of l) + ze(y.name, p.All_declarations_of_0_must_have_identical_type_parameters, d); + } + } + } + function F7e(r, a, l) { + const f = wr(a), d = gg(a); + for (const y of r) { + const x = l(y), I = x.length; + if (I < d || I > f) + return !1; + for (let J = 0; J < I; J++) { + const z = x[J], G = a[J]; + if (z.name.escapedText !== G.symbol.escapedName) + return !1; + const ve = PC(z), de = ve && Ci(ve), We = m_(G); + if (de && We && !lh(de, We)) + return !1; + const lt = z.default && Ci(z.default), gt = A2(G); + if (lt && gt && !lh(lt, gt)) + return !1; + } + } + return !0; + } + function O7e(r) { + const a = !U && R < El.ClassAndClassElementDecorators && g0( + /*useLegacyDecorators*/ + !1, + r + ), l = R < El.PrivateNamesAndClassStaticBlocks || R < El.ClassAndClassElementDecorators, f = !W; + if (a || l) + for (const d of r.members) { + if (a && xB( + /*useLegacyDecorators*/ + !1, + d, + r + )) + return Yc(Ty(r)) ?? r; + if (l) { + if (kc(d)) + return d; + if (Js(d) && (Du(d) || f && dA(d))) + return d; + } + } + } + function Cut(r) { + if (r.name) return; + const a = ore(r); + if (!JB(a)) return; + const l = !U && R < El.ClassAndClassElementDecorators; + let f; + l && g0( + /*useLegacyDecorators*/ + !1, + r + ) ? f = Yc(Ty(r)) ?? r : f = O7e(r), f && (xl( + f, + 4194304 + /* SetFunctionName */ + ), (rl(a) || os(a) || ya(a)) && Gs(a.name) && xl( + f, + 8388608 + /* PropKey */ + )); + } + function Eut(r) { + return L7e(r), fC(r), Cut(r), Yr(yn(r)); + } + function Dut(r) { + lr(r.members, la), A1(r); + } + function wut(r) { + const a = Nn(r.modifiers, ul); + U && a && ot(r.members, (l) => cl(l) && Du(l)) && mr(a, p.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator), !r.name && !Gn( + r, + 2048 + /* Default */ + ) && Bl(r, p.A_class_declaration_without_the_default_modifier_must_have_a_name), L7e(r), lr(r.members, la), A1(r); + } + function L7e(r) { + uft(r), iR(r), PP(r, r.name), uR(xy(r)), OI(r); + const a = yn(r), l = bo(a), f = yf(l), d = Yr(a); + I7e(a), xX(a), Jct(r), !!(r.flags & 33554432) || zct(r); + const x = wd(r); + if (x) { + lr(x.typeArguments, la), R < El.Classes && xl( + x.parent, + 1 + /* Extends */ + ); + const z = Lb(r); + z && z !== x && Hi(z.expression); + const G = bd(l); + G.length && n(() => { + const ve = G[0], de = Xh(l), We = e_(de); + if (Nut(We, x), la(x.expression), ot(x.typeArguments)) { + lr(x.typeArguments, la); + for (const gt of vd(We, x.typeArguments, x)) + if (!s7e(x, gt.typeParameters)) + break; + } + const lt = yf(ve, l.thisType); + if (xu( + f, + lt, + /*errorNode*/ + void 0 + ) ? xu(d, zNe(We), r.name || r, p.Class_static_side_0_incorrectly_extends_base_class_static_side_1) : j7e(r, f, lt, p.Class_0_incorrectly_extends_base_class_1), de.flags & 8650752 && (Ql(d) ? Is( + de, + 1 + /* Construct */ + ).some( + (jt) => jt.flags & 4 + /* Abstract */ + ) && !Gn( + r, + 64 + /* Abstract */ + ) && ze(r.name || r, p.A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_be_declared_abstract) : ze(r.name || r, p.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any)), !(We.symbol && We.symbol.flags & 32) && !(de.flags & 8650752)) { + const gt = ih(We, x.typeArguments, x); + lr(gt, (jt) => !zm(jt.declaration) && !lh(Wa(jt), ve)) && ze(x.expression, p.Base_constructors_must_all_have_the_same_return_type); + } + Fut(l, ve); + }); + } + Put(r, l, f, d); + const I = $C(r); + if (I) + for (const z of I) + (!to(z.expression) || Eu(z.expression)) && ze(z.expression, p.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments), xme(z), n(J(z)); + n(() => { + AX(l, a), AX( + d, + a, + /*isStaticIndex*/ + !0 + ), Sme(r), Mut(r); + }); + function J(z) { + return () => { + const G = td(Ci(z)); + if (!Gr(G)) + if (XL(G)) { + const ve = G.symbol && G.symbol.flags & 32 ? p.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass : p.Class_0_incorrectly_implements_interface_1, de = yf(G, l.thisType); + xu( + f, + de, + /*errorNode*/ + void 0 + ) || j7e(r, f, de, ve); + } else + ze(z, p.A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members); + }; + } + } + function Put(r, a, l, f) { + const y = wd(r) && bd(a), x = y?.length ? yf(Ca(y), a.thisType) : void 0, I = Xh(a); + for (const J of r.members) + nJ(J) || (nc(J) && lr(J.parameters, (z) => { + K_(z, J) && M7e( + r, + f, + I, + x, + a, + l, + z, + /*memberIsParameterProperty*/ + !0 + ); + }), M7e( + r, + f, + I, + x, + a, + l, + J, + /*memberIsParameterProperty*/ + !1 + )); + } + function M7e(r, a, l, f, d, y, x, I, J = !0) { + const z = x.name && Pp(x.name) || Pp(x); + return z ? R7e( + r, + a, + l, + f, + d, + y, + N5(x), + Jb(x), + Js(x), + I, + z, + J ? x : void 0 + ) : 0; + } + function R7e(r, a, l, f, d, y, x, I, J, z, G, ve) { + const de = an(r), We = !!(r.flags & 33554432); + if (x && G?.valueDeclaration && Hc(G.valueDeclaration) && G.valueDeclaration.name && KPe(G.valueDeclaration.name)) + return ze( + ve, + de ? p.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_name_is_dynamic : p.This_member_cannot_have_an_override_modifier_because_its_name_is_dynamic + ), 2; + if (f && (x || F.noImplicitOverride)) { + const lt = J ? a : y, gt = J ? l : f, jt = Ys(lt, G.escapedName), ar = Ys(gt, G.escapedName), jr = Wr(f); + if (jt && !ar && x) { + if (ve) { + const Kr = H8e(cc(G), gt); + Kr ? ze( + ve, + de ? p.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1 : p.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1, + jr, + Wi(Kr) + ) : ze( + ve, + de ? p.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0 : p.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0, + jr + ); + } + return 2; + } else if (jt && ar?.declarations && F.noImplicitOverride && !We) { + const Kr = ot(ar.declarations, Jb); + if (x) + return 0; + if (Kr) { + if (I && Kr) + return ve && ze(ve, p.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0, jr), 1; + } else { + if (ve) { + const or = z ? de ? p.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 : p.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0 : de ? p.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 : p.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0; + ze(ve, or, jr); + } + return 1; + } + } + } else if (x) { + if (ve) { + const lt = Wr(d); + ze( + ve, + de ? p.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class : p.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class, + lt + ); + } + return 2; + } + return 0; + } + function j7e(r, a, l, f) { + let d = !1; + for (const y of r.members) { + if (Js(y)) + continue; + const x = y.name && Pp(y.name) || Pp(y); + if (x) { + const I = Ys(a, x.escapedName), J = Ys(l, x.escapedName); + if (I && J) { + const z = () => Ts( + /*details*/ + void 0, + p.Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2, + Wi(x), + Wr(a), + Wr(l) + ); + xu( + Yr(I), + Yr(J), + y.name || y, + /*headMessage*/ + void 0, + z + ) || (d = !0); + } + } + } + d || xu(a, l, r.name || r, f); + } + function Nut(r, a) { + const l = Is( + r, + 1 + /* Construct */ + ); + if (l.length) { + const f = l[0].declaration; + if (f && sf( + f, + 2 + /* Private */ + )) { + const d = Eh(r.symbol); + Wme(a, d) || ze(a, p.Cannot_extend_a_class_0_Class_constructor_is_marked_as_private, q0(r.symbol)); + } + } + } + function Aut(r, a, l) { + if (!a.name) + return 0; + const f = yn(r), d = bo(f), y = yf(d), x = Yr(f), J = wd(r) && bd(d), z = J?.length ? yf(Ca(J), d.thisType) : void 0, G = Xh(d), ve = a.parent ? N5(a) : Gn( + a, + 16 + /* Override */ + ); + return R7e( + r, + x, + G, + z, + d, + y, + ve, + Jb(a), + Js(a), + /*memberIsParameterProperty*/ + !1, + l + ); + } + function $E(r) { + return uc(r) & 1 ? r.links.target : r; + } + function Iut(r) { + return kn( + r.declarations, + (a) => a.kind === 264 || a.kind === 265 + /* InterfaceDeclaration */ + ); + } + function Fut(r, a) { + var l, f, d, y, x; + const I = $a(a), J = /* @__PURE__ */ new Map(); + e: for (const z of I) { + const G = $E(z); + if (G.flags & 4194304) + continue; + const ve = N2(r, G.escapedName); + if (!ve) + continue; + const de = $E(ve), We = up(G); + if (E.assert(!!de, "derived should point to something, even if it is the base class' declaration."), de === G) { + const lt = Eh(r.symbol); + if (We & 64 && (!lt || !Gn( + lt, + 64 + /* Abstract */ + ))) { + for (const Kr of bd(r)) { + if (Kr === a) continue; + const or = N2(Kr, G.escapedName), ir = or && $E(or); + if (ir && ir !== G) + continue e; + } + const gt = Wr(a), jt = Wr(r), ar = Wi(z), jr = Er((l = J.get(lt)) == null ? void 0 : l.missedProperties, ar); + J.set(lt, { baseTypeName: gt, typeName: jt, missedProperties: jr }); + } + } else { + const lt = up(de); + if (We & 2 || lt & 2) + continue; + let gt; + const jt = G.flags & 98308, ar = de.flags & 98308; + if (jt && ar) { + if ((uc(G) & 6 ? (f = G.declarations) != null && f.some((or) => B7e(or, We)) : (d = G.declarations) != null && d.every((or) => B7e(or, We))) || uc(G) & 262144 || de.valueDeclaration && _n(de.valueDeclaration)) + continue; + const jr = jt !== 4 && ar === 4; + if (jr || jt === 4 && ar !== 4) { + const or = jr ? p._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property : p._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor; + ze(_s(de.valueDeclaration) || de.valueDeclaration, or, Wi(G), Wr(a), Wr(r)); + } else if ($) { + const or = (y = de.declarations) == null ? void 0 : y.find((ir) => ir.kind === 173 && !ir.initializer); + if (or && !(de.flags & 33554432) && !(We & 64) && !(lt & 64) && !((x = de.declarations) != null && x.some((ir) => !!(ir.flags & 33554432)))) { + const ir = wN(Eh(r.symbol)), nn = or.name; + if (or.exclamationToken || !ir || !Me(nn) || !K || !z7e(nn, r, ir)) { + const Qn = p.Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration; + ze(_s(de.valueDeclaration) || de.valueDeclaration, Qn, Wi(G), Wr(a)); + } + } + } + continue; + } else if (Mde(G)) { + if (Mde(de) || de.flags & 4) + continue; + E.assert(!!(de.flags & 98304)), gt = p.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor; + } else G.flags & 98304 ? gt = p.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function : gt = p.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function; + ze(_s(de.valueDeclaration) || de.valueDeclaration, gt, Wr(a), Wi(G), Wr(r)); + } + } + for (const [z, G] of J) + if (wr(G.missedProperties) === 1) + Rc(z) ? ze(z, p.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1, Ca(G.missedProperties), G.baseTypeName) : ze(z, p.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2, G.typeName, Ca(G.missedProperties), G.baseTypeName); + else if (wr(G.missedProperties) > 5) { + const ve = hr(G.missedProperties.slice(0, 4), (We) => `'${We}'`).join(", "), de = wr(G.missedProperties) - 4; + Rc(z) ? ze(z, p.Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1_and_2_more, G.baseTypeName, ve, de) : ze(z, p.Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2_and_3_more, G.typeName, G.baseTypeName, ve, de); + } else { + const ve = hr(G.missedProperties, (de) => `'${de}'`).join(", "); + Rc(z) ? ze(z, p.Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1, G.baseTypeName, ve) : ze(z, p.Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2, G.typeName, G.baseTypeName, ve); + } + } + function B7e(r, a) { + return a & 64 && (!os(r) || !r.initializer) || Vl(r.parent); + } + function Out(r, a, l) { + if (!wr(a)) + return l; + const f = /* @__PURE__ */ new Map(); + lr(l, (d) => { + f.set(d.escapedName, d); + }); + for (const d of a) { + const y = $a(yf(d, r.thisType)); + for (const x of y) { + const I = f.get(x.escapedName); + I && x.parent === I.parent && f.delete(x.escapedName); + } + } + return is(f.values()); + } + function Lut(r, a) { + const l = bd(r); + if (l.length < 2) + return !0; + const f = /* @__PURE__ */ new Map(); + lr(Pfe(r).declaredProperties, (y) => { + f.set(y.escapedName, { prop: y, containingType: r }); + }); + let d = !0; + for (const y of l) { + const x = $a(yf(y, r.thisType)); + for (const I of x) { + const J = f.get(I.escapedName); + if (!J) + f.set(I.escapedName, { prop: I, containingType: y }); + else if (J.containingType !== r && !wnt(J.prop, I)) { + d = !1; + const G = Wr(J.containingType), ve = Wr(y); + let de = Ts( + /*details*/ + void 0, + p.Named_property_0_of_types_1_and_2_are_not_identical, + Wi(I), + G, + ve + ); + de = Ts(de, p.Interface_0_cannot_simultaneously_extend_types_1_and_2, Wr(r), G, ve), Aa.add(Fg(xr(a), a, de)); + } + } + } + return d; + } + function Mut(r) { + if (!K || !se || r.flags & 33554432) + return; + const a = wN(r); + for (const l of r.members) + if (!(pu(l) & 128) && !Js(l) && J7e(l)) { + const f = l.name; + if (Me(f) || Ai(f) || Gs(f)) { + const d = Yr(yn(l)); + d.flags & 3 || jE(d) || (!a || !z7e(f, d, a)) && ze(l.name, p.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor, co(f)); + } + } + } + function J7e(r) { + return r.kind === 173 && !Jb(r) && !r.exclamationToken && !r.initializer; + } + function Rut(r, a, l, f, d) { + for (const y of l) + if (y.pos >= f && y.pos <= d) { + const x = N.createPropertyAccessExpression(N.createThis(), r); + za(x.expression, x), za(x, y), x.flowNode = y.returnFlowNode; + const I = s0(x, a, P1(a)); + if (!jE(I)) + return !0; + } + return !1; + } + function z7e(r, a, l) { + const f = Gs(r) ? N.createElementAccessExpression(N.createThis(), r.expression) : N.createPropertyAccessExpression(N.createThis(), r); + za(f.expression, f), za(f, l), f.flowNode = l.returnFlowNode; + const d = s0(f, a, P1(a)); + return !jE(d); + } + function jut(r) { + fh(r) || hft(r), qX(r.parent) || mr(r, p._0_declarations_can_only_be_declared_inside_a_block, "interface"), uR(r.typeParameters), n(() => { + NP(r.name, p.Interface_name_cannot_be_0), OI(r); + const a = yn(r); + I7e(a); + const l = Oo( + a, + 265 + /* InterfaceDeclaration */ + ); + if (r === l) { + const f = bo(a), d = yf(f); + if (Lut(f, r.name)) { + for (const y of bd(f)) + xu(d, yf(y, f.thisType), r.name, p.Interface_0_incorrectly_extends_interface_1); + AX(f, a); + } + } + t7e(r); + }), lr(GD(r), (a) => { + (!to(a.expression) || Eu(a.expression)) && ze(a.expression, p.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments), xme(a); + }), lr(r.members, la), n(() => { + Sme(r), A1(r); + }); + } + function But(r) { + if (fh(r), NP(r.name, p.Type_alias_name_cannot_be_0), qX(r.parent) || mr(r, p._0_declarations_can_only_be_declared_inside_a_block, "type"), OI(r), uR(r.typeParameters), r.type.kind === 141) { + const a = wr(r.typeParameters); + (a === 0 ? r.name.escapedText === "BuiltinIteratorReturn" : a === 1 && AW.has(r.name.escapedText)) || ze(r.type, p.The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types); + } else + la(r.type), A1(r); + } + function W7e(r) { + const a = xn(r); + if (!(a.flags & 1024)) { + a.flags |= 1024; + let l = 0, f; + for (const d of r.members) { + const y = Jut(d, l, f); + xn(d).enumMemberValue = y, l = typeof y.value == "number" ? y.value + 1 : void 0, f = d; + } + } + } + function Jut(r, a, l) { + if (x3(r.name)) + ze(r.name, p.Computed_property_names_are_not_allowed_in_enums); + else if (u6(r.name)) + ze(r.name, p.An_enum_member_cannot_have_a_numeric_name); + else { + const f = dx(r.name); + zg(f) && !v4(f) && ze(r.name, p.An_enum_member_cannot_have_a_numeric_name); + } + if (r.initializer) + return zut(r); + if (r.parent.flags & 33554432 && !V1(r.parent)) + return yl( + /*value*/ + void 0 + ); + if (a === void 0) + return ze(r.name, p.Enum_member_must_have_initializer), yl( + /*value*/ + void 0 + ); + if (zp(F) && l?.initializer) { + const f = qT(l); + typeof f.value == "number" && !f.resolvedOtherFiles || ze( + r.name, + p.Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is_enabled + ); + } + return yl(a); + } + function zut(r) { + const a = V1(r.parent), l = r.initializer, f = Fe(l, r); + return f.value !== void 0 ? a && typeof f.value == "number" && !isFinite(f.value) ? ze( + l, + isNaN(f.value) ? p.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : p.const_enum_member_initializer_was_evaluated_to_a_non_finite_value + ) : zp(F) && typeof f.value == "string" && !f.isSyntacticallyString && ze( + l, + p._0_has_a_string_type_but_must_have_syntactically_recognizable_string_syntax_when_isolatedModules_is_enabled, + `${An(r.parent.name)}.${dx(r.name)}` + ) : a ? ze(l, p.const_enum_member_initializers_must_be_constant_expressions) : r.parent.flags & 33554432 ? ze(l, p.In_ambient_enum_declarations_member_initializer_must_be_constant_expression) : xu(Hi(l), wt, l, p.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values), f; + } + function U7e(r, a) { + const l = dc( + r, + 111551, + /*ignoreErrors*/ + !0 + ); + if (!l) return yl( + /*value*/ + void 0 + ); + if (r.kind === 80) { + const f = r; + if (v4(f.escapedText) && l === ME( + f.escapedText, + 111551, + /*diagnostic*/ + void 0 + )) + return yl( + +f.escapedText, + /*isSyntacticallyString*/ + !1 + ); + } + if (l.flags & 8) + return a ? V7e(r, l, a) : qT(l.valueDeclaration); + if (oC(l)) { + const f = l.valueDeclaration; + if (f && ei(f) && !f.type && f.initializer && (!a || f !== a && qh(f, a))) { + const d = Fe(f.initializer, f); + return a && xr(a) !== xr(f) ? yl( + d.value, + /*isSyntacticallyString*/ + !1, + /*resolvedOtherFiles*/ + !0, + /*hasExternalReferences*/ + !0 + ) : yl( + d.value, + d.isSyntacticallyString, + d.resolvedOtherFiles, + /*hasExternalReferences*/ + !0 + ); + } + } + return yl( + /*value*/ + void 0 + ); + } + function Wut(r, a) { + const l = r.expression; + if (to(l) && ja(r.argumentExpression)) { + const f = dc( + l, + 111551, + /*ignoreErrors*/ + !0 + ); + if (f && f.flags & 384) { + const d = tc(r.argumentExpression.text), y = f.exports.get(d); + if (y) + return E.assert(xr(y.valueDeclaration) === xr(f.valueDeclaration)), a ? V7e(r, y, a) : qT(y.valueDeclaration); + } + } + return yl( + /*value*/ + void 0 + ); + } + function V7e(r, a, l) { + const f = a.valueDeclaration; + if (!f || f === l) + return ze(r, p.Property_0_is_used_before_being_assigned, Wi(a)), yl( + /*value*/ + void 0 + ); + if (!qh(f, l)) + return ze(r, p.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums), yl( + /*value*/ + 0 + ); + const d = qT(f); + return l.parent !== f.parent ? yl( + d.value, + d.isSyntacticallyString, + d.resolvedOtherFiles, + /*hasExternalReferences*/ + !0 + ) : d; + } + function Uut(r) { + n(() => Vut(r)); + } + function Vut(r) { + fh(r), PP(r, r.name), OI(r), r.members.forEach(la), F.erasableSyntaxOnly && !(r.flags & 33554432) && ze(r, p.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled), W7e(r); + const a = yn(r), l = Oo(a, r.kind); + if (r === l) { + if (a.declarations && a.declarations.length > 1) { + const d = V1(r); + lr(a.declarations, (y) => { + ov(y) && V1(y) !== d && ze(_s(y), p.Enum_declarations_must_all_be_const_or_non_const); + }); + } + let f = !1; + lr(a.declarations, (d) => { + if (d.kind !== 267) + return !1; + const y = d; + if (!y.members.length) + return !1; + const x = y.members[0]; + x.initializer || (f ? ze(x.name, p.In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element) : f = !0); + }); + } + } + function qut(r) { + Ai(r.name) && ze(r, p.An_enum_member_cannot_be_named_with_a_private_identifier), r.initializer && Hi(r.initializer); + } + function Hut(r) { + const a = r.declarations; + if (a) { + for (const l of a) + if ((l.kind === 264 || l.kind === 263 && Mp(l.body)) && !(l.flags & 33554432)) + return l; + } + } + function Gut(r, a) { + const l = Dd(r), f = Dd(a); + return m0(l) ? m0(f) : m0(f) ? !1 : l === f; + } + function $ut(r) { + r.body && (la(r.body), $m(r) || A1(r)), n(a); + function a() { + var l, f; + const d = $m(r), y = r.flags & 33554432; + d && !y && ze(r.name, p.Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context); + const x = Vu(r), I = x ? p.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file : p.A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module; + if (_R(r, I)) + return; + if (fh(r) || !y && r.name.kind === 11 && mr(r.name, p.Only_ambient_modules_can_use_quoted_names), Me(r.name) && (PP(r, r.name), !(r.flags & 2080))) { + const z = xr(r), G = QZ(r), ve = om(z, G); + rT.add( + ll(z, ve.start, ve.length, p.A_namespace_declaration_should_not_be_declared_using_the_module_keyword_Please_use_the_namespace_keyword_instead) + ); + } + OI(r); + const J = yn(r); + if (J.flags & 512 && !y && IW(r, By(F))) { + if (F.erasableSyntaxOnly && ze(r.name, p.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled), zp(F) && !xr(r).externalModuleIndicator && ze(r.name, p.Namespaces_are_not_allowed_in_global_script_files_when_0_is_enabled_If_this_file_is_not_intended_to_be_a_global_script_set_moduleDetection_to_force_or_add_an_empty_export_statement, Ee), ((l = J.declarations) == null ? void 0 : l.length) > 1) { + const z = Hut(J); + z && (xr(r) !== xr(z) ? ze(r.name, p.A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged) : r.pos < z.pos && ze(r.name, p.A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged)); + const G = Oo( + J, + 264 + /* ClassDeclaration */ + ); + G && Gut(r, G) && (xn(r).flags |= 2048); + } + if (F.verbatimModuleSyntax && r.parent.kind === 308 && e.getEmitModuleFormatOfFile(r.parent) === 1) { + const z = (f = r.modifiers) == null ? void 0 : f.find( + (G) => G.kind === 95 + /* ExportKeyword */ + ); + z && ze(z, p.A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled); + } + } + if (x) + if (Pb(r)) { + if ((d || yn(r).flags & 33554432) && r.body) + for (const G of r.body.statements) + Rme(G, d); + } else m0(r.parent) ? d ? ze(r.name, p.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations) : Dl(op(r.name)) && ze(r.name, p.Ambient_module_declaration_cannot_specify_relative_module_name) : d ? ze(r.name, p.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations) : ze(r.name, p.Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces); + } + } + function Rme(r, a) { + switch (r.kind) { + case 244: + for (const f of r.declarationList.declarations) + Rme(f, a); + break; + case 278: + case 279: + Bl(r, p.Exports_and_export_assignments_are_not_permitted_in_module_augmentations); + break; + case 272: + if (cS(r)) break; + // falls through + case 273: + Bl(r, p.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module); + break; + case 209: + case 261: + const l = r.name; + if (ws(l)) { + for (const f of l.elements) + Rme(f, a); + break; + } + // falls through + case 264: + case 267: + case 263: + case 265: + case 268: + case 266: + if (a) + return; + break; + } + } + function Xut(r) { + switch (r.kind) { + case 80: + return r; + case 167: + do + r = r.left; + while (r.kind !== 80); + return r; + case 212: + do { + if (Lg(r.expression) && !Ai(r.name)) + return r.name; + r = r.expression; + } while (r.kind !== 80); + return r; + } + } + function IX(r) { + const a = hx(r); + if (!a || lc(a)) + return !1; + if (!ca(a)) + return ze(a, p.String_literal_expected), !1; + const l = r.parent.kind === 269 && Vu(r.parent.parent); + if (r.parent.kind !== 308 && !l) + return ze( + a, + r.kind === 279 ? p.Export_declarations_are_not_permitted_in_a_namespace : p.Import_declarations_in_a_namespace_cannot_reference_a_module + ), !1; + if (l && Dl(a.text) && !eP(r)) + return ze(r, p.Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name), !1; + if (!_l(r) && r.attributes) { + const f = r.attributes.token === 118 ? p.Import_attribute_values_must_be_string_literal_expressions : p.Import_assertion_values_must_be_string_literal_expressions; + let d = !1; + for (const y of r.attributes.elements) + ca(y.value) || (d = !0, ze(y.value, f)); + return !d; + } + return !0; + } + function FX(r, a = !0) { + r === void 0 || r.kind !== 11 || (a ? (B === 5 || B === 6) && mr(r, p.String_literal_import_and_export_names_are_not_supported_when_the_module_flag_is_set_to_es2015_or_es2020) : mr(r, p.Identifier_expected)); + } + function OX(r) { + var a, l, f, d, y; + let x = yn(r); + const I = Rl(x); + if (I !== Y) { + if (x = Oa(x.exportSymbol || x), an(r) && !(I.flags & 111551) && !p0(r)) { + const G = Cy(r) ? r.propertyName || r.name : wl(r) ? r.name : r; + if (E.assert( + r.kind !== 281 + /* NamespaceExport */ + ), r.kind === 282) { + const ve = ze(G, p.Types_cannot_appear_in_export_declarations_in_JavaScript_files), de = (l = (a = xr(r).symbol) == null ? void 0 : a.exports) == null ? void 0 : l.get(wb(r.propertyName || r.name)); + if (de === I) { + const We = (f = de.declarations) == null ? void 0 : f.find(FC); + We && zs( + ve, + sn( + We, + p._0_is_automatically_exported_here, + Si(de.escapedName) + ) + ); + } + } else { + E.assert( + r.kind !== 261 + /* VariableDeclaration */ + ); + const ve = dr(r, Q_(qo, _l)), de = (ve && ((d = gx(ve)) == null ? void 0 : d.text)) ?? "...", We = Si(Me(G) ? G.escapedText : x.escapedName); + ze( + G, + p._0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation, + We, + `import("${de}").${We}` + ); + } + return; + } + const J = O_(I), z = (x.flags & 1160127 ? 111551 : 0) | (x.flags & 788968 ? 788968 : 0) | (x.flags & 1920 ? 1920 : 0); + if (J & z) { + const G = r.kind === 282 ? p.Export_declaration_conflicts_with_exported_declaration_of_0 : p.Import_declaration_conflicts_with_local_declaration_of_0; + ze(r, G, Wi(x)); + } else r.kind !== 282 && F.isolatedModules && !dr(r, p0) && x.flags & 1160127 && ze( + r, + p.Import_0_conflicts_with_local_value_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled, + Wi(x), + Ee + ); + if (zp(F) && !p0(r) && !(r.flags & 33554432)) { + const G = Vd(x), ve = !(J & 111551); + if (ve || G) + switch (r.kind) { + case 274: + case 277: + case 272: { + if (F.verbatimModuleSyntax) { + E.assertIsDefined(r.name, "An ImportClause with a symbol should have a name"); + const de = F.verbatimModuleSyntax && cS(r) ? p.An_import_alias_cannot_resolve_to_a_type_or_type_only_declaration_when_verbatimModuleSyntax_is_enabled : ve ? p._0_is_a_type_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled : p._0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled, We = Iy(r.kind === 277 && r.propertyName || r.name); + fs( + ze(r, de, We), + ve ? void 0 : G, + We + ); + } + ve && r.kind === 272 && sf( + r, + 32 + /* Export */ + ) && ze(r, p.Cannot_use_export_import_on_a_type_or_type_only_namespace_when_0_is_enabled, Ee); + break; + } + case 282: + if (F.verbatimModuleSyntax || xr(G) !== xr(r)) { + const de = Iy(r.propertyName || r.name), We = ve ? ze(r, p.Re_exporting_a_type_when_0_is_enabled_requires_using_export_type, Ee) : ze(r, p._0_resolves_to_a_type_only_declaration_and_must_be_re_exported_using_a_type_only_re_export_when_1_is_enabled, de, Ee); + fs(We, ve ? void 0 : G, de); + break; + } + } + if (F.verbatimModuleSyntax && r.kind !== 272 && !an(r) && e.getEmitModuleFormatOfFile(xr(r)) === 1 ? ze(r, nT(r)) : B === 200 && r.kind !== 272 && r.kind !== 261 && e.getEmitModuleFormatOfFile(xr(r)) === 1 && ze(r, p.ECMAScript_module_syntax_is_not_allowed_in_a_CommonJS_module_when_module_is_set_to_preserve), F.verbatimModuleSyntax && !p0(r) && !(r.flags & 33554432) && J & 128) { + const de = I.valueDeclaration, We = (y = e.getRedirectFromOutput(xr(de).resolvedPath)) == null ? void 0 : y.resolvedRef; + de.flags & 33554432 && (!We || !By(We.commandLine.options)) && ze(r, p.Cannot_access_ambient_const_enums_when_0_is_enabled, Ee); + } + } + if (Xu(r)) { + const G = jme(x, r); + Zu(G) && G.declarations && Zp(r, G.declarations, G.escapedName); + } + } + } + function jme(r, a) { + if (!(r.flags & 2097152) || Zu(r) || !F_(r)) + return r; + const l = Rl(r); + if (l === Y) return l; + for (; r.flags & 2097152; ) { + const f = tX(r); + if (f) { + if (f === l) break; + if (f.declarations && wr(f.declarations)) + if (Zu(f)) { + Zp(a, f.declarations, f.escapedName); + break; + } else { + if (r === l) break; + r = f; + } + } else + break; + } + return l; + } + function LX(r) { + PP(r, r.name), OX(r), r.kind === 277 && (FX(r.propertyName), Gm(r.propertyName || r.name) && mm(F) && e.getEmitModuleFormatOfFile(xr(r)) < 4 && xl( + r, + 131072 + /* ImportDefault */ + )); + } + function Bme(r) { + var a; + const l = r.attributes; + if (l) { + const f = tpe( + /*reportErrors*/ + !0 + ); + f !== ta && xu(bfe(l), xM( + f, + 32768 + /* Undefined */ + ), l); + const d = mU(r), y = R6(l, d ? mr : void 0), x = r.attributes.token === 118; + if (d && y) + return; + if (!Pee(B)) + return mr( + l, + x ? p.Import_attributes_are_only_supported_when_the_module_option_is_set_to_esnext_node18_node20_nodenext_or_preserve : p.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_node18_node20_nodenext_or_preserve + ); + if (102 <= B && B <= 199 && !x) + return Bl(l, p.Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert); + if (r.moduleSpecifier && Hh(r.moduleSpecifier) === 1) + return mr( + l, + x ? p.Import_attributes_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls : p.Import_assertions_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls + ); + if (xm(r) || (qo(r) ? (a = r.importClause) == null ? void 0 : a.isTypeOnly : r.isTypeOnly)) + return mr(l, x ? p.Import_attributes_cannot_be_used_with_type_only_imports_or_exports : p.Import_assertions_cannot_be_used_with_type_only_imports_or_exports); + if (y) + return mr(l, p.resolution_mode_can_only_be_set_for_type_only_imports); + } + } + function Qut(r) { + return t_(mc(r.value)); + } + function Yut(r) { + if (!_R(r, an(r) ? p.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : p.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) { + if (!fh(r) && r.modifiers && Bl(r, p.An_import_declaration_cannot_have_modifiers), IX(r)) { + let a; + const l = r.importClause; + l && !zft(l) ? (l.name && LX(l), l.namedBindings && (l.namedBindings.kind === 275 ? (LX(l.namedBindings), e.getEmitModuleFormatOfFile(xr(r)) < 4 && mm(F) && xl( + r, + 65536 + /* ImportStar */ + )) : (a = Mu(r, r.moduleSpecifier), a && lr(l.namedBindings.elements, LX))), !l.isTypeOnly && 101 <= B && B <= 199 && d1(r.moduleSpecifier, a) && !Zut(r) && ze(r.moduleSpecifier, p.Importing_a_JSON_file_into_an_ECMAScript_module_requires_a_type_Colon_json_import_attribute_when_module_is_set_to_0, TC[B])) : je && !l && Mu(r, r.moduleSpecifier); + } + Bme(r); + } + } + function Zut(r) { + return !!r.attributes && r.attributes.elements.some((a) => { + var l; + return op(a.name) === "type" && ((l = Bn(a.value, ja)) == null ? void 0 : l.text) === "json"; + }); + } + function Kut(r) { + if (!_R(r, an(r) ? p.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : p.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module) && (fh(r), F.erasableSyntaxOnly && !(r.flags & 33554432) && ze(r, p.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled), cS(r) || IX(r))) + if (LX(r), cC( + r, + 6 + /* ExportImportEquals */ + ), r.moduleReference.kind !== 284) { + const a = Rl(yn(r)); + if (a !== Y) { + const l = O_(a); + if (l & 111551) { + const f = i_(r.moduleReference); + dc( + f, + 112575 + /* Namespace */ + ).flags & 1920 || ze(f, p.Module_0_is_hidden_by_a_local_declaration_with_the_same_name, co(f)); + } + l & 788968 && NP(r.name, p.Import_name_cannot_be_0); + } + r.isTypeOnly && mr(r, p.An_import_alias_cannot_use_import_type); + } else + 5 <= B && B <= 99 && !r.isTypeOnly && !(r.flags & 33554432) && mr(r, p.Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead); + } + function e_t(r) { + if (!_R(r, an(r) ? p.An_export_declaration_can_only_be_used_at_the_top_level_of_a_module : p.An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) { + if (!fh(r) && KK(r) && Bl(r, p.An_export_declaration_cannot_have_modifiers), t_t(r), !r.moduleSpecifier || IX(r)) + if (r.exportClause && !Km(r.exportClause)) { + lr(r.exportClause.elements, r_t); + const a = r.parent.kind === 269 && Vu(r.parent.parent), l = !a && r.parent.kind === 269 && !r.moduleSpecifier && r.flags & 33554432; + r.parent.kind !== 308 && !a && !l && ze(r, p.Export_declarations_are_not_permitted_in_a_namespace); + } else { + const a = Mu(r, r.moduleSpecifier); + a && hd(a) ? ze(r.moduleSpecifier, p.Module_0_uses_export_and_cannot_be_used_with_export_Asterisk, Wi(a)) : r.exportClause && (OX(r.exportClause), FX(r.exportClause.name)), e.getEmitModuleFormatOfFile(xr(r)) < 4 && (r.exportClause ? mm(F) && xl( + r, + 65536 + /* ImportStar */ + ) : xl( + r, + 32768 + /* ExportStar */ + )); + } + Bme(r); + } + } + function t_t(r) { + var a; + return r.isTypeOnly && ((a = r.exportClause) == null ? void 0 : a.kind) === 280 ? C5e(r.exportClause) : !1; + } + function _R(r, a) { + const l = r.parent.kind === 308 || r.parent.kind === 269 || r.parent.kind === 268; + return l || Bl(r, a), !l; + } + function r_t(r) { + OX(r); + const a = r.parent.parent.moduleSpecifier !== void 0; + if (FX(r.propertyName, a), FX(r.name), J_(F) && DE( + r.propertyName || r.name, + /*setVisibility*/ + !0 + ), a) + mm(F) && e.getEmitModuleFormatOfFile(xr(r)) < 4 && Gm(r.propertyName || r.name) && xl( + r, + 131072 + /* ImportDefault */ + ); + else { + const l = r.propertyName || r.name; + if (l.kind === 11) + return; + const f = st( + l, + l.escapedText, + 2998271, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !0 + ); + f && (f === ne || f === Se || f.declarations && m0(bt(f.declarations[0]))) ? ze(l, p.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, An(l)) : cC( + r, + 7 + /* ExportSpecifier */ + ); + } + } + function n_t(r) { + const a = r.isExportEquals ? p.An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration : p.A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration; + if (_R(r, a)) + return; + F.erasableSyntaxOnly && r.isExportEquals && !(r.flags & 33554432) && ze(r, p.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled); + const l = r.parent.kind === 308 ? r.parent : r.parent.parent; + if (l.kind === 268 && !Vu(l)) { + r.isExportEquals ? ze(r, p.An_export_assignment_cannot_be_used_in_a_namespace) : ze(r, p.A_default_export_can_only_be_used_in_an_ECMAScript_style_module); + return; + } + !fh(r) && rJ(r) && Bl(r, p.An_export_assignment_cannot_have_modifiers); + const f = Kc(r); + f && xu(mc(r.expression), Ci(f), r.expression); + const d = !r.isExportEquals && !(r.flags & 33554432) && F.verbatimModuleSyntax && e.getEmitModuleFormatOfFile(xr(r)) === 1; + if (r.expression.kind === 80) { + const y = r.expression, x = _t(dc( + y, + -1, + /*ignoreErrors*/ + !0, + /*dontResolveAlias*/ + !0, + r + )); + if (x) { + cC( + r, + 3 + /* ExportAssignment */ + ); + const I = Vd( + x, + 111551 + /* Value */ + ); + if (O_(x) & 111551 ? (mc(y), !d && !(r.flags & 33554432) && F.verbatimModuleSyntax && I && ze( + y, + r.isExportEquals ? p.An_export_declaration_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_a_type_only_declaration : p.An_export_default_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_a_type_only_declaration, + An(y) + )) : !d && !(r.flags & 33554432) && F.verbatimModuleSyntax && ze( + y, + r.isExportEquals ? p.An_export_declaration_must_reference_a_value_when_verbatimModuleSyntax_is_enabled_but_0_only_refers_to_a_type : p.An_export_default_must_reference_a_value_when_verbatimModuleSyntax_is_enabled_but_0_only_refers_to_a_type, + An(y) + ), !d && !(r.flags & 33554432) && zp(F) && !(x.flags & 111551)) { + const J = O_( + x, + /*excludeTypeOnlyMeanings*/ + !1, + /*excludeLocalMeanings*/ + !0 + ); + x.flags & 2097152 && J & 788968 && !(J & 111551) && (!I || xr(I) !== xr(r)) ? ze( + y, + r.isExportEquals ? p._0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported : p._0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default, + An(y), + Ee + ) : I && xr(I) !== xr(r) && fs( + ze( + y, + r.isExportEquals ? p._0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported : p._0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default, + An(y), + Ee + ), + I, + An(y) + ); + } + } else + mc(y); + J_(F) && DE( + y, + /*setVisibility*/ + !0 + ); + } else + mc(r.expression); + d && ze(r, nT(r)), q7e(l), r.flags & 33554432 && !to(r.expression) && mr(r.expression, p.The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context), r.isExportEquals && (B >= 5 && B !== 200 && (r.flags & 33554432 && e.getImpliedNodeFormatForEmit(xr(r)) === 99 || !(r.flags & 33554432) && e.getImpliedNodeFormatForEmit(xr(r)) !== 1) ? mr(r, p.Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead) : B === 4 && !(r.flags & 33554432) && mr(r, p.Export_assignment_is_not_supported_when_module_flag_is_system)); + } + function i_t(r) { + return hl(r.exports, (a, l) => l !== "export="); + } + function q7e(r) { + const a = yn(r), l = Pn(a); + if (!l.exportsChecked) { + const f = a.exports.get("export="); + if (f && i_t(a)) { + const y = F_(f) || f.valueDeclaration; + y && !eP(y) && !an(y) && ze(y, p.An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements); + } + const d = Om(a); + d && d.forEach(({ declarations: y, flags: x }, I) => { + if (I === "__export" || x & 1920) + return; + const J = l0(y, ZI(PRe, KI(Vl))); + if (!(x & 524288 && J <= 2) && J > 1 && !MX(y)) + for (const z of y) + V1e(z) && Aa.add(sn(z, p.Cannot_redeclare_exported_variable_0, Si(I))); + }), l.exportsChecked = !0; + } + } + function MX(r) { + return r && r.length > 1 && r.every((a) => an(a) && To(a) && (lS(a.expression) || Lg(a.expression))); + } + function la(r) { + if (r) { + const a = k; + k = r, h = 0, s_t(r), k = a; + } + } + function s_t(r) { + if (dC(r) & 8388608) + return; + H3(r) && lr(r.jsDoc, ({ comment: l, tags: f }) => { + H7e(l), lr(f, (d) => { + H7e(d.comment), an(r) && la(d); + }); + }); + const a = r.kind; + if (i) + switch (a) { + case 268: + case 264: + case 265: + case 263: + i.throwIfCancellationRequested(); + } + switch (a >= 244 && a <= 260 && HC(r) && r.flowNode && !AM(r.flowNode) && dd(F.allowUnreachableCode === !1, r, p.Unreachable_code_detected), a) { + case 169: + return ZIe(r); + case 170: + return KIe(r); + case 173: + return r7e(r); + case 172: + return Wct(r); + case 186: + case 185: + case 180: + case 181: + case 182: + return II(r); + case 175: + case 174: + return Uct(r); + case 176: + return Vct(r); + case 177: + return qct(r); + case 178: + case 179: + return i7e(r); + case 184: + return xme(r); + case 183: + return jct(r); + case 187: + return Yct(r); + case 188: + return Zct(r); + case 189: + return Kct(r); + case 190: + return elt(r); + case 193: + case 194: + return tlt(r); + case 197: + case 191: + case 192: + return la(r.type); + case 198: + return slt(r); + case 199: + return alt(r); + case 195: + return olt(r); + case 196: + return clt(r); + case 204: + return llt(r); + case 206: + return ult(r); + case 203: + return _lt(r); + case 329: + return Alt(r); + case 330: + return Nlt(r); + case 347: + case 339: + case 341: + return blt(r); + case 346: + return Slt(r); + case 345: + return Tlt(r); + case 325: + case 326: + case 327: + return klt(r); + case 342: + return Clt(r); + case 349: + return Elt(r); + case 318: + Dlt(r); + // falls through + case 316: + case 315: + case 313: + case 314: + case 323: + G7e(r), xs(r, la); + return; + case 319: + a_t(r); + return; + case 310: + return la(r.type); + case 334: + case 336: + case 335: + return Ilt(r); + case 351: + return xlt(r); + case 344: + return wlt(r); + case 352: + return Plt(r); + case 200: + return rlt(r); + case 201: + return nlt(r); + case 263: + return vlt(r); + case 242: + case 269: + return EX(r); + case 244: + return Qlt(r); + case 245: + return Ylt(r); + case 246: + return Zlt(r); + case 247: + return tut(r); + case 248: + return rut(r); + case 249: + return nut(r); + case 250: + return sut(r); + case 251: + return iut(r); + case 252: + case 253: + return dut(r); + case 254: + return mut(r); + case 255: + return gut(r); + case 256: + return hut(r); + case 257: + return yut(r); + case 258: + return vut(r); + case 259: + return but(r); + case 261: + return $lt(r); + case 209: + return Xlt(r); + case 264: + return wut(r); + case 265: + return jut(r); + case 266: + return But(r); + case 267: + return Uut(r); + case 307: + return qut(r); + case 268: + return $ut(r); + case 273: + return Yut(r); + case 272: + return Kut(r); + case 279: + return e_t(r); + case 278: + return n_t(r); + case 243: + case 260: + o0(r); + return; + case 283: + return Gct(r); + } + } + function H7e(r) { + as(r) && lr(r, (a) => { + cx(a) && la(a); + }); + } + function G7e(r) { + if (!an(r)) + if (AF(r) || v6(r)) { + const a = qs( + AF(r) ? 54 : 58 + /* QuestionToken */ + ), l = r.postfix ? p._0_at_the_end_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1 : p._0_at_the_start_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1, f = r.type, d = Ci(f); + mr( + r, + l, + a, + Wr( + v6(r) && !(d === nr || d === _r) ? Xn(Er([d, ue], r.postfix ? void 0 : Mt)) : d + ) + ); + } else + mr(r, p.JSDoc_types_can_only_be_used_inside_documentation_comments); + } + function a_t(r) { + G7e(r), la(r.type); + const { parent: a } = r; + if (Ii(a) && b6(a.parent)) { + pa(a.parent.parameters) !== a && ze(r, p.A_rest_parameter_must_be_last_in_a_parameter_list); + return; + } + lv(a) || ze(r, p.JSDoc_may_only_appear_in_the_last_parameter_of_a_signature); + const l = r.parent.parent; + if (!Lf(l)) { + ze(r, p.JSDoc_may_only_appear_in_the_last_parameter_of_a_signature); + return; + } + const f = G3(l); + if (!f) + return; + const d = $1(l); + (!d || pa(d.parameters).symbol !== f) && ze(r, p.A_rest_parameter_must_be_last_in_a_parameter_list); + } + function o_t(r) { + const a = Ci(r.type), { parent: l } = r, f = r.parent.parent; + if (lv(r.parent) && Lf(f)) { + const d = $1(f), y = Sz(f.parent.parent); + if (d || y) { + const x = Do(y ? f.parent.parent.typeExpression.parameters : d.parameters), I = G3(f); + if (!x || I && x.symbol === I && Hm(x)) + return Tu(a); + } + } + return Ii(l) && b6(l.parent) ? Tu(a) : Ru(a); + } + function fC(r) { + const a = xr(r), l = xn(a); + l.flags & 1 ? E.assert(!l.deferredNodes, "A type-checked file should have no deferred nodes.") : (l.deferredNodes || (l.deferredNodes = /* @__PURE__ */ new Set()), l.deferredNodes.add(r)); + } + function $7e(r) { + const a = xn(r); + a.deferredNodes && a.deferredNodes.forEach(c_t), a.deferredNodes = void 0; + } + function c_t(r) { + var a, l; + (a = on) == null || a.push(on.Phase.Check, "checkDeferredNode", { kind: r.kind, pos: r.pos, end: r.end, path: r.tracingPath }); + const f = k; + switch (k = r, h = 0, r.kind) { + case 214: + case 215: + case 216: + case 171: + case 287: + WT(r); + break; + case 219: + case 220: + case 175: + case 174: + Kot(r); + break; + case 178: + case 179: + i7e(r); + break; + case 232: + Dut(r); + break; + case 169: + Rct(r); + break; + case 286: + aat(r); + break; + case 285: + cat(r); + break; + case 217: + case 235: + case 218: + xot(r); + break; + case 223: + Hi(r.expression); + break; + case 227: + F5(r) && WT(r); + break; + } + k = f, (l = on) == null || l.pop(); + } + function l_t(r, a) { + var l, f; + (l = on) == null || l.push( + on.Phase.Check, + a ? "checkSourceFileNodes" : "checkSourceFile", + { path: r.path }, + /*separateBeginAndEnd*/ + !0 + ); + const d = a ? "beforeCheckNodes" : "beforeCheck", y = a ? "afterCheckNodes" : "afterCheck"; + Ko(d), a ? __t(r, a) : u_t(r), Ko(y), rp("Check", d, y), (f = on) == null || f.pop(); + } + function X7e(r, a) { + if (a) + return !1; + switch (r) { + case 0: + return !!F.noUnusedLocals; + case 1: + return !!F.noUnusedParameters; + default: + return E.assertNever(r); + } + } + function Q7e(r) { + return Or.get(r.path) || Ge; + } + function u_t(r) { + const a = xn(r); + if (!(a.flags & 1)) { + if (a6(r, F, e)) + return; + x5e(r), Ap(o1), Ap(j0), Ap(Bh), Ap(Jh), Ap(zh), a.flags & 8388608 && (o1 = a.potentialThisCollisions, j0 = a.potentialNewTargetCollisions, Bh = a.potentialWeakMapSetCollisions, Jh = a.potentialReflectCollisions, zh = a.potentialUnusedRenamedBindingElementsInTypes), lr(r.statements, la), la(r.endOfFileToken), $7e(r), tf(r) && A1(r), n(() => { + !r.isDeclarationFile && (F.noUnusedLocals || F.noUnusedParameters) && m7e(Q7e(r), (l, f, d) => { + !fx(l) && X7e(f, !!(l.flags & 33554432)) && Aa.add(d); + }), r.isDeclarationFile || Mlt(); + }), tf(r) && q7e(r), o1.length && (lr(o1, Blt), Ap(o1)), j0.length && (lr(j0, Jlt), Ap(j0)), Bh.length && (lr(Bh, Vlt), Ap(Bh)), Jh.length && (lr(Jh, Hlt), Ap(Jh)), a.flags |= 1; + } + } + function __t(r, a) { + const l = xn(r); + if (!(l.flags & 1)) { + if (a6(r, F, e)) + return; + x5e(r), Ap(o1), Ap(j0), Ap(Bh), Ap(Jh), Ap(zh), lr(a, la), $7e(r), (l.potentialThisCollisions || (l.potentialThisCollisions = [])).push(...o1), (l.potentialNewTargetCollisions || (l.potentialNewTargetCollisions = [])).push(...j0), (l.potentialWeakMapSetCollisions || (l.potentialWeakMapSetCollisions = [])).push(...Bh), (l.potentialReflectCollisions || (l.potentialReflectCollisions = [])).push(...Jh), (l.potentialUnusedRenamedBindingElementsInTypes || (l.potentialUnusedRenamedBindingElementsInTypes = [])).push( + ...zh + ), l.flags |= 8388608; + for (const f of a) { + const d = xn(f); + d.flags |= 8388608; + } + } + } + function Y7e(r, a, l) { + try { + return i = a, f_t(r, l); + } finally { + i = void 0; + } + } + function Jme() { + for (const r of t) + r(); + t = []; + } + function zme(r, a) { + Jme(); + const l = n; + n = (f) => f(), l_t(r, a), n = l; + } + function f_t(r, a) { + if (r) { + Jme(); + const l = Aa.getGlobalDiagnostics(), f = l.length; + zme(r, a); + const d = Aa.getDiagnostics(r.fileName); + if (a) + return d; + const y = Aa.getGlobalDiagnostics(); + if (y !== l) { + const x = nQ(l, y, c4); + return Bi(x, d); + } else if (f === 0 && y.length > 0) + return Bi(y, d); + return d; + } + return lr(e.getSourceFiles(), (l) => zme(l)), Aa.getDiagnostics(); + } + function p_t() { + return Jme(), Aa.getGlobalDiagnostics(); + } + function d_t(r, a) { + if (r.flags & 67108864) + return []; + const l = Bs(); + let f = !1; + return d(), l.delete( + "this" + /* This */ + ), qfe(l); + function d() { + for (; r; ) { + switch (qm(r) && r.locals && !m0(r) && x(r.locals, a), r.kind) { + case 308: + if (!fl(r)) break; + // falls through + case 268: + I( + yn(r).exports, + a & 2623475 + /* ModuleMember */ + ); + break; + case 267: + x( + yn(r).exports, + a & 8 + /* EnumMember */ + ); + break; + case 232: + r.name && y(r.symbol, a); + // this fall-through is necessary because we would like to handle + // type parameter inside class expression similar to how we handle it in classDeclaration and interface Declaration. + // falls through + case 264: + case 265: + f || x( + dg(yn(r)), + a & 788968 + /* Type */ + ); + break; + case 219: + r.name && y(r.symbol, a); + break; + } + hK(r) && y(ie, a), f = Js(r), r = r.parent; + } + x(Ye, a); + } + function y(J, z) { + if (t6(J) & z) { + const G = J.escapedName; + l.has(G) || l.set(G, J); + } + } + function x(J, z) { + z && J.forEach((G) => { + y(G, z); + }); + } + function I(J, z) { + z && J.forEach((G) => { + !Oo( + G, + 282 + /* ExportSpecifier */ + ) && !Oo( + G, + 281 + /* NamespaceExport */ + ) && G.escapedName !== "default" && y(G, z); + }); + } + } + function m_t(r) { + return r.kind === 80 && Fx(r.parent) && _s(r.parent) === r; + } + function Z7e(r) { + for (; r.parent.kind === 167; ) + r = r.parent; + return r.parent.kind === 184; + } + function g_t(r) { + for (; r.parent.kind === 212; ) + r = r.parent; + return r.parent.kind === 234; + } + function K7e(r, a) { + let l, f = Wl(r); + for (; f && !(l = a(f)); ) + f = Wl(f); + return l; + } + function h_t(r) { + return !!dr(r, (a) => nc(a) && Mp(a.body) || os(a) ? !0 : $n(a) || io(a) ? "quit" : !1); + } + function Wme(r, a) { + return !!K7e(r, (l) => l === a); + } + function y_t(r) { + for (; r.parent.kind === 167; ) + r = r.parent; + if (r.parent.kind === 272) + return r.parent.moduleReference === r ? r.parent : void 0; + if (r.parent.kind === 278) + return r.parent.expression === r ? r.parent : void 0; + } + function RX(r) { + return y_t(r) !== void 0; + } + function v_t(r) { + switch (Ac(r.parent.parent)) { + case 1: + case 3: + return Hf(r.parent); + case 5: + if (wn(r.parent) && r6(r.parent) === r) + return; + // falls through + case 4: + case 2: + return yn(r.parent.parent); + } + } + function b_t(r) { + let a = r.parent; + for (; s_(a); ) + r = a, a = a.parent; + if (a && a.kind === 206 && a.qualifier === r) + return a; + } + function S_t(r) { + if (r.expression.kind === 110) { + const a = qu( + r, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + if (Es(a)) { + const l = l8e(a); + if (l) { + const f = ub( + l, + /*contextFlags*/ + void 0 + ), d = _8e(l, f); + return d && !gn(d); + } + } + } + } + function e5e(r) { + if (Qm(r)) + return Hf(r.parent); + if (an(r) && r.parent.kind === 212 && r.parent === r.parent.parent.left && !Ai(r) && !uv(r) && !S_t(r.parent)) { + const a = v_t(r); + if (a) + return a; + } + if (r.parent.kind === 278 && to(r)) { + const a = dc( + r, + /*all meanings*/ + 2998271, + /*ignoreErrors*/ + !0 + ); + if (a && a !== Y) + return a; + } else if (r_(r) && RX(r)) { + const a = Q1( + r, + 272 + /* ImportEqualsDeclaration */ + ); + return E.assert(a !== void 0), h1( + r, + /*dontResolveAlias*/ + !0 + ); + } + if (r_(r)) { + const a = b_t(r); + if (a) { + Ci(a); + const l = xn(r).resolvedSymbol; + return l === Y ? void 0 : l; + } + } + for (; see(r); ) + r = r.parent; + if (g_t(r)) { + let a = 0; + r.parent.kind === 234 ? (a = lm(r) ? 788968 : 111551, I5(r.parent) && (a |= 111551)) : a = 1920, a |= 2097152; + const l = to(r) ? dc( + r, + a, + /*ignoreErrors*/ + !0 + ) : void 0; + if (l) + return l; + } + if (r.parent.kind === 342) + return G3(r.parent); + if (r.parent.kind === 169 && r.parent.parent.kind === 346) { + E.assert(!an(r)); + const a = FK(r.parent); + return a && a.symbol; + } + if (Xm(r)) { + if (lc(r)) + return; + const a = dr(r, Q_(cx, M4, uv)), l = a ? 901119 : 111551; + if (r.kind === 80) { + if (UC(r) && uC(r)) { + const d = nX(r.parent); + return d === Y ? void 0 : d; + } + const f = dc( + r, + l, + /*ignoreErrors*/ + !0, + /*dontResolveAlias*/ + !0, + $1(r) + ); + if (!f && a) { + const d = dr(r, Q_($n, Vl)); + if (d) + return fR( + r, + /*ignoreErrors*/ + !0, + yn(d) + ); + } + if (f && a) { + const d = Fb(r); + if (d && Ph(d) && d === f.valueDeclaration) + return dc( + r, + l, + /*ignoreErrors*/ + !0, + /*dontResolveAlias*/ + !0, + xr(d) + ) || f; + } + return f; + } else { + if (Ai(r)) + return oX(r); + if (r.kind === 212 || r.kind === 167) { + const f = xn(r); + return f.resolvedSymbol ? f.resolvedSymbol : (r.kind === 212 ? (aX( + r, + 0 + /* Normal */ + ), f.resolvedSymbol || (f.resolvedSymbol = t5e(mc(r.expression), Yh(r.name)))) : z8e( + r, + 0 + /* Normal */ + ), !f.resolvedSymbol && a && s_(r) ? fR(r) : f.resolvedSymbol); + } else if (uv(r)) + return fR(r); + } + } else if (r_(r) && Z7e(r)) { + const a = r.parent.kind === 184 ? 788968 : 1920, l = dc( + r, + a, + /*ignoreErrors*/ + !0, + /*dontResolveAlias*/ + !0 + ); + return l && l !== Y ? l : s$(r); + } + if (r.parent.kind === 183) + return dc( + r, + /*meaning*/ + 1, + /*ignoreErrors*/ + !0 + ); + } + function t5e(r, a) { + const l = Vfe(r, a); + if (l.length && r.members) { + const f = t$($d(r).members); + if (l === Su(r)) + return f; + if (f) { + const d = Pn(f), y = Fi(l, (I) => I.declaration), x = hr(y, Ma).join(","); + if (d.filteredIndexSymbolCache || (d.filteredIndexSymbolCache = /* @__PURE__ */ new Map()), d.filteredIndexSymbolCache.has(x)) + return d.filteredIndexSymbolCache.get(x); + { + const I = ga( + 131072, + "__index" + /* Index */ + ); + return I.declarations = Fi(l, (J) => J.declaration), I.parent = r.aliasSymbol ? r.aliasSymbol : r.symbol ? r.symbol : Pp(I.declarations[0].parent), d.filteredIndexSymbolCache.set(x, I), I; + } + } + } + } + function fR(r, a, l) { + if (r_(r)) { + let x = dc( + r, + 901119, + a, + /*dontResolveAlias*/ + !0, + $1(r) + ); + if (!x && Me(r) && l && (x = Oa(Xl(gf(l), r.escapedText, 901119))), x) + return x; + } + const f = Me(r) ? l : fR(r.left, a, l), d = Me(r) ? r.escapedText : r.right.escapedText; + if (f) { + const y = f.flags & 111551 && Ys(Yr(f), "prototype"), x = y ? Yr(y) : bo(f); + return Ys(x, d); + } + } + function Pp(r, a) { + if (Di(r)) + return fl(r) ? Oa(r.symbol) : void 0; + const { parent: l } = r, f = l.parent; + if (!(r.flags & 67108864)) { + if (q1e(r)) { + const d = yn(l); + return Cy(r.parent) && r.parent.propertyName === r ? tX(d) : d; + } else if (X3(r)) + return yn(l.parent); + if (r.kind === 80) { + if (RX(r)) + return e5e(r); + if (l.kind === 209 && f.kind === 207 && r === l.propertyName) { + const d = pC(f), y = Ys(d, r.escapedText); + if (y) + return y; + } else if (DS(l) && l.name === r) + return l.keywordToken === 105 && An(r) === "target" ? ime(l).symbol : l.keywordToken === 102 && An(r) === "meta" ? U3e().members.get("meta") : void 0; + } + switch (r.kind) { + case 80: + case 81: + case 212: + case 167: + if (!jb(r)) + return e5e(r); + // falls through + case 110: + const d = qu( + r, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + if (Es(d)) { + const I = Xf(d); + if (I.thisParameter) + return I.thisParameter; + } + if (a5(r)) + return Hi(r).symbol; + // falls through + case 198: + return kpe(r).symbol; + case 108: + return Hi(r).symbol; + case 137: + const y = r.parent; + return y && y.kind === 177 ? y.parent.symbol : void 0; + case 11: + case 15: + if (H1(r.parent.parent) && jD(r.parent.parent) === r || (r.parent.kind === 273 || r.parent.kind === 279) && r.parent.moduleSpecifier === r || an(r) && xm(r.parent) && r.parent.moduleSpecifier === r || an(r) && x_( + r.parent, + /*requireStringLiteralLikeArgument*/ + !1 + ) || T_(r.parent) || E0(r.parent) && bh(r.parent.parent) && r.parent.parent.argument === r.parent) + return Mu(r, r, a); + if (Ps(l) && uS(l) && l.arguments[1] === r) + return yn(l); + // falls through + case 9: + const x = uo(l) ? l.argumentExpression === r ? lu(l.expression) : void 0 : E0(l) && $b(f) ? Ci(f.objectType) : void 0; + return x && Ys(x, tc(r.text)); + case 90: + case 100: + case 39: + case 86: + return Hf(r.parent); + case 206: + return bh(r) ? Pp(r.argument.literal, a) : void 0; + case 95: + return Mo(r.parent) ? E.checkDefined(r.parent.symbol) : void 0; + case 102: + if (DS(r.parent) && r.parent.name.escapedText === "defer") + return; + // falls through + case 105: + return DS(r.parent) ? CIe(r.parent).symbol : void 0; + case 104: + if (_n(r.parent)) { + const I = lu(r.parent.right), J = mme(I); + return J?.symbol ?? I.symbol; + } + return; + case 237: + return Hi(r).symbol; + case 296: + if (UC(r) && uC(r)) { + const I = nX(r.parent); + return I === Y ? void 0 : I; + } + // falls through + default: + return; + } + } + } + function T_t(r) { + if (Me(r) && wn(r.parent) && r.parent.name === r) { + const a = Yh(r), l = lu(r.parent.expression), f = l.flags & 1048576 ? l.types : [l]; + return ka(f, (d) => kn(Su(d), (y) => Kk(a, y.keyType))); + } + } + function x_t(r) { + if (r && r.kind === 305) + return dc( + r.name, + 2208703, + /*ignoreErrors*/ + !0 + ); + } + function k_t(r) { + if (Nu(r)) { + const a = r.propertyName || r.name; + return r.parent.parent.moduleSpecifier ? Uv(r.parent.parent, r) : a.kind === 11 ? void 0 : ( + // Skip for invalid syntax like this: export { "x" } + dc( + a, + 2998271, + /*ignoreErrors*/ + !0 + ) + ); + } else + return dc( + r, + 2998271, + /*ignoreErrors*/ + !0 + ); + } + function pC(r) { + if (Di(r) && !fl(r) || r.flags & 67108864) + return qe; + const a = oJ(r), l = a && xp(yn(a.class)); + if (lm(r)) { + const f = Ci(r); + return l ? yf(f, l.thisType) : f; + } + if (Xm(r)) + return r5e(r); + if (l && !a.isImplements) { + const f = Yc(bd(l)); + return f ? yf(f, l.thisType) : qe; + } + if (Fx(r)) { + const f = yn(r); + return bo(f); + } + if (m_t(r)) { + const f = Pp(r); + return f ? bo(f) : qe; + } + if (ya(r)) + return Xk( + r, + /*includeOptionality*/ + !0, + 0 + /* Normal */ + ) || qe; + if (Pl(r)) { + const f = yn(r); + return f ? Yr(f) : qe; + } + if (q1e(r)) { + const f = Pp(r); + return f ? Yr(f) : qe; + } + if (ws(r)) + return Xk( + r.parent, + /*includeOptionality*/ + !0, + 0 + /* Normal */ + ) || qe; + if (RX(r)) { + const f = Pp(r); + if (f) { + const d = bo(f); + return Gr(d) ? Yr(f) : d; + } + } + return DS(r.parent) && r.parent.keywordToken === r.kind ? CIe(r.parent) : PS(r) ? tpe( + /*reportErrors*/ + !1 + ) : qe; + } + function jX(r) { + if (E.assert( + r.kind === 211 || r.kind === 210 + /* ArrayLiteralExpression */ + ), r.parent.kind === 251) { + const d = cR(r.parent); + return VT(r, d || qe); + } + if (r.parent.kind === 227) { + const d = lu(r.parent.right); + return VT(r, d || qe); + } + if (r.parent.kind === 304) { + const d = Us(r.parent.parent, _a), y = jX(d) || qe, x = MC(d.properties, r.parent); + return JIe(d, y, x); + } + const a = Us(r.parent, nu), l = jX(a) || qe, f = ay(65, l, ue, r.parent) || qe; + return zIe(a, l, a.elements.indexOf(r), f); + } + function C_t(r) { + const a = jX(Us(r.parent.parent, wD)); + return a && Ys(a, r.escapedText); + } + function r5e(r) { + return r4(r) && (r = r.parent), t_(lu(r)); + } + function n5e(r) { + const a = Hf(r.parent); + return Js(r) ? Yr(a) : bo(a); + } + function i5e(r) { + const a = r.name; + switch (a.kind) { + case 80: + return H_(An(a)); + case 9: + case 11: + return H_(a.text); + case 168: + const l = Td(a); + return cu( + l, + 12288 + /* ESSymbolLike */ + ) ? l : at; + default: + return E.fail("Unsupported property name."); + } + } + function Ume(r) { + r = e_(r); + const a = Bs($a(r)), l = Is( + r, + 0 + /* Call */ + ).length ? Gi : Is( + r, + 1 + /* Construct */ + ).length ? Da : void 0; + return l && lr($a(l), (f) => { + a.has(f.escapedName) || a.set(f.escapedName, f); + }), d_(a); + } + function BX(r) { + return Is( + r, + 0 + /* Call */ + ).length !== 0 || Is( + r, + 1 + /* Construct */ + ).length !== 0; + } + function s5e(r) { + const a = E_t(r); + return a ? ka(a, s5e) : [r]; + } + function E_t(r) { + if (uc(r) & 6) + return Fi(Pn(r).containingType.types, (a) => Ys(a, r.escapedName)); + if (r.flags & 33554432) { + const { links: { leftSpread: a, rightSpread: l, syntheticOrigin: f } } = r; + return a ? [a, l] : f ? [f] : ZT(D_t(r)); + } + } + function D_t(r) { + let a, l = r; + for (; l = Pn(l).target; ) + a = l; + return a; + } + function w_t(r) { + if (Bo(r)) return !1; + const a = vs(r, Me); + if (!a) return !1; + const l = a.parent; + return l ? !((wn(l) || rl(l)) && l.name === a) && WI(a) === ie : !1; + } + function P_t(r) { + return d3(r.parent) && r === r.parent.name; + } + function N_t(r, a) { + var l; + const f = vs(r, Me); + if (f) { + let d = WI( + f, + /*startInDeclarationContainer*/ + P_t(f) + ); + if (d) { + if (d.flags & 1048576) { + const x = Oa(d.exportSymbol); + if (!a && x.flags & 944 && !(x.flags & 3)) + return; + d = x; + } + const y = Tl(d); + if (y) { + if (y.flags & 512 && ((l = y.valueDeclaration) == null ? void 0 : l.kind) === 308) { + const x = y.valueDeclaration, I = xr(f); + return x !== I ? void 0 : x; + } + return dr(f.parent, (x) => d3(x) && yn(x) === y); + } + } + } + } + function A_t(r) { + const a = kte(r); + if (a) + return a; + const l = vs(r, Me); + if (l) { + const f = H_t(l); + if (lT( + f, + /*excludes*/ + 111551 + /* Value */ + ) && !Vd( + f, + 111551 + /* Value */ + )) + return F_(f); + } + } + function I_t(r) { + return r.valueDeclaration && ya(r.valueDeclaration) && Y2(r.valueDeclaration).parent.kind === 300; + } + function a5e(r) { + if (r.flags & 418 && r.valueDeclaration && !Di(r.valueDeclaration)) { + const a = Pn(r); + if (a.isDeclarationWithCollidingName === void 0) { + const l = Dd(r.valueDeclaration); + if (GZ(l) || I_t(r)) + if (st( + l.parent, + r.escapedName, + 111551, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !1 + )) + a.isDeclarationWithCollidingName = !0; + else if (Vme( + r.valueDeclaration, + 16384 + /* CapturedBlockScopedBinding */ + )) { + const f = Vme( + r.valueDeclaration, + 32768 + /* BlockScopedBindingInLoop */ + ), d = wy( + l, + /*lookInLabeledStatements*/ + !1 + ), y = l.kind === 242 && wy( + l.parent, + /*lookInLabeledStatements*/ + !1 + ); + a.isDeclarationWithCollidingName = !tK(l) && (!f || !d && !y); + } else + a.isDeclarationWithCollidingName = !1; + } + return a.isDeclarationWithCollidingName; + } + return !1; + } + function F_t(r) { + if (!Bo(r)) { + const a = vs(r, Me); + if (a) { + const l = WI(a); + if (l && a5e(l)) + return l.valueDeclaration; + } + } + } + function O_t(r) { + const a = vs(r, Pl); + if (a) { + const l = yn(a); + if (l) + return a5e(l); + } + return !1; + } + function o5e(r) { + switch (E.assert(Ce), r.kind) { + case 272: + return JX(yn(r)); + case 274: + case 275: + case 277: + case 282: + const a = yn(r); + return !!a && JX( + a, + /*excludeTypeOnlyValues*/ + !0 + ); + case 279: + const l = r.exportClause; + return !!l && (Km(l) || ot(l.elements, o5e)); + case 278: + return r.expression && r.expression.kind === 80 ? JX( + yn(r), + /*excludeTypeOnlyValues*/ + !0 + ) : !0; + } + return !1; + } + function L_t(r) { + const a = vs(r, _l); + return a === void 0 || a.parent.kind !== 308 || !cS(a) ? !1 : JX(yn(a)) && a.moduleReference && !lc(a.moduleReference); + } + function JX(r, a) { + if (!r) + return !1; + const l = xr(r.valueDeclaration), f = l && yn(l); + q_(f); + const d = _t(Rl(r)); + return d === Y ? !a || !Vd(r) : !!(O_( + r, + a, + /*excludeLocalMeanings*/ + !0 + ) & 111551) && (By(F) || !zI(d)); + } + function zI(r) { + return dme(r) || !!r.constEnumOnlyModule; + } + function c5e(r, a) { + if (E.assert(Ce), U0(r)) { + const l = yn(r), f = l && Pn(l); + if (f?.referenced) + return !0; + const d = Pn(l).aliasTarget; + if (d && pu(r) & 32 && O_(d) & 111551 && (By(F) || !zI(d))) + return !0; + } + return a ? !!xs(r, (l) => c5e(l, a)) : !1; + } + function l5e(r) { + if (Mp(r.body)) { + if (Pg(r) || am(r)) return !1; + const a = yn(r), l = I2(a); + return l.length > 1 || // If there is single signature for the symbol, it is overload if that signature isn't coming from the node + // e.g.: function foo(a: string): string; + // function foo(a: any) { // This is implementation of the overloads + // return a; + // } + l.length === 1 && l[0].declaration !== r; + } + return !1; + } + function M_t(r) { + const a = f5e(r); + if (!a) return !1; + const l = Ci(a); + return Gr(l) || jE(l); + } + function pR(r, a) { + return (R_t(r, a) || j_t(r)) && !M_t(r); + } + function R_t(r, a) { + return !K || K8(r) || Lf(r) || !r.initializer ? !1 : Gn( + r, + 31 + /* ParameterPropertyModifier */ + ) ? !!a && io(a) : !0; + } + function j_t(r) { + return K && K8(r) && (Lf(r) || !r.initializer) && Gn( + r, + 31 + /* ParameterPropertyModifier */ + ); + } + function u5e(r) { + const a = vs(r, (f) => Cc(f) || ei(f)); + if (!a) + return !1; + let l; + if (ei(a)) { + if (a.type || !an(a) && !UI(a)) + return !1; + const f = zD(a); + if (!f || !Ed(f)) + return !1; + l = yn(f); + } else + l = yn(a); + return !l || !(l.flags & 16 | 3) ? !1 : !!hl(gf(l), (f) => f.flags & 111551 && Mx(f.valueDeclaration)); + } + function B_t(r) { + const a = vs(r, Cc); + if (!a) + return Ge; + const l = yn(a); + return l && $a(Yr(l)) || Ge; + } + function dC(r) { + var a; + const l = r.id || 0; + return l < 0 || l >= Av.length ? 0 : ((a = Av[l]) == null ? void 0 : a.flags) || 0; + } + function Vme(r, a) { + return J_t(r, a), !!(dC(r) & a); + } + function J_t(r, a) { + if (!F.noCheck && m4(xr(r), F) || xn(r).calculatedFlags & a) + return; + switch (a) { + case 16: + case 32: + return x(r); + case 128: + case 256: + case 2097152: + return y(r); + case 512: + case 8192: + case 65536: + case 262144: + return J(r); + case 536870912: + return G(r); + case 4096: + case 32768: + case 16384: + return de(r); + default: + return E.assertNever(a, `Unhandled node check flag calculation: ${E.formatNodeCheckFlags(a)}`); + } + function f(lt, gt) { + const jt = gt(lt, lt.parent); + if (jt !== "skip") + return jt || Kx(lt, gt); + } + function d(lt) { + const gt = xn(lt); + if (gt.calculatedFlags & a) return "skip"; + gt.calculatedFlags |= 2097536, x(lt); + } + function y(lt) { + f(lt, d); + } + function x(lt) { + const gt = xn(lt); + gt.calculatedFlags |= 48, lt.kind === 108 && $$(lt); + } + function I(lt) { + const gt = xn(lt); + if (gt.calculatedFlags & a) return "skip"; + gt.calculatedFlags |= 336384, G(lt); + } + function J(lt) { + f(lt, I); + } + function z(lt) { + return Xm(lt) || gu(lt.parent) && (lt.parent.objectAssignmentInitializer ?? lt.parent.name) === lt; + } + function G(lt) { + const gt = xn(lt); + if (gt.calculatedFlags |= 536870912, Me(lt) && (gt.calculatedFlags |= 49152, z(lt) && !(wn(lt.parent) && lt.parent.name === lt))) { + const jt = ju(lt); + jt && jt !== Y && s8e(lt, jt); + } + } + function ve(lt) { + const gt = xn(lt); + if (gt.calculatedFlags & a) return "skip"; + gt.calculatedFlags |= 53248, We(lt); + } + function de(lt) { + const gt = Dd(Qm(lt) ? lt.parent : lt); + f(gt, ve); + } + function We(lt) { + G(lt), Gs(lt) && Td(lt), Ai(lt) && Hc(lt.parent) && SX(lt.parent); + } + } + function qT(r) { + return W7e(r.parent), xn(r).enumMemberValue ?? yl( + /*value*/ + void 0 + ); + } + function _5e(r) { + switch (r.kind) { + case 307: + case 212: + case 213: + return !0; + } + return !1; + } + function zX(r) { + if (r.kind === 307) + return qT(r).value; + xn(r).resolvedSymbol || mc(r); + const a = xn(r).resolvedSymbol || (to(r) ? dc( + r, + 111551, + /*ignoreErrors*/ + !0 + ) : void 0); + if (a && a.flags & 8) { + const l = a.valueDeclaration; + if (V1(l.parent)) + return qT(l).value; + } + } + function qme(r) { + return !!(r.flags & 524288) && Is( + r, + 0 + /* Call */ + ).length > 0; + } + function z_t(r, a) { + var l; + const f = vs(r, r_); + if (!f || a && (a = vs(a), !a)) + return 0; + let d = !1; + if (s_(f)) { + const G = dc( + i_(f), + 111551, + /*ignoreErrors*/ + !0, + /*dontResolveAlias*/ + !0, + a + ); + d = !!((l = G?.declarations) != null && l.every(p0)); + } + const y = dc( + f, + 111551, + /*ignoreErrors*/ + !0, + /*dontResolveAlias*/ + !0, + a + ), x = y && y.flags & 2097152 ? Rl(y) : y; + d || (d = !!(y && Vd( + y, + 111551 + /* Value */ + ))); + const I = dc( + f, + 788968, + /*ignoreErrors*/ + !0, + /*dontResolveAlias*/ + !0, + a + ), J = I && I.flags & 2097152 ? Rl(I) : I; + if (y || d || (d = !!(I && Vd( + I, + 788968 + /* Type */ + ))), x && x === J) { + const G = rpe( + /*reportErrors*/ + !1 + ); + if (G && x === G) + return 9; + const ve = Yr(x); + if (ve && Gd(ve)) + return d ? 10 : 1; + } + if (!J) + return d ? 11 : 0; + const z = bo(J); + return Gr(z) ? d ? 11 : 0 : z.flags & 3 ? 11 : cu( + z, + 245760 + /* Never */ + ) ? 2 : cu( + z, + 528 + /* BooleanLike */ + ) ? 6 : cu( + z, + 296 + /* NumberLike */ + ) ? 3 : cu( + z, + 2112 + /* BigIntLike */ + ) ? 4 : cu( + z, + 402653316 + /* StringLike */ + ) ? 5 : Sa(z) ? 7 : cu( + z, + 12288 + /* ESSymbolLike */ + ) ? 8 : qme(z) ? 10 : Ep(z) ? 7 : 11; + } + function W_t(r, a, l, f, d) { + const y = vs(r, fF); + if (!y) + return N.createToken( + 133 + /* AnyKeyword */ + ); + const x = yn(y); + return pe.serializeTypeForDeclaration(y, x, a, l | 1024, f, d); + } + function Hme(r) { + r = vs(r, a3); + const a = r.kind === 179 ? 178 : 179, l = Oo(yn(r), a), f = l && l.pos < r.pos ? l : r, d = l && l.pos < r.pos ? r : l, y = r.kind === 179 ? r : l, x = r.kind === 178 ? r : l; + return { + firstAccessor: f, + secondAccessor: d, + setAccessor: y, + getAccessor: x + }; + } + function U_t(r, a, l, f, d) { + const y = vs(r, Es); + return y ? pe.serializeReturnTypeForSignature(y, a, l | 1024, f, d) : N.createToken( + 133 + /* AnyKeyword */ + ); + } + function V_t(r, a, l, f, d) { + const y = vs(r, ut); + return y ? pe.serializeTypeForExpression(y, a, l | 1024, f, d) : N.createToken( + 133 + /* AnyKeyword */ + ); + } + function q_t(r) { + return Ye.has(tc(r)); + } + function WI(r, a) { + const l = xn(r).resolvedSymbol; + if (l) + return l; + let f = r; + if (a) { + const d = r.parent; + Pl(d) && r === d.name && (f = bt(d)); + } + return st( + f, + r.escapedText, + 3257279, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !0 + ); + } + function H_t(r) { + const a = xn(r).resolvedSymbol; + return a && a !== Y ? a : st( + r, + r.escapedText, + 3257279, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !0, + /*excludeGlobals*/ + void 0 + ); + } + function G_t(r) { + if (!Bo(r)) { + const a = vs(r, Me); + if (a) { + const l = WI(a); + if (l) + return _t(l).valueDeclaration; + } + } + } + function $_t(r) { + if (!Bo(r)) { + const a = vs(r, Me); + if (a) { + const l = WI(a); + if (l) + return kn(_t(l).declarations, (f) => { + switch (f.kind) { + case 261: + case 170: + case 209: + case 173: + case 304: + case 305: + case 307: + case 211: + case 263: + case 219: + case 220: + case 264: + case 232: + case 267: + case 175: + case 178: + case 179: + case 268: + return !0; + } + return !1; + }); + } + } + } + function X_t(r) { + return C3(r) || ei(r) && UI(r) ? L2(Yr(yn(r))) : !1; + } + function Q_t(r, a, l) { + const f = r.flags & 1056 ? pe.symbolToExpression( + r.symbol, + 111551, + a, + /*flags*/ + void 0, + /*internalFlags*/ + void 0, + l + ) : r === rt ? N.createTrue() : r === Rr && N.createFalse(); + if (f) return f; + const d = r.value; + return typeof d == "object" ? N.createBigIntLiteral(d) : typeof d == "string" ? N.createStringLiteral(d) : d < 0 ? N.createPrefixUnaryExpression(41, N.createNumericLiteral(-d)) : N.createNumericLiteral(d); + } + function Y_t(r, a) { + const l = Yr(yn(r)); + return Q_t(l, r, a); + } + function Gme(r) { + return r ? (pd(r), xr(r).localJsxFactory || Uh) : Uh; + } + function $me(r) { + if (r) { + const a = xr(r); + if (a) { + if (a.localJsxFragmentFactory) + return a.localJsxFragmentFactory; + const l = a.pragmas.get("jsxfrag"), f = as(l) ? l[0] : l; + if (f) + return a.localJsxFragmentFactory = tk(f.arguments.factory, R), a.localJsxFragmentFactory; + } + } + if (F.jsxFragmentFactory) + return tk(F.jsxFragmentFactory, R); + } + function f5e(r) { + const a = Kc(r); + if (a) + return a; + if (r.kind === 170 && r.parent.kind === 179) { + const l = Hme(r.parent).getAccessor; + if (l) + return nf(l); + } + } + function Z_t() { + return { + getReferencedExportContainer: N_t, + getReferencedImportDeclaration: A_t, + getReferencedDeclarationWithCollidingName: F_t, + isDeclarationWithCollidingName: O_t, + isValueAliasDeclaration: (a) => { + const l = vs(a); + return l && Ce ? o5e(l) : !0; + }, + hasGlobalName: q_t, + isReferencedAliasDeclaration: (a, l) => { + const f = vs(a); + return f && Ce ? c5e(f, l) : !0; + }, + hasNodeCheckFlag: (a, l) => { + const f = vs(a); + return f ? Vme(f, l) : !1; + }, + isTopLevelValueImportEqualsWithEntityName: L_t, + isDeclarationVisible: fg, + isImplementationOfOverload: l5e, + requiresAddingImplicitUndefined: pR, + isExpandoFunctionDeclaration: u5e, + getPropertiesOfContainerFunction: B_t, + createTypeOfDeclaration: W_t, + createReturnTypeOfSignatureDeclaration: U_t, + createTypeOfExpression: V_t, + createLiteralConstValue: Y_t, + isSymbolAccessible: v1, + isEntityNameVisible: $k, + getConstantValue: (a) => { + const l = vs(a, _5e); + return l ? zX(l) : void 0; + }, + getEnumMemberValue: (a) => { + const l = vs(a, Ph); + return l ? qT(l) : void 0; + }, + collectLinkedAliases: DE, + markLinkedReferences: (a) => { + const l = vs(a); + return l && cC( + l, + 0 + /* Unspecified */ + ); + }, + getReferencedValueDeclaration: G_t, + getReferencedValueDeclarations: $_t, + getTypeReferenceSerializationKind: z_t, + isOptionalParameter: K8, + isArgumentsLocalBinding: w_t, + getExternalModuleFileFromDeclaration: (a) => { + const l = vs(a, iK); + return l && Xme(l); + }, + isLiteralConstDeclaration: X_t, + isLateBound: (a) => { + const l = vs(a, Pl), f = l && yn(l); + return !!(f && uc(f) & 4096); + }, + getJsxFactoryEntity: Gme, + getJsxFragmentFactoryEntity: $me, + isBindingCapturedByNode: (a, l) => { + const f = vs(a), d = vs(l); + return !!f && !!d && (ei(d) || ya(d)) && ost(f, d); + }, + getDeclarationStatementsForSourceFile: (a, l, f, d) => { + const y = vs(a); + E.assert(y && y.kind === 308, "Non-sourcefile node passed into getDeclarationsForSourceFile"); + const x = yn(a); + return x ? (q_(x), x.exports ? pe.symbolTableToDeclarationStatements(x.exports, a, l, f, d) : []) : a.locals ? pe.symbolTableToDeclarationStatements(a.locals, a, l, f, d) : []; + }, + isImportRequiredByAugmentation: r, + isDefinitelyReferenceToGlobalSymbolObject: lg, + createLateBoundIndexSignatures: (a, l, f, d, y) => { + const x = a.symbol, I = Su(Yr(x)), J = e$(x), z = J && r$(J, is(dg(x).values())); + let G; + for (const de of [I, z]) + if (wr(de)) { + G || (G = []); + for (const We of de) { + if (We.declaration || We === Yi) continue; + if (We.components && Ni(We.components, (jt) => { + var ar; + return !!(jt.name && Gs(jt.name) && to(jt.name.expression) && l && ((ar = $k( + jt.name.expression, + l, + /*shouldComputeAliasToMakeVisible*/ + !1 + )) == null ? void 0 : ar.accessibility) === 0); + })) { + const jt = kn(We.components, (ar) => !PE(ar)); + G.push(...hr(jt, (ar) => { + ve(ar.name.expression); + const jr = de === I ? [N.createModifier( + 126 + /* StaticKeyword */ + )] : void 0; + return N.createPropertyDeclaration( + Er(jr, We.isReadonly ? N.createModifier( + 148 + /* ReadonlyKeyword */ + ) : void 0), + ar.name, + ($u(ar) || os(ar) || cd(ar) || rc(ar) || Pg(ar) || am(ar)) && ar.questionToken ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, + pe.typeToTypeNode(Yr(ar.symbol), l, f, d, y), + /*initializer*/ + void 0 + ); + })); + continue; + } + const lt = pe.indexInfoToIndexSignatureDeclaration(We, l, f, d, y); + lt && de === I && (lt.modifiers || (lt.modifiers = N.createNodeArray())).unshift(N.createModifier( + 126 + /* StaticKeyword */ + )), lt && G.push(lt); + } + } + return G; + function ve(de) { + if (!y.trackSymbol) return; + const We = i_(de), lt = st( + We, + We.escapedText, + 1160127, + /*nameNotFoundMessage*/ + void 0, + /*isUse*/ + !0 + ); + lt && y.trackSymbol( + lt, + l, + 111551 + /* Value */ + ); + } + }, + symbolToDeclarations: (a, l, f, d, y, x) => pe.symbolToDeclarations(a, l, f, d, y, x) + }; + function r(a) { + const l = xr(a); + if (!l.symbol) return !1; + const f = Xme(a); + if (!f || f === l) return !1; + const d = Om(l.symbol); + for (const y of is(d.values())) + if (y.mergeId) { + const x = Oa(y); + if (x.declarations) { + for (const I of x.declarations) + if (xr(I) === f) + return !0; + } + } + return !1; + } + } + function Xme(r) { + const a = r.kind === 268 ? Bn(r.name, ca) : hx(r), l = V_( + a, + a, + /*moduleNotFoundError*/ + void 0 + ); + if (l) + return Oo( + l, + 308 + /* SourceFile */ + ); + } + function K_t() { + for (const a of e.getSourceFiles()) + yne(a, F); + ic = /* @__PURE__ */ new Map(); + let r; + for (const a of e.getSourceFiles()) + if (!a.redirectInfo) { + if (!tf(a)) { + const l = a.locals.get("globalThis"); + if (l?.declarations) + for (const f of l.declarations) + Aa.add(sn(f, p.Declaration_name_conflicts_with_built_in_global_identifier_0, "globalThis")); + Im(Ye, a.locals); + } + a.jsGlobalAugmentations && Im(Ye, a.jsGlobalAugmentations), a.patternAmbientModules && a.patternAmbientModules.length && (P_ = Bi(P_, a.patternAmbientModules)), a.moduleAugmentations.length && (r || (r = [])).push(a.moduleAugmentations), a.symbol && a.symbol.globalExports && a.symbol.globalExports.forEach((f, d) => { + Ye.has(d) || Ye.set(d, f); + }); + } + if (r) + for (const a of r) + for (const l of a) + $m(l.parent) && b2(l); + if (Bv(), Pn(ne).type = M, Pn(ie).type = bc( + "IArguments", + /*arity*/ + 0, + /*reportErrors*/ + !0 + ), Pn(Y).type = qe, Pn(Se).type = Wc(16, Se), wa = bc( + "Array", + /*arity*/ + 1, + /*reportErrors*/ + !0 + ), Ot = bc( + "Object", + /*arity*/ + 0, + /*reportErrors*/ + !0 + ), Mr = bc( + "Function", + /*arity*/ + 0, + /*reportErrors*/ + !0 + ), Gi = ae && bc( + "CallableFunction", + /*arity*/ + 0, + /*reportErrors*/ + !0 + ) || Mr, Da = ae && bc( + "NewableFunction", + /*arity*/ + 0, + /*reportErrors*/ + !0 + ) || Mr, il = bc( + "String", + /*arity*/ + 0, + /*reportErrors*/ + !0 + ), Po = bc( + "Number", + /*arity*/ + 0, + /*reportErrors*/ + !0 + ), sc = bc( + "Boolean", + /*arity*/ + 0, + /*reportErrors*/ + !0 + ), vc = bc( + "RegExp", + /*arity*/ + 0, + /*reportErrors*/ + !0 + ), Gl = Tu(Le), Ol = Tu(mt), Ol === ta && (Ol = Ho( + /*symbol*/ + void 0, + A, + Ge, + Ge, + Ge + )), ma = Y3e( + "ReadonlyArray", + /*arity*/ + 1 + ) || wa, pf = ma ? pP(ma, [Le]) : Gl, Df = Y3e( + "ThisType", + /*arity*/ + 1 + ), r) + for (const a of r) + for (const l of a) + $m(l.parent) || b2(l); + ic.forEach(({ firstFile: a, secondFile: l, conflictingSymbols: f }) => { + if (f.size < 8) + f.forEach(({ isBlockScoped: d, firstFileLocations: y, secondFileLocations: x }, I) => { + const J = d ? p.Cannot_redeclare_block_scoped_variable_0 : p.Duplicate_identifier_0; + for (const z of y) + jv(z, J, I, x); + for (const z of x) + jv(z, J, I, y); + }); + else { + const d = is(f.keys()).join(", "); + Aa.add(zs( + sn(a, p.Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0, d), + sn(l, p.Conflicts_are_in_this_file) + )), Aa.add(zs( + sn(l, p.Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0, d), + sn(a, p.Conflicts_are_in_this_file) + )); + } + }), ic = void 0; + } + function xl(r, a) { + if (F.importHelpers) { + const l = xr(r); + if (RC(l, F) && !(r.flags & 33554432)) { + const f = tft(l, r); + if (f !== Y) { + const d = Pn(f); + if (d.requestedExternalEmitHelpers ?? (d.requestedExternalEmitHelpers = 0), (d.requestedExternalEmitHelpers & a) !== a) { + const y = a & ~d.requestedExternalEmitHelpers; + for (let x = 1; x <= 16777216; x <<= 1) + if (y & x) + for (const I of eft(x)) { + const J = zc(Xl( + Om(f), + tc(I), + 111551 + /* Value */ + )); + J ? x & 524288 ? ot(I2(J), (z) => $_(z) > 3) || ze(r, p.This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0, Py, I, 4) : x & 1048576 ? ot(I2(J), (z) => $_(z) > 4) || ze(r, p.This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0, Py, I, 5) : x & 1024 && (ot(I2(J), (z) => $_(z) > 2) || ze(r, p.This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0, Py, I, 3)) : ze(r, p.This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0, Py, I); + } + } + d.requestedExternalEmitHelpers |= a; + } + } + } + } + function eft(r) { + switch (r) { + case 1: + return ["__extends"]; + case 2: + return ["__assign"]; + case 4: + return ["__rest"]; + case 8: + return U ? ["__decorate"] : ["__esDecorate", "__runInitializers"]; + case 16: + return ["__metadata"]; + case 32: + return ["__param"]; + case 64: + return ["__awaiter"]; + case 128: + return ["__generator"]; + case 256: + return ["__values"]; + case 512: + return ["__read"]; + case 1024: + return ["__spreadArray"]; + case 2048: + return ["__await"]; + case 4096: + return ["__asyncGenerator"]; + case 8192: + return ["__asyncDelegator"]; + case 16384: + return ["__asyncValues"]; + case 32768: + return ["__exportStar"]; + case 65536: + return ["__importStar"]; + case 131072: + return ["__importDefault"]; + case 262144: + return ["__makeTemplateObject"]; + case 524288: + return ["__classPrivateFieldGet"]; + case 1048576: + return ["__classPrivateFieldSet"]; + case 2097152: + return ["__classPrivateFieldIn"]; + case 4194304: + return ["__setFunctionName"]; + case 8388608: + return ["__propKey"]; + case 16777216: + return ["__addDisposableResource", "__disposeResources"]; + case 33554432: + return ["__rewriteRelativeImportExtension"]; + default: + return E.fail("Unrecognized helper"); + } + } + function tft(r, a) { + const l = xn(r); + return l.externalHelpersModule || (l.externalHelpersModule = _T(Xft(r), Py, p.This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found, a) || Y), l.externalHelpersModule; + } + function fh(r) { + var a; + const l = ift(r) || rft(r); + if (l !== void 0) + return l; + if (Ii(r) && My(r)) + return Bl(r, p.Neither_decorators_nor_modifiers_may_be_applied_to_this_parameters); + const f = Ic(r) ? r.declarationList.flags & 7 : 0; + let d, y, x, I, J, z = 0, G = !1, ve = !1; + for (const de of r.modifiers) + if (ul(de)) { + if (F3(U, r, r.parent, r.parent.parent)) { + if (U && (r.kind === 178 || r.kind === 179)) { + const We = Hme(r); + if (Ff(We.firstAccessor) && r === We.secondAccessor) + return Bl(r, p.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name); + } + } else return r.kind === 175 && !Mp(r.body) ? Bl(r, p.A_decorator_can_only_decorate_a_method_implementation_not_an_overload) : Bl(r, p.Decorators_are_not_valid_here); + if (z & -34849) + return mr(de, p.Decorators_are_not_valid_here); + if (ve && z & 98303) { + E.assertIsDefined(J); + const We = xr(de); + return F1(We) ? !1 : (zs( + ze(de, p.Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export), + sn(J, p.Decorator_used_before_export_here) + ), !0); + } + z |= 32768, z & 98303 ? z & 32 && (G = !0) : ve = !0, J ?? (J = de); + } else { + if (de.kind !== 148) { + if (r.kind === 172 || r.kind === 174) + return mr(de, p._0_modifier_cannot_appear_on_a_type_member, qs(de.kind)); + if (r.kind === 182 && (de.kind !== 126 || !$n(r.parent))) + return mr(de, p._0_modifier_cannot_appear_on_an_index_signature, qs(de.kind)); + } + if (de.kind !== 103 && de.kind !== 147 && de.kind !== 87 && r.kind === 169) + return mr(de, p._0_modifier_cannot_appear_on_a_type_parameter, qs(de.kind)); + switch (de.kind) { + case 87: { + if (r.kind !== 267 && r.kind !== 169) + return mr(r, p.A_class_member_cannot_have_the_0_keyword, qs( + 87 + /* ConstKeyword */ + )); + const gt = Up(r.parent) && X1(r.parent) || r.parent; + if (r.kind === 169 && !(io(gt) || $n(gt) || Zm(gt) || _6(gt) || Ux(gt) || N4(gt) || cd(gt))) + return mr(de, p._0_modifier_can_only_appear_on_a_type_parameter_of_a_function_method_or_class, qs(de.kind)); + break; + } + case 164: + if (z & 16) + return mr(de, p._0_modifier_already_seen, "override"); + if (z & 128) + return mr(de, p._0_modifier_cannot_be_used_with_1_modifier, "override", "declare"); + if (z & 8) + return mr(de, p._0_modifier_must_precede_1_modifier, "override", "readonly"); + if (z & 512) + return mr(de, p._0_modifier_must_precede_1_modifier, "override", "accessor"); + if (z & 1024) + return mr(de, p._0_modifier_must_precede_1_modifier, "override", "async"); + z |= 16, I = de; + break; + case 125: + case 124: + case 123: + const We = Qv(kx(de.kind)); + if (z & 7) + return mr(de, p.Accessibility_modifier_already_seen); + if (z & 16) + return mr(de, p._0_modifier_must_precede_1_modifier, We, "override"); + if (z & 256) + return mr(de, p._0_modifier_must_precede_1_modifier, We, "static"); + if (z & 512) + return mr(de, p._0_modifier_must_precede_1_modifier, We, "accessor"); + if (z & 8) + return mr(de, p._0_modifier_must_precede_1_modifier, We, "readonly"); + if (z & 1024) + return mr(de, p._0_modifier_must_precede_1_modifier, We, "async"); + if (r.parent.kind === 269 || r.parent.kind === 308) + return mr(de, p._0_modifier_cannot_appear_on_a_module_or_namespace_element, We); + if (z & 64) + return de.kind === 123 ? mr(de, p._0_modifier_cannot_be_used_with_1_modifier, We, "abstract") : mr(de, p._0_modifier_must_precede_1_modifier, We, "abstract"); + if (Du(r)) + return mr(de, p.An_accessibility_modifier_cannot_be_used_with_a_private_identifier); + z |= kx(de.kind); + break; + case 126: + if (z & 256) + return mr(de, p._0_modifier_already_seen, "static"); + if (z & 8) + return mr(de, p._0_modifier_must_precede_1_modifier, "static", "readonly"); + if (z & 1024) + return mr(de, p._0_modifier_must_precede_1_modifier, "static", "async"); + if (z & 512) + return mr(de, p._0_modifier_must_precede_1_modifier, "static", "accessor"); + if (r.parent.kind === 269 || r.parent.kind === 308) + return mr(de, p._0_modifier_cannot_appear_on_a_module_or_namespace_element, "static"); + if (r.kind === 170) + return mr(de, p._0_modifier_cannot_appear_on_a_parameter, "static"); + if (z & 64) + return mr(de, p._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract"); + if (z & 16) + return mr(de, p._0_modifier_must_precede_1_modifier, "static", "override"); + z |= 256, d = de; + break; + case 129: + if (z & 512) + return mr(de, p._0_modifier_already_seen, "accessor"); + if (z & 8) + return mr(de, p._0_modifier_cannot_be_used_with_1_modifier, "accessor", "readonly"); + if (z & 128) + return mr(de, p._0_modifier_cannot_be_used_with_1_modifier, "accessor", "declare"); + if (r.kind !== 173) + return mr(de, p.accessor_modifier_can_only_appear_on_a_property_declaration); + z |= 512; + break; + case 148: + if (z & 8) + return mr(de, p._0_modifier_already_seen, "readonly"); + if (r.kind !== 173 && r.kind !== 172 && r.kind !== 182 && r.kind !== 170) + return mr(de, p.readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature); + if (z & 512) + return mr(de, p._0_modifier_cannot_be_used_with_1_modifier, "readonly", "accessor"); + z |= 8; + break; + case 95: + if (F.verbatimModuleSyntax && !(r.flags & 33554432) && r.kind !== 266 && r.kind !== 265 && // ModuleDeclaration needs to be checked that it is uninstantiated later + r.kind !== 268 && r.parent.kind === 308 && e.getEmitModuleFormatOfFile(xr(r)) === 1) + return mr(de, p.A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled); + if (z & 32) + return mr(de, p._0_modifier_already_seen, "export"); + if (z & 128) + return mr(de, p._0_modifier_must_precede_1_modifier, "export", "declare"); + if (z & 64) + return mr(de, p._0_modifier_must_precede_1_modifier, "export", "abstract"); + if (z & 1024) + return mr(de, p._0_modifier_must_precede_1_modifier, "export", "async"); + if ($n(r.parent)) + return mr(de, p._0_modifier_cannot_appear_on_class_elements_of_this_kind, "export"); + if (r.kind === 170) + return mr(de, p._0_modifier_cannot_appear_on_a_parameter, "export"); + if (f === 4) + return mr(de, p._0_modifier_cannot_appear_on_a_using_declaration, "export"); + if (f === 6) + return mr(de, p._0_modifier_cannot_appear_on_an_await_using_declaration, "export"); + z |= 32; + break; + case 90: + const lt = r.parent.kind === 308 ? r.parent : r.parent.parent; + if (lt.kind === 268 && !Vu(lt)) + return mr(de, p.A_default_export_can_only_be_used_in_an_ECMAScript_style_module); + if (f === 4) + return mr(de, p._0_modifier_cannot_appear_on_a_using_declaration, "default"); + if (f === 6) + return mr(de, p._0_modifier_cannot_appear_on_an_await_using_declaration, "default"); + if (z & 32) { + if (G) + return mr(J, p.Decorators_are_not_valid_here); + } else return mr(de, p._0_modifier_must_precede_1_modifier, "export", "default"); + z |= 2048; + break; + case 138: + if (z & 128) + return mr(de, p._0_modifier_already_seen, "declare"); + if (z & 1024) + return mr(de, p._0_modifier_cannot_be_used_in_an_ambient_context, "async"); + if (z & 16) + return mr(de, p._0_modifier_cannot_be_used_in_an_ambient_context, "override"); + if ($n(r.parent) && !os(r)) + return mr(de, p._0_modifier_cannot_appear_on_class_elements_of_this_kind, "declare"); + if (r.kind === 170) + return mr(de, p._0_modifier_cannot_appear_on_a_parameter, "declare"); + if (f === 4) + return mr(de, p._0_modifier_cannot_appear_on_a_using_declaration, "declare"); + if (f === 6) + return mr(de, p._0_modifier_cannot_appear_on_an_await_using_declaration, "declare"); + if (r.parent.flags & 33554432 && r.parent.kind === 269) + return mr(de, p.A_declare_modifier_cannot_be_used_in_an_already_ambient_context); + if (Du(r)) + return mr(de, p._0_modifier_cannot_be_used_with_a_private_identifier, "declare"); + if (z & 512) + return mr(de, p._0_modifier_cannot_be_used_with_1_modifier, "declare", "accessor"); + z |= 128, y = de; + break; + case 128: + if (z & 64) + return mr(de, p._0_modifier_already_seen, "abstract"); + if (r.kind !== 264 && r.kind !== 186) { + if (r.kind !== 175 && r.kind !== 173 && r.kind !== 178 && r.kind !== 179) + return mr(de, p.abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration); + if (!(r.parent.kind === 264 && Gn( + r.parent, + 64 + /* Abstract */ + ))) { + const gt = r.kind === 173 ? p.Abstract_properties_can_only_appear_within_an_abstract_class : p.Abstract_methods_can_only_appear_within_an_abstract_class; + return mr(de, gt); + } + if (z & 256) + return mr(de, p._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract"); + if (z & 2) + return mr(de, p._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract"); + if (z & 1024 && x) + return mr(x, p._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract"); + if (z & 16) + return mr(de, p._0_modifier_must_precede_1_modifier, "abstract", "override"); + if (z & 512) + return mr(de, p._0_modifier_must_precede_1_modifier, "abstract", "accessor"); + } + if (wl(r) && r.name.kind === 81) + return mr(de, p._0_modifier_cannot_be_used_with_a_private_identifier, "abstract"); + z |= 64; + break; + case 134: + if (z & 1024) + return mr(de, p._0_modifier_already_seen, "async"); + if (z & 128 || r.parent.flags & 33554432) + return mr(de, p._0_modifier_cannot_be_used_in_an_ambient_context, "async"); + if (r.kind === 170) + return mr(de, p._0_modifier_cannot_appear_on_a_parameter, "async"); + if (z & 64) + return mr(de, p._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract"); + z |= 1024, x = de; + break; + case 103: + case 147: { + const gt = de.kind === 103 ? 8192 : 16384, jt = de.kind === 103 ? "in" : "out", ar = Up(r.parent) && (X1(r.parent) || Nn((a = GC(r.parent)) == null ? void 0 : a.tags, IS)) || r.parent; + if (r.kind !== 169 || ar && !(Vl(ar) || $n(ar) || Wp(ar) || IS(ar))) + return mr(de, p._0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias, jt); + if (z & gt) + return mr(de, p._0_modifier_already_seen, jt); + if (gt & 8192 && z & 16384) + return mr(de, p._0_modifier_must_precede_1_modifier, "in", "out"); + z |= gt; + break; + } + } + } + return r.kind === 177 ? z & 256 ? mr(d, p._0_modifier_cannot_appear_on_a_constructor_declaration, "static") : z & 16 ? mr(I, p._0_modifier_cannot_appear_on_a_constructor_declaration, "override") : z & 1024 ? mr(x, p._0_modifier_cannot_appear_on_a_constructor_declaration, "async") : !1 : (r.kind === 273 || r.kind === 272) && z & 128 ? mr(y, p.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare") : r.kind === 170 && z & 31 && ws(r.name) ? mr(r, p.A_parameter_property_may_not_be_declared_using_a_binding_pattern) : r.kind === 170 && z & 31 && r.dotDotDotToken ? mr(r, p.A_parameter_property_cannot_be_declared_using_a_rest_parameter) : z & 1024 ? aft(r, x) : !1; + } + function rft(r) { + if (!r.modifiers) return !1; + const a = nft(r); + return a && Bl(a, p.Modifiers_cannot_appear_here); + } + function WX(r, a) { + const l = Nn(r.modifiers, Zs); + return l && l.kind !== a ? l : void 0; + } + function nft(r) { + switch (r.kind) { + case 178: + case 179: + case 177: + case 173: + case 172: + case 175: + case 174: + case 182: + case 268: + case 273: + case 272: + case 279: + case 278: + case 219: + case 220: + case 170: + case 169: + return; + case 176: + case 304: + case 305: + case 271: + case 283: + return Nn(r.modifiers, Zs); + default: + if (r.parent.kind === 269 || r.parent.kind === 308) + return; + switch (r.kind) { + case 263: + return WX( + r, + 134 + /* AsyncKeyword */ + ); + case 264: + case 186: + return WX( + r, + 128 + /* AbstractKeyword */ + ); + case 232: + case 265: + case 266: + return Nn(r.modifiers, Zs); + case 244: + return r.declarationList.flags & 4 ? WX( + r, + 135 + /* AwaitKeyword */ + ) : Nn(r.modifiers, Zs); + case 267: + return WX( + r, + 87 + /* ConstKeyword */ + ); + default: + E.assertNever(r); + } + } + } + function ift(r) { + const a = sft(r); + return a && Bl(a, p.Decorators_are_not_valid_here); + } + function sft(r) { + return jz(r) ? Nn(r.modifiers, ul) : void 0; + } + function aft(r, a) { + switch (r.kind) { + case 175: + case 263: + case 219: + case 220: + return !1; + } + return mr(a, p._0_modifier_cannot_be_used_here, "async"); + } + function mC(r, a = p.Trailing_comma_not_allowed) { + return r && r.hasTrailingComma ? _b(r[0], r.end - 1, 1, a) : !1; + } + function p5e(r, a) { + if (r && r.length === 0) { + const l = r.pos - 1, f = oa(a.text, r.end) + 1; + return _b(a, l, f - l, p.Type_parameter_list_cannot_be_empty); + } + return !1; + } + function oft(r) { + let a = !1; + const l = r.length; + for (let f = 0; f < l; f++) { + const d = r[f]; + if (d.dotDotDotToken) { + if (f !== l - 1) + return mr(d.dotDotDotToken, p.A_rest_parameter_must_be_last_in_a_parameter_list); + if (d.flags & 33554432 || mC(r, p.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma), d.questionToken) + return mr(d.questionToken, p.A_rest_parameter_cannot_be_optional); + if (d.initializer) + return mr(d.name, p.A_rest_parameter_cannot_have_an_initializer); + } else if (YG(d)) { + if (a = !0, d.questionToken && d.initializer) + return mr(d.name, p.Parameter_cannot_have_question_mark_and_initializer); + } else if (a && !d.initializer) + return mr(d.name, p.A_required_parameter_cannot_follow_an_optional_parameter); + } + } + function cft(r) { + return kn(r, (a) => !!a.initializer || ws(a.name) || Hm(a)); + } + function lft(r) { + if (R >= 3) { + const a = r.body && Ns(r.body) && Oz(r.body.statements); + if (a) { + const l = cft(r.parameters); + if (wr(l)) { + lr(l, (d) => { + zs( + ze(d, p.This_parameter_is_not_allowed_with_use_strict_directive), + sn(a, p.use_strict_directive_used_here) + ); + }); + const f = l.map((d, y) => y === 0 ? sn(d, p.Non_simple_parameter_declared_here) : sn(d, p.and_here)); + return zs(ze(a, p.use_strict_directive_cannot_be_used_with_non_simple_parameter_list), ...f), !0; + } + } + } + return !1; + } + function UX(r) { + const a = xr(r); + return fh(r) || p5e(r.typeParameters, a) || oft(r.parameters) || _ft(r, a) || io(r) && lft(r); + } + function uft(r) { + const a = xr(r); + return gft(r) || p5e(r.typeParameters, a); + } + function _ft(r, a) { + if (!xo(r)) + return !1; + r.typeParameters && !(wr(r.typeParameters) > 1 || r.typeParameters.hasTrailingComma || r.typeParameters[0].constraint) && a && xc(a.fileName, [ + ".mts", + ".cts" + /* Cts */ + ]) && mr(r.typeParameters[0], p.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint); + const { equalsGreaterThanToken: l } = r, f = js(a, l.pos).line, d = js(a, l.end).line; + return f !== d && mr(l, p.Line_terminator_not_permitted_before_arrow); + } + function fft(r) { + const a = r.parameters[0]; + if (r.parameters.length !== 1) + return mr(a ? a.name : r, p.An_index_signature_must_have_exactly_one_parameter); + if (mC(r.parameters, p.An_index_signature_cannot_have_a_trailing_comma), a.dotDotDotToken) + return mr(a.dotDotDotToken, p.An_index_signature_cannot_have_a_rest_parameter); + if (rJ(a)) + return mr(a.name, p.An_index_signature_parameter_cannot_have_an_accessibility_modifier); + if (a.questionToken) + return mr(a.questionToken, p.An_index_signature_parameter_cannot_have_a_question_mark); + if (a.initializer) + return mr(a.name, p.An_index_signature_parameter_cannot_have_an_initializer); + if (!a.type) + return mr(a.name, p.An_index_signature_parameter_must_have_a_type_annotation); + const l = Ci(a.type); + return wp(l, (f) => !!(f.flags & 8576)) || nb(l) ? mr(a.name, p.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead) : G_(l, n$) ? r.type ? !1 : mr(r, p.An_index_signature_must_have_a_type_annotation) : mr(a.name, p.An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type); + } + function pft(r) { + return fh(r) || fft(r); + } + function dft(r, a) { + if (a && a.length === 0) { + const l = xr(r), f = a.pos - 1, d = oa(l.text, a.end) + 1; + return _b(l, f, d - f, p.Type_argument_list_cannot_be_empty); + } + return !1; + } + function dR(r, a) { + return mC(a) || dft(r, a); + } + function mft(r) { + return r.questionDotToken || r.flags & 64 ? mr(r.template, p.Tagged_template_expressions_are_not_permitted_in_an_optional_chain) : !1; + } + function d5e(r) { + const a = r.types; + if (mC(a)) + return !0; + if (a && a.length === 0) { + const l = qs(r.token); + return _b(r, a.pos, 0, p._0_list_cannot_be_empty, l); + } + return ot(a, m5e); + } + function m5e(r) { + return Dh(r) && P4(r.expression) && r.typeArguments ? mr(r, p.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments) : dR(r, r.typeArguments); + } + function gft(r) { + let a = !1, l = !1; + if (!fh(r) && r.heritageClauses) + for (const f of r.heritageClauses) { + if (f.token === 96) { + if (a) + return Bl(f, p.extends_clause_already_seen); + if (l) + return Bl(f, p.extends_clause_must_precede_implements_clause); + if (f.types.length > 1) + return Bl(f.types[1], p.Classes_can_only_extend_a_single_class); + a = !0; + } else { + if (E.assert( + f.token === 119 + /* ImplementsKeyword */ + ), l) + return Bl(f, p.implements_clause_already_seen); + l = !0; + } + d5e(f); + } + } + function hft(r) { + let a = !1; + if (r.heritageClauses) + for (const l of r.heritageClauses) { + if (l.token === 96) { + if (a) + return Bl(l, p.extends_clause_already_seen); + a = !0; + } else + return E.assert( + l.token === 119 + /* ImplementsKeyword */ + ), Bl(l, p.Interface_declaration_cannot_have_implements_clause); + d5e(l); + } + return !1; + } + function VX(r) { + if (r.kind !== 168) + return !1; + const a = r; + return a.expression.kind === 227 && a.expression.operatorToken.kind === 28 ? mr(a.expression, p.A_comma_expression_is_not_allowed_in_a_computed_property_name) : !1; + } + function Qme(r) { + if (r.asteriskToken) { + if (E.assert( + r.kind === 263 || r.kind === 219 || r.kind === 175 + /* MethodDeclaration */ + ), r.flags & 33554432) + return mr(r.asteriskToken, p.Generators_are_not_allowed_in_an_ambient_context); + if (!r.body) + return mr(r.asteriskToken, p.An_overload_signature_cannot_be_declared_as_a_generator); + } + } + function Yme(r, a) { + return !!r && mr(r, a); + } + function g5e(r, a) { + return !!r && mr(r, a); + } + function yft(r, a) { + const l = /* @__PURE__ */ new Map(); + for (const f of r.properties) { + if (f.kind === 306) { + if (a) { + const x = Ba(f.expression); + if (nu(x) || _a(x)) + return mr(f.expression, p.A_rest_element_cannot_contain_a_binding_pattern); + } + continue; + } + const d = f.name; + if (d.kind === 168 && VX(d), f.kind === 305 && !a && f.objectAssignmentInitializer && mr(f.equalsToken, p.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern), d.kind === 81 && mr(d, p.Private_identifiers_are_not_allowed_outside_class_bodies), Vp(f) && f.modifiers) + for (const x of f.modifiers) + Zs(x) && (x.kind !== 134 || f.kind !== 175) && mr(x, p._0_modifier_cannot_be_used_here, Qo(x)); + else if (ure(f) && f.modifiers) + for (const x of f.modifiers) + Zs(x) && mr(x, p._0_modifier_cannot_be_used_here, Qo(x)); + let y; + switch (f.kind) { + case 305: + case 304: + g5e(f.exclamationToken, p.A_definite_assignment_assertion_is_not_permitted_in_this_context), Yme(f.questionToken, p.An_object_member_cannot_be_declared_optional), d.kind === 9 && k5e(d), d.kind === 10 && Qg( + /*isError*/ + !0, + sn(d, p.A_bigint_literal_cannot_be_used_as_a_property_name) + ), y = 4; + break; + case 175: + y = 8; + break; + case 178: + y = 1; + break; + case 179: + y = 2; + break; + default: + E.assertNever(f, "Unexpected syntax kind:" + f.kind); + } + if (!a) { + const x = ege(d); + if (x === void 0) + continue; + const I = l.get(x); + if (!I) + l.set(x, y); + else if (y & 8 && I & 8) + mr(d, p.Duplicate_identifier_0, Qo(d)); + else if (y & 4 && I & 4) + mr(d, p.An_object_literal_cannot_have_multiple_properties_with_the_same_name, Qo(d)); + else if (y & 3 && I & 3) + if (I !== 3 && y !== I) + l.set(x, y | I); + else + return mr(d, p.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name); + else + return mr(d, p.An_object_literal_cannot_have_property_and_accessor_with_the_same_name); + } + } + } + function vft(r) { + bft(r.tagName), dR(r, r.typeArguments); + const a = /* @__PURE__ */ new Map(); + for (const l of r.attributes.properties) { + if (l.kind === 294) + continue; + const { name: f, initializer: d } = l, y = S4(f); + if (!a.get(y)) + a.set(y, !0); + else + return mr(f, p.JSX_elements_cannot_have_multiple_attributes_with_the_same_name); + if (d && d.kind === 295 && !d.expression) + return mr(d, p.JSX_attributes_must_only_be_assigned_a_non_empty_expression); + } + } + function bft(r) { + if (wn(r) && Fd(r.expression)) + return mr(r.expression, p.JSX_property_access_expressions_cannot_include_JSX_namespace_names); + if (Fd(r) && G5(F) && !YC(r.namespace.escapedText)) + return mr(r, p.React_components_cannot_include_JSX_namespace_names); + } + function Sft(r) { + if (r.expression && B4(r.expression)) + return mr(r.expression, p.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array); + } + function h5e(r) { + if (o0(r)) + return !0; + if (r.kind === 251 && r.awaitModifier && !(r.flags & 65536)) { + const a = xr(r); + if (n5(r)) { + if (!F1(a)) + switch (RC(a, F) || Aa.add(sn(r.awaitModifier, p.for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module)), B) { + case 100: + case 101: + case 102: + case 199: + if (a.impliedNodeFormat === 1) { + Aa.add( + sn(r.awaitModifier, p.The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level) + ); + break; + } + // fallthrough + case 7: + case 99: + case 200: + case 4: + if (R >= 4) + break; + // fallthrough + default: + Aa.add( + sn(r.awaitModifier, p.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher) + ); + break; + } + } else if (!F1(a)) { + const l = sn(r.awaitModifier, p.for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules), f = Af(r); + if (f && f.kind !== 177) { + E.assert((Mc(f) & 2) === 0, "Enclosing function should never be an async function."); + const d = sn(f, p.Did_you_mean_to_mark_this_function_as_async); + zs(l, d); + } + return Aa.add(l), !0; + } + } + if (JN(r) && !(r.flags & 65536) && Me(r.initializer) && r.initializer.escapedText === "async") + return mr(r.initializer, p.The_left_hand_side_of_a_for_of_statement_may_not_be_async), !1; + if (r.initializer.kind === 262) { + const a = r.initializer; + if (!Kme(a)) { + const l = a.declarations; + if (!l.length) + return !1; + if (l.length > 1) { + const d = r.kind === 250 ? p.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement : p.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement; + return Bl(a.declarations[1], d); + } + const f = l[0]; + if (f.initializer) { + const d = r.kind === 250 ? p.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer : p.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer; + return mr(f.name, d); + } + if (f.type) { + const d = r.kind === 250 ? p.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation : p.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation; + return mr(f, d); + } + } + } + return !1; + } + function Tft(r) { + if (!(r.flags & 33554432) && r.parent.kind !== 188 && r.parent.kind !== 265) { + if (R < 2 && Ai(r.name)) + return mr(r.name, p.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher); + if (r.body === void 0 && !Gn( + r, + 64 + /* Abstract */ + )) + return _b(r, r.end - 1, 1, p._0_expected, "{"); + } + if (r.body) { + if (Gn( + r, + 64 + /* Abstract */ + )) + return mr(r, p.An_abstract_accessor_cannot_have_an_implementation); + if (r.parent.kind === 188 || r.parent.kind === 265) + return mr(r.body, p.An_implementation_cannot_be_declared_in_ambient_contexts); + } + if (r.typeParameters) + return mr(r.name, p.An_accessor_cannot_have_type_parameters); + if (!xft(r)) + return mr( + r.name, + r.kind === 178 ? p.A_get_accessor_cannot_have_parameters : p.A_set_accessor_must_have_exactly_one_parameter + ); + if (r.kind === 179) { + if (r.type) + return mr(r.name, p.A_set_accessor_cannot_have_a_return_type_annotation); + const a = E.checkDefined(e4(r), "Return value does not match parameter count assertion."); + if (a.dotDotDotToken) + return mr(a.dotDotDotToken, p.A_set_accessor_cannot_have_rest_parameter); + if (a.questionToken) + return mr(a.questionToken, p.A_set_accessor_cannot_have_an_optional_parameter); + if (a.initializer) + return mr(r.name, p.A_set_accessor_parameter_cannot_have_an_initializer); + } + return !1; + } + function xft(r) { + return Zme(r) || r.parameters.length === (r.kind === 178 ? 0 : 1); + } + function Zme(r) { + if (r.parameters.length === (r.kind === 178 ? 1 : 2)) + return Rb(r); + } + function kft(r) { + if (r.operator === 158) { + if (r.type.kind !== 155) + return mr(r.type, p._0_expected, qs( + 155 + /* SymbolKeyword */ + )); + let a = $3(r.parent); + if (an(a) && lv(a)) { + const l = Fb(a); + l && (a = bx(l) || l); + } + switch (a.kind) { + case 261: + const l = a; + if (l.name.kind !== 80) + return mr(r, p.unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name); + if (!LD(l)) + return mr(r, p.unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement); + if (!(l.parent.flags & 2)) + return mr(a.name, p.A_variable_whose_type_is_a_unique_symbol_type_must_be_const); + break; + case 173: + if (!Js(a) || !gS(a)) + return mr(a.name, p.A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly); + break; + case 172: + if (!Gn( + a, + 8 + /* Readonly */ + )) + return mr(a.name, p.A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly); + break; + default: + return mr(r, p.unique_symbol_types_are_not_allowed_here); + } + } else if (r.operator === 148 && r.type.kind !== 189 && r.type.kind !== 190) + return Bl(r, p.readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types, qs( + 155 + /* SymbolKeyword */ + )); + } + function AP(r, a) { + if (KPe(r) && !to(uo(r) ? Ba(r.argumentExpression) : r.expression)) + return mr(r, a); + } + function y5e(r) { + if (UX(r)) + return !0; + if (r.kind === 175) { + if (r.parent.kind === 211) { + if (r.modifiers && !(r.modifiers.length === 1 && Ca(r.modifiers).kind === 134)) + return Bl(r, p.Modifiers_cannot_appear_here); + if (Yme(r.questionToken, p.An_object_member_cannot_be_declared_optional)) + return !0; + if (g5e(r.exclamationToken, p.A_definite_assignment_assertion_is_not_permitted_in_this_context)) + return !0; + if (r.body === void 0) + return _b(r, r.end - 1, 1, p._0_expected, "{"); + } + if (Qme(r)) + return !0; + } + if ($n(r.parent)) { + if (R < 2 && Ai(r.name)) + return mr(r.name, p.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher); + if (r.flags & 33554432) + return AP(r.name, p.A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type); + if (r.kind === 175 && !r.body) + return AP(r.name, p.A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type); + } else { + if (r.parent.kind === 265) + return AP(r.name, p.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type); + if (r.parent.kind === 188) + return AP(r.name, p.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type); + } + } + function Cft(r) { + let a = r; + for (; a; ) { + if (IC(a)) + return mr(r, p.Jump_target_cannot_cross_function_boundary); + switch (a.kind) { + case 257: + if (r.label && a.label.escapedText === r.label.escapedText) + return r.kind === 252 && !wy( + a.statement, + /*lookInLabeledStatements*/ + !0 + ) ? mr(r, p.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement) : !1; + break; + case 256: + if (r.kind === 253 && !r.label) + return !1; + break; + default: + if (wy( + a, + /*lookInLabeledStatements*/ + !1 + ) && !r.label) + return !1; + break; + } + a = a.parent; + } + if (r.label) { + const l = r.kind === 253 ? p.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement : p.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement; + return mr(r, l); + } else { + const l = r.kind === 253 ? p.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement : p.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement; + return mr(r, l); + } + } + function Eft(r) { + if (r.dotDotDotToken) { + const a = r.parent.elements; + if (r !== pa(a)) + return mr(r, p.A_rest_element_must_be_last_in_a_destructuring_pattern); + if (mC(a, p.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma), r.propertyName) + return mr(r.name, p.A_rest_element_cannot_have_a_property_name); + } + if (r.dotDotDotToken && r.initializer) + return _b(r, r.initializer.pos - 1, 1, p.A_rest_element_cannot_have_an_initializer); + } + function v5e(r) { + return If(r) || r.kind === 225 && r.operator === 41 && r.operand.kind === 9; + } + function Dft(r) { + return r.kind === 10 || r.kind === 225 && r.operator === 41 && r.operand.kind === 10; + } + function wft(r) { + if ((wn(r) || uo(r) && v5e(r.argumentExpression)) && to(r.expression)) + return !!(mc(r).flags & 1056); + } + function b5e(r) { + const a = r.initializer; + if (a) { + const l = !(v5e(a) || wft(a) || a.kind === 112 || a.kind === 97 || Dft(a)); + if ((C3(r) || ei(r) && UI(r)) && !r.type) { + if (l) + return mr(a, p.A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference); + } else + return mr(a, p.Initializers_are_not_allowed_in_ambient_contexts); + } + } + function Pft(r) { + const a = U2(r), l = a & 7; + if (ws(r.name)) + switch (l) { + case 6: + return mr(r, p._0_declarations_may_not_have_binding_patterns, "await using"); + case 4: + return mr(r, p._0_declarations_may_not_have_binding_patterns, "using"); + } + if (r.parent.parent.kind !== 250 && r.parent.parent.kind !== 251) { + if (a & 33554432) + b5e(r); + else if (!r.initializer) { + if (ws(r.name) && !ws(r.parent)) + return mr(r, p.A_destructuring_declaration_must_have_an_initializer); + switch (l) { + case 6: + return mr(r, p._0_declarations_must_be_initialized, "await using"); + case 4: + return mr(r, p._0_declarations_must_be_initialized, "using"); + case 2: + return mr(r, p._0_declarations_must_be_initialized, "const"); + } + } + } + if (r.exclamationToken && (r.parent.parent.kind !== 244 || !r.type || r.initializer || a & 33554432)) { + const f = r.initializer ? p.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions : r.type ? p.A_definite_assignment_assertion_is_not_permitted_in_this_context : p.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations; + return mr(r.exclamationToken, f); + } + return e.getEmitModuleFormatOfFile(xr(r)) < 4 && !(r.parent.parent.flags & 33554432) && Gn( + r.parent.parent, + 32 + /* Export */ + ) && S5e(r.name), !!l && T5e(r.name); + } + function S5e(r) { + if (r.kind === 80) { + if (An(r) === "__esModule") + return Ift("noEmit", r, p.Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules); + } else { + const a = r.elements; + for (const l of a) + if (!vl(l)) + return S5e(l.name); + } + return !1; + } + function T5e(r) { + if (r.kind === 80) { + if (r.escapedText === "let") + return mr(r, p.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations); + } else { + const a = r.elements; + for (const l of a) + vl(l) || T5e(l.name); + } + return !1; + } + function Kme(r) { + const a = r.declarations; + if (mC(r.declarations)) + return !0; + if (!r.declarations.length) + return _b(r, a.pos, a.end - a.pos, p.Variable_declaration_list_cannot_be_empty); + const l = r.flags & 7; + if (l === 4 || l === 6) { + if (PF(r.parent)) + return mr( + r, + l === 4 ? p.The_left_hand_side_of_a_for_in_statement_cannot_be_a_using_declaration : p.The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration + ); + if (r.flags & 33554432) + return mr( + r, + l === 4 ? p.using_declarations_are_not_allowed_in_ambient_contexts : p.await_using_declarations_are_not_allowed_in_ambient_contexts + ); + if (l === 6) + return BIe(r); + } + return !1; + } + function qX(r) { + switch (r.kind) { + case 246: + case 247: + case 248: + case 255: + case 249: + case 250: + case 251: + return !1; + case 257: + return qX(r.parent); + } + return !0; + } + function Nft(r) { + if (!qX(r.parent)) { + const a = U2(r.declarationList) & 7; + if (a) { + const l = a === 1 ? "let" : a === 2 ? "const" : a === 4 ? "using" : a === 6 ? "await using" : E.fail("Unknown BlockScope flag"); + ze(r, p._0_declarations_can_only_be_declared_inside_a_block, l); + } + } + } + function Aft(r) { + const a = r.name.escapedText; + switch (r.keywordToken) { + case 105: + if (a !== "target") + return mr(r.name, p._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, Si(r.name.escapedText), qs(r.keywordToken), "target"); + break; + case 102: + if (a !== "meta") { + const l = Ps(r.parent) && r.parent.expression === r; + if (a === "defer") { + if (!l) + return _b(r, r.end, 0, p._0_expected, "("); + } else + return l ? mr(r.name, p._0_is_not_a_valid_meta_property_for_keyword_import_Did_you_mean_meta_or_defer, Si(r.name.escapedText)) : mr(r.name, p._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, Si(r.name.escapedText), qs(r.keywordToken), "meta"); + } + break; + } + } + function F1(r) { + return r.parseDiagnostics.length > 0; + } + function Bl(r, a, ...l) { + const f = xr(r); + if (!F1(f)) { + const d = om(f, r.pos); + return Aa.add(ll(f, d.start, d.length, a, ...l)), !0; + } + return !1; + } + function _b(r, a, l, f, ...d) { + const y = xr(r); + return F1(y) ? !1 : (Aa.add(ll(y, a, l, f, ...d)), !0); + } + function Ift(r, a, l, ...f) { + const d = xr(a); + return F1(d) ? !1 : (B0(r, a, l, ...f), !0); + } + function mr(r, a, ...l) { + const f = xr(r); + return F1(f) ? !1 : (ze(r, a, ...l), !0); + } + function Fft(r) { + const a = an(r) ? P5(r) : void 0, l = r.typeParameters || a && Yc(a); + if (l) { + const f = l.pos === l.end ? l.pos : oa(xr(r).text, l.pos); + return _b(r, f, l.end - f, p.Type_parameters_cannot_appear_on_a_constructor_declaration); + } + } + function Oft(r) { + const a = r.type || nf(r); + if (a) + return mr(a, p.Type_annotation_cannot_appear_on_a_constructor_declaration); + } + function Lft(r) { + if (Gs(r.name) && _n(r.name.expression) && r.name.expression.operatorToken.kind === 103) + return mr(r.parent.members[0], p.A_mapped_type_may_not_declare_properties_or_methods); + if ($n(r.parent)) { + if (ca(r.name) && r.name.text === "constructor") + return mr(r.name, p.Classes_may_not_have_a_field_named_constructor); + if (AP(r.name, p.A_computed_property_name_in_a_class_property_declaration_must_have_a_simple_literal_type_or_a_unique_symbol_type)) + return !0; + if (R < 2 && Ai(r.name)) + return mr(r.name, p.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher); + if (R < 2 && b_(r) && !(r.flags & 33554432)) + return mr(r.name, p.Properties_with_the_accessor_modifier_are_only_available_when_targeting_ECMAScript_2015_and_higher); + if (b_(r) && Yme(r.questionToken, p.An_accessor_property_cannot_be_declared_optional)) + return !0; + } else if (r.parent.kind === 265) { + if (AP(r.name, p.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) + return !0; + if (E.assertNode(r, $u), r.initializer) + return mr(r.initializer, p.An_interface_property_cannot_have_an_initializer); + } else if (a_(r.parent)) { + if (AP(r.name, p.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) + return !0; + if (E.assertNode(r, $u), r.initializer) + return mr(r.initializer, p.A_type_literal_property_cannot_have_an_initializer); + } + if (r.flags & 33554432 && b5e(r), os(r) && r.exclamationToken && (!$n(r.parent) || !r.type || r.initializer || r.flags & 33554432 || Js(r) || Jb(r))) { + const a = r.initializer ? p.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions : r.type ? p.A_definite_assignment_assertion_is_not_permitted_in_this_context : p.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations; + return mr(r.exclamationToken, a); + } + } + function Mft(r) { + return r.kind === 265 || r.kind === 266 || r.kind === 273 || r.kind === 272 || r.kind === 279 || r.kind === 278 || r.kind === 271 || Gn( + r, + 2208 + /* Default */ + ) ? !1 : Bl(r, p.Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier); + } + function Rft(r) { + for (const a of r.statements) + if ((Pl(a) || a.kind === 244) && Mft(a)) + return !0; + return !1; + } + function x5e(r) { + return !!(r.flags & 33554432) && Rft(r); + } + function o0(r) { + if (r.flags & 33554432) { + if (!xn(r).hasReportedStatementInAmbientContext && (Es(r.parent) || Dy(r.parent))) + return xn(r).hasReportedStatementInAmbientContext = Bl(r, p.An_implementation_cannot_be_declared_in_ambient_contexts); + if (r.parent.kind === 242 || r.parent.kind === 269 || r.parent.kind === 308) { + const l = xn(r.parent); + if (!l.hasReportedStatementInAmbientContext) + return l.hasReportedStatementInAmbientContext = Bl(r, p.Statements_are_not_allowed_in_ambient_contexts); + } + } + return !1; + } + function k5e(r) { + const a = Qo(r).includes("."), l = r.numericLiteralFlags & 16; + a || l || +r.text <= 2 ** 53 - 1 || Qg( + /*isError*/ + !1, + sn(r, p.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers) + ); + } + function jft(r) { + return !!(!(E0(r.parent) || iv(r.parent) && E0(r.parent.parent)) && !(r.flags & 33554432) && R < 7 && mr(r, p.BigInt_literals_are_not_available_when_targeting_lower_than_ES2020)); + } + function Bft(r, a, ...l) { + const f = xr(r); + if (!F1(f)) { + const d = om(f, r.pos); + return Aa.add(ll( + f, + ec(d), + /*length*/ + 0, + a, + ...l + )), !0; + } + return !1; + } + function Jft() { + return Ef || (Ef = [], Ye.forEach((r, a) => { + kne.test(a) && Ef.push(r); + })), Ef; + } + function zft(r) { + var a, l; + if (r.phaseModifier === 156) { + if (r.name && r.namedBindings) + return mr(r, p.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both); + if (((a = r.namedBindings) == null ? void 0 : a.kind) === 276) + return C5e(r.namedBindings); + } else if (r.phaseModifier === 166) { + if (r.name) + return mr(r, p.Default_imports_are_not_allowed_in_a_deferred_import); + if (((l = r.namedBindings) == null ? void 0 : l.kind) === 276) + return mr(r, p.Named_imports_are_not_allowed_in_a_deferred_import); + if (B !== 99 && B !== 200) + return mr(r, p.Deferred_imports_are_only_supported_when_the_module_flag_is_set_to_esnext_or_preserve); + } + return !1; + } + function C5e(r) { + return !!lr(r.elements, (a) => { + if (a.isTypeOnly) + return Bl( + a, + a.kind === 277 ? p.The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement : p.The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement + ); + }); + } + function Wft(r) { + if (F.verbatimModuleSyntax && B === 1) + return mr(r, nT(r)); + if (r.expression.kind === 237) { + if (B !== 99 && B !== 200) + return mr(r, p.Deferred_imports_are_only_supported_when_the_module_flag_is_set_to_esnext_or_preserve); + } else if (B === 5) + return mr(r, p.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_node18_node20_or_nodenext); + if (r.typeArguments) + return mr(r, p.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments); + const a = r.arguments; + if (!(100 <= B && B <= 199) && B !== 99 && B !== 200 && (mC(a), a.length > 1)) { + const f = a[1]; + return mr(f, p.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_node18_node20_nodenext_or_preserve); + } + if (a.length === 0 || a.length > 2) + return mr(r, p.Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_set_of_attributes_as_arguments); + const l = Nn(a, dp); + return l ? mr(l, p.Argument_of_dynamic_import_cannot_be_spread_element) : !1; + } + function Uft(r, a) { + const l = Dn(r); + if (l & 20 && a.flags & 1048576) + return Nn(a.types, (f) => { + if (f.flags & 524288) { + const d = l & Dn(f); + if (d & 4) + return r.target === f.target; + if (d & 16) + return !!r.aliasSymbol && r.aliasSymbol === f.aliasSymbol; + } + return !1; + }); + } + function Vft(r, a) { + if (Dn(r) & 128 && wp(a, iy)) + return Nn(a.types, (l) => !iy(l)); + } + function qft(r, a) { + let l = 0; + if (Is(r, l).length > 0 || (l = 1, Is(r, l).length > 0)) + return Nn(a.types, (d) => Is(d, l).length > 0); + } + function Hft(r, a) { + let l; + if (!(r.flags & 406978556)) { + let f = 0; + for (const d of a.types) + if (!(d.flags & 406978556)) { + const y = sa([jm(r), jm(d)]); + if (y.flags & 4194304) + return d; + if (Qd(y) || y.flags & 1048576) { + const x = y.flags & 1048576 ? l0(y.types, Qd) : 1; + x >= f && (l = d, f = x); + } + } + } + return l; + } + function Gft(r) { + if (Dc( + r, + 67108864 + /* NonPrimitive */ + )) { + const a = Xc(r, (l) => !(l.flags & 402784252)); + if (!(a.flags & 131072)) + return a; + } + return r; + } + function E5e(r, a, l) { + if (a.flags & 1048576 && r.flags & 2621440) { + const f = DAe(a, r); + if (f) + return f; + const d = $a(r); + if (d) { + const y = EAe(d, a); + if (y) { + const x = Mpe(a, hr(y, (I) => [() => Yr(I), I.escapedName]), l); + if (x !== a) + return x; + } + } + } + } + function ege(r) { + const a = dS(r); + return a || (Gs(r) ? cde(lu(r.expression)) : void 0); + } + function HX(r) { + return tr === r || (tr = r, Nr = J1(r)), Nr; + } + function U2(r) { + return St === r || (St = r, Bt = yh(r)), Bt; + } + function UI(r) { + const a = U2(r) & 7; + return a === 2 || a === 4 || a === 6; + } + function $ft(r, a) { + const l = F.importHelpers ? 1 : 0, f = r?.imports[l]; + return f && E.assert(lo(f) && f.text === a, `Expected sourceFile.imports[${l}] to be the synthesized JSX runtime import`), f; + } + function Xft(r) { + E.assert(F.importHelpers, "Expected importHelpers to be enabled"); + const a = r.imports[0]; + return E.assert(a && lo(a) && a.text === "tslib", "Expected sourceFile.imports[0] to be the synthesized tslib import"), a; + } + } + function ARe(e) { + return !Dy(e); + } + function V1e(e) { + return e.kind !== 263 && e.kind !== 175 || !!e.body; + } + function q1e(e) { + switch (e.parent.kind) { + case 277: + case 282: + return Me(e) || e.kind === 11; + default: + return Qm(e); + } + } + var Rf; + ((e) => { + e.JSX = "JSX", e.IntrinsicElements = "IntrinsicElements", e.ElementClass = "ElementClass", e.ElementAttributesPropertyNameContainer = "ElementAttributesProperty", e.ElementChildrenAttributeNameContainer = "ElementChildrenAttribute", e.Element = "Element", e.ElementType = "ElementType", e.IntrinsicAttributes = "IntrinsicAttributes", e.IntrinsicClassAttributes = "IntrinsicClassAttributes", e.LibraryManagedAttributes = "LibraryManagedAttributes"; + })(Rf || (Rf = {})); + var FW; + ((e) => { + e.Fragment = "Fragment"; + })(FW || (FW = {})); + function H1e(e) { + switch (e) { + case 0: + return "yieldType"; + case 1: + return "returnType"; + case 2: + return "nextType"; + } + } + function Iu(e) { + return !!(e.flags & 1); + } + function G1e(e) { + return !!(e.flags & 2); + } + function IRe(e) { + return { + getCommonSourceDirectory: e.getCommonSourceDirectory ? () => e.getCommonSourceDirectory() : () => "", + getCurrentDirectory: () => e.getCurrentDirectory(), + getSymlinkCache: Os(e, e.getSymlinkCache), + getPackageJsonInfoCache: () => { + var t; + return (t = e.getPackageJsonInfoCache) == null ? void 0 : t.call(e); + }, + useCaseSensitiveFileNames: () => e.useCaseSensitiveFileNames(), + redirectTargetsMap: e.redirectTargetsMap, + getRedirectFromSourceFile: (t) => e.getRedirectFromSourceFile(t), + isSourceOfProjectReferenceRedirect: (t) => e.isSourceOfProjectReferenceRedirect(t), + fileExists: (t) => e.fileExists(t), + getFileIncludeReasons: () => e.getFileIncludeReasons(), + readFile: e.readFile ? (t) => e.readFile(t) : void 0, + getDefaultResolutionModeForFile: (t) => e.getDefaultResolutionModeForFile(t), + getModeForResolutionAtIndex: (t, n) => e.getModeForResolutionAtIndex(t, n), + getGlobalTypingsCacheLocation: Os(e, e.getGlobalTypingsCacheLocation) + }; + } + var Dne = class J5e { + constructor(t, n, i) { + this.moduleResolverHost = void 0, this.inner = void 0, this.disableTrackSymbol = !1; + for (var s; n instanceof J5e; ) + n = n.inner; + this.inner = n, this.moduleResolverHost = i, this.context = t, this.canTrackSymbol = !!((s = this.inner) != null && s.trackSymbol); + } + trackSymbol(t, n, i) { + var s, o; + if ((s = this.inner) != null && s.trackSymbol && !this.disableTrackSymbol) { + if (this.inner.trackSymbol(t, n, i)) + return this.onDiagnosticReported(), !0; + t.flags & 262144 || ((o = this.context).trackedSymbols ?? (o.trackedSymbols = [])).push([t, n, i]); + } + return !1; + } + reportInaccessibleThisError() { + var t; + (t = this.inner) != null && t.reportInaccessibleThisError && (this.onDiagnosticReported(), this.inner.reportInaccessibleThisError()); + } + reportPrivateInBaseOfClassExpression(t) { + var n; + (n = this.inner) != null && n.reportPrivateInBaseOfClassExpression && (this.onDiagnosticReported(), this.inner.reportPrivateInBaseOfClassExpression(t)); + } + reportInaccessibleUniqueSymbolError() { + var t; + (t = this.inner) != null && t.reportInaccessibleUniqueSymbolError && (this.onDiagnosticReported(), this.inner.reportInaccessibleUniqueSymbolError()); + } + reportCyclicStructureError() { + var t; + (t = this.inner) != null && t.reportCyclicStructureError && (this.onDiagnosticReported(), this.inner.reportCyclicStructureError()); + } + reportLikelyUnsafeImportRequiredError(t) { + var n; + (n = this.inner) != null && n.reportLikelyUnsafeImportRequiredError && (this.onDiagnosticReported(), this.inner.reportLikelyUnsafeImportRequiredError(t)); + } + reportTruncationError() { + var t; + (t = this.inner) != null && t.reportTruncationError && (this.onDiagnosticReported(), this.inner.reportTruncationError()); + } + reportNonlocalAugmentation(t, n, i) { + var s; + (s = this.inner) != null && s.reportNonlocalAugmentation && (this.onDiagnosticReported(), this.inner.reportNonlocalAugmentation(t, n, i)); + } + reportNonSerializableProperty(t) { + var n; + (n = this.inner) != null && n.reportNonSerializableProperty && (this.onDiagnosticReported(), this.inner.reportNonSerializableProperty(t)); + } + onDiagnosticReported() { + this.context.reportedDiagnostic = !0; + } + reportInferenceFallback(t) { + var n; + (n = this.inner) != null && n.reportInferenceFallback && !this.context.suppressReportInferenceFallback && (this.onDiagnosticReported(), this.inner.reportInferenceFallback(t)); + } + pushErrorFallbackNode(t) { + var n, i; + return (i = (n = this.inner) == null ? void 0 : n.pushErrorFallbackNode) == null ? void 0 : i.call(n, t); + } + popErrorFallbackNode() { + var t, n; + return (n = (t = this.inner) == null ? void 0 : t.popErrorFallbackNode) == null ? void 0 : n.call(t); + } + }; + function Qe(e, t, n, i) { + if (e === void 0) + return e; + const s = t(e); + let o; + if (s !== void 0) + return as(s) ? o = (i || jRe)(s) : o = s, E.assertNode(o, n), o; + } + function Ar(e, t, n, i, s) { + if (e === void 0) + return e; + const o = e.length; + (i === void 0 || i < 0) && (i = 0), (s === void 0 || s > o - i) && (s = o - i); + let c, _ = -1, u = -1; + i > 0 || s < o ? c = e.hasTrailingComma && i + s === o : (_ = e.pos, u = e.end, c = e.hasTrailingComma); + const g = $1e(e, t, n, i, s); + if (g !== e) { + const m = N.createNodeArray(g, c); + return Ad(m, _, u), m; + } + return e; + } + function Q4(e, t, n, i, s) { + if (e === void 0) + return e; + const o = e.length; + return (i === void 0 || i < 0) && (i = 0), (s === void 0 || s > o - i) && (s = o - i), $1e(e, t, n, i, s); + } + function $1e(e, t, n, i, s) { + let o; + const c = e.length; + (i > 0 || s < c) && (o = []); + for (let _ = 0; _ < s; _++) { + const u = e[_ + i], g = u !== void 0 ? t ? t(u) : u : void 0; + if ((o !== void 0 || g === void 0 || g !== u) && (o === void 0 && (o = e.slice(0, _), E.assertEachNode(o, n)), g)) + if (as(g)) + for (const m of g) + E.assertNode(m, n), o.push(m); + else + E.assertNode(g, n), o.push(g); + } + return o || (E.assertEachNode(e, n), e); + } + function OW(e, t, n, i, s, o = Ar) { + return n.startLexicalEnvironment(), e = o(e, t, Ti, i), s && (e = n.factory.ensureUseStrict(e)), N.mergeLexicalEnvironment(e, n.endLexicalEnvironment()); + } + function _c(e, t, n, i = Ar) { + let s; + return n.startLexicalEnvironment(), e && (n.setLexicalEnvironmentFlags(1, !0), s = i(e, t, Ii), n.getLexicalEnvironmentFlags() & 2 && da(n.getCompilerOptions()) >= 2 && (s = FRe(s, n)), n.setLexicalEnvironmentFlags(1, !1)), n.suspendLexicalEnvironment(), s; + } + function FRe(e, t) { + let n; + for (let i = 0; i < e.length; i++) { + const s = e[i], o = ORe(s, t); + (n || o !== s) && (n || (n = e.slice(0, i)), n[i] = o); + } + return n ? ct(t.factory.createNodeArray(n, e.hasTrailingComma), e) : e; + } + function ORe(e, t) { + return e.dotDotDotToken ? e : ws(e.name) ? LRe(e, t) : e.initializer ? MRe(e, e.name, e.initializer, t) : e; + } + function LRe(e, t) { + const { factory: n } = t; + return t.addInitializationStatement( + n.createVariableStatement( + /*modifiers*/ + void 0, + n.createVariableDeclarationList([ + n.createVariableDeclaration( + e.name, + /*exclamationToken*/ + void 0, + e.type, + e.initializer ? n.createConditionalExpression( + n.createStrictEquality( + n.getGeneratedNameForNode(e), + n.createVoidZero() + ), + /*questionToken*/ + void 0, + e.initializer, + /*colonToken*/ + void 0, + n.getGeneratedNameForNode(e) + ) : n.getGeneratedNameForNode(e) + ) + ]) + ) + ), n.updateParameterDeclaration( + e, + e.modifiers, + e.dotDotDotToken, + n.getGeneratedNameForNode(e), + e.questionToken, + e.type, + /*initializer*/ + void 0 + ); + } + function MRe(e, t, n, i) { + const s = i.factory; + return i.addInitializationStatement( + s.createIfStatement( + s.createTypeCheck(s.cloneNode(t), "undefined"), + un( + ct( + s.createBlock([ + s.createExpressionStatement( + un( + ct( + s.createAssignment( + un( + s.cloneNode(t), + 96 + /* NoSourceMap */ + ), + un( + n, + 96 | Ea(n) | 3072 + /* NoComments */ + ) + ), + e + ), + 3072 + /* NoComments */ + ) + ) + ]), + e + ), + 3905 + /* NoComments */ + ) + ) + ), s.updateParameterDeclaration( + e, + e.modifiers, + e.dotDotDotToken, + e.name, + e.questionToken, + e.type, + /*initializer*/ + void 0 + ); + } + function jf(e, t, n, i = Qe) { + n.resumeLexicalEnvironment(); + const s = i(e, t, N7), o = n.endLexicalEnvironment(); + if (ot(o)) { + if (!s) + return n.factory.createBlock(o); + const c = n.factory.converters.convertToFunctionBlock(s), _ = N.mergeLexicalEnvironment(c.statements, o); + return n.factory.updateBlock(c, _); + } + return s; + } + function c_(e, t, n, i = Qe) { + n.startBlockScope(); + const s = i(e, t, Ti, n.factory.liftToBlock); + E.assert(s); + const o = n.endBlockScope(); + return ot(o) ? Ns(s) ? (o.push(...s.statements), n.factory.updateBlock(s, o)) : (o.push(s), n.factory.createBlock(o)) : s; + } + function SO(e, t, n = t) { + if (n === t || e.length <= 1) + return Ar(e, t, ut); + let i = 0; + const s = e.length; + return Ar(e, (o) => { + const c = i < s - 1; + return i++, c ? n(o) : t(o); + }, ut); + } + function br(e, t, n = SA, i = Ar, s, o = Qe) { + if (e === void 0) + return; + const c = RRe[e.kind]; + return c === void 0 ? e : c(e, t, n, i, o, s); + } + var RRe = { + 167: function(t, n, i, s, o, c) { + return i.factory.updateQualifiedName( + t, + E.checkDefined(o(t.left, n, r_)), + E.checkDefined(o(t.right, n, Me)) + ); + }, + 168: function(t, n, i, s, o, c) { + return i.factory.updateComputedPropertyName( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + // Signature elements + 169: function(t, n, i, s, o, c) { + return i.factory.updateTypeParameterDeclaration( + t, + s(t.modifiers, n, Zs), + E.checkDefined(o(t.name, n, Me)), + o(t.constraint, n, li), + o(t.default, n, li) + ); + }, + 170: function(t, n, i, s, o, c) { + return i.factory.updateParameterDeclaration( + t, + s(t.modifiers, n, Jo), + c ? o(t.dotDotDotToken, c, TF) : t.dotDotDotToken, + E.checkDefined(o(t.name, n, rS)), + c ? o(t.questionToken, c, Vy) : t.questionToken, + o(t.type, n, li), + o(t.initializer, n, ut) + ); + }, + 171: function(t, n, i, s, o, c) { + return i.factory.updateDecorator( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + // Type elements + 172: function(t, n, i, s, o, c) { + return i.factory.updatePropertySignature( + t, + s(t.modifiers, n, Zs), + E.checkDefined(o(t.name, n, qc)), + c ? o(t.questionToken, c, Vy) : t.questionToken, + o(t.type, n, li) + ); + }, + 173: function(t, n, i, s, o, c) { + return i.factory.updatePropertyDeclaration( + t, + s(t.modifiers, n, Jo), + E.checkDefined(o(t.name, n, qc)), + // QuestionToken and ExclamationToken are mutually exclusive in PropertyDeclaration + c ? o(t.questionToken ?? t.exclamationToken, c, _re) : t.questionToken ?? t.exclamationToken, + o(t.type, n, li), + o(t.initializer, n, ut) + ); + }, + 174: function(t, n, i, s, o, c) { + return i.factory.updateMethodSignature( + t, + s(t.modifiers, n, Zs), + E.checkDefined(o(t.name, n, qc)), + c ? o(t.questionToken, c, Vy) : t.questionToken, + s(t.typeParameters, n, Lo), + s(t.parameters, n, Ii), + o(t.type, n, li) + ); + }, + 175: function(t, n, i, s, o, c) { + return i.factory.updateMethodDeclaration( + t, + s(t.modifiers, n, Jo), + c ? o(t.asteriskToken, c, MN) : t.asteriskToken, + E.checkDefined(o(t.name, n, qc)), + c ? o(t.questionToken, c, Vy) : t.questionToken, + s(t.typeParameters, n, Lo), + _c(t.parameters, n, i, s), + o(t.type, n, li), + jf(t.body, n, i, o) + ); + }, + 177: function(t, n, i, s, o, c) { + return i.factory.updateConstructorDeclaration( + t, + s(t.modifiers, n, Jo), + _c(t.parameters, n, i, s), + jf(t.body, n, i, o) + ); + }, + 178: function(t, n, i, s, o, c) { + return i.factory.updateGetAccessorDeclaration( + t, + s(t.modifiers, n, Jo), + E.checkDefined(o(t.name, n, qc)), + _c(t.parameters, n, i, s), + o(t.type, n, li), + jf(t.body, n, i, o) + ); + }, + 179: function(t, n, i, s, o, c) { + return i.factory.updateSetAccessorDeclaration( + t, + s(t.modifiers, n, Jo), + E.checkDefined(o(t.name, n, qc)), + _c(t.parameters, n, i, s), + jf(t.body, n, i, o) + ); + }, + 176: function(t, n, i, s, o, c) { + return i.startLexicalEnvironment(), i.suspendLexicalEnvironment(), i.factory.updateClassStaticBlockDeclaration( + t, + jf(t.body, n, i, o) + ); + }, + 180: function(t, n, i, s, o, c) { + return i.factory.updateCallSignature( + t, + s(t.typeParameters, n, Lo), + s(t.parameters, n, Ii), + o(t.type, n, li) + ); + }, + 181: function(t, n, i, s, o, c) { + return i.factory.updateConstructSignature( + t, + s(t.typeParameters, n, Lo), + s(t.parameters, n, Ii), + o(t.type, n, li) + ); + }, + 182: function(t, n, i, s, o, c) { + return i.factory.updateIndexSignature( + t, + s(t.modifiers, n, Jo), + s(t.parameters, n, Ii), + E.checkDefined(o(t.type, n, li)) + ); + }, + // Types + 183: function(t, n, i, s, o, c) { + return i.factory.updateTypePredicateNode( + t, + o(t.assertsModifier, n, Ite), + E.checkDefined(o(t.parameterName, n, fre)), + o(t.type, n, li) + ); + }, + 184: function(t, n, i, s, o, c) { + return i.factory.updateTypeReferenceNode( + t, + E.checkDefined(o(t.typeName, n, r_)), + s(t.typeArguments, n, li) + ); + }, + 185: function(t, n, i, s, o, c) { + return i.factory.updateFunctionTypeNode( + t, + s(t.typeParameters, n, Lo), + s(t.parameters, n, Ii), + E.checkDefined(o(t.type, n, li)) + ); + }, + 186: function(t, n, i, s, o, c) { + return i.factory.updateConstructorTypeNode( + t, + s(t.modifiers, n, Zs), + s(t.typeParameters, n, Lo), + s(t.parameters, n, Ii), + E.checkDefined(o(t.type, n, li)) + ); + }, + 187: function(t, n, i, s, o, c) { + return i.factory.updateTypeQueryNode( + t, + E.checkDefined(o(t.exprName, n, r_)), + s(t.typeArguments, n, li) + ); + }, + 188: function(t, n, i, s, o, c) { + return i.factory.updateTypeLiteralNode( + t, + s(t.members, n, kb) + ); + }, + 189: function(t, n, i, s, o, c) { + return i.factory.updateArrayTypeNode( + t, + E.checkDefined(o(t.elementType, n, li)) + ); + }, + 190: function(t, n, i, s, o, c) { + return i.factory.updateTupleTypeNode( + t, + s(t.elements, n, li) + ); + }, + 191: function(t, n, i, s, o, c) { + return i.factory.updateOptionalTypeNode( + t, + E.checkDefined(o(t.type, n, li)) + ); + }, + 192: function(t, n, i, s, o, c) { + return i.factory.updateRestTypeNode( + t, + E.checkDefined(o(t.type, n, li)) + ); + }, + 193: function(t, n, i, s, o, c) { + return i.factory.updateUnionTypeNode( + t, + s(t.types, n, li) + ); + }, + 194: function(t, n, i, s, o, c) { + return i.factory.updateIntersectionTypeNode( + t, + s(t.types, n, li) + ); + }, + 195: function(t, n, i, s, o, c) { + return i.factory.updateConditionalTypeNode( + t, + E.checkDefined(o(t.checkType, n, li)), + E.checkDefined(o(t.extendsType, n, li)), + E.checkDefined(o(t.trueType, n, li)), + E.checkDefined(o(t.falseType, n, li)) + ); + }, + 196: function(t, n, i, s, o, c) { + return i.factory.updateInferTypeNode( + t, + E.checkDefined(o(t.typeParameter, n, Lo)) + ); + }, + 206: function(t, n, i, s, o, c) { + return i.factory.updateImportTypeNode( + t, + E.checkDefined(o(t.argument, n, li)), + o(t.attributes, n, PS), + o(t.qualifier, n, r_), + s(t.typeArguments, n, li), + t.isTypeOf + ); + }, + 303: function(t, n, i, s, o, c) { + return i.factory.updateImportTypeAssertionContainer( + t, + E.checkDefined(o(t.assertClause, n, Wte)), + t.multiLine + ); + }, + 203: function(t, n, i, s, o, c) { + return i.factory.updateNamedTupleMember( + t, + c ? o(t.dotDotDotToken, c, TF) : t.dotDotDotToken, + E.checkDefined(o(t.name, n, Me)), + c ? o(t.questionToken, c, Vy) : t.questionToken, + E.checkDefined(o(t.type, n, li)) + ); + }, + 197: function(t, n, i, s, o, c) { + return i.factory.updateParenthesizedType( + t, + E.checkDefined(o(t.type, n, li)) + ); + }, + 199: function(t, n, i, s, o, c) { + return i.factory.updateTypeOperatorNode( + t, + E.checkDefined(o(t.type, n, li)) + ); + }, + 200: function(t, n, i, s, o, c) { + return i.factory.updateIndexedAccessTypeNode( + t, + E.checkDefined(o(t.objectType, n, li)), + E.checkDefined(o(t.indexType, n, li)) + ); + }, + 201: function(t, n, i, s, o, c) { + return i.factory.updateMappedTypeNode( + t, + c ? o(t.readonlyToken, c, pre) : t.readonlyToken, + E.checkDefined(o(t.typeParameter, n, Lo)), + o(t.nameType, n, li), + c ? o(t.questionToken, c, dre) : t.questionToken, + o(t.type, n, li), + s(t.members, n, kb) + ); + }, + 202: function(t, n, i, s, o, c) { + return i.factory.updateLiteralTypeNode( + t, + E.checkDefined(o(t.literal, n, PZ)) + ); + }, + 204: function(t, n, i, s, o, c) { + return i.factory.updateTemplateLiteralType( + t, + E.checkDefined(o(t.head, n, Jx)), + s(t.templateSpans, n, mz) + ); + }, + 205: function(t, n, i, s, o, c) { + return i.factory.updateTemplateLiteralTypeSpan( + t, + E.checkDefined(o(t.type, n, li)), + E.checkDefined(o(t.literal, n, E7)) + ); + }, + // Binding patterns + 207: function(t, n, i, s, o, c) { + return i.factory.updateObjectBindingPattern( + t, + s(t.elements, n, ya) + ); + }, + 208: function(t, n, i, s, o, c) { + return i.factory.updateArrayBindingPattern( + t, + s(t.elements, n, w7) + ); + }, + 209: function(t, n, i, s, o, c) { + return i.factory.updateBindingElement( + t, + c ? o(t.dotDotDotToken, c, TF) : t.dotDotDotToken, + o(t.propertyName, n, qc), + E.checkDefined(o(t.name, n, rS)), + o(t.initializer, n, ut) + ); + }, + // Expression + 210: function(t, n, i, s, o, c) { + return i.factory.updateArrayLiteralExpression( + t, + s(t.elements, n, ut) + ); + }, + 211: function(t, n, i, s, o, c) { + return i.factory.updateObjectLiteralExpression( + t, + s(t.properties, n, vh) + ); + }, + 212: function(t, n, i, s, o, c) { + return T7(t) ? i.factory.updatePropertyAccessChain( + t, + E.checkDefined(o(t.expression, n, ut)), + c ? o(t.questionDotToken, c, xF) : t.questionDotToken, + E.checkDefined(o(t.name, n, wg)) + ) : i.factory.updatePropertyAccessExpression( + t, + E.checkDefined(o(t.expression, n, ut)), + E.checkDefined(o(t.name, n, wg)) + ); + }, + 213: function(t, n, i, s, o, c) { + return Rj(t) ? i.factory.updateElementAccessChain( + t, + E.checkDefined(o(t.expression, n, ut)), + c ? o(t.questionDotToken, c, xF) : t.questionDotToken, + E.checkDefined(o(t.argumentExpression, n, ut)) + ) : i.factory.updateElementAccessExpression( + t, + E.checkDefined(o(t.expression, n, ut)), + E.checkDefined(o(t.argumentExpression, n, ut)) + ); + }, + 214: function(t, n, i, s, o, c) { + return K2(t) ? i.factory.updateCallChain( + t, + E.checkDefined(o(t.expression, n, ut)), + c ? o(t.questionDotToken, c, xF) : t.questionDotToken, + s(t.typeArguments, n, li), + s(t.arguments, n, ut) + ) : i.factory.updateCallExpression( + t, + E.checkDefined(o(t.expression, n, ut)), + s(t.typeArguments, n, li), + s(t.arguments, n, ut) + ); + }, + 215: function(t, n, i, s, o, c) { + return i.factory.updateNewExpression( + t, + E.checkDefined(o(t.expression, n, ut)), + s(t.typeArguments, n, li), + s(t.arguments, n, ut) + ); + }, + 216: function(t, n, i, s, o, c) { + return i.factory.updateTaggedTemplateExpression( + t, + E.checkDefined(o(t.tag, n, ut)), + s(t.typeArguments, n, li), + E.checkDefined(o(t.template, n, ox)) + ); + }, + 217: function(t, n, i, s, o, c) { + return i.factory.updateTypeAssertion( + t, + E.checkDefined(o(t.type, n, li)), + E.checkDefined(o(t.expression, n, ut)) + ); + }, + 218: function(t, n, i, s, o, c) { + return i.factory.updateParenthesizedExpression( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + 219: function(t, n, i, s, o, c) { + return i.factory.updateFunctionExpression( + t, + s(t.modifiers, n, Zs), + c ? o(t.asteriskToken, c, MN) : t.asteriskToken, + o(t.name, n, Me), + s(t.typeParameters, n, Lo), + _c(t.parameters, n, i, s), + o(t.type, n, li), + jf(t.body, n, i, o) + ); + }, + 220: function(t, n, i, s, o, c) { + return i.factory.updateArrowFunction( + t, + s(t.modifiers, n, Zs), + s(t.typeParameters, n, Lo), + _c(t.parameters, n, i, s), + o(t.type, n, li), + c ? E.checkDefined(o(t.equalsGreaterThanToken, c, Ate)) : t.equalsGreaterThanToken, + jf(t.body, n, i, o) + ); + }, + 221: function(t, n, i, s, o, c) { + return i.factory.updateDeleteExpression( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + 222: function(t, n, i, s, o, c) { + return i.factory.updateTypeOfExpression( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + 223: function(t, n, i, s, o, c) { + return i.factory.updateVoidExpression( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + 224: function(t, n, i, s, o, c) { + return i.factory.updateAwaitExpression( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + 225: function(t, n, i, s, o, c) { + return i.factory.updatePrefixUnaryExpression( + t, + E.checkDefined(o(t.operand, n, ut)) + ); + }, + 226: function(t, n, i, s, o, c) { + return i.factory.updatePostfixUnaryExpression( + t, + E.checkDefined(o(t.operand, n, ut)) + ); + }, + 227: function(t, n, i, s, o, c) { + return i.factory.updateBinaryExpression( + t, + E.checkDefined(o(t.left, n, ut)), + c ? E.checkDefined(o(t.operatorToken, c, gre)) : t.operatorToken, + E.checkDefined(o(t.right, n, ut)) + ); + }, + 228: function(t, n, i, s, o, c) { + return i.factory.updateConditionalExpression( + t, + E.checkDefined(o(t.condition, n, ut)), + c ? E.checkDefined(o(t.questionToken, c, Vy)) : t.questionToken, + E.checkDefined(o(t.whenTrue, n, ut)), + c ? E.checkDefined(o(t.colonToken, c, Nte)) : t.colonToken, + E.checkDefined(o(t.whenFalse, n, ut)) + ); + }, + 229: function(t, n, i, s, o, c) { + return i.factory.updateTemplateExpression( + t, + E.checkDefined(o(t.head, n, Jx)), + s(t.templateSpans, n, g6) + ); + }, + 230: function(t, n, i, s, o, c) { + return i.factory.updateYieldExpression( + t, + c ? o(t.asteriskToken, c, MN) : t.asteriskToken, + o(t.expression, n, ut) + ); + }, + 231: function(t, n, i, s, o, c) { + return i.factory.updateSpreadElement( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + 232: function(t, n, i, s, o, c) { + return i.factory.updateClassExpression( + t, + s(t.modifiers, n, Jo), + o(t.name, n, Me), + s(t.typeParameters, n, Lo), + s(t.heritageClauses, n, cf), + s(t.members, n, Hc) + ); + }, + 234: function(t, n, i, s, o, c) { + return i.factory.updateExpressionWithTypeArguments( + t, + E.checkDefined(o(t.expression, n, ut)), + s(t.typeArguments, n, li) + ); + }, + 235: function(t, n, i, s, o, c) { + return i.factory.updateAsExpression( + t, + E.checkDefined(o(t.expression, n, ut)), + E.checkDefined(o(t.type, n, li)) + ); + }, + 239: function(t, n, i, s, o, c) { + return i.factory.updateSatisfiesExpression( + t, + E.checkDefined(o(t.expression, n, ut)), + E.checkDefined(o(t.type, n, li)) + ); + }, + 236: function(t, n, i, s, o, c) { + return Eu(t) ? i.factory.updateNonNullChain( + t, + E.checkDefined(o(t.expression, n, ut)) + ) : i.factory.updateNonNullExpression( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + 237: function(t, n, i, s, o, c) { + return i.factory.updateMetaProperty( + t, + E.checkDefined(o(t.name, n, Me)) + ); + }, + // Misc + 240: function(t, n, i, s, o, c) { + return i.factory.updateTemplateSpan( + t, + E.checkDefined(o(t.expression, n, ut)), + E.checkDefined(o(t.literal, n, E7)) + ); + }, + // Element + 242: function(t, n, i, s, o, c) { + return i.factory.updateBlock( + t, + s(t.statements, n, Ti) + ); + }, + 244: function(t, n, i, s, o, c) { + return i.factory.updateVariableStatement( + t, + s(t.modifiers, n, Jo), + E.checkDefined(o(t.declarationList, n, Ul)) + ); + }, + 245: function(t, n, i, s, o, c) { + return i.factory.updateExpressionStatement( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + 246: function(t, n, i, s, o, c) { + return i.factory.updateIfStatement( + t, + E.checkDefined(o(t.expression, n, ut)), + E.checkDefined(o(t.thenStatement, n, Ti, i.factory.liftToBlock)), + o(t.elseStatement, n, Ti, i.factory.liftToBlock) + ); + }, + 247: function(t, n, i, s, o, c) { + return i.factory.updateDoStatement( + t, + c_(t.statement, n, i, o), + E.checkDefined(o(t.expression, n, ut)) + ); + }, + 248: function(t, n, i, s, o, c) { + return i.factory.updateWhileStatement( + t, + E.checkDefined(o(t.expression, n, ut)), + c_(t.statement, n, i, o) + ); + }, + 249: function(t, n, i, s, o, c) { + return i.factory.updateForStatement( + t, + o(t.initializer, n, ip), + o(t.condition, n, ut), + o(t.incrementor, n, ut), + c_(t.statement, n, i, o) + ); + }, + 250: function(t, n, i, s, o, c) { + return i.factory.updateForInStatement( + t, + E.checkDefined(o(t.initializer, n, ip)), + E.checkDefined(o(t.expression, n, ut)), + c_(t.statement, n, i, o) + ); + }, + 251: function(t, n, i, s, o, c) { + return i.factory.updateForOfStatement( + t, + c ? o(t.awaitModifier, c, pz) : t.awaitModifier, + E.checkDefined(o(t.initializer, n, ip)), + E.checkDefined(o(t.expression, n, ut)), + c_(t.statement, n, i, o) + ); + }, + 252: function(t, n, i, s, o, c) { + return i.factory.updateContinueStatement( + t, + o(t.label, n, Me) + ); + }, + 253: function(t, n, i, s, o, c) { + return i.factory.updateBreakStatement( + t, + o(t.label, n, Me) + ); + }, + 254: function(t, n, i, s, o, c) { + return i.factory.updateReturnStatement( + t, + o(t.expression, n, ut) + ); + }, + 255: function(t, n, i, s, o, c) { + return i.factory.updateWithStatement( + t, + E.checkDefined(o(t.expression, n, ut)), + E.checkDefined(o(t.statement, n, Ti, i.factory.liftToBlock)) + ); + }, + 256: function(t, n, i, s, o, c) { + return i.factory.updateSwitchStatement( + t, + E.checkDefined(o(t.expression, n, ut)), + E.checkDefined(o(t.caseBlock, n, O4)) + ); + }, + 257: function(t, n, i, s, o, c) { + return i.factory.updateLabeledStatement( + t, + E.checkDefined(o(t.label, n, Me)), + E.checkDefined(o(t.statement, n, Ti, i.factory.liftToBlock)) + ); + }, + 258: function(t, n, i, s, o, c) { + return i.factory.updateThrowStatement( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + 259: function(t, n, i, s, o, c) { + return i.factory.updateTryStatement( + t, + E.checkDefined(o(t.tryBlock, n, Ns)), + o(t.catchClause, n, Zb), + o(t.finallyBlock, n, Ns) + ); + }, + 261: function(t, n, i, s, o, c) { + return i.factory.updateVariableDeclaration( + t, + E.checkDefined(o(t.name, n, rS)), + c ? o(t.exclamationToken, c, RN) : t.exclamationToken, + o(t.type, n, li), + o(t.initializer, n, ut) + ); + }, + 262: function(t, n, i, s, o, c) { + return i.factory.updateVariableDeclarationList( + t, + s(t.declarations, n, ei) + ); + }, + 263: function(t, n, i, s, o, c) { + return i.factory.updateFunctionDeclaration( + t, + s(t.modifiers, n, Zs), + c ? o(t.asteriskToken, c, MN) : t.asteriskToken, + o(t.name, n, Me), + s(t.typeParameters, n, Lo), + _c(t.parameters, n, i, s), + o(t.type, n, li), + jf(t.body, n, i, o) + ); + }, + 264: function(t, n, i, s, o, c) { + return i.factory.updateClassDeclaration( + t, + s(t.modifiers, n, Jo), + o(t.name, n, Me), + s(t.typeParameters, n, Lo), + s(t.heritageClauses, n, cf), + s(t.members, n, Hc) + ); + }, + 265: function(t, n, i, s, o, c) { + return i.factory.updateInterfaceDeclaration( + t, + s(t.modifiers, n, Jo), + E.checkDefined(o(t.name, n, Me)), + s(t.typeParameters, n, Lo), + s(t.heritageClauses, n, cf), + s(t.members, n, kb) + ); + }, + 266: function(t, n, i, s, o, c) { + return i.factory.updateTypeAliasDeclaration( + t, + s(t.modifiers, n, Jo), + E.checkDefined(o(t.name, n, Me)), + s(t.typeParameters, n, Lo), + E.checkDefined(o(t.type, n, li)) + ); + }, + 267: function(t, n, i, s, o, c) { + return i.factory.updateEnumDeclaration( + t, + s(t.modifiers, n, Jo), + E.checkDefined(o(t.name, n, Me)), + s(t.members, n, Ph) + ); + }, + 268: function(t, n, i, s, o, c) { + return i.factory.updateModuleDeclaration( + t, + s(t.modifiers, n, Jo), + E.checkDefined(o(t.name, n, mre)), + o(t.body, n, AZ) + ); + }, + 269: function(t, n, i, s, o, c) { + return i.factory.updateModuleBlock( + t, + s(t.statements, n, Ti) + ); + }, + 270: function(t, n, i, s, o, c) { + return i.factory.updateCaseBlock( + t, + s(t.clauses, n, I7) + ); + }, + 271: function(t, n, i, s, o, c) { + return i.factory.updateNamespaceExportDeclaration( + t, + E.checkDefined(o(t.name, n, Me)) + ); + }, + 272: function(t, n, i, s, o, c) { + return i.factory.updateImportEqualsDeclaration( + t, + s(t.modifiers, n, Jo), + t.isTypeOnly, + E.checkDefined(o(t.name, n, Me)), + E.checkDefined(o(t.moduleReference, n, MZ)) + ); + }, + 273: function(t, n, i, s, o, c) { + return i.factory.updateImportDeclaration( + t, + s(t.modifiers, n, Jo), + o(t.importClause, n, ld), + E.checkDefined(o(t.moduleSpecifier, n, ut)), + o(t.attributes, n, PS) + ); + }, + 301: function(t, n, i, s, o, c) { + return i.factory.updateImportAttributes( + t, + s(t.elements, n, Ute), + t.multiLine + ); + }, + 302: function(t, n, i, s, o, c) { + return i.factory.updateImportAttribute( + t, + E.checkDefined(o(t.name, n, xZ)), + E.checkDefined(o(t.value, n, ut)) + ); + }, + 274: function(t, n, i, s, o, c) { + return i.factory.updateImportClause( + t, + t.phaseModifier, + o(t.name, n, Me), + o(t.namedBindings, n, Qj) + ); + }, + 275: function(t, n, i, s, o, c) { + return i.factory.updateNamespaceImport( + t, + E.checkDefined(o(t.name, n, Me)) + ); + }, + 281: function(t, n, i, s, o, c) { + return i.factory.updateNamespaceExport( + t, + E.checkDefined(o(t.name, n, Me)) + ); + }, + 276: function(t, n, i, s, o, c) { + return i.factory.updateNamedImports( + t, + s(t.elements, n, Xu) + ); + }, + 277: function(t, n, i, s, o, c) { + return i.factory.updateImportSpecifier( + t, + t.isTypeOnly, + o(t.propertyName, n, NF), + E.checkDefined(o(t.name, n, Me)) + ); + }, + 278: function(t, n, i, s, o, c) { + return i.factory.updateExportAssignment( + t, + s(t.modifiers, n, Jo), + E.checkDefined(o(t.expression, n, ut)) + ); + }, + 279: function(t, n, i, s, o, c) { + return i.factory.updateExportDeclaration( + t, + s(t.modifiers, n, Jo), + t.isTypeOnly, + o(t.exportClause, n, Bj), + o(t.moduleSpecifier, n, ut), + o(t.attributes, n, PS) + ); + }, + 280: function(t, n, i, s, o, c) { + return i.factory.updateNamedExports( + t, + s(t.elements, n, Nu) + ); + }, + 282: function(t, n, i, s, o, c) { + return i.factory.updateExportSpecifier( + t, + t.isTypeOnly, + o(t.propertyName, n, NF), + E.checkDefined(o(t.name, n, NF)) + ); + }, + // Module references + 284: function(t, n, i, s, o, c) { + return i.factory.updateExternalModuleReference( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + // JSX + 285: function(t, n, i, s, o, c) { + return i.factory.updateJsxElement( + t, + E.checkDefined(o(t.openingElement, n, Id)), + s(t.children, n, g3), + E.checkDefined(o(t.closingElement, n, Qb)) + ); + }, + 286: function(t, n, i, s, o, c) { + return i.factory.updateJsxSelfClosingElement( + t, + E.checkDefined(o(t.tagName, n, PD)), + s(t.typeArguments, n, li), + E.checkDefined(o(t.attributes, n, Yb)) + ); + }, + 287: function(t, n, i, s, o, c) { + return i.factory.updateJsxOpeningElement( + t, + E.checkDefined(o(t.tagName, n, PD)), + s(t.typeArguments, n, li), + E.checkDefined(o(t.attributes, n, Yb)) + ); + }, + 288: function(t, n, i, s, o, c) { + return i.factory.updateJsxClosingElement( + t, + E.checkDefined(o(t.tagName, n, PD)) + ); + }, + 296: function(t, n, i, s, o, c) { + return i.factory.updateJsxNamespacedName( + t, + E.checkDefined(o(t.namespace, n, Me)), + E.checkDefined(o(t.name, n, Me)) + ); + }, + 289: function(t, n, i, s, o, c) { + return i.factory.updateJsxFragment( + t, + E.checkDefined(o(t.openingFragment, n, ud)), + s(t.children, n, g3), + E.checkDefined(o(t.closingFragment, n, qte)) + ); + }, + 292: function(t, n, i, s, o, c) { + return i.factory.updateJsxAttribute( + t, + E.checkDefined(o(t.name, n, Kee)), + o(t.initializer, n, RZ) + ); + }, + 293: function(t, n, i, s, o, c) { + return i.factory.updateJsxAttributes( + t, + s(t.properties, n, A7) + ); + }, + 294: function(t, n, i, s, o, c) { + return i.factory.updateJsxSpreadAttribute( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + 295: function(t, n, i, s, o, c) { + return i.factory.updateJsxExpression( + t, + o(t.expression, n, ut) + ); + }, + // Clauses + 297: function(t, n, i, s, o, c) { + return i.factory.updateCaseClause( + t, + E.checkDefined(o(t.expression, n, ut)), + s(t.statements, n, Ti) + ); + }, + 298: function(t, n, i, s, o, c) { + return i.factory.updateDefaultClause( + t, + s(t.statements, n, Ti) + ); + }, + 299: function(t, n, i, s, o, c) { + return i.factory.updateHeritageClause( + t, + s(t.types, n, Dh) + ); + }, + 300: function(t, n, i, s, o, c) { + return i.factory.updateCatchClause( + t, + o(t.variableDeclaration, n, ei), + E.checkDefined(o(t.block, n, Ns)) + ); + }, + // Property assignments + 304: function(t, n, i, s, o, c) { + return i.factory.updatePropertyAssignment( + t, + E.checkDefined(o(t.name, n, qc)), + E.checkDefined(o(t.initializer, n, ut)) + ); + }, + 305: function(t, n, i, s, o, c) { + return i.factory.updateShorthandPropertyAssignment( + t, + E.checkDefined(o(t.name, n, Me)), + o(t.objectAssignmentInitializer, n, ut) + ); + }, + 306: function(t, n, i, s, o, c) { + return i.factory.updateSpreadAssignment( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + // Enum + 307: function(t, n, i, s, o, c) { + return i.factory.updateEnumMember( + t, + E.checkDefined(o(t.name, n, qc)), + o(t.initializer, n, ut) + ); + }, + // Top-level nodes + 308: function(t, n, i, s, o, c) { + return i.factory.updateSourceFile( + t, + OW(t.statements, n, i) + ); + }, + // Transformation nodes + 356: function(t, n, i, s, o, c) { + return i.factory.updatePartiallyEmittedExpression( + t, + E.checkDefined(o(t.expression, n, ut)) + ); + }, + 357: function(t, n, i, s, o, c) { + return i.factory.updateCommaListExpression( + t, + s(t.elements, n, ut) + ); + } + }; + function jRe(e) { + return E.assert(e.length <= 1, "Too many nodes written to output."), xg(e); + } + function wne(e, t, n, i, s) { + var { enter: o, exit: c } = s.extendedDiagnostics ? $R("Source Map", "beforeSourcemap", "afterSourcemap") : CQ, _ = [], u = [], g = /* @__PURE__ */ new Map(), m, h = [], S, T = [], k = "", D = 0, P = 0, A = 0, O = 0, F = 0, R = 0, B = !1, U = 0, $ = 0, W = 0, _e = 0, K = 0, V = 0, ae = !1, se = !1, ce = !1; + return { + getSources: () => _, + addSource: fe, + setSourceContent: he, + addName: q, + addMapping: me, + appendSourceMap: Z, + toJSON: ne, + toString: () => JSON.stringify(ne()) + }; + function fe(ie) { + o(); + const Ne = rx( + i, + ie, + e.getCurrentDirectory(), + e.getCanonicalFileName, + /*isAbsolutePathAnUrl*/ + !0 + ); + let Ee = g.get(Ne); + return Ee === void 0 && (Ee = u.length, u.push(Ne), _.push(ie), g.set(Ne, Ee)), c(), Ee; + } + function he(ie, Ne) { + if (o(), Ne !== null) { + for (m || (m = []); m.length < ie; ) + m.push(null); + m[ie] = Ne; + } + c(); + } + function q(ie) { + o(), S || (S = /* @__PURE__ */ new Map()); + let Ne = S.get(ie); + return Ne === void 0 && (Ne = h.length, h.push(ie), S.set(ie, Ne)), c(), Ne; + } + function be(ie, Ne) { + return !ae || U !== ie || $ !== Ne; + } + function je(ie, Ne, Ee) { + return ie !== void 0 && Ne !== void 0 && Ee !== void 0 && W === ie && (_e > Ne || _e === Ne && K > Ee); + } + function me(ie, Ne, Ee, Ce, Ve, St) { + E.assert(ie >= U, "generatedLine cannot backtrack"), E.assert(Ne >= 0, "generatedCharacter cannot be negative"), E.assert(Ee === void 0 || Ee >= 0, "sourceIndex cannot be negative"), E.assert(Ce === void 0 || Ce >= 0, "sourceLine cannot be negative"), E.assert(Ve === void 0 || Ve >= 0, "sourceCharacter cannot be negative"), o(), (be(ie, Ne) || je(Ee, Ce, Ve)) && (Fe(), U = ie, $ = Ne, se = !1, ce = !1, ae = !0), Ee !== void 0 && Ce !== void 0 && Ve !== void 0 && (W = Ee, _e = Ce, K = Ve, se = !0, St !== void 0 && (V = St, ce = !0)), c(); + } + function Z(ie, Ne, Ee, Ce, Ve, St) { + E.assert(ie >= U, "generatedLine cannot backtrack"), E.assert(Ne >= 0, "generatedCharacter cannot be negative"), o(); + const Bt = []; + let tr; + const Nr = jW(Ee.mappings); + for (const st of Nr) { + if (St && (st.generatedLine > St.line || st.generatedLine === St.line && st.generatedCharacter > St.character)) + break; + if (Ve && (st.generatedLine < Ve.line || Ve.line === st.generatedLine && st.generatedCharacter < Ve.character)) + continue; + let Wt, Jr, ui, Ji; + if (st.sourceIndex !== void 0) { + if (Wt = Bt[st.sourceIndex], Wt === void 0) { + const pn = Ee.sources[st.sourceIndex], _i = Ee.sourceRoot ? On(Ee.sourceRoot, pn) : pn, Je = On(Hn(Ce), _i); + Bt[st.sourceIndex] = Wt = fe(Je), Ee.sourcesContent && typeof Ee.sourcesContent[st.sourceIndex] == "string" && he(Wt, Ee.sourcesContent[st.sourceIndex]); + } + Jr = st.sourceLine, ui = st.sourceCharacter, Ee.names && st.nameIndex !== void 0 && (tr || (tr = []), Ji = tr[st.nameIndex], Ji === void 0 && (tr[st.nameIndex] = Ji = q(Ee.names[st.nameIndex]))); + } + const Dt = st.generatedLine - (Ve ? Ve.line : 0), Mn = Dt + ie, ai = Ve && Ve.line === st.generatedLine ? st.generatedCharacter - Ve.character : st.generatedCharacter, fi = Dt === 0 ? ai + Ne : ai; + me(Mn, fi, Wt, Jr, ui, Ji); + } + c(); + } + function pe() { + return !B || D !== U || P !== $ || A !== W || O !== _e || F !== K || R !== V; + } + function Te(ie) { + T.push(ie), T.length >= 1024 && Ye(); + } + function Fe() { + if (!(!ae || !pe())) { + if (o(), D < U) { + do + Te( + 59 + /* semicolon */ + ), D++; + while (D < U); + P = 0; + } else + E.assertEqual(D, U, "generatedLine cannot backtrack"), B && Te( + 44 + /* comma */ + ); + Se($ - P), P = $, se && (Se(W - A), A = W, Se(_e - O), O = _e, Se(K - F), F = K, ce && (Se(V - R), R = V)), B = !0, c(); + } + } + function Ye() { + T.length > 0 && (k += String.fromCharCode.apply(void 0, T), T.length = 0); + } + function ne() { + return Fe(), Ye(), { + version: 3, + file: t, + sourceRoot: n, + sources: u, + names: h, + mappings: k, + sourcesContent: m + }; + } + function Se(ie) { + ie < 0 ? ie = (-ie << 1) + 1 : ie = ie << 1; + do { + let Ne = ie & 31; + ie = ie >> 5, ie > 0 && (Ne = Ne | 32), Te(zRe(Ne)); + } while (ie > 0); + } + } + var Pne = /\/\/[@#] source[M]appingURL=(.+)\r?\n?$/, LW = /^\/\/[@#] source[M]appingURL=(.+)\r?\n?$/, MW = /^\s*(\/\/[@#] .*)?$/; + function RW(e, t) { + return { + getLineCount: () => t.length, + getLineText: (n) => e.substring(t[n], t[n + 1]) + }; + } + function Nne(e) { + for (let t = e.getLineCount() - 1; t >= 0; t--) { + const n = e.getLineText(t), i = LW.exec(n); + if (i) + return i[1].trimEnd(); + if (!n.match(MW)) + break; + } + } + function BRe(e) { + return typeof e == "string" || e === null; + } + function JRe(e) { + return e !== null && typeof e == "object" && e.version === 3 && typeof e.file == "string" && typeof e.mappings == "string" && as(e.sources) && Ni(e.sources, gs) && (e.sourceRoot === void 0 || e.sourceRoot === null || typeof e.sourceRoot == "string") && (e.sourcesContent === void 0 || e.sourcesContent === null || as(e.sourcesContent) && Ni(e.sourcesContent, BRe)) && (e.names === void 0 || e.names === null || as(e.names) && Ni(e.names, gs)); + } + function Ane(e) { + try { + const t = JSON.parse(e); + if (JRe(t)) + return t; + } catch { + } + } + function jW(e) { + let t = !1, n = 0, i = 0, s = 0, o = 0, c = 0, _ = 0, u = 0, g; + return { + get pos() { + return n; + }, + get error() { + return g; + }, + get state() { + return m( + /*hasSource*/ + !0, + /*hasName*/ + !0 + ); + }, + next() { + for (; !t && n < e.length; ) { + const A = e.charCodeAt(n); + if (A === 59) { + i++, s = 0, n++; + continue; + } + if (A === 44) { + n++; + continue; + } + let O = !1, F = !1; + if (s += P(), k()) return h(); + if (s < 0) return T("Invalid generatedCharacter found"); + if (!D()) { + if (O = !0, o += P(), k()) return h(); + if (o < 0) return T("Invalid sourceIndex found"); + if (D()) return T("Unsupported Format: No entries after sourceIndex"); + if (c += P(), k()) return h(); + if (c < 0) return T("Invalid sourceLine found"); + if (D()) return T("Unsupported Format: No entries after sourceLine"); + if (_ += P(), k()) return h(); + if (_ < 0) return T("Invalid sourceCharacter found"); + if (!D()) { + if (F = !0, u += P(), k()) return h(); + if (u < 0) return T("Invalid nameIndex found"); + if (!D()) return T("Unsupported Error Format: Entries after nameIndex"); + } + } + return { value: m(O, F), done: t }; + } + return h(); + }, + [Symbol.iterator]() { + return this; + } + }; + function m(A, O) { + return { + generatedLine: i, + generatedCharacter: s, + sourceIndex: A ? o : void 0, + sourceLine: A ? c : void 0, + sourceCharacter: A ? _ : void 0, + nameIndex: O ? u : void 0 + }; + } + function h() { + return t = !0, { value: void 0, done: !0 }; + } + function S(A) { + g === void 0 && (g = A); + } + function T(A) { + return S(A), h(); + } + function k() { + return g !== void 0; + } + function D() { + return n === e.length || e.charCodeAt(n) === 44 || e.charCodeAt(n) === 59; + } + function P() { + let A = !0, O = 0, F = 0; + for (; A; n++) { + if (n >= e.length) return S("Error in decoding base64VLQFormatDecode, past the mapping string"), -1; + const R = WRe(e.charCodeAt(n)); + if (R === -1) return S("Invalid character in VLQ"), -1; + A = (R & 32) !== 0, F = F | (R & 31) << O, O += 5; + } + return (F & 1) === 0 ? F = F >> 1 : (F = F >> 1, F = -F), F; + } + } + function X1e(e, t) { + return e === t || e.generatedLine === t.generatedLine && e.generatedCharacter === t.generatedCharacter && e.sourceIndex === t.sourceIndex && e.sourceLine === t.sourceLine && e.sourceCharacter === t.sourceCharacter && e.nameIndex === t.nameIndex; + } + function Ine(e) { + return e.sourceIndex !== void 0 && e.sourceLine !== void 0 && e.sourceCharacter !== void 0; + } + function zRe(e) { + return e >= 0 && e < 26 ? 65 + e : e >= 26 && e < 52 ? 97 + e - 26 : e >= 52 && e < 62 ? 48 + e - 52 : e === 62 ? 43 : e === 63 ? 47 : E.fail(`${e}: not a base64 value`); + } + function WRe(e) { + return e >= 65 && e <= 90 ? e - 65 : e >= 97 && e <= 122 ? e - 97 + 26 : e >= 48 && e <= 57 ? e - 48 + 52 : e === 43 ? 62 : e === 47 ? 63 : -1; + } + function Q1e(e) { + return e.sourceIndex !== void 0 && e.sourcePosition !== void 0; + } + function Y1e(e, t) { + return e.generatedPosition === t.generatedPosition && e.sourceIndex === t.sourceIndex && e.sourcePosition === t.sourcePosition; + } + function URe(e, t) { + return E.assert(e.sourceIndex === t.sourceIndex), ho(e.sourcePosition, t.sourcePosition); + } + function VRe(e, t) { + return ho(e.generatedPosition, t.generatedPosition); + } + function qRe(e) { + return e.sourcePosition; + } + function HRe(e) { + return e.generatedPosition; + } + function Fne(e, t, n) { + const i = Hn(n), s = t.sourceRoot ? Qi(t.sourceRoot, i) : i, o = Qi(t.file, i), c = e.getSourceFileLike(o), _ = t.sources.map((O) => Qi(O, s)), u = new Map(_.map((O, F) => [e.getCanonicalFileName(O), F])); + let g, m, h; + return { + getSourcePosition: A, + getGeneratedPosition: P + }; + function S(O) { + const F = c !== void 0 ? GP( + c, + O.generatedLine, + O.generatedCharacter, + /*allowEdits*/ + !0 + ) : -1; + let R, B; + if (Ine(O)) { + const U = e.getSourceFileLike(_[O.sourceIndex]); + R = t.sources[O.sourceIndex], B = U !== void 0 ? GP( + U, + O.sourceLine, + O.sourceCharacter, + /*allowEdits*/ + !0 + ) : -1; + } + return { + generatedPosition: F, + source: R, + sourceIndex: O.sourceIndex, + sourcePosition: B, + nameIndex: O.nameIndex + }; + } + function T() { + if (g === void 0) { + const O = jW(t.mappings), F = is(O, S); + O.error !== void 0 ? (e.log && e.log(`Encountered error while decoding sourcemap: ${O.error}`), g = Ge) : g = F; + } + return g; + } + function k(O) { + if (h === void 0) { + const F = []; + for (const R of T()) { + if (!Q1e(R)) continue; + let B = F[R.sourceIndex]; + B || (F[R.sourceIndex] = B = []), B.push(R); + } + h = F.map((R) => tD(R, URe, Y1e)); + } + return h[O]; + } + function D() { + if (m === void 0) { + const O = []; + for (const F of T()) + O.push(F); + m = tD(O, VRe, Y1e); + } + return m; + } + function P(O) { + const F = u.get(e.getCanonicalFileName(O.fileName)); + if (F === void 0) return O; + const R = k(F); + if (!ot(R)) return O; + let B = $T(R, O.pos, qRe, ho); + B < 0 && (B = ~B); + const U = R[B]; + return U === void 0 || U.sourceIndex !== F ? O : { fileName: o, pos: U.generatedPosition }; + } + function A(O) { + const F = D(); + if (!ot(F)) return O; + let R = $T(F, O.pos, HRe, ho); + R < 0 && (R = ~R); + const B = F[R]; + return B === void 0 || !Q1e(B) ? O : { fileName: _[B.sourceIndex], pos: B.sourcePosition }; + } + } + var BW = { + getSourcePosition: go, + getGeneratedPosition: go + }; + function l_(e) { + return e = Vo(e), e ? Ma(e) : 0; + } + function Z1e(e) { + return !e || !bm(e) && !mp(e) ? !1 : ot(e.elements, K1e); + } + function K1e(e) { + return Gm(e.propertyName || e.name); + } + function Ld(e, t) { + return n; + function n(s) { + return s.kind === 308 ? t(s) : i(s); + } + function i(s) { + return e.factory.createBundle(hr(s.sourceFiles, t)); + } + } + function One(e) { + return !!qC(e); + } + function TO(e) { + if (qC(e)) + return !0; + const t = e.importClause && e.importClause.namedBindings; + if (!t || !bm(t)) return !1; + let n = 0; + for (const i of t.elements) + K1e(i) && n++; + return n > 0 && n !== t.elements.length || !!(t.elements.length - n) && fS(e); + } + function JW(e) { + return !TO(e) && (fS(e) || !!e.importClause && bm(e.importClause.namedBindings) && Z1e(e.importClause.namedBindings)); + } + function zW(e, t) { + const n = e.getEmitResolver(), i = e.getCompilerOptions(), s = [], o = new GRe(), c = [], _ = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Set(); + let g, m = !1, h, S = !1, T = !1, k = !1; + for (const O of t.statements) + switch (O.kind) { + case 273: + s.push(O), !T && TO(O) && (T = !0), !k && JW(O) && (k = !0); + break; + case 272: + O.moduleReference.kind === 284 && s.push(O); + break; + case 279: + if (O.moduleSpecifier) + if (!O.exportClause) + s.push(O), S = !0; + else if (s.push(O), mp(O.exportClause)) + P(O), k || (k = Z1e(O.exportClause)); + else { + const F = O.exportClause.name, R = Iy(F); + _.get(R) || (Y4(c, l_(O), F), _.set(R, !0), g = Er(g, F)), T = !0; + } + else + P(O); + break; + case 278: + O.isExportEquals && !h && (h = O); + break; + case 244: + if (Gn( + O, + 32 + /* Export */ + )) + for (const F of O.declarationList.declarations) + g = eve(F, _, g, c); + break; + case 263: + Gn( + O, + 32 + /* Export */ + ) && A( + O, + /*name*/ + void 0, + Gn( + O, + 2048 + /* Default */ + ) + ); + break; + case 264: + if (Gn( + O, + 32 + /* Export */ + )) + if (Gn( + O, + 2048 + /* Default */ + )) + m || (Y4(c, l_(O), e.factory.getDeclarationName(O)), m = !0); + else { + const F = O.name; + F && !_.get(An(F)) && (Y4(c, l_(O), F), _.set(An(F), !0), g = Er(g, F)); + } + break; + } + const D = Lz(e.factory, e.getEmitHelperFactory(), t, i, S, T, k); + return D && s.unshift(D), { externalImports: s, exportSpecifiers: o, exportEquals: h, hasExportStarsToExportValues: S, exportedBindings: c, exportedNames: g, exportedFunctions: u, externalHelpersImportDeclaration: D }; + function P(O) { + for (const F of Us(O.exportClause, mp).elements) { + const R = Iy(F.name); + if (!_.get(R)) { + const B = F.propertyName || F.name; + if (B.kind !== 11) { + O.moduleSpecifier || o.add(B, F); + const U = n.getReferencedImportDeclaration(B) || n.getReferencedValueDeclaration(B); + if (U) { + if (U.kind === 263) { + A(U, F.name, Gm(F.name)); + continue; + } + Y4(c, l_(U), F.name); + } + } + _.set(R, !0), g = Er(g, F.name); + } + } + } + function A(O, F, R) { + if (u.add(Vo(O, Cc)), R) + m || (Y4(c, l_(O), F ?? e.factory.getDeclarationName(O)), m = !0); + else { + F ?? (F = O.name); + const B = Iy(F); + _.get(B) || (Y4(c, l_(O), F), _.set(B, !0)); + } + } + } + function eve(e, t, n, i) { + if (ws(e.name)) + for (const s of e.name.elements) + vl(s) || (n = eve(s, t, n, i)); + else if (!Bo(e.name)) { + const s = An(e.name); + t.get(s) || (t.set(s, !0), n = Er(n, e.name), Nh(e.name) && Y4(i, l_(e), e.name)); + } + return n; + } + function Y4(e, t, n) { + let i = e[t]; + return i ? i.push(n) : e[t] = i = [n], i; + } + var L6 = class YE { + constructor() { + this._map = /* @__PURE__ */ new Map(); + } + get size() { + return this._map.size; + } + has(t) { + return this._map.has(YE.toKey(t)); + } + get(t) { + return this._map.get(YE.toKey(t)); + } + set(t, n) { + return this._map.set(YE.toKey(t), n), this; + } + delete(t) { + var n; + return ((n = this._map) == null ? void 0 : n.delete(YE.toKey(t))) ?? !1; + } + clear() { + this._map.clear(); + } + values() { + return this._map.values(); + } + static toKey(t) { + if (tS(t) || Bo(t)) { + const n = t.emitNode.autoGenerate; + if ((n.flags & 7) === 4) { + const i = QN(t), s = wg(i) && i !== t ? YE.toKey(i) : `(generated@${Ma(i)})`; + return _v( + /*privateName*/ + !1, + n.prefix, + s, + n.suffix, + YE.toKey + ); + } else { + const i = `(auto@${n.id})`; + return _v( + /*privateName*/ + !1, + n.prefix, + i, + n.suffix, + YE.toKey + ); + } + } + return Ai(t) ? An(t).slice(1) : An(t); + } + }, GRe = class extends L6 { + add(e, t) { + let n = this.get(e); + return n ? n.push(t) : this.set(e, n = [t]), n; + } + remove(e, t) { + const n = this.get(e); + n && (YT(n, t), n.length || this.delete(e)); + } + }; + function r2(e) { + return ja(e) || e.kind === 9 || k_(e.kind) || Me(e); + } + function rg(e) { + return !Me(e) && r2(e); + } + function Z4(e) { + return e >= 65 && e <= 79; + } + function K4(e) { + switch (e) { + case 65: + return 40; + case 66: + return 41; + case 67: + return 42; + case 68: + return 43; + case 69: + return 44; + case 70: + return 45; + case 71: + return 48; + case 72: + return 49; + case 73: + return 50; + case 74: + return 51; + case 75: + return 52; + case 79: + return 53; + case 76: + return 57; + case 77: + return 56; + case 78: + return 61; + } + } + function xO(e) { + if (!Al(e)) + return; + const t = Ba(e.expression); + return oS(t) ? t : void 0; + } + function tve(e, t, n) { + for (let i = t; i < e.length; i += 1) { + const s = e[i]; + if (xO(s)) + return n.unshift(i), !0; + if (wS(s) && tve(s.tryBlock.statements, 0, n)) + return n.unshift(i), !0; + } + return !1; + } + function kO(e, t) { + const n = []; + return tve(e, t, n), n; + } + function WW(e, t, n) { + return kn(e.members, (i) => XRe(i, t, n)); + } + function $Re(e) { + return QRe(e) || kc(e); + } + function CO(e) { + return kn(e.members, $Re); + } + function XRe(e, t, n) { + return os(e) && (!!e.initializer || !t) && cl(e) === n; + } + function QRe(e) { + return os(e) && cl(e); + } + function dA(e) { + return e.kind === 173 && e.initializer !== void 0; + } + function Lne(e) { + return !Js(e) && (ax(e) || b_(e)) && Ai(e.name); + } + function Mne(e) { + let t; + if (e) { + const n = e.parameters, i = n.length > 0 && My(n[0]), s = i ? 1 : 0, o = i ? n.length - 1 : n.length; + for (let c = 0; c < o; c++) { + const _ = n[c + s]; + (t || Ff(_)) && (t || (t = new Array(o)), t[c] = Ty(_)); + } + } + return t; + } + function UW(e, t) { + const n = Ty(e), i = t ? Mne(Mg(e)) : void 0; + if (!(!ot(n) && !ot(i))) + return { + decorators: n, + parameters: i + }; + } + function EO(e, t, n) { + switch (e.kind) { + case 178: + case 179: + return n ? YRe( + e, + t + ) : rve( + e, + /*useLegacyDecorators*/ + !1 + ); + case 175: + return rve(e, n); + case 173: + return ZRe(e); + default: + return; + } + } + function YRe(e, t, n) { + if (!e.body) + return; + const { firstAccessor: i, secondAccessor: s, getAccessor: o, setAccessor: c } = Bb(t.members, e), _ = Ff(i) ? i : s && Ff(s) ? s : void 0; + if (!_ || e !== _) + return; + const u = Ty(_), g = Mne(c); + if (!(!ot(u) && !ot(g))) + return { + decorators: u, + parameters: g, + getDecorators: o && Ty(o), + setDecorators: c && Ty(c) + }; + } + function rve(e, t) { + if (!e.body) + return; + const n = Ty(e), i = t ? Mne(e) : void 0; + if (!(!ot(n) && !ot(i))) + return { decorators: n, parameters: i }; + } + function ZRe(e) { + const t = Ty(e); + if (ot(t)) + return { decorators: t }; + } + function KRe(e, t) { + for (; e; ) { + const n = t(e); + if (n !== void 0) return n; + e = e.previous; + } + } + function Rne(e) { + return { data: e }; + } + function VW(e, t) { + var n, i; + return tS(t) ? (n = e?.generatedIdentifiers) == null ? void 0 : n.get(QN(t)) : (i = e?.identifiers) == null ? void 0 : i.get(t.escapedText); + } + function jS(e, t, n) { + tS(t) ? (e.generatedIdentifiers ?? (e.generatedIdentifiers = /* @__PURE__ */ new Map()), e.generatedIdentifiers.set(QN(t), n)) : (e.identifiers ?? (e.identifiers = /* @__PURE__ */ new Map()), e.identifiers.set(t.escapedText, n)); + } + function jne(e, t) { + return KRe(e, (n) => VW(n.privateEnv, t)); + } + function eje(e) { + return !e.initializer && Me(e.name); + } + function mA(e) { + return Ni(e, eje); + } + function sk(e, t) { + if (!e || !ca(e) || !V3(e.text, t)) + return e; + const n = S0(e.text, TA(e.text, t)); + return n !== e.text ? Cn(ct(N.createStringLiteral(n, e.singleQuote), e), e) : e; + } + var Bne = /* @__PURE__ */ ((e) => (e[e.All = 0] = "All", e[e.ObjectRest = 1] = "ObjectRest", e))(Bne || {}); + function BS(e, t, n, i, s, o) { + let c = e, _; + if (y0(e)) + for (_ = e.right; oee(e.left) || lJ(e.left); ) + if (y0(_)) + c = e = _, _ = e.right; + else + return E.checkDefined(Qe(_, t, ut)); + let u; + const g = { + context: n, + level: i, + downlevelIteration: !!n.getCompilerOptions().downlevelIteration, + hoistTempVariables: !0, + emitExpression: m, + emitBindingOrAssignment: h, + createArrayBindingOrAssignmentPattern: (S) => cje(n.factory, S), + createObjectBindingOrAssignmentPattern: (S) => uje(n.factory, S), + createArrayBindingOrAssignmentElement: fje, + visitor: t + }; + if (_ && (_ = Qe(_, t, ut), E.assert(_), Me(_) && Jne(e, _.escapedText) || zne(e) ? _ = ak( + g, + _, + /*reuseIdentifierExpressions*/ + !1, + c + ) : s ? _ = ak( + g, + _, + /*reuseIdentifierExpressions*/ + !0, + c + ) : lo(e) && (c = _)), ew( + g, + e, + _, + c, + /*skipInitializer*/ + y0(e) + ), _ && s) { + if (!ot(u)) + return _; + u.push(_); + } + return n.factory.inlineExpressions(u) || n.factory.createOmittedExpression(); + function m(S) { + u = Er(u, S); + } + function h(S, T, k, D) { + E.assertNode(S, o ? Me : ut); + const P = o ? o(S, T, k) : ct( + n.factory.createAssignment(E.checkDefined(Qe(S, t, ut)), T), + k + ); + P.original = D, m(P); + } + } + function Jne(e, t) { + const n = $y(e); + return l3(n) ? tje(n, t) : Me(n) ? n.escapedText === t : !1; + } + function tje(e, t) { + const n = C6(e); + for (const i of n) + if (Jne(i, t)) + return !0; + return !1; + } + function zne(e) { + const t = zF(e); + if (t && Gs(t) && !eS(t.expression)) + return !0; + const n = $y(e); + return !!n && l3(n) && rje(n); + } + function rje(e) { + return !!lr(C6(e), zne); + } + function n2(e, t, n, i, s, o = !1, c) { + let _; + const u = [], g = [], m = { + context: n, + level: i, + downlevelIteration: !!n.getCompilerOptions().downlevelIteration, + hoistTempVariables: o, + emitExpression: h, + emitBindingOrAssignment: S, + createArrayBindingOrAssignmentPattern: (T) => oje(n.factory, T), + createObjectBindingOrAssignmentPattern: (T) => lje(n.factory, T), + createArrayBindingOrAssignmentElement: (T) => _je(n.factory, T), + visitor: t + }; + if (ei(e)) { + let T = $N(e); + T && (Me(T) && Jne(e, T.escapedText) || zne(e)) && (T = ak( + m, + E.checkDefined(Qe(T, m.visitor, ut)), + /*reuseIdentifierExpressions*/ + !1, + T + ), e = n.factory.updateVariableDeclaration( + e, + e.name, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + T + )); + } + if (ew(m, e, s, e, c), _) { + const T = n.factory.createTempVariable( + /*recordTempVariable*/ + void 0 + ); + if (o) { + const k = n.factory.inlineExpressions(_); + _ = void 0, S( + T, + k, + /*location*/ + void 0, + /*original*/ + void 0 + ); + } else { + n.hoistVariableDeclaration(T); + const k = pa(u); + k.pendingExpressions = Er( + k.pendingExpressions, + n.factory.createAssignment(T, k.value) + ), In(k.pendingExpressions, _), k.value = T; + } + } + for (const { pendingExpressions: T, name: k, value: D, location: P, original: A } of u) { + const O = n.factory.createVariableDeclaration( + k, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + T ? n.factory.inlineExpressions(Er(T, D)) : D + ); + O.original = A, ct(O, P), g.push(O); + } + return g; + function h(T) { + _ = Er(_, T); + } + function S(T, k, D, P) { + E.assertNode(T, rS), _ && (k = n.factory.inlineExpressions(Er(_, k)), _ = void 0), u.push({ pendingExpressions: _, name: T, value: k, location: D, original: P }); + } + } + function ew(e, t, n, i, s) { + const o = $y(t); + if (!s) { + const c = Qe($N(t), e.visitor, ut); + c ? n ? (n = sje(e, n, c, i), !rg(c) && l3(o) && (n = ak( + e, + n, + /*reuseIdentifierExpressions*/ + !0, + i + ))) : n = c : n || (n = e.context.factory.createVoidZero()); + } + qj(o) ? nje(e, t, o, n, i) : Hj(o) ? ije(e, t, o, n, i) : e.emitBindingOrAssignment( + o, + n, + i, + /*original*/ + t + ); + } + function nje(e, t, n, i, s) { + const o = C6(n), c = o.length; + if (c !== 1) { + const g = !c3(t) || c !== 0; + i = ak(e, i, g, s); + } + let _, u; + for (let g = 0; g < c; g++) { + const m = o[g]; + if (JF(m)) { + if (g === c - 1) { + _ && (e.emitBindingOrAssignment(e.createObjectBindingOrAssignmentPattern(_), i, s, n), _ = void 0); + const h = e.context.getEmitHelperFactory().createRestHelper(i, o, u, n); + ew(e, m, h, m); + } + } else { + const h = Mz(m); + if (e.level >= 1 && !(m.transformFlags & 98304) && !($y(m).transformFlags & 98304) && !Gs(h)) + _ = Er(_, Qe(m, e.visitor, EZ)); + else { + _ && (e.emitBindingOrAssignment(e.createObjectBindingOrAssignmentPattern(_), i, s, n), _ = void 0); + const S = aje(e, i, h); + Gs(h) && (u = Er(u, S.argumentExpression)), ew( + e, + m, + S, + /*location*/ + m + ); + } + } + } + _ && e.emitBindingOrAssignment(e.createObjectBindingOrAssignmentPattern(_), i, s, n); + } + function ije(e, t, n, i, s) { + const o = C6(n), c = o.length; + if (e.level < 1 && e.downlevelIteration) + i = ak( + e, + ct( + e.context.getEmitHelperFactory().createReadHelper( + i, + c > 0 && JF(o[c - 1]) ? void 0 : c + ), + s + ), + /*reuseIdentifierExpressions*/ + !1, + s + ); + else if (c !== 1 && (e.level < 1 || c === 0) || Ni(o, vl)) { + const g = !c3(t) || c !== 0; + i = ak(e, i, g, s); + } + let _, u; + for (let g = 0; g < c; g++) { + const m = o[g]; + if (e.level >= 1) + if (m.transformFlags & 65536 || e.hasTransformedPriorElement && !nve(m)) { + e.hasTransformedPriorElement = !0; + const h = e.context.factory.createTempVariable( + /*recordTempVariable*/ + void 0 + ); + e.hoistTempVariables && e.context.hoistVariableDeclaration(h), u = Er(u, [h, m]), _ = Er(_, e.createArrayBindingOrAssignmentElement(h)); + } else + _ = Er(_, m); + else { + if (vl(m)) + continue; + if (JF(m)) { + if (g === c - 1) { + const h = e.context.factory.createArraySliceCall(i, g); + ew( + e, + m, + h, + /*location*/ + m + ); + } + } else { + const h = e.context.factory.createElementAccessExpression(i, g); + ew( + e, + m, + h, + /*location*/ + m + ); + } + } + } + if (_ && e.emitBindingOrAssignment(e.createArrayBindingOrAssignmentPattern(_), i, s, n), u) + for (const [g, m] of u) + ew(e, m, g, m); + } + function nve(e) { + const t = $y(e); + if (!t || vl(t)) return !0; + const n = zF(e); + if (n && !um(n)) return !1; + const i = $N(e); + return i && !rg(i) ? !1 : l3(t) ? Ni(C6(t), nve) : Me(t); + } + function sje(e, t, n, i) { + return t = ak( + e, + t, + /*reuseIdentifierExpressions*/ + !0, + i + ), e.context.factory.createConditionalExpression( + e.context.factory.createTypeCheck(t, "undefined"), + /*questionToken*/ + void 0, + n, + /*colonToken*/ + void 0, + t + ); + } + function aje(e, t, n) { + const { factory: i } = e.context; + if (Gs(n)) { + const s = ak( + e, + E.checkDefined(Qe(n.expression, e.visitor, ut)), + /*reuseIdentifierExpressions*/ + !1, + /*location*/ + n + ); + return e.context.factory.createElementAccessExpression(t, s); + } else if (If(n) || u6(n)) { + const s = i.cloneNode(n); + return e.context.factory.createElementAccessExpression(t, s); + } else { + const s = e.context.factory.createIdentifier(An(n)); + return e.context.factory.createPropertyAccessExpression(t, s); + } + } + function ak(e, t, n, i) { + if (Me(t) && n) + return t; + { + const s = e.context.factory.createTempVariable( + /*recordTempVariable*/ + void 0 + ); + return e.hoistTempVariables ? (e.context.hoistVariableDeclaration(s), e.emitExpression(ct(e.context.factory.createAssignment(s, t), i))) : e.emitBindingOrAssignment( + s, + t, + i, + /*original*/ + void 0 + ), s; + } + } + function oje(e, t) { + return E.assertEachNode(t, w7), e.createArrayBindingPattern(t); + } + function cje(e, t) { + return E.assertEachNode(t, _3), e.createArrayLiteralExpression(hr(t, e.converters.convertToArrayAssignmentElement)); + } + function lje(e, t) { + return E.assertEachNode(t, ya), e.createObjectBindingPattern(t); + } + function uje(e, t) { + return E.assertEachNode(t, u3), e.createObjectLiteralExpression(hr(t, e.converters.convertToObjectAssignmentElement)); + } + function _je(e, t) { + return e.createBindingElement( + /*dotDotDotToken*/ + void 0, + /*propertyName*/ + void 0, + t + ); + } + function fje(e) { + return e; + } + function pje(e, t, n = e.createThis()) { + const i = e.createAssignment(t, n), s = e.createExpressionStatement(i), o = e.createBlock( + [s], + /*multiLine*/ + !1 + ), c = e.createClassStaticBlockDeclaration(o); + return mu(c).classThis = t, c; + } + function tw(e) { + var t; + if (!kc(e) || e.body.statements.length !== 1) + return !1; + const n = e.body.statements[0]; + return Al(n) && Nl( + n.expression, + /*excludeCompoundAssignment*/ + !0 + ) && Me(n.expression.left) && ((t = e.emitNode) == null ? void 0 : t.classThis) === n.expression.left && n.expression.right.kind === 110; + } + function qW(e) { + var t; + return !!((t = e.emitNode) != null && t.classThis) && ot(e.members, tw); + } + function Wne(e, t, n, i) { + if (qW(t)) + return t; + const s = pje(e, n, i); + t.name && ha(s.body.statements[0], t.name); + const o = e.createNodeArray([s, ...t.members]); + ct(o, t.members); + const c = tl(t) ? e.updateClassDeclaration( + t, + t.modifiers, + t.name, + t.typeParameters, + t.heritageClauses, + o + ) : e.updateClassExpression( + t, + t.modifiers, + t.name, + t.typeParameters, + t.heritageClauses, + o + ); + return mu(c).classThis = n, c; + } + function DO(e, t, n) { + const i = Vo(hc(n)); + return (tl(i) || Cc(i)) && !i.name && Gn( + i, + 2048 + /* Default */ + ) ? e.createStringLiteral("default") : e.createStringLiteralFromNode(t); + } + function ive(e, t, n) { + const { factory: i } = e; + if (n !== void 0) + return { assignedName: i.createStringLiteral(n), name: t }; + if (um(t) || Ai(t)) + return { assignedName: i.createStringLiteralFromNode(t), name: t }; + if (um(t.expression) && !Me(t.expression)) + return { assignedName: i.createStringLiteralFromNode(t.expression), name: t }; + const s = i.getGeneratedNameForNode(t); + e.hoistVariableDeclaration(s); + const o = e.getEmitHelperFactory().createPropKeyHelper(t.expression), c = i.createAssignment(s, o), _ = i.updateComputedPropertyName(t, c); + return { assignedName: s, name: _ }; + } + function dje(e, t, n = e.factory.createThis()) { + const { factory: i } = e, s = e.getEmitHelperFactory().createSetFunctionNameHelper(n, t), o = i.createExpressionStatement(s), c = i.createBlock( + [o], + /*multiLine*/ + !1 + ), _ = i.createClassStaticBlockDeclaration(c); + return mu(_).assignedName = t, _; + } + function ok(e) { + var t; + if (!kc(e) || e.body.statements.length !== 1) + return !1; + const n = e.body.statements[0]; + return Al(n) && E4(n.expression, "___setFunctionName") && n.expression.arguments.length >= 2 && n.expression.arguments[1] === ((t = e.emitNode) == null ? void 0 : t.assignedName); + } + function wO(e) { + var t; + return !!((t = e.emitNode) != null && t.assignedName) && ot(e.members, ok); + } + function HW(e) { + return !!e.name || wO(e); + } + function PO(e, t, n, i) { + if (wO(t)) + return t; + const { factory: s } = e, o = dje(e, n, i); + t.name && ha(o.body.statements[0], t.name); + const c = oc(t.members, tw) + 1, _ = t.members.slice(0, c), u = t.members.slice(c), g = s.createNodeArray([..._, o, ...u]); + return ct(g, t.members), t = tl(t) ? s.updateClassDeclaration( + t, + t.modifiers, + t.name, + t.typeParameters, + t.heritageClauses, + g + ) : s.updateClassExpression( + t, + t.modifiers, + t.name, + t.typeParameters, + t.heritageClauses, + g + ), mu(t).assignedName = n, t; + } + function M6(e, t, n, i) { + if (i && ca(n) && kB(n)) + return t; + const { factory: s } = e, o = hc(t), c = Rc(o) ? Us(PO(e, o, n), Rc) : e.getEmitHelperFactory().createSetFunctionNameHelper(o, n); + return s.restoreOuterExpressions(t, c); + } + function mje(e, t, n, i) { + const { factory: s } = e, { assignedName: o, name: c } = ive(e, t.name, i), _ = M6(e, t.initializer, o, n); + return s.updatePropertyAssignment( + t, + c, + _ + ); + } + function gje(e, t, n, i) { + const { factory: s } = e, o = i !== void 0 ? s.createStringLiteral(i) : DO(s, t.name, t.objectAssignmentInitializer), c = M6(e, t.objectAssignmentInitializer, o, n); + return s.updateShorthandPropertyAssignment( + t, + t.name, + c + ); + } + function hje(e, t, n, i) { + const { factory: s } = e, o = i !== void 0 ? s.createStringLiteral(i) : DO(s, t.name, t.initializer), c = M6(e, t.initializer, o, n); + return s.updateVariableDeclaration( + t, + t.name, + t.exclamationToken, + t.type, + c + ); + } + function yje(e, t, n, i) { + const { factory: s } = e, o = i !== void 0 ? s.createStringLiteral(i) : DO(s, t.name, t.initializer), c = M6(e, t.initializer, o, n); + return s.updateParameterDeclaration( + t, + t.modifiers, + t.dotDotDotToken, + t.name, + t.questionToken, + t.type, + c + ); + } + function vje(e, t, n, i) { + const { factory: s } = e, o = i !== void 0 ? s.createStringLiteral(i) : DO(s, t.name, t.initializer), c = M6(e, t.initializer, o, n); + return s.updateBindingElement( + t, + t.dotDotDotToken, + t.propertyName, + t.name, + c + ); + } + function bje(e, t, n, i) { + const { factory: s } = e, { assignedName: o, name: c } = ive(e, t.name, i), _ = M6(e, t.initializer, o, n); + return s.updatePropertyDeclaration( + t, + t.modifiers, + c, + t.questionToken ?? t.exclamationToken, + t.type, + _ + ); + } + function Sje(e, t, n, i) { + const { factory: s } = e, o = i !== void 0 ? s.createStringLiteral(i) : DO(s, t.left, t.right), c = M6(e, t.right, o, n); + return s.updateBinaryExpression( + t, + t.left, + t.operatorToken, + c + ); + } + function Tje(e, t, n, i) { + const { factory: s } = e, o = i !== void 0 ? s.createStringLiteral(i) : s.createStringLiteral(t.isExportEquals ? "" : "default"), c = M6(e, t.expression, o, n); + return s.updateExportAssignment( + t, + t.modifiers, + c + ); + } + function lf(e, t, n, i) { + switch (t.kind) { + case 304: + return mje(e, t, n, i); + case 305: + return gje(e, t, n, i); + case 261: + return hje(e, t, n, i); + case 170: + return yje(e, t, n, i); + case 209: + return vje(e, t, n, i); + case 173: + return bje(e, t, n, i); + case 227: + return Sje(e, t, n, i); + case 278: + return Tje(e, t, n, i); + } + } + var Une = /* @__PURE__ */ ((e) => (e[e.LiftRestriction = 0] = "LiftRestriction", e[e.All = 1] = "All", e))(Une || {}); + function GW(e, t, n, i, s, o) { + const c = Qe(t.tag, n, ut); + E.assert(c); + const _ = [void 0], u = [], g = [], m = t.template; + if (o === 0 && !HB(m)) + return br(t, n, e); + const { factory: h } = e; + if (TS(m)) + u.push(Vne(h, m)), g.push(qne(h, m, i)); + else { + u.push(Vne(h, m.head)), g.push(qne(h, m.head, i)); + for (const T of m.templateSpans) + u.push(Vne(h, T.literal)), g.push(qne(h, T.literal, i)), _.push(E.checkDefined(Qe(T.expression, n, ut))); + } + const S = e.getEmitHelperFactory().createTemplateObjectHelper( + h.createArrayLiteralExpression(u), + h.createArrayLiteralExpression(g) + ); + if (fl(i)) { + const T = h.createUniqueName("templateObject"); + s(T), _[0] = h.createLogicalOr( + T, + h.createAssignment( + T, + S + ) + ); + } else + _[0] = S; + return h.createCallExpression( + c, + /*typeArguments*/ + void 0, + _ + ); + } + function Vne(e, t) { + return t.templateFlags & 26656 ? e.createVoidZero() : e.createStringLiteral(t.text); + } + function qne(e, t, n) { + let i = t.rawText; + if (i === void 0) { + E.assertIsDefined(n, "Template literal node is missing 'rawText' and does not have a source file. Possibly bad transform."), i = Db(n, t); + const s = t.kind === 15 || t.kind === 18; + i = i.substring(1, i.length - (s ? 1 : 2)); + } + return i = i.replace(/\r\n?/g, ` +`), ct(e.createStringLiteral(i), t); + } + function Hne(e) { + const { + factory: t, + getEmitHelperFactory: n, + startLexicalEnvironment: i, + resumeLexicalEnvironment: s, + endLexicalEnvironment: o, + hoistVariableDeclaration: c + } = e, _ = e.getEmitResolver(), u = e.getCompilerOptions(), g = da(u), m = Hu(u), h = !!u.experimentalDecorators, S = u.emitDecoratorMetadata ? $ne(e) : void 0, T = e.onEmitNode, k = e.onSubstituteNode; + e.onEmitNode = Ec, e.onSubstituteNode = zf, e.enableSubstitution( + 212 + /* PropertyAccessExpression */ + ), e.enableSubstitution( + 213 + /* ElementAccessExpression */ + ); + let D, P, A, O, F, R = 0, B; + return U; + function U(ge) { + return ge.kind === 309 ? $(ge) : W(ge); + } + function $(ge) { + return t.createBundle( + ge.sourceFiles.map(W) + ); + } + function W(ge) { + if (ge.isDeclarationFile) + return ge; + D = ge; + const H = _e(ge, Se); + return Wg(H, e.readEmitHelpers()), D = void 0, H; + } + function _e(ge, H) { + const tt = O, Ft = F; + K(ge); + const Kt = H(ge); + return O !== tt && (F = Ft), O = tt, Kt; + } + function K(ge) { + switch (ge.kind) { + case 308: + case 270: + case 269: + case 242: + O = ge, F = void 0; + break; + case 264: + case 263: + if (Gn( + ge, + 128 + /* Ambient */ + )) + break; + ge.name ? M(ge) : E.assert(ge.kind === 264 || Gn( + ge, + 2048 + /* Default */ + )); + break; + } + } + function V(ge) { + return _e(ge, ae); + } + function ae(ge) { + return ge.transformFlags & 1 ? ne(ge) : ge; + } + function se(ge) { + return _e(ge, ce); + } + function ce(ge) { + switch (ge.kind) { + case 273: + case 272: + case 278: + case 279: + return he(ge); + default: + return ae(ge); + } + } + function fe(ge) { + const H = vs(ge); + if (H === ge || Mo(ge)) + return !1; + if (!H || H.kind !== ge.kind) + return !0; + switch (ge.kind) { + case 273: + if (E.assertNode(H, qo), ge.importClause !== H.importClause || ge.attributes !== H.attributes) + return !0; + break; + case 272: + if (E.assertNode(H, _l), ge.name !== H.name || ge.isTypeOnly !== H.isTypeOnly || ge.moduleReference !== H.moduleReference && (r_(ge.moduleReference) || r_(H.moduleReference))) + return !0; + break; + case 279: + if (E.assertNode(H, Bc), ge.exportClause !== H.exportClause || ge.attributes !== H.attributes) + return !0; + break; + } + return !1; + } + function he(ge) { + if (fe(ge)) + return ge.transformFlags & 1 ? br(ge, V, e) : ge; + switch (ge.kind) { + case 273: + return wt(ge); + case 272: + return cr(ge); + case 278: + return rt(ge); + case 279: + return vt(ge); + default: + E.fail("Unhandled ellided statement"); + } + } + function q(ge) { + return _e(ge, be); + } + function be(ge) { + if (!(ge.kind === 279 || ge.kind === 273 || ge.kind === 274 || ge.kind === 272 && ge.moduleReference.kind === 284)) + return ge.transformFlags & 1 || Gn( + ge, + 32 + /* Export */ + ) ? ne(ge) : ge; + } + function je(ge) { + return (H) => _e(H, (tt) => me(tt, ge)); + } + function me(ge, H) { + switch (ge.kind) { + case 177: + return Je(ge); + case 173: + return _i(ge, H); + case 178: + return ki(ge, H); + case 179: + return Ds(ge, H); + case 175: + return Jn(ge, H); + case 176: + return br(ge, V, e); + case 241: + return ge; + case 182: + return; + default: + return E.failBadSyntaxKind(ge); + } + } + function Z(ge) { + return (H) => _e(H, (tt) => pe(tt, ge)); + } + function pe(ge, H) { + switch (ge.kind) { + case 304: + case 305: + case 306: + return V(ge); + case 178: + return ki(ge, H); + case 179: + return Ds(ge, H); + case 175: + return Jn(ge, H); + default: + return E.failBadSyntaxKind(ge); + } + } + function Te(ge) { + return ul(ge) ? void 0 : V(ge); + } + function Fe(ge) { + return Zs(ge) ? void 0 : V(ge); + } + function Ye(ge) { + if (!ul(ge) && !(kx(ge.kind) & 28895) && !(P && ge.kind === 95)) + return ge; + } + function ne(ge) { + if (Ti(ge) && Gn( + ge, + 128 + /* Ambient */ + )) + return t.createNotEmittedStatement(ge); + switch (ge.kind) { + case 95: + case 90: + return P ? void 0 : ge; + case 125: + case 123: + case 124: + case 128: + case 164: + case 87: + case 138: + case 148: + case 103: + case 147: + // TypeScript accessibility and readonly modifiers are elided + // falls through + case 189: + case 190: + case 191: + case 192: + case 188: + case 183: + case 169: + case 133: + case 159: + case 136: + case 154: + case 150: + case 146: + case 116: + case 155: + case 186: + case 185: + case 187: + case 184: + case 193: + case 194: + case 195: + case 197: + case 198: + case 199: + case 200: + case 201: + case 202: + // TypeScript type nodes are elided. + // falls through + case 182: + return; + case 266: + return t.createNotEmittedStatement(ge); + case 271: + return; + case 265: + return t.createNotEmittedStatement(ge); + case 264: + return Ve(ge); + case 232: + return St(ge); + case 299: + return ai(ge); + case 234: + return fi(ge); + case 211: + return ie(ge); + case 177: + case 173: + case 175: + case 178: + case 179: + case 176: + return E.fail("Class and object literal elements must be visited with their respective visitors"); + case 263: + return Ks(ge); + case 219: + return yr(ge); + case 220: + return bs(ge); + case 170: + return Xe(ge); + case 218: + return Y(ge); + case 217: + case 235: + return Ae(ge); + case 239: + return Ke(ge); + case 214: + return Tt(ge); + case 215: + return Le(ge); + case 216: + return mt(ge); + case 236: + return $e(ge); + case 267: + return Lt(ge); + case 244: + return Et(ge); + case 261: + return it(ge); + case 268: + return Mt(ge); + case 272: + return cr(ge); + case 286: + return pt(ge); + case 287: + return Ct(ge); + default: + return br(ge, V, e); + } + } + function Se(ge) { + const H = du(u, "alwaysStrict") && !(fl(ge) && m >= 5) && !ap(ge); + return t.updateSourceFile( + ge, + OW( + ge.statements, + se, + e, + /*start*/ + 0, + H + ) + ); + } + function ie(ge) { + return t.updateObjectLiteralExpression( + ge, + Ar(ge.properties, Z(ge), vh) + ); + } + function Ne(ge) { + let H = 0; + ot(WW( + ge, + /*requireInitializer*/ + !0, + /*isStatic*/ + !0 + )) && (H |= 1); + const tt = wd(ge); + return tt && hc(tt.expression).kind !== 106 && (H |= 64), g0(h, ge) && (H |= 2), RD(h, ge) && (H |= 4), fr(ge) ? H |= 8 : oi(ge) ? H |= 32 : Xt(ge) && (H |= 16), H; + } + function Ee(ge) { + return !!(ge.transformFlags & 8192); + } + function Ce(ge) { + return Ff(ge) || ot(ge.typeParameters) || ot(ge.heritageClauses, Ee) || ot(ge.members, Ee); + } + function Ve(ge) { + const H = Ne(ge), tt = g <= 1 && !!(H & 7); + if (!Ce(ge) && !g0(h, ge) && !fr(ge)) + return t.updateClassDeclaration( + ge, + Ar(ge.modifiers, Ye, Zs), + ge.name, + /*typeParameters*/ + void 0, + Ar(ge.heritageClauses, V, cf), + Ar(ge.members, je(ge), Hc) + ); + tt && e.startLexicalEnvironment(); + const Ft = tt || H & 8; + let Kt = Ft ? Ar(ge.modifiers, Fe, Jo) : Ar(ge.modifiers, V, Jo); + H & 2 && (Kt = tr(Kt, ge)); + const Vn = Ft && !ge.name || H & 4 || H & 1 ? ge.name ?? t.getGeneratedNameForNode(ge) : ge.name, ln = t.updateClassDeclaration( + ge, + Kt, + Vn, + /*typeParameters*/ + void 0, + Ar(ge.heritageClauses, V, cf), + Bt(ge) + ); + let kr = Ea(ge); + H & 1 && (kr |= 64), un(ln, kr); + let Li; + if (tt) { + const Yi = [ln], no = _J( + oa(D.text, ge.members.end), + 20 + /* CloseBraceToken */ + ), ra = t.getInternalName(ge), Eo = t.createPartiallyEmittedExpression(ra); + o6(Eo, no.end), un( + Eo, + 3072 + /* NoComments */ + ); + const $c = t.createReturnStatement(Eo); + h4($c, no.pos), un( + $c, + 3840 + /* NoTokenSourceMaps */ + ), Yi.push($c), Ig(Yi, e.endLexicalEnvironment()); + const Jc = t.createImmediatelyInvokedArrowFunction(Yi); + FN( + Jc, + 1 + /* TypeScriptClassWrapper */ + ); + const vo = t.createVariableDeclaration( + t.getLocalName( + ge, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !1 + ), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + Jc + ); + Cn(vo, ge); + const ic = t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList( + [vo], + 1 + /* Let */ + ) + ); + Cn(ic, ge), el(ic, ge), ha(ic, Ch(ge)), Au(ic), Li = ic; + } else + Li = ln; + if (Ft) { + if (H & 8) + return [ + Li, + Fs(ge) + ]; + if (H & 32) + return [ + Li, + t.createExportDefault(t.getLocalName( + ge, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + )) + ]; + if (H & 16) + return [ + Li, + t.createExternalModuleExport(t.getDeclarationName( + ge, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + )) + ]; + } + return Li; + } + function St(ge) { + let H = Ar(ge.modifiers, Fe, Jo); + return g0(h, ge) && (H = tr(H, ge)), t.updateClassExpression( + ge, + H, + ge.name, + /*typeParameters*/ + void 0, + Ar(ge.heritageClauses, V, cf), + Bt(ge) + ); + } + function Bt(ge) { + const H = Ar(ge.members, je(ge), Hc); + let tt; + const Ft = Mg(ge), Kt = Ft && kn(Ft.parameters, (Hr) => K_(Hr, Ft)); + if (Kt) + for (const Hr of Kt) { + const Vn = t.createPropertyDeclaration( + /*modifiers*/ + void 0, + Hr.name, + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + ); + Cn(Vn, Hr), tt = Er(tt, Vn); + } + return tt ? (tt = In(tt, H), ct( + t.createNodeArray(tt), + /*location*/ + ge.members + )) : H; + } + function tr(ge, H) { + const tt = st(H, H); + if (ot(tt)) { + const Ft = []; + In(Ft, HR(ge, XN)), In(Ft, kn(ge, ul)), In(Ft, tt), In(Ft, kn(yQ(ge, XN), Zs)), ge = ct(t.createNodeArray(Ft), ge); + } + return ge; + } + function Nr(ge, H, tt) { + if ($n(tt) && xB(h, H, tt)) { + const Ft = st(H, tt); + if (ot(Ft)) { + const Kt = []; + In(Kt, kn(ge, ul)), In(Kt, Ft), In(Kt, kn(ge, Zs)), ge = ct(t.createNodeArray(Kt), ge); + } + } + return ge; + } + function st(ge, H) { + if (h) + return Wt(ge, H); + } + function Wt(ge, H) { + if (S) { + let tt; + if (Jr(ge)) { + const Ft = n().createMetadataHelper("design:type", S.serializeTypeOfNode({ currentLexicalScope: O, currentNameScope: H }, ge, H)); + tt = Er(tt, t.createDecorator(Ft)); + } + if (Ji(ge)) { + const Ft = n().createMetadataHelper("design:paramtypes", S.serializeParameterTypesOfNode({ currentLexicalScope: O, currentNameScope: H }, ge, H)); + tt = Er(tt, t.createDecorator(Ft)); + } + if (ui(ge)) { + const Ft = n().createMetadataHelper("design:returntype", S.serializeReturnTypeOfNode({ currentLexicalScope: O, currentNameScope: H }, ge)); + tt = Er(tt, t.createDecorator(Ft)); + } + return tt; + } + } + function Jr(ge) { + const H = ge.kind; + return H === 175 || H === 178 || H === 179 || H === 173; + } + function ui(ge) { + return ge.kind === 175; + } + function Ji(ge) { + switch (ge.kind) { + case 264: + case 232: + return Mg(ge) !== void 0; + case 175: + case 178: + case 179: + return !0; + } + return !1; + } + function Dt(ge, H) { + const tt = ge.name; + return Ai(tt) ? t.createIdentifier("") : Gs(tt) ? tt.expression : Me(tt) ? t.createStringLiteral(An(tt)) : t.cloneNode(tt); + } + function Mn(ge) { + const H = ge.name; + if (h && Gs(H) && Ff(ge)) { + const tt = Qe(H.expression, V, ut); + E.assert(tt); + const Ft = id(tt); + if (!rg(Ft)) { + const Kt = t.getGeneratedNameForNode(H); + return c(Kt), t.updateComputedPropertyName(H, t.createAssignment(Kt, tt)); + } + } + return E.checkDefined(Qe(H, V, qc)); + } + function ai(ge) { + if (ge.token !== 119) + return br(ge, V, e); + } + function fi(ge) { + return t.updateExpressionWithTypeArguments( + ge, + E.checkDefined(Qe(ge.expression, V, S_)), + /*typeArguments*/ + void 0 + ); + } + function pn(ge) { + return !lc(ge.body); + } + function _i(ge, H) { + const tt = ge.flags & 33554432 || Gn( + ge, + 64 + /* Abstract */ + ); + if (tt && !(h && Ff(ge))) + return; + let Ft = $n(H) ? tt ? Ar(ge.modifiers, Fe, Jo) : Ar(ge.modifiers, V, Jo) : Ar(ge.modifiers, Te, Jo); + return Ft = Nr(Ft, ge, H), tt ? t.updatePropertyDeclaration( + ge, + Bi(Ft, t.createModifiersFromModifierFlags( + 128 + /* Ambient */ + )), + E.checkDefined(Qe(ge.name, V, qc)), + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + ) : t.updatePropertyDeclaration( + ge, + Ft, + Mn(ge), + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + Qe(ge.initializer, V, ut) + ); + } + function Je(ge) { + if (pn(ge)) + return t.updateConstructorDeclaration( + ge, + /*modifiers*/ + void 0, + _c(ge.parameters, V, e), + er(ge.body, ge) + ); + } + function ft(ge, H, tt, Ft, Kt, Hr) { + const Vn = Ft[Kt], ln = H[Vn]; + if (In(ge, Ar(H, V, Ti, tt, Vn - tt)), wS(ln)) { + const kr = []; + ft( + kr, + ln.tryBlock.statements, + /*statementOffset*/ + 0, + Ft, + Kt + 1, + Hr + ); + const Li = t.createNodeArray(kr); + ct(Li, ln.tryBlock.statements), ge.push(t.updateTryStatement( + ln, + t.updateBlock(ln.tryBlock, kr), + Qe(ln.catchClause, V, Zb), + Qe(ln.finallyBlock, V, Ns) + )); + } else + In(ge, Ar(H, V, Ti, Vn, 1)), In(ge, Hr); + In(ge, Ar(H, V, Ti, Vn + 1)); + } + function er(ge, H) { + const tt = H && kn(H.parameters, (kr) => K_(kr, H)); + if (!ot(tt)) + return jf(ge, V, e); + let Ft = []; + s(); + const Kt = t.copyPrologue( + ge.statements, + Ft, + /*ensureUseStrict*/ + !1, + V + ), Hr = kO(ge.statements, Kt), Vn = Fi(tt, qr); + Hr.length ? ft( + Ft, + ge.statements, + Kt, + Hr, + /*superPathDepth*/ + 0, + Vn + ) : (In(Ft, Vn), In(Ft, Ar(ge.statements, V, Ti, Kt))), Ft = t.mergeLexicalEnvironment(Ft, o()); + const ln = t.createBlock( + ct(t.createNodeArray(Ft), ge.statements), + /*multiLine*/ + !0 + ); + return ct( + ln, + /*location*/ + ge + ), Cn(ln, ge), ln; + } + function qr(ge) { + const H = ge.name; + if (!Me(H)) + return; + const tt = za(ct(t.cloneNode(H), H), H.parent); + un( + tt, + 3168 + /* NoSourceMap */ + ); + const Ft = za(ct(t.cloneNode(H), H), H.parent); + return un( + Ft, + 3072 + /* NoComments */ + ), Au( + IN( + ct( + Cn( + t.createExpressionStatement( + t.createAssignment( + ct( + t.createPropertyAccessExpression( + t.createThis(), + tt + ), + ge.name + ), + Ft + ) + ), + ge + ), + Z1(ge, -1) + ) + ) + ); + } + function Jn(ge, H) { + if (!(ge.transformFlags & 1)) + return ge; + if (!pn(ge)) + return; + let tt = $n(H) ? Ar(ge.modifiers, V, Jo) : Ar(ge.modifiers, Te, Jo); + return tt = Nr(tt, ge, H), t.updateMethodDeclaration( + ge, + tt, + ge.asteriskToken, + Mn(ge), + /*questionToken*/ + void 0, + /*typeParameters*/ + void 0, + _c(ge.parameters, V, e), + /*type*/ + void 0, + jf(ge.body, V, e) + ); + } + function Un(ge) { + return !(lc(ge.body) && Gn( + ge, + 64 + /* Abstract */ + )); + } + function ki(ge, H) { + if (!(ge.transformFlags & 1)) + return ge; + if (!Un(ge)) + return; + let tt = $n(H) ? Ar(ge.modifiers, V, Jo) : Ar(ge.modifiers, Te, Jo); + return tt = Nr(tt, ge, H), t.updateGetAccessorDeclaration( + ge, + tt, + Mn(ge), + _c(ge.parameters, V, e), + /*type*/ + void 0, + jf(ge.body, V, e) || t.createBlock([]) + ); + } + function Ds(ge, H) { + if (!(ge.transformFlags & 1)) + return ge; + if (!Un(ge)) + return; + let tt = $n(H) ? Ar(ge.modifiers, V, Jo) : Ar(ge.modifiers, Te, Jo); + return tt = Nr(tt, ge, H), t.updateSetAccessorDeclaration( + ge, + tt, + Mn(ge), + _c(ge.parameters, V, e), + jf(ge.body, V, e) || t.createBlock([]) + ); + } + function Ks(ge) { + if (!pn(ge)) + return t.createNotEmittedStatement(ge); + const H = t.updateFunctionDeclaration( + ge, + Ar(ge.modifiers, Ye, Zs), + ge.asteriskToken, + ge.name, + /*typeParameters*/ + void 0, + _c(ge.parameters, V, e), + /*type*/ + void 0, + jf(ge.body, V, e) || t.createBlock([]) + ); + if (fr(ge)) { + const tt = [H]; + return Rs(tt, ge), tt; + } + return H; + } + function yr(ge) { + return pn(ge) ? t.updateFunctionExpression( + ge, + Ar(ge.modifiers, Ye, Zs), + ge.asteriskToken, + ge.name, + /*typeParameters*/ + void 0, + _c(ge.parameters, V, e), + /*type*/ + void 0, + jf(ge.body, V, e) || t.createBlock([]) + ) : t.createOmittedExpression(); + } + function bs(ge) { + return t.updateArrowFunction( + ge, + Ar(ge.modifiers, Ye, Zs), + /*typeParameters*/ + void 0, + _c(ge.parameters, V, e), + /*type*/ + void 0, + ge.equalsGreaterThanToken, + jf(ge.body, V, e) + ); + } + function Xe(ge) { + if (My(ge)) + return; + const H = t.updateParameterDeclaration( + ge, + Ar(ge.modifiers, (tt) => ul(tt) ? V(tt) : void 0, Jo), + ge.dotDotDotToken, + E.checkDefined(Qe(ge.name, V, rS)), + /*questionToken*/ + void 0, + /*type*/ + void 0, + Qe(ge.initializer, V, ut) + ); + return H !== ge && (el(H, ge), ct(H, dm(ge)), ha(H, dm(ge)), un( + H.name, + 64 + /* NoTrailingSourceMap */ + )), H; + } + function Et(ge) { + if (fr(ge)) { + const H = s4(ge.declarationList); + return H.length === 0 ? void 0 : ct( + t.createExpressionStatement( + t.inlineExpressions( + hr(H, re) + ) + ), + ge + ); + } else + return br(ge, V, e); + } + function re(ge) { + const H = ge.name; + return ws(H) ? BS( + ge, + V, + e, + 0, + /*needsValue*/ + !1, + pc + ) : ct( + t.createAssignment( + Zo(H), + E.checkDefined(Qe(ge.initializer, V, ut)) + ), + /*location*/ + ge + ); + } + function it(ge) { + const H = t.updateVariableDeclaration( + ge, + E.checkDefined(Qe(ge.name, V, rS)), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + Qe(ge.initializer, V, ut) + ); + return ge.type && Ste(H.name, ge.type), H; + } + function Y(ge) { + const H = hc(ge.expression, -55); + if (Eb(H) || m6(H)) { + const tt = Qe(ge.expression, V, ut); + return E.assert(tt), t.createPartiallyEmittedExpression(tt, ge); + } + return br(ge, V, e); + } + function Ae(ge) { + const H = Qe(ge.expression, V, ut); + return E.assert(H), t.createPartiallyEmittedExpression(H, ge); + } + function $e(ge) { + const H = Qe(ge.expression, V, S_); + return E.assert(H), t.createPartiallyEmittedExpression(H, ge); + } + function Ke(ge) { + const H = Qe(ge.expression, V, ut); + return E.assert(H), t.createPartiallyEmittedExpression(H, ge); + } + function Tt(ge) { + return t.updateCallExpression( + ge, + E.checkDefined(Qe(ge.expression, V, ut)), + /*typeArguments*/ + void 0, + Ar(ge.arguments, V, ut) + ); + } + function Le(ge) { + return t.updateNewExpression( + ge, + E.checkDefined(Qe(ge.expression, V, ut)), + /*typeArguments*/ + void 0, + Ar(ge.arguments, V, ut) + ); + } + function mt(ge) { + return t.updateTaggedTemplateExpression( + ge, + E.checkDefined(Qe(ge.tag, V, ut)), + /*typeArguments*/ + void 0, + E.checkDefined(Qe(ge.template, V, ox)) + ); + } + function pt(ge) { + return t.updateJsxSelfClosingElement( + ge, + E.checkDefined(Qe(ge.tagName, V, PD)), + /*typeArguments*/ + void 0, + E.checkDefined(Qe(ge.attributes, V, Yb)) + ); + } + function Ct(ge) { + return t.updateJsxOpeningElement( + ge, + E.checkDefined(Qe(ge.tagName, V, PD)), + /*typeArguments*/ + void 0, + E.checkDefined(Qe(ge.attributes, V, Yb)) + ); + } + function qe(ge) { + return !V1(ge) || By(u); + } + function Lt(ge) { + if (!qe(ge)) + return t.createNotEmittedStatement(ge); + const H = []; + let tt = 4; + const Ft = dt(H, ge); + Ft && (m !== 4 || O !== D) && (tt |= 1024); + const Kt = so(ge), Hr = zi(ge), Vn = fr(ge) ? t.getExternalModuleOrNamespaceExportName( + A, + ge, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ) : t.getDeclarationName( + ge, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ); + let ln = t.createLogicalOr( + Vn, + t.createAssignment( + Vn, + t.createObjectLiteralExpression() + ) + ); + if (fr(ge)) { + const Li = t.getLocalName( + ge, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ); + ln = t.createAssignment(Li, ln); + } + const kr = t.createExpressionStatement( + t.createCallExpression( + t.createFunctionExpression( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + [t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + Kt + )], + /*type*/ + void 0, + rn(ge, Hr) + ), + /*typeArguments*/ + void 0, + [ln] + ) + ); + return Cn(kr, ge), Ft && (tv(kr, void 0), Rx(kr, void 0)), ct(kr, ge), gm(kr, tt), H.push(kr), H; + } + function rn(ge, H) { + const tt = A; + A = H; + const Ft = []; + i(); + const Kt = hr(ge.members, Pe); + return Ig(Ft, o()), In(Ft, Kt), A = tt, t.createBlock( + ct( + t.createNodeArray(Ft), + /*location*/ + ge.members + ), + /*multiLine*/ + !0 + ); + } + function Pe(ge) { + const H = Dt( + ge + ), tt = _.getEnumMemberValue(ge), Ft = yt(ge, tt?.value), Kt = t.createAssignment( + t.createElementAccessExpression( + A, + H + ), + Ft + ), Hr = typeof tt?.value == "string" || tt?.isSyntacticallyString ? Kt : t.createAssignment( + t.createElementAccessExpression( + A, + Kt + ), + H + ); + return ct( + t.createExpressionStatement( + ct( + Hr, + ge + ) + ), + ge + ); + } + function yt(ge, H) { + return H !== void 0 ? typeof H == "string" ? t.createStringLiteral(H) : H < 0 ? t.createPrefixUnaryExpression(41, t.createNumericLiteral(-H)) : t.createNumericLiteral(H) : (hs(), ge.initializer ? E.checkDefined(Qe(ge.initializer, V, ut)) : t.createVoidZero()); + } + function ue(ge) { + const H = vs(ge, jc); + return H ? IW(H, By(u)) : !0; + } + function M(ge) { + F || (F = /* @__PURE__ */ new Map()); + const H = Q(ge); + F.has(H) || F.set(H, ge); + } + function ye(ge) { + if (F) { + const H = Q(ge); + return F.get(H) === ge; + } + return !0; + } + function Q(ge) { + return E.assertNode(ge.name, Me), ge.name.escapedText; + } + function dt(ge, H) { + const tt = t.createVariableDeclaration(t.getLocalName( + H, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + )), Ft = O.kind === 308 ? 0 : 1, Kt = t.createVariableStatement( + Ar(H.modifiers, Ye, Zs), + t.createVariableDeclarationList([tt], Ft) + ); + return Cn(tt, H), tv(tt, void 0), Rx(tt, void 0), Cn(Kt, H), M(H), ye(H) ? (H.kind === 267 ? ha(Kt.declarationList, H) : ha(Kt, H), el(Kt, H), gm( + Kt, + 2048 + /* NoTrailingComments */ + ), ge.push(Kt), !0) : !1; + } + function Mt(ge) { + if (!ue(ge)) + return t.createNotEmittedStatement(ge); + E.assertNode(ge.name, Me, "A TypeScript namespace should have an Identifier name."), Gc(); + const H = []; + let tt = 4; + const Ft = dt(H, ge); + Ft && (m !== 4 || O !== D) && (tt |= 1024); + const Kt = so(ge), Hr = zi(ge), Vn = fr(ge) ? t.getExternalModuleOrNamespaceExportName( + A, + ge, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ) : t.getDeclarationName( + ge, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ); + let ln = t.createLogicalOr( + Vn, + t.createAssignment( + Vn, + t.createObjectLiteralExpression() + ) + ); + if (fr(ge)) { + const Li = t.getLocalName( + ge, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ); + ln = t.createAssignment(Li, ln); + } + const kr = t.createExpressionStatement( + t.createCallExpression( + t.createFunctionExpression( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + [t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + Kt + )], + /*type*/ + void 0, + ke(ge, Hr) + ), + /*typeArguments*/ + void 0, + [ln] + ) + ); + return Cn(kr, ge), Ft && (tv(kr, void 0), Rx(kr, void 0)), ct(kr, ge), gm(kr, tt), H.push(kr), H; + } + function ke(ge, H) { + const tt = A, Ft = P, Kt = F; + A = H, P = ge, F = void 0; + const Hr = []; + i(); + let Vn, ln; + if (ge.body) + if (ge.body.kind === 269) + _e(ge.body, (Li) => In(Hr, Ar(Li.statements, q, Ti))), Vn = ge.body.statements, ln = ge.body; + else { + const Li = Mt(ge.body); + Li && (as(Li) ? In(Hr, Li) : Hr.push(Li)); + const Yi = at(ge).body; + Vn = Z1(Yi.statements, -1); + } + Ig(Hr, o()), A = tt, P = Ft, F = Kt; + const kr = t.createBlock( + ct( + t.createNodeArray(Hr), + /*location*/ + Vn + ), + /*multiLine*/ + !0 + ); + return ct(kr, ln), (!ge.body || ge.body.kind !== 269) && un( + kr, + Ea(kr) | 3072 + /* NoComments */ + ), kr; + } + function at(ge) { + if (ge.body.kind === 268) + return at(ge.body) || ge.body; + } + function wt(ge) { + if (!ge.importClause) + return ge; + if (ge.importClause.isTypeOnly) + return; + const H = Qe(ge.importClause, Zr, ld); + return H ? t.updateImportDeclaration( + ge, + /*modifiers*/ + void 0, + H, + ge.moduleSpecifier, + ge.attributes + ) : void 0; + } + function Zr(ge) { + E.assert( + ge.phaseModifier !== 156 + /* TypeKeyword */ + ); + const H = _o(ge) ? ge.name : void 0, tt = Qe(ge.namedBindings, Rr, Qj); + return H || tt ? t.updateImportClause(ge, ge.phaseModifier, H, tt) : void 0; + } + function Rr(ge) { + if (ge.kind === 275) + return _o(ge) ? ge : void 0; + { + const H = u.verbatimModuleSyntax, tt = Ar(ge.elements, Pr, Xu); + return H || ot(tt) ? t.updateNamedImports(ge, tt) : void 0; + } + } + function Pr(ge) { + return !ge.isTypeOnly && _o(ge) ? ge : void 0; + } + function rt(ge) { + return u.verbatimModuleSyntax || _.isValueAliasDeclaration(ge) ? br(ge, V, e) : void 0; + } + function vt(ge) { + if (ge.isTypeOnly) + return; + if (!ge.exportClause || Km(ge.exportClause)) + return t.updateExportDeclaration( + ge, + ge.modifiers, + ge.isTypeOnly, + ge.exportClause, + ge.moduleSpecifier, + ge.attributes + ); + const H = !!u.verbatimModuleSyntax, tt = Qe( + ge.exportClause, + (Ft) => _r(Ft, H), + Bj + ); + return tt ? t.updateExportDeclaration( + ge, + /*modifiers*/ + void 0, + ge.isTypeOnly, + tt, + ge.moduleSpecifier, + ge.attributes + ) : void 0; + } + function Nt(ge, H) { + const tt = Ar(ge.elements, nr, Nu); + return H || ot(tt) ? t.updateNamedExports(ge, tt) : void 0; + } + function Jt(ge) { + return t.updateNamespaceExport(ge, E.checkDefined(Qe(ge.name, V, Me))); + } + function _r(ge, H) { + return Km(ge) ? Jt(ge) : Nt(ge, H); + } + function nr(ge) { + return !ge.isTypeOnly && (u.verbatimModuleSyntax || _.isValueAliasDeclaration(ge)) ? ge : void 0; + } + function kt(ge) { + return _o(ge) || !fl(D) && _.isTopLevelValueImportEqualsWithEntityName(ge); + } + function cr(ge) { + if (ge.isTypeOnly) + return; + if (H1(ge)) + return _o(ge) ? br(ge, V, e) : void 0; + if (!kt(ge)) + return; + const H = VN(t, ge.moduleReference); + return un( + H, + 7168 + /* NoNestedComments */ + ), Xt(ge) || !fr(ge) ? Cn( + ct( + t.createVariableStatement( + Ar(ge.modifiers, Ye, Zs), + t.createVariableDeclarationList([ + Cn( + t.createVariableDeclaration( + ge.name, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + H + ), + ge + ) + ]) + ), + ge + ), + ge + ) : Cn( + ds( + ge.name, + H, + ge + ), + ge + ); + } + function fr(ge) { + return P !== void 0 && Gn( + ge, + 32 + /* Export */ + ); + } + function vr(ge) { + return P === void 0 && Gn( + ge, + 32 + /* Export */ + ); + } + function Xt(ge) { + return vr(ge) && !Gn( + ge, + 2048 + /* Default */ + ); + } + function oi(ge) { + return vr(ge) && Gn( + ge, + 2048 + /* Default */ + ); + } + function Fs(ge) { + const H = t.createAssignment( + t.getExternalModuleOrNamespaceExportName( + A, + ge, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ), + t.getLocalName(ge) + ); + ha(H, cp(ge.name ? ge.name.pos : ge.pos, ge.end)); + const tt = t.createExpressionStatement(H); + return ha(tt, cp(-1, ge.end)), tt; + } + function Rs(ge, H) { + ge.push(Fs(H)); + } + function ds(ge, H, tt) { + return ct( + t.createExpressionStatement( + t.createAssignment( + t.getNamespaceMemberName( + A, + ge, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ), + H + ) + ), + tt + ); + } + function pc(ge, H, tt) { + return ct(t.createAssignment(Zo(ge), H), tt); + } + function Zo(ge) { + return t.getNamespaceMemberName( + A, + ge, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ); + } + function so(ge) { + const H = t.getGeneratedNameForNode(ge); + return ha(H, ge.name), H; + } + function zi(ge) { + return t.getGeneratedNameForNode(ge); + } + function hs() { + (R & 8) === 0 && (R |= 8, e.enableSubstitution( + 80 + /* Identifier */ + )); + } + function Gc() { + (R & 2) === 0 && (R |= 2, e.enableSubstitution( + 80 + /* Identifier */ + ), e.enableSubstitution( + 305 + /* ShorthandPropertyAssignment */ + ), e.enableEmitNotification( + 268 + /* ModuleDeclaration */ + )); + } + function Co(ge) { + return Vo(ge).kind === 268; + } + function ta(ge) { + return Vo(ge).kind === 267; + } + function Ec(ge, H, tt) { + const Ft = B, Kt = D; + Di(H) && (D = H), R & 2 && Co(H) && (B |= 2), R & 8 && ta(H) && (B |= 8), T(ge, H, tt), B = Ft, D = Kt; + } + function zf(ge, H) { + return H = k(ge, H), ge === 1 ? Ws(H) : gu(H) ? cs(H) : H; + } + function cs(ge) { + if (R & 2) { + const H = ge.name, tt = va(H); + if (tt) { + if (ge.objectAssignmentInitializer) { + const Ft = t.createAssignment(tt, ge.objectAssignmentInitializer); + return ct(t.createPropertyAssignment(H, Ft), ge); + } + return ct(t.createPropertyAssignment(H, tt), ge); + } + } + return ge; + } + function Ws(ge) { + switch (ge.kind) { + case 80: + return Fa(ge); + case 212: + return zt(ge); + case 213: + return Za(ge); + } + return ge; + } + function Fa(ge) { + return va(ge) || ge; + } + function va(ge) { + if (R & B && !Bo(ge) && !Nh(ge)) { + const H = _.getReferencedExportContainer( + ge, + /*prefixLocals*/ + !1 + ); + if (H && H.kind !== 308 && (B & 2 && H.kind === 268 || B & 8 && H.kind === 267)) + return ct( + t.createPropertyAccessExpression(t.getGeneratedNameForNode(H), ge), + /*location*/ + ge + ); + } + } + function zt(ge) { + return Fc(ge); + } + function Za(ge) { + return Fc(ge); + } + function yc(ge) { + return ge.replace(/\*\//g, "*_/"); + } + function Fc(ge) { + const H = Hl(ge); + if (H !== void 0) { + vte(ge, H); + const tt = typeof H == "string" ? t.createStringLiteral(H) : H < 0 ? t.createPrefixUnaryExpression(41, t.createNumericLiteral(-H)) : t.createNumericLiteral(H); + if (!u.removeComments) { + const Ft = Vo(ge, To); + C4(tt, 3, ` ${yc(Qo(Ft))} `); + } + return tt; + } + return ge; + } + function Hl(ge) { + if (!zp(u)) + return wn(ge) || uo(ge) ? _.getConstantValue(ge) : void 0; + } + function _o(ge) { + return u.verbatimModuleSyntax || an(ge) || _.isReferencedAliasDeclaration(ge); + } + } + function Gne(e) { + const { + factory: t, + getEmitHelperFactory: n, + hoistVariableDeclaration: i, + endLexicalEnvironment: s, + startLexicalEnvironment: o, + resumeLexicalEnvironment: c, + addBlockScopedVariable: _ + } = e, u = e.getEmitResolver(), g = e.getCompilerOptions(), m = da(g), h = gN(g), S = !!g.experimentalDecorators, T = !h, k = h && m < 9, D = T || k, P = m < 9, A = m < 99 ? -1 : h ? 0 : 3, O = m < 9, F = O && m >= 2, R = D || P || A === -1, B = e.onSubstituteNode; + e.onSubstituteNode = yc; + const U = e.onEmitNode; + e.onEmitNode = Za; + let $ = !1, W = 0, _e, K, V, ae; + const se = /* @__PURE__ */ new Map(), ce = /* @__PURE__ */ new Set(); + let fe, he, q = !1, be = !1; + return Ld(e, je); + function je(H) { + if (H.isDeclarationFile || (ae = void 0, $ = !!(sd(H) & 32), !R && !$)) + return H; + const tt = br(H, Z, e); + return Wg(tt, e.readEmitHelpers()), tt; + } + function me(H) { + switch (H.kind) { + case 129: + return ft() ? void 0 : H; + default: + return Bn(H, Zs); + } + } + function Z(H) { + if (!(H.transformFlags & 16777216) && !(H.transformFlags & 134234112)) + return H; + switch (H.kind) { + case 264: + return Lt(H); + case 232: + return Pe(H); + case 176: + case 173: + return E.fail("Use `classElementVisitor` instead."); + case 304: + return Ce(H); + case 244: + return Ve(H); + case 261: + return St(H); + case 170: + return Bt(H); + case 209: + return tr(H); + case 278: + return Nr(H); + case 81: + return Ne(H); + case 212: + return Ds(H); + case 213: + return Ks(H); + case 225: + case 226: + return yr( + H, + /*discarded*/ + !1 + ); + case 227: + return $e( + H, + /*discarded*/ + !1 + ); + case 218: + return Tt( + H, + /*discarded*/ + !1 + ); + case 214: + return re(H); + case 245: + return Xe(H); + case 216: + return it(H); + case 249: + return bs(H); + case 110: + return M(H); + case 263: + case 219: + return Dt( + /*classElement*/ + void 0, + pe, + H + ); + case 177: + case 175: + case 178: + case 179: + return Dt( + H, + pe, + H + ); + default: + return pe(H); + } + } + function pe(H) { + return br(H, Z, e); + } + function Te(H) { + switch (H.kind) { + case 225: + case 226: + return yr( + H, + /*discarded*/ + !0 + ); + case 227: + return $e( + H, + /*discarded*/ + !0 + ); + case 357: + return Ke( + H + ); + case 218: + return Tt( + H, + /*discarded*/ + !0 + ); + default: + return Z(H); + } + } + function Fe(H) { + switch (H.kind) { + case 299: + return br(H, Fe, e); + case 234: + return Ct(H); + default: + return Z(H); + } + } + function Ye(H) { + switch (H.kind) { + case 211: + case 210: + return zt(H); + default: + return Z(H); + } + } + function ne(H) { + switch (H.kind) { + case 177: + return Dt( + H, + Jr, + H + ); + case 178: + case 179: + case 175: + return Dt( + H, + Ji, + H + ); + case 173: + return Dt( + H, + er, + H + ); + case 176: + return Dt( + H, + ue, + H + ); + case 168: + return Wt(H); + case 241: + return H; + default: + return Jo(H) ? me(H) : Z(H); + } + } + function Se(H) { + switch (H.kind) { + case 168: + return Wt(H); + default: + return Z(H); + } + } + function ie(H) { + switch (H.kind) { + case 173: + return Je(H); + case 178: + case 179: + return ne(H); + default: + E.assertMissingNode(H, "Expected node to either be a PropertyDeclaration, GetAccessorDeclaration, or SetAccessorDeclaration"); + break; + } + } + function Ne(H) { + return !P || Ti(H.parent) ? H : Cn(t.createIdentifier(""), H); + } + function Ee(H) { + const tt = hs(H.left); + if (tt) { + const Ft = Qe(H.right, Z, ut); + return Cn( + n().createClassPrivateFieldInHelper(tt.brandCheckIdentifier, Ft), + H + ); + } + return br(H, Z, e); + } + function Ce(H) { + return rf(H, Ae) && (H = lf(e, H)), br(H, Z, e); + } + function Ve(H) { + const tt = V; + V = []; + const Ft = br(H, Z, e), Kt = ot(V) ? [Ft, ...V] : Ft; + return V = tt, Kt; + } + function St(H) { + return rf(H, Ae) && (H = lf(e, H)), br(H, Z, e); + } + function Bt(H) { + return rf(H, Ae) && (H = lf(e, H)), br(H, Z, e); + } + function tr(H) { + return rf(H, Ae) && (H = lf(e, H)), br(H, Z, e); + } + function Nr(H) { + return rf(H, Ae) && (H = lf( + e, + H, + /*ignoreEmptyStringLiteral*/ + !0, + H.isExportEquals ? "" : "default" + )), br(H, Z, e); + } + function st(H) { + return ot(K) && (o_(H) ? (K.push(H.expression), H = t.updateParenthesizedExpression(H, t.inlineExpressions(K))) : (K.push(H), H = t.inlineExpressions(K)), K = void 0), H; + } + function Wt(H) { + const tt = Qe(H.expression, Z, ut); + return t.updateComputedPropertyName(H, st(tt)); + } + function Jr(H) { + return fe ? dt(H, fe) : pe(H); + } + function ui(H) { + return !!(P || cl(H) && sd(H) & 32); + } + function Ji(H) { + if (E.assert(!Ff(H)), !Du(H) || !ui(H)) + return br(H, ne, e); + const tt = hs(H.name); + if (E.assert(tt, "Undeclared private name for property declaration."), !tt.isValid) + return H; + const Ft = Mn(H); + Ft && vr().push( + t.createAssignment( + Ft, + t.createFunctionExpression( + kn(H.modifiers, (Kt) => Zs(Kt) && !Wx(Kt) && !dz(Kt)), + H.asteriskToken, + Ft, + /*typeParameters*/ + void 0, + _c(H.parameters, Z, e), + /*type*/ + void 0, + jf(H.body, Z, e) + ) + ) + ); + } + function Dt(H, tt, Ft) { + if (H !== he) { + const Kt = he; + he = H; + const Hr = tt(Ft); + return he = Kt, Hr; + } + return tt(Ft); + } + function Mn(H) { + E.assert(Ai(H.name)); + const tt = hs(H.name); + if (E.assert(tt, "Undeclared private name for property declaration."), tt.kind === "m") + return tt.methodName; + if (tt.kind === "a") { + if (Pg(H)) + return tt.getterName; + if (am(H)) + return tt.setterName; + } + } + function ai() { + const H = cr(); + return H.classThis ?? H.classConstructor ?? fe?.name; + } + function fi(H) { + const tt = hm(H), Ft = x0(H), Kt = H.name; + let Hr = Kt, Vn = Kt; + if (Gs(Kt) && !rg(Kt.expression)) { + const Eo = UF(Kt); + if (Eo) + Hr = t.updateComputedPropertyName(Kt, Qe(Kt.expression, Z, ut)), Vn = t.updateComputedPropertyName(Kt, Eo.left); + else { + const $c = t.createTempVariable(i); + ha($c, Kt.expression); + const Jc = Qe(Kt.expression, Z, ut), vo = t.createAssignment($c, Jc); + ha(vo, Kt.expression), Hr = t.updateComputedPropertyName(Kt, vo), Vn = t.updateComputedPropertyName(Kt, $c); + } + } + const ln = Ar(H.modifiers, me, Zs), kr = zz(t, H, ln, H.initializer); + Cn(kr, H), un( + kr, + 3072 + /* NoComments */ + ), ha(kr, Ft); + const Li = Js(H) ? ai() ?? t.createThis() : t.createThis(), Yi = yre(t, H, ln, Hr, Li); + Cn(Yi, H), el(Yi, tt), ha(Yi, Ft); + const no = t.createModifiersFromModifierFlags(pm(ln)), ra = vre(t, H, no, Vn, Li); + return Cn(ra, H), un( + ra, + 3072 + /* NoComments */ + ), ha(ra, Ft), Q4([kr, Yi, ra], ie, Hc); + } + function pn(H) { + if (ui(H)) { + const tt = hs(H.name); + if (E.assert(tt, "Undeclared private name for property declaration."), !tt.isValid) + return H; + if (tt.isStatic && !P) { + const Ft = wt(H, t.createThis()); + if (Ft) + return t.createClassStaticBlockDeclaration(t.createBlock( + [Ft], + /*multiLine*/ + !0 + )); + } + return; + } + return T && !Js(H) && ae?.data && ae.data.facts & 16 ? t.updatePropertyDeclaration( + H, + Ar(H.modifiers, Z, Jo), + H.name, + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + ) : (rf(H, Ae) && (H = lf(e, H)), t.updatePropertyDeclaration( + H, + Ar(H.modifiers, me, Zs), + Qe(H.name, Se, qc), + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + Qe(H.initializer, Z, ut) + )); + } + function _i(H) { + if (D && !b_(H)) { + const tt = _r( + H.name, + /*shouldHoist*/ + !!H.initializer || h + ); + if (tt && vr().push(...bre(tt)), Js(H) && !P) { + const Ft = wt(H, t.createThis()); + if (Ft) { + const Kt = t.createClassStaticBlockDeclaration( + t.createBlock([Ft]) + ); + return Cn(Kt, H), el(Kt, H), el(Ft, { pos: -1, end: -1 }), tv(Ft, void 0), Rx(Ft, void 0), Kt; + } + } + return; + } + return t.updatePropertyDeclaration( + H, + Ar(H.modifiers, me, Zs), + Qe(H.name, Se, qc), + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + Qe(H.initializer, Z, ut) + ); + } + function Je(H) { + return E.assert(!Ff(H), "Decorators should already have been transformed and elided."), Du(H) ? pn(H) : _i(H); + } + function ft() { + return A === -1 || A === 3 && !!ae?.data && !!(ae.data.facts & 16); + } + function er(H) { + return b_(H) && (ft() || cl(H) && sd(H) & 32) ? fi(H) : Je(H); + } + function qr() { + return !!he && cl(he) && Dy(he) && b_(Vo(he)); + } + function Jn(H) { + if (qr()) { + const tt = hc(H); + tt.kind === 110 && ce.add(tt); + } + } + function Un(H, tt) { + return tt = Qe(tt, Z, ut), Jn(tt), ki(H, tt); + } + function ki(H, tt) { + switch (el(tt, Z1(tt, -1)), H.kind) { + case "a": + return n().createClassPrivateFieldGetHelper( + tt, + H.brandCheckIdentifier, + H.kind, + H.getterName + ); + case "m": + return n().createClassPrivateFieldGetHelper( + tt, + H.brandCheckIdentifier, + H.kind, + H.methodName + ); + case "f": + return n().createClassPrivateFieldGetHelper( + tt, + H.brandCheckIdentifier, + H.kind, + H.isStatic ? H.variableName : void 0 + ); + case "untransformed": + return E.fail("Access helpers should not be created for untransformed private elements"); + default: + E.assertNever(H, "Unknown private element type"); + } + } + function Ds(H) { + if (Ai(H.name)) { + const tt = hs(H.name); + if (tt) + return ct( + Cn( + Un(tt, H.expression), + H + ), + H + ); + } + if (F && he && j_(H) && Me(H.name) && rw(he) && ae?.data) { + const { classConstructor: tt, superClassReference: Ft, facts: Kt } = ae.data; + if (Kt & 1) + return Jt(H); + if (tt && Ft) { + const Hr = t.createReflectGetCall( + Ft, + t.createStringLiteralFromNode(H.name), + tt + ); + return Cn(Hr, H.expression), ct(Hr, H.expression), Hr; + } + } + return br(H, Z, e); + } + function Ks(H) { + if (F && he && j_(H) && rw(he) && ae?.data) { + const { classConstructor: tt, superClassReference: Ft, facts: Kt } = ae.data; + if (Kt & 1) + return Jt(H); + if (tt && Ft) { + const Hr = t.createReflectGetCall( + Ft, + Qe(H.argumentExpression, Z, ut), + tt + ); + return Cn(Hr, H.expression), ct(Hr, H.expression), Hr; + } + } + return br(H, Z, e); + } + function yr(H, tt) { + if (H.operator === 46 || H.operator === 47) { + const Ft = Ba(H.operand); + if (AC(Ft)) { + let Kt; + if (Kt = hs(Ft.name)) { + const Hr = Qe(Ft.expression, Z, ut); + Jn(Hr); + const { readExpression: Vn, initializeExpression: ln } = Et(Hr); + let kr = Un(Kt, Vn); + const Li = iv(H) || tt ? void 0 : t.createTempVariable(i); + return kr = RF(t, H, kr, i, Li), kr = Le( + Kt, + ln || Vn, + kr, + 64 + /* EqualsToken */ + ), Cn(kr, H), ct(kr, H), Li && (kr = t.createComma(kr, Li), ct(kr, H)), kr; + } + } else if (F && he && j_(Ft) && rw(he) && ae?.data) { + const { classConstructor: Kt, superClassReference: Hr, facts: Vn } = ae.data; + if (Vn & 1) { + const ln = Jt(Ft); + return iv(H) ? t.updatePrefixUnaryExpression(H, ln) : t.updatePostfixUnaryExpression(H, ln); + } + if (Kt && Hr) { + let ln, kr; + if (wn(Ft) ? Me(Ft.name) && (kr = ln = t.createStringLiteralFromNode(Ft.name)) : rg(Ft.argumentExpression) ? kr = ln = Ft.argumentExpression : (kr = t.createTempVariable(i), ln = t.createAssignment(kr, Qe(Ft.argumentExpression, Z, ut))), ln && kr) { + let Li = t.createReflectGetCall(Hr, kr, Kt); + ct(Li, Ft); + const Yi = tt ? void 0 : t.createTempVariable(i); + return Li = RF(t, H, Li, i, Yi), Li = t.createReflectSetCall(Hr, ln, Li, Kt), Cn(Li, H), ct(Li, H), Yi && (Li = t.createComma(Li, Yi), ct(Li, H)), Li; + } + } + } + } + return br(H, Z, e); + } + function bs(H) { + return t.updateForStatement( + H, + Qe(H.initializer, Te, ip), + Qe(H.condition, Z, ut), + Qe(H.incrementor, Te, ut), + c_(H.statement, Z, e) + ); + } + function Xe(H) { + return t.updateExpressionStatement( + H, + Qe(H.expression, Te, ut) + ); + } + function Et(H) { + const tt = lo(H) ? H : t.cloneNode(H); + if (H.kind === 110 && ce.has(H) && ce.add(tt), rg(H)) + return { readExpression: tt, initializeExpression: void 0 }; + const Ft = t.createTempVariable(i), Kt = t.createAssignment(Ft, tt); + return { readExpression: Ft, initializeExpression: Kt }; + } + function re(H) { + var tt; + if (AC(H.expression) && hs(H.expression.name)) { + const { thisArg: Ft, target: Kt } = t.createCallBinding(H.expression, i, m); + return K2(H) ? t.updateCallChain( + H, + t.createPropertyAccessChain(Qe(Kt, Z, ut), H.questionDotToken, "call"), + /*questionDotToken*/ + void 0, + /*typeArguments*/ + void 0, + [Qe(Ft, Z, ut), ...Ar(H.arguments, Z, ut)] + ) : t.updateCallExpression( + H, + t.createPropertyAccessExpression(Qe(Kt, Z, ut), "call"), + /*typeArguments*/ + void 0, + [Qe(Ft, Z, ut), ...Ar(H.arguments, Z, ut)] + ); + } + if (F && he && j_(H.expression) && rw(he) && ((tt = ae?.data) != null && tt.classConstructor)) { + const Ft = t.createFunctionCallCall( + Qe(H.expression, Z, ut), + ae.data.classConstructor, + Ar(H.arguments, Z, ut) + ); + return Cn(Ft, H), ct(Ft, H), Ft; + } + return br(H, Z, e); + } + function it(H) { + var tt; + if (AC(H.tag) && hs(H.tag.name)) { + const { thisArg: Ft, target: Kt } = t.createCallBinding(H.tag, i, m); + return t.updateTaggedTemplateExpression( + H, + t.createCallExpression( + t.createPropertyAccessExpression(Qe(Kt, Z, ut), "bind"), + /*typeArguments*/ + void 0, + [Qe(Ft, Z, ut)] + ), + /*typeArguments*/ + void 0, + Qe(H.template, Z, ox) + ); + } + if (F && he && j_(H.tag) && rw(he) && ((tt = ae?.data) != null && tt.classConstructor)) { + const Ft = t.createFunctionBindCall( + Qe(H.tag, Z, ut), + ae.data.classConstructor, + [] + ); + return Cn(Ft, H), ct(Ft, H), t.updateTaggedTemplateExpression( + H, + Ft, + /*typeArguments*/ + void 0, + Qe(H.template, Z, ox) + ); + } + return br(H, Z, e); + } + function Y(H) { + if (ae && se.set(Vo(H), ae), P) { + if (tw(H)) { + const Kt = Qe(H.body.statements[0].expression, Z, ut); + return Nl( + Kt, + /*excludeCompoundAssignment*/ + !0 + ) && Kt.left === Kt.right ? void 0 : Kt; + } + if (ok(H)) + return Qe(H.body.statements[0].expression, Z, ut); + o(); + let tt = Dt( + H, + (Kt) => Ar(Kt, Z, Ti), + H.body.statements + ); + tt = t.mergeLexicalEnvironment(tt, s()); + const Ft = t.createImmediatelyInvokedArrowFunction(tt); + return Cn(Ba(Ft.expression), H), gm( + Ba(Ft.expression), + 4 + /* AdviseOnEmitNode */ + ), Cn(Ft, H), ct(Ft, H), Ft; + } + } + function Ae(H) { + if (Rc(H) && !H.name) { + const tt = CO(H); + return ot(tt, ok) ? !1 : (P || !!sd(H)) && ot(tt, (Kt) => kc(Kt) || Du(Kt) || D && dA(Kt)); + } + return !1; + } + function $e(H, tt) { + if (y0(H)) { + const Ft = K; + K = void 0, H = t.updateBinaryExpression( + H, + Qe(H.left, Ye, ut), + H.operatorToken, + Qe(H.right, Z, ut) + ); + const Kt = ot(K) ? t.inlineExpressions(RP([...K, H])) : H; + return K = Ft, Kt; + } + if (Nl(H)) { + rf(H, Ae) && (H = lf(e, H), E.assertNode(H, Nl)); + const Ft = hc( + H.left, + 9 + /* Parentheses */ + ); + if (AC(Ft)) { + const Kt = hs(Ft.name); + if (Kt) + return ct( + Cn( + Le(Kt, Ft.expression, H.right, H.operatorToken.kind), + H + ), + H + ); + } else if (F && he && j_(H.left) && rw(he) && ae?.data) { + const { classConstructor: Kt, superClassReference: Hr, facts: Vn } = ae.data; + if (Vn & 1) + return t.updateBinaryExpression( + H, + Jt(H.left), + H.operatorToken, + Qe(H.right, Z, ut) + ); + if (Kt && Hr) { + let ln = uo(H.left) ? Qe(H.left.argumentExpression, Z, ut) : Me(H.left.name) ? t.createStringLiteralFromNode(H.left.name) : void 0; + if (ln) { + let kr = Qe(H.right, Z, ut); + if (Z4(H.operatorToken.kind)) { + let Yi = ln; + rg(ln) || (Yi = t.createTempVariable(i), ln = t.createAssignment(Yi, ln)); + const no = t.createReflectGetCall( + Hr, + Yi, + Kt + ); + Cn(no, H.left), ct(no, H.left), kr = t.createBinaryExpression( + no, + K4(H.operatorToken.kind), + kr + ), ct(kr, H); + } + const Li = tt ? void 0 : t.createTempVariable(i); + return Li && (kr = t.createAssignment(Li, kr), ct(Li, H)), kr = t.createReflectSetCall( + Hr, + ln, + kr, + Kt + ), Cn(kr, H), ct(kr, H), Li && (kr = t.createComma(kr, Li), ct(kr, H)), kr; + } + } + } + } + return Dje(H) ? Ee(H) : br(H, Z, e); + } + function Ke(H, tt) { + const Ft = SO(H.elements, Te); + return t.updateCommaListExpression(H, Ft); + } + function Tt(H, tt) { + const Ft = tt ? Te : Z, Kt = Qe(H.expression, Ft, ut); + return t.updateParenthesizedExpression(H, Kt); + } + function Le(H, tt, Ft, Kt) { + if (tt = Qe(tt, Z, ut), Ft = Qe(Ft, Z, ut), Jn(tt), Z4(Kt)) { + const { readExpression: Hr, initializeExpression: Vn } = Et(tt); + tt = Vn || Hr, Ft = t.createBinaryExpression( + ki(H, Hr), + K4(Kt), + Ft + ); + } + switch (el(tt, Z1(tt, -1)), H.kind) { + case "a": + return n().createClassPrivateFieldSetHelper( + tt, + H.brandCheckIdentifier, + Ft, + H.kind, + H.setterName + ); + case "m": + return n().createClassPrivateFieldSetHelper( + tt, + H.brandCheckIdentifier, + Ft, + H.kind, + /*f*/ + void 0 + ); + case "f": + return n().createClassPrivateFieldSetHelper( + tt, + H.brandCheckIdentifier, + Ft, + H.kind, + H.isStatic ? H.variableName : void 0 + ); + case "untransformed": + return E.fail("Access helpers should not be created for untransformed private elements"); + default: + E.assertNever(H, "Unknown private element type"); + } + } + function mt(H) { + return kn(H.members, Lne); + } + function pt(H) { + var tt; + let Ft = 0; + const Kt = Vo(H); + $n(Kt) && g0(S, Kt) && (Ft |= 1), P && (qW(H) || wO(H)) && (Ft |= 2); + let Hr = !1, Vn = !1, ln = !1, kr = !1; + for (const Yi of H.members) + Js(Yi) ? ((Yi.name && (Ai(Yi.name) || b_(Yi)) && P || b_(Yi) && A === -1 && !H.name && !((tt = H.emitNode) != null && tt.classThis)) && (Ft |= 2), (os(Yi) || kc(Yi)) && (O && Yi.transformFlags & 16384 && (Ft |= 8, Ft & 1 || (Ft |= 2)), F && Yi.transformFlags & 134217728 && (Ft & 1 || (Ft |= 6)))) : Jb(Vo(Yi)) || (b_(Yi) ? (kr = !0, ln || (ln = Du(Yi))) : Du(Yi) ? (ln = !0, u.hasNodeCheckFlag( + Yi, + 262144 + /* ContainsConstructorReference */ + ) && (Ft |= 2)) : os(Yi) && (Hr = !0, Vn || (Vn = !!Yi.initializer))); + return (k && Hr || T && Vn || P && ln || P && kr && A === -1) && (Ft |= 16), Ft; + } + function Ct(H) { + var tt; + if ((((tt = ae?.data) == null ? void 0 : tt.facts) || 0) & 4) { + const Kt = t.createTempVariable( + i, + /*reservedInNestedScopes*/ + !0 + ); + return cr().superClassReference = Kt, t.updateExpressionWithTypeArguments( + H, + t.createAssignment( + Kt, + Qe(H.expression, Z, ut) + ), + /*typeArguments*/ + void 0 + ); + } + return br(H, Z, e); + } + function qe(H, tt) { + var Ft; + const Kt = fe, Hr = K, Vn = ae; + fe = H, K = void 0, nr(); + const ln = sd(H) & 32; + if (P || ln) { + const Yi = _s(H); + if (Yi && Me(Yi)) + fr().data.className = Yi; + else if ((Ft = H.emitNode) != null && Ft.assignedName && ca(H.emitNode.assignedName)) { + if (H.emitNode.assignedName.textSourceNode && Me(H.emitNode.assignedName.textSourceNode)) + fr().data.className = H.emitNode.assignedName.textSourceNode; + else if (R_(H.emitNode.assignedName.text, m)) { + const no = t.createIdentifier(H.emitNode.assignedName.text); + fr().data.className = no; + } + } + } + if (P) { + const Yi = mt(H); + ot(Yi) && (fr().data.weakSetName = so( + "instances", + Yi[0].name + )); + } + const kr = pt(H); + kr && (cr().facts = kr), kr & 8 && vt(); + const Li = tt(H, kr); + return kt(), E.assert(ae === Vn), fe = Kt, K = Hr, Li; + } + function Lt(H) { + return qe(H, rn); + } + function rn(H, tt) { + var Ft, Kt; + let Hr; + if (tt & 2) + if (P && ((Ft = H.emitNode) != null && Ft.classThis)) + cr().classConstructor = H.emitNode.classThis, Hr = t.createAssignment(H.emitNode.classThis, t.getInternalName(H)); + else { + const vo = t.createTempVariable( + i, + /*reservedInNestedScopes*/ + !0 + ); + cr().classConstructor = t.cloneNode(vo), Hr = t.createAssignment(vo, t.getInternalName(H)); + } + (Kt = H.emitNode) != null && Kt.classThis && (cr().classThis = H.emitNode.classThis); + const Vn = u.hasNodeCheckFlag( + H, + 262144 + /* ContainsConstructorReference */ + ), ln = Gn( + H, + 32 + /* Export */ + ), kr = Gn( + H, + 2048 + /* Default */ + ); + let Li = Ar(H.modifiers, me, Zs); + const Yi = Ar(H.heritageClauses, Fe, cf), { members: no, prologue: ra } = ye(H), Eo = []; + if (Hr && vr().unshift(Hr), ot(K) && Eo.push(t.createExpressionStatement(t.inlineExpressions(K))), T || P || sd(H) & 32) { + const vo = CO(H); + ot(vo) && at(Eo, vo, t.getInternalName(H)); + } + Eo.length > 0 && ln && kr && (Li = Ar(Li, (vo) => XN(vo) ? void 0 : vo, Zs), Eo.push(t.createExportAssignment( + /*modifiers*/ + void 0, + /*isExportEquals*/ + !1, + t.getLocalName( + H, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ) + ))); + const $c = cr().classConstructor; + Vn && $c && (rt(), _e[l_(H)] = $c); + const Jc = t.updateClassDeclaration( + H, + Li, + H.name, + /*typeParameters*/ + void 0, + Yi, + no + ); + return Eo.unshift(Jc), ra && Eo.unshift(t.createExpressionStatement(ra)), Eo; + } + function Pe(H) { + return qe(H, yt); + } + function yt(H, tt) { + var Ft, Kt, Hr; + const Vn = !!(tt & 1), ln = CO(H), kr = u.hasNodeCheckFlag( + H, + 262144 + /* ContainsConstructorReference */ + ), Li = u.hasNodeCheckFlag( + H, + 32768 + /* BlockScopedBindingInLoop */ + ); + let Yi; + function no() { + var au; + if (P && ((au = H.emitNode) != null && au.classThis)) + return cr().classConstructor = H.emitNode.classThis; + const Ef = t.createTempVariable( + Li ? _ : i, + /*reservedInNestedScopes*/ + !0 + ); + return cr().classConstructor = t.cloneNode(Ef), Ef; + } + (Ft = H.emitNode) != null && Ft.classThis && (cr().classThis = H.emitNode.classThis), tt & 2 && (Yi ?? (Yi = no())); + const ra = Ar(H.modifiers, me, Zs), Eo = Ar(H.heritageClauses, Fe, cf), { members: $c, prologue: Jc } = ye(H), vo = t.updateClassExpression( + H, + ra, + H.name, + /*typeParameters*/ + void 0, + Eo, + $c + ), ic = []; + if (Jc && ic.push(Jc), (P || sd(H) & 32) && ot(ln, (au) => kc(au) || Du(au) || D && dA(au)) || ot(K)) + if (Vn) + E.assertIsDefined(V, "Decorated classes transformed by TypeScript are expected to be within a variable declaration."), ot(K) && In(V, hr(K, t.createExpressionStatement)), ot(ln) && at(V, ln, ((Kt = H.emitNode) == null ? void 0 : Kt.classThis) ?? t.getInternalName(H)), Yi ? ic.push(t.createAssignment(Yi, vo)) : P && ((Hr = H.emitNode) != null && Hr.classThis) ? ic.push(t.createAssignment(H.emitNode.classThis, vo)) : ic.push(vo); + else { + if (Yi ?? (Yi = no()), kr) { + rt(); + const au = t.cloneNode(Yi); + au.emitNode.autoGenerate.flags &= -9, _e[l_(H)] = au; + } + ic.push(t.createAssignment(Yi, vo)), In(ic, K), In(ic, Zr(ln, Yi)), ic.push(t.cloneNode(Yi)); + } + else + ic.push(vo); + return ic.length > 1 && (gm( + vo, + 131072 + /* Indented */ + ), ic.forEach(Au)), t.inlineExpressions(ic); + } + function ue(H) { + if (!P) + return br(H, Z, e); + } + function M(H) { + if (O && he && kc(he) && ae?.data) { + const { classThis: tt, classConstructor: Ft } = ae.data; + return tt ?? Ft ?? H; + } + return H; + } + function ye(H) { + const tt = !!(sd(H) & 32); + if (P || $) { + for (const ln of H.members) + if (Du(ln)) + if (ui(ln)) + Zo(ln, ln.name, Xt); + else { + const kr = fr(); + jS(kr, ln.name, { kind: "untransformed" }); + } + if (P && ot(mt(H)) && Q(), ft()) { + for (const ln of H.members) + if (b_(ln)) { + const kr = t.getGeneratedPrivateNameForNode( + ln.name, + /*prefix*/ + void 0, + "_accessor_storage" + ); + if (P || tt && cl(ln)) + Zo(ln, kr, oi); + else { + const Li = fr(); + jS(Li, kr, { kind: "untransformed" }); + } + } + } + } + let Ft = Ar(H.members, ne, Hc), Kt; + ot(Ft, nc) || (Kt = dt( + /*constructor*/ + void 0, + H + )); + let Hr, Vn; + if (!P && ot(K)) { + let ln = t.createExpressionStatement(t.inlineExpressions(K)); + if (ln.transformFlags & 134234112) { + const Li = t.createTempVariable(i), Yi = t.createArrowFunction( + /*modifiers*/ + void 0, + /*typeParameters*/ + void 0, + /*parameters*/ + [], + /*type*/ + void 0, + /*equalsGreaterThanToken*/ + void 0, + t.createBlock([ln]) + ); + Hr = t.createAssignment(Li, Yi), ln = t.createExpressionStatement(t.createCallExpression( + Li, + /*typeArguments*/ + void 0, + [] + )); + } + const kr = t.createBlock([ln]); + Vn = t.createClassStaticBlockDeclaration(kr), K = void 0; + } + if (Kt || Vn) { + let ln; + const kr = Nn(Ft, tw), Li = Nn(Ft, ok); + ln = Er(ln, kr), ln = Er(ln, Li), ln = Er(ln, Kt), ln = Er(ln, Vn); + const Yi = kr || Li ? kn(Ft, (no) => no !== kr && no !== Li) : Ft; + ln = In(ln, Yi), Ft = ct( + t.createNodeArray(ln), + /*location*/ + H.members + ); + } + return { members: Ft, prologue: Hr }; + } + function Q() { + const { weakSetName: H } = fr().data; + E.assert(H, "weakSetName should be set in private identifier environment"), vr().push( + t.createAssignment( + H, + t.createNewExpression( + t.createIdentifier("WeakSet"), + /*typeArguments*/ + void 0, + [] + ) + ) + ); + } + function dt(H, tt) { + if (H = Qe(H, Z, nc), !ae?.data || !(ae.data.facts & 16)) + return H; + const Ft = wd(tt), Kt = !!(Ft && hc(Ft.expression).kind !== 106), Hr = _c(H ? H.parameters : void 0, Z, e), Vn = ke(tt, H, Kt); + return Vn ? H ? (E.assert(Hr), t.updateConstructorDeclaration( + H, + /*modifiers*/ + void 0, + Hr, + Vn + )) : Au( + Cn( + ct( + t.createConstructorDeclaration( + /*modifiers*/ + void 0, + Hr ?? [], + Vn + ), + H || tt + ), + H + ) + ) : H; + } + function Mt(H, tt, Ft, Kt, Hr, Vn, ln) { + const kr = Kt[Hr], Li = tt[kr]; + if (In(H, Ar(tt, Z, Ti, Ft, kr - Ft)), Ft = kr + 1, wS(Li)) { + const Yi = []; + Mt( + Yi, + Li.tryBlock.statements, + /*statementOffset*/ + 0, + Kt, + Hr + 1, + Vn, + ln + ); + const no = t.createNodeArray(Yi); + ct(no, Li.tryBlock.statements), H.push(t.updateTryStatement( + Li, + t.updateBlock(Li.tryBlock, Yi), + Qe(Li.catchClause, Z, Zb), + Qe(Li.finallyBlock, Z, Ns) + )); + } else { + for (In(H, Ar(tt, Z, Ti, kr, 1)); Ft < tt.length; ) { + const Yi = tt[Ft]; + if (K_(Vo(Yi), ln)) + Ft++; + else + break; + } + In(H, Vn); + } + In(H, Ar(tt, Z, Ti, Ft)); + } + function ke(H, tt, Ft) { + var Kt; + const Hr = WW( + H, + /*requireInitializer*/ + !1, + /*isStatic*/ + !1 + ); + let Vn = Hr; + h || (Vn = kn(Vn, (Jc) => !!Jc.initializer || Ai(Jc.name) || fm(Jc))); + const ln = mt(H), kr = ot(Vn) || ot(ln); + if (!tt && !kr) + return jf( + /*node*/ + void 0, + Z, + e + ); + c(); + const Li = !tt && Ft; + let Yi = 0, no = []; + const ra = [], Eo = t.createThis(); + if (Nt(ra, ln, Eo), tt) { + const Jc = kn(Hr, (ic) => K_(Vo(ic), tt)), vo = kn(Vn, (ic) => !K_(Vo(ic), tt)); + at(ra, Jc, Eo), at(ra, vo, Eo); + } else + at(ra, Vn, Eo); + if (tt?.body) { + Yi = t.copyPrologue( + tt.body.statements, + no, + /*ensureUseStrict*/ + !1, + Z + ); + const Jc = kO(tt.body.statements, Yi); + if (Jc.length) + Mt( + no, + tt.body.statements, + Yi, + Jc, + /*superPathDepth*/ + 0, + ra, + tt + ); + else { + for (; Yi < tt.body.statements.length; ) { + const vo = tt.body.statements[Yi]; + if (K_(Vo(vo), tt)) + Yi++; + else + break; + } + In(no, ra), In(no, Ar(tt.body.statements, Z, Ti, Yi)); + } + } else + Li && no.push( + t.createExpressionStatement( + t.createCallExpression( + t.createSuper(), + /*typeArguments*/ + void 0, + [t.createSpreadElement(t.createIdentifier("arguments"))] + ) + ) + ), In(no, ra); + if (no = t.mergeLexicalEnvironment(no, s()), no.length === 0 && !tt) + return; + const $c = tt?.body && tt.body.statements.length >= no.length ? tt.body.multiLine ?? no.length > 0 : no.length > 0; + return ct( + t.createBlock( + ct( + t.createNodeArray(no), + /*location*/ + ((Kt = tt?.body) == null ? void 0 : Kt.statements) ?? H.members + ), + $c + ), + tt?.body + ); + } + function at(H, tt, Ft) { + for (const Kt of tt) { + if (Js(Kt) && !P) + continue; + const Hr = wt(Kt, Ft); + Hr && H.push(Hr); + } + } + function wt(H, tt) { + const Ft = kc(H) ? Dt(H, Y, H) : Rr(H, tt); + if (!Ft) + return; + const Kt = t.createExpressionStatement(Ft); + Cn(Kt, H), gm( + Kt, + Ea(H) & 3072 + /* NoComments */ + ), el(Kt, H); + const Hr = Vo(H); + return Ii(Hr) ? (ha(Kt, Hr), IN(Kt)) : ha(Kt, dm(H)), tv(Ft, void 0), Rx(Ft, void 0), fm(Hr) && gm( + Kt, + 3072 + /* NoComments */ + ), Kt; + } + function Zr(H, tt) { + const Ft = []; + for (const Kt of H) { + const Hr = kc(Kt) ? Dt(Kt, Y, Kt) : Dt( + Kt, + () => Rr(Kt, tt), + /*arg*/ + void 0 + ); + Hr && (Au(Hr), Cn(Hr, Kt), gm( + Hr, + Ea(Kt) & 3072 + /* NoComments */ + ), ha(Hr, dm(Kt)), el(Hr, Kt), Ft.push(Hr)); + } + return Ft; + } + function Rr(H, tt) { + var Ft; + const Kt = he, Hr = Pr(H, tt); + return Hr && cl(H) && ((Ft = ae?.data) != null && Ft.facts) && (Cn(Hr, H), gm( + Hr, + 4 + /* AdviseOnEmitNode */ + ), ha(Hr, x0(H.name)), se.set(Vo(H), ae)), he = Kt, Hr; + } + function Pr(H, tt) { + const Ft = !h; + rf(H, Ae) && (H = lf(e, H)); + const Kt = fm(H) ? t.getGeneratedPrivateNameForNode(H.name) : Gs(H.name) && !rg(H.name.expression) ? t.updateComputedPropertyName(H.name, t.getGeneratedNameForNode(H.name)) : H.name; + if (cl(H) && (he = H), Ai(Kt) && ui(H)) { + const ln = hs(Kt); + if (ln) + return ln.kind === "f" ? ln.isStatic ? xje( + t, + ln.variableName, + Qe(H.initializer, Z, ut) + ) : kje( + t, + tt, + Qe(H.initializer, Z, ut), + ln.brandCheckIdentifier + ) : void 0; + E.fail("Undeclared private name for property declaration."); + } + if ((Ai(Kt) || cl(H)) && !H.initializer) + return; + const Hr = Vo(H); + if (Gn( + Hr, + 64 + /* Abstract */ + )) + return; + let Vn = Qe(H.initializer, Z, ut); + if (K_(Hr, Hr.parent) && Me(Kt)) { + const ln = t.cloneNode(Kt); + Vn ? (o_(Vn) && qN(Vn.expression) && E4(Vn.expression.left, "___runInitializers") && Gx(Vn.expression.right) && E_(Vn.expression.right.expression) && (Vn = Vn.expression.left), Vn = t.inlineExpressions([Vn, ln])) : Vn = ln, un( + Kt, + 3168 + /* NoSourceMap */ + ), ha(ln, Hr.name), un( + ln, + 3072 + /* NoComments */ + ); + } else + Vn ?? (Vn = t.createVoidZero()); + if (Ft || Ai(Kt)) { + const ln = FS( + t, + tt, + Kt, + /*location*/ + Kt + ); + return gm( + ln, + 1024 + /* NoLeadingComments */ + ), t.createAssignment(ln, Vn); + } else { + const ln = Gs(Kt) ? Kt.expression : Me(Kt) ? t.createStringLiteral(Si(Kt.escapedText)) : Kt, kr = t.createPropertyDescriptor({ value: Vn, configurable: !0, writable: !0, enumerable: !0 }); + return t.createObjectDefinePropertyCall(tt, ln, kr); + } + } + function rt() { + (W & 1) === 0 && (W |= 1, e.enableSubstitution( + 80 + /* Identifier */ + ), _e = []); + } + function vt() { + (W & 2) === 0 && (W |= 2, e.enableSubstitution( + 110 + /* ThisKeyword */ + ), e.enableEmitNotification( + 263 + /* FunctionDeclaration */ + ), e.enableEmitNotification( + 219 + /* FunctionExpression */ + ), e.enableEmitNotification( + 177 + /* Constructor */ + ), e.enableEmitNotification( + 178 + /* GetAccessor */ + ), e.enableEmitNotification( + 179 + /* SetAccessor */ + ), e.enableEmitNotification( + 175 + /* MethodDeclaration */ + ), e.enableEmitNotification( + 173 + /* PropertyDeclaration */ + ), e.enableEmitNotification( + 168 + /* ComputedPropertyName */ + )); + } + function Nt(H, tt, Ft) { + if (!P || !ot(tt)) + return; + const { weakSetName: Kt } = fr().data; + E.assert(Kt, "weakSetName should be set in private identifier environment"), H.push( + t.createExpressionStatement( + Cje(t, Ft, Kt) + ) + ); + } + function Jt(H) { + return wn(H) ? t.updatePropertyAccessExpression( + H, + t.createVoidZero(), + H.name + ) : t.updateElementAccessExpression( + H, + t.createVoidZero(), + Qe(H.argumentExpression, Z, ut) + ); + } + function _r(H, tt) { + if (Gs(H)) { + const Ft = UF(H), Kt = Qe(H.expression, Z, ut), Hr = id(Kt), Vn = rg(Hr); + if (!(!!Ft || Nl(Hr) && Bo(Hr.left)) && !Vn && tt) { + const kr = t.getGeneratedNameForNode(H); + return u.hasNodeCheckFlag( + H, + 32768 + /* BlockScopedBindingInLoop */ + ) ? _(kr) : i(kr), t.createAssignment(kr, Kt); + } + return Vn || Me(Hr) ? void 0 : Kt; + } + } + function nr() { + ae = { previous: ae, data: void 0 }; + } + function kt() { + ae = ae?.previous; + } + function cr() { + return E.assert(ae), ae.data ?? (ae.data = { + facts: 0, + classConstructor: void 0, + classThis: void 0, + superClassReference: void 0 + // privateIdentifierEnvironment: undefined, + }); + } + function fr() { + return E.assert(ae), ae.privateEnv ?? (ae.privateEnv = Rne({ + className: void 0, + weakSetName: void 0 + })); + } + function vr() { + return K ?? (K = []); + } + function Xt(H, tt, Ft, Kt, Hr, Vn, ln) { + b_(H) ? pc(H, tt, Ft, Kt, Hr, Vn) : os(H) ? oi(H, tt, Ft, Kt, Hr, Vn) : rc(H) ? Fs(H, tt, Ft, Kt, Hr, Vn) : pp(H) ? Rs(H, tt, Ft, Kt, Hr, Vn, ln) : z_(H) && ds(H, tt, Ft, Kt, Hr, Vn, ln); + } + function oi(H, tt, Ft, Kt, Hr, Vn, ln) { + if (Hr) { + const kr = E.checkDefined(Ft.classThis ?? Ft.classConstructor, "classConstructor should be set in private identifier environment"), Li = zi(tt); + jS(Kt, tt, { + kind: "f", + isStatic: !0, + brandCheckIdentifier: kr, + variableName: Li, + isValid: Vn + }); + } else { + const kr = zi(tt); + jS(Kt, tt, { + kind: "f", + isStatic: !1, + brandCheckIdentifier: kr, + isValid: Vn + }), vr().push(t.createAssignment( + kr, + t.createNewExpression( + t.createIdentifier("WeakMap"), + /*typeArguments*/ + void 0, + [] + ) + )); + } + } + function Fs(H, tt, Ft, Kt, Hr, Vn, ln) { + const kr = zi(tt), Li = Hr ? E.checkDefined(Ft.classThis ?? Ft.classConstructor, "classConstructor should be set in private identifier environment") : E.checkDefined(Kt.data.weakSetName, "weakSetName should be set in private identifier environment"); + jS(Kt, tt, { + kind: "m", + methodName: kr, + brandCheckIdentifier: Li, + isStatic: Hr, + isValid: Vn + }); + } + function Rs(H, tt, Ft, Kt, Hr, Vn, ln) { + const kr = zi(tt, "_get"), Li = Hr ? E.checkDefined(Ft.classThis ?? Ft.classConstructor, "classConstructor should be set in private identifier environment") : E.checkDefined(Kt.data.weakSetName, "weakSetName should be set in private identifier environment"); + ln?.kind === "a" && ln.isStatic === Hr && !ln.getterName ? ln.getterName = kr : jS(Kt, tt, { + kind: "a", + getterName: kr, + setterName: void 0, + brandCheckIdentifier: Li, + isStatic: Hr, + isValid: Vn + }); + } + function ds(H, tt, Ft, Kt, Hr, Vn, ln) { + const kr = zi(tt, "_set"), Li = Hr ? E.checkDefined(Ft.classThis ?? Ft.classConstructor, "classConstructor should be set in private identifier environment") : E.checkDefined(Kt.data.weakSetName, "weakSetName should be set in private identifier environment"); + ln?.kind === "a" && ln.isStatic === Hr && !ln.setterName ? ln.setterName = kr : jS(Kt, tt, { + kind: "a", + getterName: void 0, + setterName: kr, + brandCheckIdentifier: Li, + isStatic: Hr, + isValid: Vn + }); + } + function pc(H, tt, Ft, Kt, Hr, Vn, ln) { + const kr = zi(tt, "_get"), Li = zi(tt, "_set"), Yi = Hr ? E.checkDefined(Ft.classThis ?? Ft.classConstructor, "classConstructor should be set in private identifier environment") : E.checkDefined(Kt.data.weakSetName, "weakSetName should be set in private identifier environment"); + jS(Kt, tt, { + kind: "a", + getterName: kr, + setterName: Li, + brandCheckIdentifier: Yi, + isStatic: Hr, + isValid: Vn + }); + } + function Zo(H, tt, Ft) { + const Kt = cr(), Hr = fr(), Vn = VW(Hr, tt), ln = cl(H), kr = !Eje(tt) && Vn === void 0; + Ft(H, tt, Kt, Hr, ln, kr, Vn); + } + function so(H, tt, Ft) { + const { className: Kt } = fr().data, Hr = Kt ? { prefix: "_", node: Kt, suffix: "_" } : "_", Vn = typeof H == "object" ? t.getGeneratedNameForNode(H, 24, Hr, Ft) : typeof H == "string" ? t.createUniqueName(H, 16, Hr, Ft) : t.createTempVariable( + /*recordTempVariable*/ + void 0, + /*reservedInNestedScopes*/ + !0, + Hr, + Ft + ); + return u.hasNodeCheckFlag( + tt, + 32768 + /* BlockScopedBindingInLoop */ + ) ? _(Vn) : i(Vn), Vn; + } + function zi(H, tt) { + const Ft = FD(H); + return so(Ft?.substring(1) ?? H, H, tt); + } + function hs(H) { + const tt = jne(ae, H); + return tt?.kind === "untransformed" ? void 0 : tt; + } + function Gc(H) { + const tt = t.getGeneratedNameForNode(H), Ft = hs(H.name); + if (!Ft) + return br(H, Z, e); + let Kt = H.expression; + return (A3(H) || j_(H) || !r2(H.expression)) && (Kt = t.createTempVariable( + i, + /*reservedInNestedScopes*/ + !0 + ), vr().push(t.createBinaryExpression(Kt, 64, Qe(H.expression, Z, ut)))), t.createAssignmentTargetWrapper( + tt, + Le( + Ft, + Kt, + tt, + 64 + /* EqualsToken */ + ) + ); + } + function Co(H) { + if (_a(H) || nu(H)) + return zt(H); + if (AC(H)) + return Gc(H); + if (F && he && j_(H) && rw(he) && ae?.data) { + const { classConstructor: tt, superClassReference: Ft, facts: Kt } = ae.data; + if (Kt & 1) + return Jt(H); + if (tt && Ft) { + const Hr = uo(H) ? Qe(H.argumentExpression, Z, ut) : Me(H.name) ? t.createStringLiteralFromNode(H.name) : void 0; + if (Hr) { + const Vn = t.createTempVariable( + /*recordTempVariable*/ + void 0 + ); + return t.createAssignmentTargetWrapper( + Vn, + t.createReflectSetCall( + Ft, + Hr, + Vn, + tt + ) + ); + } + } + } + return br(H, Z, e); + } + function ta(H) { + if (rf(H, Ae) && (H = lf(e, H)), Nl( + H, + /*excludeCompoundAssignment*/ + !0 + )) { + const tt = Co(H.left), Ft = Qe(H.right, Z, ut); + return t.updateBinaryExpression(H, tt, H.operatorToken, Ft); + } + return Co(H); + } + function Ec(H) { + if (S_(H.expression)) { + const tt = Co(H.expression); + return t.updateSpreadElement(H, tt); + } + return br(H, Z, e); + } + function zf(H) { + if (_3(H)) { + if (dp(H)) return Ec(H); + if (!vl(H)) return ta(H); + } + return br(H, Z, e); + } + function cs(H) { + const tt = Qe(H.name, Z, qc); + if (Nl( + H.initializer, + /*excludeCompoundAssignment*/ + !0 + )) { + const Ft = ta(H.initializer); + return t.updatePropertyAssignment(H, tt, Ft); + } + if (S_(H.initializer)) { + const Ft = Co(H.initializer); + return t.updatePropertyAssignment(H, tt, Ft); + } + return br(H, Z, e); + } + function Ws(H) { + return rf(H, Ae) && (H = lf(e, H)), br(H, Z, e); + } + function Fa(H) { + if (S_(H.expression)) { + const tt = Co(H.expression); + return t.updateSpreadAssignment(H, tt); + } + return br(H, Z, e); + } + function va(H) { + return E.assertNode(H, u3), Vg(H) ? Fa(H) : gu(H) ? Ws(H) : rl(H) ? cs(H) : br(H, Z, e); + } + function zt(H) { + return nu(H) ? t.updateArrayLiteralExpression( + H, + Ar(H.elements, zf, ut) + ) : t.updateObjectLiteralExpression( + H, + Ar(H.properties, va, vh) + ); + } + function Za(H, tt, Ft) { + const Kt = Vo(tt), Hr = se.get(Kt); + if (Hr) { + const Vn = ae, ln = be; + ae = Hr, be = q, q = !kc(Kt) || !(sd(Kt) & 32), U(H, tt, Ft), q = be, be = ln, ae = Vn; + return; + } + switch (tt.kind) { + case 219: + if (xo(Kt) || Ea(tt) & 524288) + break; + // falls through + case 263: + case 177: + case 178: + case 179: + case 175: + case 173: { + const Vn = ae, ln = be; + ae = void 0, be = q, q = !1, U(H, tt, Ft), q = be, be = ln, ae = Vn; + return; + } + case 168: { + const Vn = ae, ln = q; + ae = ae?.previous, q = be, U(H, tt, Ft), q = ln, ae = Vn; + return; + } + } + U(H, tt, Ft); + } + function yc(H, tt) { + return tt = B(H, tt), H === 1 ? Fc(tt) : tt; + } + function Fc(H) { + switch (H.kind) { + case 80: + return _o(H); + case 110: + return Hl(H); + } + return H; + } + function Hl(H) { + if (W & 2 && ae?.data && !ce.has(H)) { + const { facts: tt, classConstructor: Ft, classThis: Kt } = ae.data, Hr = q ? Kt ?? Ft : Ft; + if (Hr) + return ct( + Cn( + t.cloneNode(Hr), + H + ), + H + ); + if (tt & 1 && S) + return t.createParenthesizedExpression(t.createVoidZero()); + } + return H; + } + function _o(H) { + return ge(H) || H; + } + function ge(H) { + if (W & 1 && u.hasNodeCheckFlag( + H, + 536870912 + /* ConstructorReference */ + )) { + const tt = u.getReferencedValueDeclaration(H); + if (tt) { + const Ft = _e[tt.id]; + if (Ft) { + const Kt = t.cloneNode(Ft); + return ha(Kt, H), el(Kt, H), Kt; + } + } + } + } + } + function xje(e, t, n) { + return e.createAssignment( + t, + e.createObjectLiteralExpression([ + e.createPropertyAssignment("value", n || e.createVoidZero()) + ]) + ); + } + function kje(e, t, n, i) { + return e.createCallExpression( + e.createPropertyAccessExpression(i, "set"), + /*typeArguments*/ + void 0, + [t, n || e.createVoidZero()] + ); + } + function Cje(e, t, n) { + return e.createCallExpression( + e.createPropertyAccessExpression(n, "add"), + /*typeArguments*/ + void 0, + [t] + ); + } + function Eje(e) { + return !tS(e) && e.escapedText === "#constructor"; + } + function Dje(e) { + return Ai(e.left) && e.operatorToken.kind === 103; + } + function wje(e) { + return os(e) && cl(e); + } + function rw(e) { + return kc(e) || wje(e); + } + function $ne(e) { + const { + factory: t, + hoistVariableDeclaration: n + } = e, i = e.getEmitResolver(), s = e.getCompilerOptions(), o = da(s), c = du(s, "strictNullChecks"); + let _, u; + return { + serializeTypeNode: (K, V) => g(K, D, V), + serializeTypeOfNode: (K, V, ae) => g(K, h, V, ae), + serializeParameterTypesOfNode: (K, V, ae) => g(K, S, V, ae), + serializeReturnTypeOfNode: (K, V) => g(K, k, V) + }; + function g(K, V, ae, se) { + const ce = _, fe = u; + _ = K.currentLexicalScope, u = K.currentNameScope; + const he = se === void 0 ? V(ae) : V(ae, se); + return _ = ce, u = fe, he; + } + function m(K, V) { + const ae = Bb(V.members, K); + return ae.setAccessor && XK(ae.setAccessor) || ae.getAccessor && nf(ae.getAccessor); + } + function h(K, V) { + switch (K.kind) { + case 173: + case 170: + return D(K.type); + case 179: + case 178: + return D(m(K, V)); + case 264: + case 232: + case 175: + return t.createIdentifier("Function"); + default: + return t.createVoidZero(); + } + } + function S(K, V) { + const ae = $n(K) ? Mg(K) : Es(K) && Mp(K.body) ? K : void 0, se = []; + if (ae) { + const ce = T(ae, V), fe = ce.length; + for (let he = 0; he < fe; he++) { + const q = ce[he]; + he === 0 && Me(q.name) && q.name.escapedText === "this" || (q.dotDotDotToken ? se.push(D(SB(q.type))) : se.push(h(q, V))); + } + } + return t.createArrayLiteralExpression(se); + } + function T(K, V) { + if (V && K.kind === 178) { + const { setAccessor: ae } = Bb(V.members, K); + if (ae) + return ae.parameters; + } + return K.parameters; + } + function k(K) { + return Es(K) && K.type ? D(K.type) : $D(K) ? t.createIdentifier("Promise") : t.createVoidZero(); + } + function D(K) { + if (K === void 0) + return t.createIdentifier("Object"); + switch (K = VD(K), K.kind) { + case 116: + case 157: + case 146: + return t.createVoidZero(); + case 185: + case 186: + return t.createIdentifier("Function"); + case 189: + case 190: + return t.createIdentifier("Array"); + case 183: + return K.assertsModifier ? t.createVoidZero() : t.createIdentifier("Boolean"); + case 136: + return t.createIdentifier("Boolean"); + case 204: + case 154: + return t.createIdentifier("String"); + case 151: + return t.createIdentifier("Object"); + case 202: + return P(K.literal); + case 150: + return t.createIdentifier("Number"); + case 163: + return _e( + "BigInt", + 7 + /* ES2020 */ + ); + case 155: + return _e( + "Symbol", + 2 + /* ES2015 */ + ); + case 184: + return F(K); + case 194: + return A( + K.types, + /*isIntersection*/ + !0 + ); + case 193: + return A( + K.types, + /*isIntersection*/ + !1 + ); + case 195: + return A( + [K.trueType, K.falseType], + /*isIntersection*/ + !1 + ); + case 199: + if (K.operator === 148) + return D(K.type); + break; + case 187: + case 200: + case 201: + case 188: + case 133: + case 159: + case 198: + case 206: + break; + // handle JSDoc types from an invalid parse + case 313: + case 314: + case 318: + case 319: + case 320: + break; + case 315: + case 316: + case 317: + return D(K.type); + default: + return E.failBadSyntaxKind(K); + } + return t.createIdentifier("Object"); + } + function P(K) { + switch (K.kind) { + case 11: + case 15: + return t.createIdentifier("String"); + case 225: { + const V = K.operand; + switch (V.kind) { + case 9: + case 10: + return P(V); + default: + return E.failBadSyntaxKind(V); + } + } + case 9: + return t.createIdentifier("Number"); + case 10: + return _e( + "BigInt", + 7 + /* ES2020 */ + ); + case 112: + case 97: + return t.createIdentifier("Boolean"); + case 106: + return t.createVoidZero(); + default: + return E.failBadSyntaxKind(K); + } + } + function A(K, V) { + let ae; + for (let se of K) { + if (se = VD(se), se.kind === 146) { + if (V) return t.createVoidZero(); + continue; + } + if (se.kind === 159) { + if (!V) return t.createIdentifier("Object"); + continue; + } + if (se.kind === 133) + return t.createIdentifier("Object"); + if (!c && (E0(se) && se.literal.kind === 106 || se.kind === 157)) + continue; + const ce = D(se); + if (Me(ce) && ce.escapedText === "Object") + return ce; + if (ae) { + if (!O(ae, ce)) + return t.createIdentifier("Object"); + } else + ae = ce; + } + return ae ?? t.createVoidZero(); + } + function O(K, V) { + return ( + // temp vars used in fallback + Bo(K) ? Bo(V) : ( + // entity names + Me(K) ? Me(V) && K.escapedText === V.escapedText : wn(K) ? wn(V) && O(K.expression, V.expression) && O(K.name, V.name) : ( + // `void 0` + Gx(K) ? Gx(V) && E_(K.expression) && K.expression.text === "0" && E_(V.expression) && V.expression.text === "0" : ( + // `"undefined"` or `"function"` in `typeof` checks + ca(K) ? ca(V) && K.text === V.text : ( + // used in `typeof` checks for fallback + p6(K) ? p6(V) && O(K.expression, V.expression) : ( + // parens in `typeof` checks with temps + o_(K) ? o_(V) && O(K.expression, V.expression) : ( + // conditionals used in fallback + ES(K) ? ES(V) && O(K.condition, V.condition) && O(K.whenTrue, V.whenTrue) && O(K.whenFalse, V.whenFalse) : ( + // logical binary and assignments used in fallback + _n(K) ? _n(V) && K.operatorToken.kind === V.operatorToken.kind && O(K.left, V.left) && O(K.right, V.right) : !1 + ) + ) + ) + ) + ) + ) + ) + ); + } + function F(K) { + const V = i.getTypeReferenceSerializationKind(K.typeName, u ?? _); + switch (V) { + case 0: + if (dr(K, (ce) => ce.parent && Gb(ce.parent) && (ce.parent.trueType === ce || ce.parent.falseType === ce))) + return t.createIdentifier("Object"); + const ae = B(K.typeName), se = t.createTempVariable(n); + return t.createConditionalExpression( + t.createTypeCheck(t.createAssignment(se, ae), "function"), + /*questionToken*/ + void 0, + se, + /*colonToken*/ + void 0, + t.createIdentifier("Object") + ); + case 1: + return U(K.typeName); + case 2: + return t.createVoidZero(); + case 4: + return _e( + "BigInt", + 7 + /* ES2020 */ + ); + case 6: + return t.createIdentifier("Boolean"); + case 3: + return t.createIdentifier("Number"); + case 5: + return t.createIdentifier("String"); + case 7: + return t.createIdentifier("Array"); + case 8: + return _e( + "Symbol", + 2 + /* ES2015 */ + ); + case 10: + return t.createIdentifier("Function"); + case 9: + return t.createIdentifier("Promise"); + case 11: + return t.createIdentifier("Object"); + default: + return E.assertNever(V); + } + } + function R(K, V) { + return t.createLogicalAnd( + t.createStrictInequality(t.createTypeOfExpression(K), t.createStringLiteral("undefined")), + V + ); + } + function B(K) { + if (K.kind === 80) { + const se = U(K); + return R(se, se); + } + if (K.left.kind === 80) + return R(U(K.left), U(K)); + const V = B(K.left), ae = t.createTempVariable(n); + return t.createLogicalAnd( + t.createLogicalAnd( + V.left, + t.createStrictInequality(t.createAssignment(ae, V.right), t.createVoidZero()) + ), + t.createPropertyAccessExpression(ae, K.right) + ); + } + function U(K) { + switch (K.kind) { + case 80: + const V = za(ct(fv.cloneNode(K), K), K.parent); + return V.original = void 0, za(V, vs(_)), V; + case 167: + return $(K); + } + } + function $(K) { + return t.createPropertyAccessExpression(U(K.left), K.right); + } + function W(K) { + return t.createConditionalExpression( + t.createTypeCheck(t.createIdentifier(K), "function"), + /*questionToken*/ + void 0, + t.createIdentifier(K), + /*colonToken*/ + void 0, + t.createIdentifier("Object") + ); + } + function _e(K, V) { + return o < V ? W(K) : t.createIdentifier(K); + } + } + function Xne(e) { + const { + factory: t, + getEmitHelperFactory: n, + hoistVariableDeclaration: i + } = e, s = e.getEmitResolver(), o = e.getCompilerOptions(), c = da(o), _ = e.onSubstituteNode; + e.onSubstituteNode = Se; + let u; + return Ld(e, g); + function g(Ce) { + const Ve = br(Ce, h, e); + return Wg(Ve, e.readEmitHelpers()), Ve; + } + function m(Ce) { + return ul(Ce) ? void 0 : Ce; + } + function h(Ce) { + if (!(Ce.transformFlags & 33554432)) + return Ce; + switch (Ce.kind) { + case 171: + return; + case 264: + return S(Ce); + case 232: + return F(Ce); + case 177: + return R(Ce); + case 175: + return U(Ce); + case 179: + return W(Ce); + case 178: + return $(Ce); + case 173: + return _e(Ce); + case 170: + return K(Ce); + default: + return br(Ce, h, e); + } + } + function S(Ce) { + if (!(g0( + /*useLegacyDecorators*/ + !0, + Ce + ) || RD( + /*useLegacyDecorators*/ + !0, + Ce + ))) + return br(Ce, h, e); + const Ve = g0( + /*useLegacyDecorators*/ + !0, + Ce + ) ? O(Ce, Ce.name) : A(Ce, Ce.name); + return Wm(Ve); + } + function T(Ce) { + return !!(Ce.transformFlags & 536870912); + } + function k(Ce) { + return ot(Ce, T); + } + function D(Ce) { + for (const Ve of Ce.members) { + if (!e2(Ve)) continue; + const St = EO( + Ve, + Ce, + /*useLegacyDecorators*/ + !0 + ); + if (ot(St?.decorators, T) || ot(St?.parameters, k)) return !0; + } + return !1; + } + function P(Ce, Ve) { + let St = []; + return se( + St, + Ce, + /*isStatic*/ + !1 + ), se( + St, + Ce, + /*isStatic*/ + !0 + ), D(Ce) && (Ve = ct( + t.createNodeArray([ + ...Ve, + t.createClassStaticBlockDeclaration( + t.createBlock( + St, + /*multiLine*/ + !0 + ) + ) + ]), + Ve + ), St = void 0), { decorationStatements: St, members: Ve }; + } + function A(Ce, Ve) { + const St = Ar(Ce.modifiers, m, Zs), Bt = Ar(Ce.heritageClauses, h, cf); + let tr = Ar(Ce.members, h, Hc), Nr = []; + ({ members: tr, decorationStatements: Nr } = P(Ce, tr)); + const st = t.updateClassDeclaration( + Ce, + St, + Ve, + /*typeParameters*/ + void 0, + Bt, + tr + ); + return In([st], Nr); + } + function O(Ce, Ve) { + const St = Gn( + Ce, + 32 + /* Export */ + ), Bt = Gn( + Ce, + 2048 + /* Default */ + ), tr = Ar(Ce.modifiers, (ft) => XN(ft) || ul(ft) ? void 0 : ft, Jo), Nr = dm(Ce), st = Fe(Ce), Wt = c < 2 ? t.getInternalName( + Ce, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ) : t.getLocalName( + Ce, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ), Jr = Ar(Ce.heritageClauses, h, cf); + let ui = Ar(Ce.members, h, Hc), Ji = []; + ({ members: ui, decorationStatements: Ji } = P(Ce, ui)); + const Dt = c >= 9 && !!st && ot(ui, (ft) => os(ft) && Gn( + ft, + 256 + /* Static */ + ) || kc(ft)); + Dt && (ui = ct( + t.createNodeArray([ + t.createClassStaticBlockDeclaration( + t.createBlock([ + t.createExpressionStatement( + t.createAssignment(st, t.createThis()) + ) + ]) + ), + ...ui + ]), + ui + )); + const Mn = t.createClassExpression( + tr, + Ve && Bo(Ve) ? void 0 : Ve, + /*typeParameters*/ + void 0, + Jr, + ui + ); + Cn(Mn, Ce), ct(Mn, Nr); + const ai = st && !Dt ? t.createAssignment(st, Mn) : Mn, fi = t.createVariableDeclaration( + Wt, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + ai + ); + Cn(fi, Ce); + const pn = t.createVariableDeclarationList( + [fi], + 1 + /* Let */ + ), _i = t.createVariableStatement( + /*modifiers*/ + void 0, + pn + ); + Cn(_i, Ce), ct(_i, Nr), el(_i, Ce); + const Je = [_i]; + if (In(Je, Ji), be(Je, Ce), St) + if (Bt) { + const ft = t.createExportDefault(Wt); + Je.push(ft); + } else { + const ft = t.createExternalModuleExport(t.getDeclarationName(Ce)); + Je.push(ft); + } + return Je; + } + function F(Ce) { + return t.updateClassExpression( + Ce, + Ar(Ce.modifiers, m, Zs), + Ce.name, + /*typeParameters*/ + void 0, + Ar(Ce.heritageClauses, h, cf), + Ar(Ce.members, h, Hc) + ); + } + function R(Ce) { + return t.updateConstructorDeclaration( + Ce, + Ar(Ce.modifiers, m, Zs), + Ar(Ce.parameters, h, Ii), + Qe(Ce.body, h, Ns) + ); + } + function B(Ce, Ve) { + return Ce !== Ve && (el(Ce, Ve), ha(Ce, dm(Ve))), Ce; + } + function U(Ce) { + return B( + t.updateMethodDeclaration( + Ce, + Ar(Ce.modifiers, m, Zs), + Ce.asteriskToken, + E.checkDefined(Qe(Ce.name, h, qc)), + /*questionToken*/ + void 0, + /*typeParameters*/ + void 0, + Ar(Ce.parameters, h, Ii), + /*type*/ + void 0, + Qe(Ce.body, h, Ns) + ), + Ce + ); + } + function $(Ce) { + return B( + t.updateGetAccessorDeclaration( + Ce, + Ar(Ce.modifiers, m, Zs), + E.checkDefined(Qe(Ce.name, h, qc)), + Ar(Ce.parameters, h, Ii), + /*type*/ + void 0, + Qe(Ce.body, h, Ns) + ), + Ce + ); + } + function W(Ce) { + return B( + t.updateSetAccessorDeclaration( + Ce, + Ar(Ce.modifiers, m, Zs), + E.checkDefined(Qe(Ce.name, h, qc)), + Ar(Ce.parameters, h, Ii), + Qe(Ce.body, h, Ns) + ), + Ce + ); + } + function _e(Ce) { + if (!(Ce.flags & 33554432 || Gn( + Ce, + 128 + /* Ambient */ + ))) + return B( + t.updatePropertyDeclaration( + Ce, + Ar(Ce.modifiers, m, Zs), + E.checkDefined(Qe(Ce.name, h, qc)), + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + Qe(Ce.initializer, h, ut) + ), + Ce + ); + } + function K(Ce) { + const Ve = t.updateParameterDeclaration( + Ce, + hre(t, Ce.modifiers), + Ce.dotDotDotToken, + E.checkDefined(Qe(Ce.name, h, rS)), + /*questionToken*/ + void 0, + /*type*/ + void 0, + Qe(Ce.initializer, h, ut) + ); + return Ve !== Ce && (el(Ve, Ce), ct(Ve, dm(Ce)), ha(Ve, dm(Ce)), un( + Ve.name, + 64 + /* NoTrailingSourceMap */ + )), Ve; + } + function V(Ce) { + return E4(Ce.expression, "___metadata"); + } + function ae(Ce) { + if (!Ce) + return; + const { false: Ve, true: St } = LR(Ce.decorators, V), Bt = []; + return In(Bt, hr(Ve, me)), In(Bt, ka(Ce.parameters, Z)), In(Bt, hr(St, me)), Bt; + } + function se(Ce, Ve, St) { + In(Ce, hr(he(Ve, St), (Bt) => t.createExpressionStatement(Bt))); + } + function ce(Ce, Ve, St) { + return O3( + /*useLegacyDecorators*/ + !0, + Ce, + St + ) && Ve === Js(Ce); + } + function fe(Ce, Ve) { + return kn(Ce.members, (St) => ce(St, Ve, Ce)); + } + function he(Ce, Ve) { + const St = fe(Ce, Ve); + let Bt; + for (const tr of St) + Bt = Er(Bt, q(Ce, tr)); + return Bt; + } + function q(Ce, Ve) { + const St = EO( + Ve, + Ce, + /*useLegacyDecorators*/ + !0 + ), Bt = ae(St); + if (!Bt) + return; + const tr = ne(Ce, Ve), Nr = pe( + Ve, + /*generateNameForComputedPropertyName*/ + !Gn( + Ve, + 128 + /* Ambient */ + ) + ), st = os(Ve) && !fm(Ve) ? t.createVoidZero() : t.createNull(), Wt = n().createDecorateHelper( + Bt, + tr, + Nr, + st + ); + return un( + Wt, + 3072 + /* NoComments */ + ), ha(Wt, dm(Ve)), Wt; + } + function be(Ce, Ve) { + const St = je(Ve); + St && Ce.push(Cn(t.createExpressionStatement(St), Ve)); + } + function je(Ce) { + const Ve = UW( + Ce, + /*useLegacyDecorators*/ + !0 + ), St = ae(Ve); + if (!St) + return; + const Bt = u && u[l_(Ce)], tr = c < 2 ? t.getInternalName( + Ce, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ) : t.getDeclarationName( + Ce, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ), Nr = n().createDecorateHelper(St, tr), st = t.createAssignment(tr, Bt ? t.createAssignment(Bt, Nr) : Nr); + return un( + st, + 3072 + /* NoComments */ + ), ha(st, dm(Ce)), st; + } + function me(Ce) { + return E.checkDefined(Qe(Ce.expression, h, ut)); + } + function Z(Ce, Ve) { + let St; + if (Ce) { + St = []; + for (const Bt of Ce) { + const tr = n().createParamHelper( + me(Bt), + Ve + ); + ct(tr, Bt.expression), un( + tr, + 3072 + /* NoComments */ + ), St.push(tr); + } + } + return St; + } + function pe(Ce, Ve) { + const St = Ce.name; + return Ai(St) ? t.createIdentifier("") : Gs(St) ? Ve && !rg(St.expression) ? t.getGeneratedNameForNode(St) : St.expression : Me(St) ? t.createStringLiteral(An(St)) : t.cloneNode(St); + } + function Te() { + u || (e.enableSubstitution( + 80 + /* Identifier */ + ), u = []); + } + function Fe(Ce) { + if (s.hasNodeCheckFlag( + Ce, + 262144 + /* ContainsConstructorReference */ + )) { + Te(); + const Ve = t.createUniqueName(Ce.name && !Bo(Ce.name) ? An(Ce.name) : "default"); + return u[l_(Ce)] = Ve, i(Ve), Ve; + } + } + function Ye(Ce) { + return t.createPropertyAccessExpression(t.getDeclarationName(Ce), "prototype"); + } + function ne(Ce, Ve) { + return Js(Ve) ? t.getDeclarationName(Ce) : Ye(Ce); + } + function Se(Ce, Ve) { + return Ve = _(Ce, Ve), Ce === 1 ? ie(Ve) : Ve; + } + function ie(Ce) { + switch (Ce.kind) { + case 80: + return Ne(Ce); + } + return Ce; + } + function Ne(Ce) { + return Ee(Ce) ?? Ce; + } + function Ee(Ce) { + if (u && s.hasNodeCheckFlag( + Ce, + 536870912 + /* ConstructorReference */ + )) { + const Ve = s.getReferencedValueDeclaration(Ce); + if (Ve) { + const St = u[Ve.id]; + if (St) { + const Bt = t.cloneNode(St); + return ha(Bt, Ce), el(Bt, Ce), Bt; + } + } + } + } + } + function Qne(e) { + const { + factory: t, + getEmitHelperFactory: n, + startLexicalEnvironment: i, + endLexicalEnvironment: s, + hoistVariableDeclaration: o + } = e, c = da(e.getCompilerOptions()); + let _, u, g, m, h, S; + return Ld(e, T); + function T(M) { + _ = void 0, S = !1; + const ye = br(M, W, e); + return Wg(ye, e.readEmitHelpers()), S && (bS( + ye, + 32 + /* TransformPrivateStaticElements */ + ), S = !1), ye; + } + function k() { + switch (u = void 0, g = void 0, m = void 0, _?.kind) { + case "class": + u = _.classInfo; + break; + case "class-element": + u = _.next.classInfo, g = _.classThis, m = _.classSuper; + break; + case "name": + const M = _.next.next.next; + M?.kind === "class-element" && (u = M.next.classInfo, g = M.classThis, m = M.classSuper); + break; + } + } + function D(M) { + _ = { kind: "class", next: _, classInfo: M, savedPendingExpressions: h }, h = void 0, k(); + } + function P() { + E.assert(_?.kind === "class", "Incorrect value for top.kind.", () => `Expected top.kind to be 'class' but got '${_?.kind}' instead.`), h = _.savedPendingExpressions, _ = _.next, k(); + } + function A(M) { + var ye, Q; + E.assert(_?.kind === "class", "Incorrect value for top.kind.", () => `Expected top.kind to be 'class' but got '${_?.kind}' instead.`), _ = { kind: "class-element", next: _ }, (kc(M) || os(M) && cl(M)) && (_.classThis = (ye = _.next.classInfo) == null ? void 0 : ye.classThis, _.classSuper = (Q = _.next.classInfo) == null ? void 0 : Q.classSuper), k(); + } + function O() { + var M; + E.assert(_?.kind === "class-element", "Incorrect value for top.kind.", () => `Expected top.kind to be 'class-element' but got '${_?.kind}' instead.`), E.assert(((M = _.next) == null ? void 0 : M.kind) === "class", "Incorrect value for top.next.kind.", () => { + var ye; + return `Expected top.next.kind to be 'class' but got '${(ye = _.next) == null ? void 0 : ye.kind}' instead.`; + }), _ = _.next, k(); + } + function F() { + E.assert(_?.kind === "class-element", "Incorrect value for top.kind.", () => `Expected top.kind to be 'class-element' but got '${_?.kind}' instead.`), _ = { kind: "name", next: _ }, k(); + } + function R() { + E.assert(_?.kind === "name", "Incorrect value for top.kind.", () => `Expected top.kind to be 'name' but got '${_?.kind}' instead.`), _ = _.next, k(); + } + function B() { + _?.kind === "other" ? (E.assert(!h), _.depth++) : (_ = { kind: "other", next: _, depth: 0, savedPendingExpressions: h }, h = void 0, k()); + } + function U() { + E.assert(_?.kind === "other", "Incorrect value for top.kind.", () => `Expected top.kind to be 'other' but got '${_?.kind}' instead.`), _.depth > 0 ? (E.assert(!h), _.depth--) : (h = _.savedPendingExpressions, _ = _.next, k()); + } + function $(M) { + return !!(M.transformFlags & 33554432) || !!g && !!(M.transformFlags & 16384) || !!g && !!m && !!(M.transformFlags & 134217728); + } + function W(M) { + if (!$(M)) + return M; + switch (M.kind) { + case 171: + return E.fail("Use `modifierVisitor` instead."); + case 264: + return je(M); + case 232: + return me(M); + case 177: + case 173: + case 176: + return E.fail("Not supported outside of a class. Use 'classElementVisitor' instead."); + case 170: + return Nr(M); + // Support NamedEvaluation to ensure the correct class name for class expressions. + case 227: + return Ji( + M, + /*discarded*/ + !1 + ); + case 304: + return _i(M); + case 261: + return Je(M); + case 209: + return ft(M); + case 278: + return Xe(M); + case 110: + return Ce(M); + case 249: + return Jr(M); + case 245: + return ui(M); + case 357: + return Mn( + M, + /*discarded*/ + !1 + ); + case 218: + return Et( + M, + /*discarded*/ + !1 + ); + case 356: + return re( + M + ); + case 214: + return Ve(M); + case 216: + return St(M); + case 225: + case 226: + return Dt( + M, + /*discarded*/ + !1 + ); + case 212: + return Bt(M); + case 213: + return tr(M); + case 168: + return pn(M); + case 175: + // object literal methods and accessors + case 179: + case 178: + case 219: + case 263: { + B(); + const ye = br(M, _e, e); + return U(), ye; + } + default: + return br(M, _e, e); + } + } + function _e(M) { + switch (M.kind) { + case 171: + return; + default: + return W(M); + } + } + function K(M) { + switch (M.kind) { + case 171: + return; + default: + return M; + } + } + function V(M) { + switch (M.kind) { + case 177: + return Te(M); + case 175: + return ne(M); + case 178: + return Se(M); + case 179: + return ie(M); + case 173: + return Ee(M); + case 176: + return Ne(M); + default: + return W(M); + } + } + function ae(M) { + switch (M.kind) { + case 225: + case 226: + return Dt( + M, + /*discarded*/ + !0 + ); + case 227: + return Ji( + M, + /*discarded*/ + !0 + ); + case 357: + return Mn( + M, + /*discarded*/ + !0 + ); + case 218: + return Et( + M, + /*discarded*/ + !0 + ); + default: + return W(M); + } + } + function se(M) { + let ye = M.name && Me(M.name) && !Bo(M.name) ? An(M.name) : M.name && Ai(M.name) && !Bo(M.name) ? An(M.name).slice(1) : M.name && ca(M.name) && R_( + M.name.text, + 99 + /* ESNext */ + ) ? M.name.text : $n(M) ? "class" : "member"; + return Pg(M) && (ye = `get_${ye}`), am(M) && (ye = `set_${ye}`), M.name && Ai(M.name) && (ye = `private_${ye}`), Js(M) && (ye = `static_${ye}`), "_" + ye; + } + function ce(M, ye) { + return t.createUniqueName( + `${se(M)}_${ye}`, + 24 + /* ReservedInNestedScopes */ + ); + } + function fe(M, ye) { + return t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList( + [ + t.createVariableDeclaration( + M, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + ye + ) + ], + 1 + /* Let */ + ) + ); + } + function he(M) { + const ye = t.createUniqueName( + "_metadata", + 48 + /* FileLevel */ + ); + let Q, dt, Mt = !1, ke = !1, at = !1, wt, Zr, Rr; + if (WC( + /*useLegacyDecorators*/ + !1, + M + )) { + const Pr = ot(M.members, (rt) => (Du(rt) || b_(rt)) && cl(rt)); + wt = t.createUniqueName( + "_classThis", + Pr ? 24 : 48 + /* FileLevel */ + ); + } + for (const Pr of M.members) { + if (ax(Pr) && O3( + /*useLegacyDecorators*/ + !1, + Pr, + M + )) + if (cl(Pr)) { + if (!dt) { + dt = t.createUniqueName( + "_staticExtraInitializers", + 48 + /* FileLevel */ + ); + const rt = n().createRunInitializersHelper(wt ?? t.createThis(), dt); + ha(rt, M.name ?? Ch(M)), Zr ?? (Zr = []), Zr.push(rt); + } + } else { + if (!Q) { + Q = t.createUniqueName( + "_instanceExtraInitializers", + 48 + /* FileLevel */ + ); + const rt = n().createRunInitializersHelper(t.createThis(), Q); + ha(rt, M.name ?? Ch(M)), Rr ?? (Rr = []), Rr.push(rt); + } + Q ?? (Q = t.createUniqueName( + "_instanceExtraInitializers", + 48 + /* FileLevel */ + )); + } + if (kc(Pr) ? ok(Pr) || (Mt = !0) : os(Pr) && (cl(Pr) ? Mt || (Mt = !!Pr.initializer || Ff(Pr)) : ke || (ke = !dB(Pr))), (Du(Pr) || b_(Pr)) && cl(Pr) && (at = !0), dt && Q && Mt && ke && at) + break; + } + return { + class: M, + classThis: wt, + metadataReference: ye, + instanceMethodExtraInitializersName: Q, + staticMethodExtraInitializersName: dt, + hasStaticInitializers: Mt, + hasNonAmbientInstanceFields: ke, + hasStaticPrivateClassElements: at, + pendingStaticInitializers: Zr, + pendingInstanceInitializers: Rr + }; + } + function q(M) { + i(), !HW(M) && g0( + /*useLegacyDecorators*/ + !1, + M + ) && (M = PO(e, M, t.createStringLiteral(""))); + const ye = t.getLocalName( + M, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !1, + /*ignoreAssignedName*/ + !0 + ), Q = he(M), dt = []; + let Mt, ke, at, wt, Zr = !1; + const Rr = $e(UW( + M, + /*useLegacyDecorators*/ + !1 + )); + Rr && (Q.classDecoratorsName = t.createUniqueName( + "_classDecorators", + 48 + /* FileLevel */ + ), Q.classDescriptorName = t.createUniqueName( + "_classDescriptor", + 48 + /* FileLevel */ + ), Q.classExtraInitializersName = t.createUniqueName( + "_classExtraInitializers", + 48 + /* FileLevel */ + ), E.assertIsDefined(Q.classThis), dt.push( + fe(Q.classDecoratorsName, t.createArrayLiteralExpression(Rr)), + fe(Q.classDescriptorName), + fe(Q.classExtraInitializersName, t.createArrayLiteralExpression()), + fe(Q.classThis) + ), Q.hasStaticPrivateClassElements && (Zr = !0, S = !0)); + const Pr = Y3( + M.heritageClauses, + 96 + /* ExtendsKeyword */ + ), rt = Pr && Yc(Pr.types), vt = rt && Qe(rt.expression, W, ut); + if (vt) { + Q.classSuper = t.createUniqueName( + "_classSuper", + 48 + /* FileLevel */ + ); + const fr = hc(vt), vr = Rc(fr) && !fr.name || yo(fr) && !fr.name || xo(fr) ? t.createComma(t.createNumericLiteral(0), vt) : vt; + dt.push(fe(Q.classSuper, vr)); + const Xt = t.updateExpressionWithTypeArguments( + rt, + Q.classSuper, + /*typeArguments*/ + void 0 + ), oi = t.updateHeritageClause(Pr, [Xt]); + wt = t.createNodeArray([oi]); + } + const Nt = Q.classThis ?? t.createThis(); + D(Q), Mt = Er(Mt, Pe(Q.metadataReference, Q.classSuper)); + let Jt = M.members; + if (Jt = Ar(Jt, (fr) => nc(fr) ? fr : V(fr), Hc), Jt = Ar(Jt, (fr) => nc(fr) ? V(fr) : fr, Hc), h) { + let fr; + for (let vr of h) { + vr = Qe(vr, function oi(Fs) { + if (!(Fs.transformFlags & 16384)) + return Fs; + switch (Fs.kind) { + case 110: + return fr || (fr = t.createUniqueName( + "_outerThis", + 16 + /* Optimistic */ + ), dt.unshift(fe(fr, t.createThis()))), fr; + default: + return br(Fs, oi, e); + } + }, ut); + const Xt = t.createExpressionStatement(vr); + Mt = Er(Mt, Xt); + } + h = void 0; + } + if (P(), ot(Q.pendingInstanceInitializers) && !Mg(M)) { + const fr = Z(M, Q); + if (fr) { + const vr = wd(M), Xt = !!(vr && hc(vr.expression).kind !== 106), oi = []; + if (Xt) { + const Rs = t.createSpreadElement(t.createIdentifier("arguments")), ds = t.createCallExpression( + t.createSuper(), + /*typeArguments*/ + void 0, + [Rs] + ); + oi.push(t.createExpressionStatement(ds)); + } + In(oi, fr); + const Fs = t.createBlock( + oi, + /*multiLine*/ + !0 + ); + at = t.createConstructorDeclaration( + /*modifiers*/ + void 0, + [], + Fs + ); + } + } + if (Q.staticMethodExtraInitializersName && dt.push( + fe(Q.staticMethodExtraInitializersName, t.createArrayLiteralExpression()) + ), Q.instanceMethodExtraInitializersName && dt.push( + fe(Q.instanceMethodExtraInitializersName, t.createArrayLiteralExpression()) + ), Q.memberInfos && hl(Q.memberInfos, (fr, vr) => { + Js(vr) && (dt.push(fe(fr.memberDecoratorsName)), fr.memberInitializersName && dt.push(fe(fr.memberInitializersName, t.createArrayLiteralExpression())), fr.memberExtraInitializersName && dt.push(fe(fr.memberExtraInitializersName, t.createArrayLiteralExpression())), fr.memberDescriptorName && dt.push(fe(fr.memberDescriptorName))); + }), Q.memberInfos && hl(Q.memberInfos, (fr, vr) => { + Js(vr) || (dt.push(fe(fr.memberDecoratorsName)), fr.memberInitializersName && dt.push(fe(fr.memberInitializersName, t.createArrayLiteralExpression())), fr.memberExtraInitializersName && dt.push(fe(fr.memberExtraInitializersName, t.createArrayLiteralExpression())), fr.memberDescriptorName && dt.push(fe(fr.memberDescriptorName))); + }), Mt = In(Mt, Q.staticNonFieldDecorationStatements), Mt = In(Mt, Q.nonStaticNonFieldDecorationStatements), Mt = In(Mt, Q.staticFieldDecorationStatements), Mt = In(Mt, Q.nonStaticFieldDecorationStatements), Q.classDescriptorName && Q.classDecoratorsName && Q.classExtraInitializersName && Q.classThis) { + Mt ?? (Mt = []); + const fr = t.createPropertyAssignment("value", Nt), vr = t.createObjectLiteralExpression([fr]), Xt = t.createAssignment(Q.classDescriptorName, vr), oi = t.createPropertyAccessExpression(Nt, "name"), Fs = n().createESDecorateHelper( + t.createNull(), + Xt, + Q.classDecoratorsName, + { kind: "class", name: oi, metadata: Q.metadataReference }, + t.createNull(), + Q.classExtraInitializersName + ), Rs = t.createExpressionStatement(Fs); + ha(Rs, Ch(M)), Mt.push(Rs); + const ds = t.createPropertyAccessExpression(Q.classDescriptorName, "value"), pc = t.createAssignment(Q.classThis, ds), Zo = t.createAssignment(ye, pc); + Mt.push(t.createExpressionStatement(Zo)); + } + if (Mt.push(yt(Nt, Q.metadataReference)), ot(Q.pendingStaticInitializers)) { + for (const fr of Q.pendingStaticInitializers) { + const vr = t.createExpressionStatement(fr); + ha(vr, x0(fr)), ke = Er(ke, vr); + } + Q.pendingStaticInitializers = void 0; + } + if (Q.classExtraInitializersName) { + const fr = n().createRunInitializersHelper(Nt, Q.classExtraInitializersName), vr = t.createExpressionStatement(fr); + ha(vr, M.name ?? Ch(M)), ke = Er(ke, vr); + } + Mt && ke && !Q.hasStaticInitializers && (In(Mt, ke), ke = void 0); + const _r = Mt && t.createClassStaticBlockDeclaration(t.createBlock( + Mt, + /*multiLine*/ + !0 + )); + _r && Zr && FN( + _r, + 32 + /* TransformPrivateStaticElements */ + ); + const nr = ke && t.createClassStaticBlockDeclaration(t.createBlock( + ke, + /*multiLine*/ + !0 + )); + if (_r || at || nr) { + const fr = [], vr = Jt.findIndex(ok); + _r ? (In(fr, Jt, 0, vr + 1), fr.push(_r), In(fr, Jt, vr + 1)) : In(fr, Jt), at && fr.push(at), nr && fr.push(nr), Jt = ct(t.createNodeArray(fr), Jt); + } + const kt = s(); + let cr; + if (Rr) { + cr = t.createClassExpression( + /*modifiers*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + wt, + Jt + ), Q.classThis && (cr = Wne(t, cr, Q.classThis)); + const fr = t.createVariableDeclaration( + ye, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + cr + ), vr = t.createVariableDeclarationList([fr]), Xt = Q.classThis ? t.createAssignment(ye, Q.classThis) : ye; + dt.push( + t.createVariableStatement( + /*modifiers*/ + void 0, + vr + ), + t.createReturnStatement(Xt) + ); + } else + cr = t.createClassExpression( + /*modifiers*/ + void 0, + M.name, + /*typeParameters*/ + void 0, + wt, + Jt + ), dt.push(t.createReturnStatement(cr)); + if (Zr) { + bS( + cr, + 32 + /* TransformPrivateStaticElements */ + ); + for (const fr of cr.members) + (Du(fr) || b_(fr)) && cl(fr) && bS( + fr, + 32 + /* TransformPrivateStaticElements */ + ); + } + return Cn(cr, M), t.createImmediatelyInvokedArrowFunction(t.mergeLexicalEnvironment(dt, kt)); + } + function be(M) { + return g0( + /*useLegacyDecorators*/ + !1, + M + ) || RD( + /*useLegacyDecorators*/ + !1, + M + ); + } + function je(M) { + if (be(M)) { + const ye = [], Q = Vo(M, $n) ?? M, dt = Q.name ? t.createStringLiteralFromNode(Q.name) : t.createStringLiteral("default"), Mt = Gn( + M, + 32 + /* Export */ + ), ke = Gn( + M, + 2048 + /* Default */ + ); + if (M.name || (M = PO(e, M, dt)), Mt && ke) { + const at = q(M); + if (M.name) { + const wt = t.createVariableDeclaration( + t.getLocalName(M), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + at + ); + Cn(wt, M); + const Zr = t.createVariableDeclarationList( + [wt], + 1 + /* Let */ + ), Rr = t.createVariableStatement( + /*modifiers*/ + void 0, + Zr + ); + ye.push(Rr); + const Pr = t.createExportDefault(t.getDeclarationName(M)); + Cn(Pr, M), el(Pr, hm(M)), ha(Pr, Ch(M)), ye.push(Pr); + } else { + const wt = t.createExportDefault(at); + Cn(wt, M), el(wt, hm(M)), ha(wt, Ch(M)), ye.push(wt); + } + } else { + E.assertIsDefined(M.name, "A class declaration that is not a default export must have a name."); + const at = q(M), wt = Mt ? (Nt) => zx(Nt) ? void 0 : K(Nt) : K, Zr = Ar(M.modifiers, wt, Zs), Rr = t.getLocalName( + M, + /*allowComments*/ + !1, + /*allowSourceMaps*/ + !0 + ), Pr = t.createVariableDeclaration( + Rr, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + at + ); + Cn(Pr, M); + const rt = t.createVariableDeclarationList( + [Pr], + 1 + /* Let */ + ), vt = t.createVariableStatement(Zr, rt); + if (Cn(vt, M), el(vt, hm(M)), ye.push(vt), Mt) { + const Nt = t.createExternalModuleExport(Rr); + Cn(Nt, M), ye.push(Nt); + } + } + return Wm(ye); + } else { + const ye = Ar(M.modifiers, K, Zs), Q = Ar(M.heritageClauses, W, cf); + D( + /*classInfo*/ + void 0 + ); + const dt = Ar(M.members, V, Hc); + return P(), t.updateClassDeclaration( + M, + ye, + M.name, + /*typeParameters*/ + void 0, + Q, + dt + ); + } + } + function me(M) { + if (be(M)) { + const ye = q(M); + return Cn(ye, M), ye; + } else { + const ye = Ar(M.modifiers, K, Zs), Q = Ar(M.heritageClauses, W, cf); + D( + /*classInfo*/ + void 0 + ); + const dt = Ar(M.members, V, Hc); + return P(), t.updateClassExpression( + M, + ye, + M.name, + /*typeParameters*/ + void 0, + Q, + dt + ); + } + } + function Z(M, ye) { + if (ot(ye.pendingInstanceInitializers)) { + const Q = []; + return Q.push( + t.createExpressionStatement( + t.inlineExpressions(ye.pendingInstanceInitializers) + ) + ), ye.pendingInstanceInitializers = void 0, Q; + } + } + function pe(M, ye, Q, dt, Mt, ke) { + const at = dt[Mt], wt = ye[at]; + if (In(M, Ar(ye, W, Ti, Q, at - Q)), wS(wt)) { + const Zr = []; + pe( + Zr, + wt.tryBlock.statements, + /*statementOffset*/ + 0, + dt, + Mt + 1, + ke + ); + const Rr = t.createNodeArray(Zr); + ct(Rr, wt.tryBlock.statements), M.push(t.updateTryStatement( + wt, + t.updateBlock(wt.tryBlock, Zr), + Qe(wt.catchClause, W, Zb), + Qe(wt.finallyBlock, W, Ns) + )); + } else + In(M, Ar(ye, W, Ti, at, 1)), In(M, ke); + In(M, Ar(ye, W, Ti, at + 1)); + } + function Te(M) { + A(M); + const ye = Ar(M.modifiers, K, Zs), Q = Ar(M.parameters, W, Ii); + let dt; + if (M.body && u) { + const Mt = Z(u.class, u); + if (Mt) { + const ke = [], at = t.copyPrologue( + M.body.statements, + ke, + /*ensureUseStrict*/ + !1, + W + ), wt = kO(M.body.statements, at); + wt.length > 0 ? pe(ke, M.body.statements, at, wt, 0, Mt) : (In(ke, Mt), In(ke, Ar(M.body.statements, W, Ti))), dt = t.createBlock( + ke, + /*multiLine*/ + !0 + ), Cn(dt, M.body), ct(dt, M.body); + } + } + return dt ?? (dt = Qe(M.body, W, Ns)), O(), t.updateConstructorDeclaration(M, ye, Q, dt); + } + function Fe(M, ye) { + return M !== ye && (el(M, ye), ha(M, Ch(ye))), M; + } + function Ye(M, ye, Q) { + let dt, Mt, ke, at, wt, Zr; + if (!ye) { + const rt = Ar(M.modifiers, K, Zs); + return F(), Mt = fi(M.name), R(), { modifiers: rt, referencedName: dt, name: Mt, initializersName: ke, descriptorName: Zr, thisArg: wt }; + } + const Rr = $e(EO( + M, + ye.class, + /*useLegacyDecorators*/ + !1 + )), Pr = Ar(M.modifiers, K, Zs); + if (Rr) { + const rt = ce(M, "decorators"), vt = t.createArrayLiteralExpression(Rr), Nt = t.createAssignment(rt, vt), Jt = { memberDecoratorsName: rt }; + ye.memberInfos ?? (ye.memberInfos = /* @__PURE__ */ new Map()), ye.memberInfos.set(M, Jt), h ?? (h = []), h.push(Nt); + const _r = ax(M) || b_(M) ? Js(M) ? ye.staticNonFieldDecorationStatements ?? (ye.staticNonFieldDecorationStatements = []) : ye.nonStaticNonFieldDecorationStatements ?? (ye.nonStaticNonFieldDecorationStatements = []) : os(M) && !b_(M) ? Js(M) ? ye.staticFieldDecorationStatements ?? (ye.staticFieldDecorationStatements = []) : ye.nonStaticFieldDecorationStatements ?? (ye.nonStaticFieldDecorationStatements = []) : E.fail(), nr = pp(M) ? "getter" : z_(M) ? "setter" : rc(M) ? "method" : b_(M) ? "accessor" : os(M) ? "field" : E.fail(); + let kt; + if (Me(M.name) || Ai(M.name)) + kt = { computed: !1, name: M.name }; + else if (um(M.name)) + kt = { computed: !0, name: t.createStringLiteralFromNode(M.name) }; + else { + const fr = M.name.expression; + um(fr) && !Me(fr) ? kt = { computed: !0, name: t.createStringLiteralFromNode(fr) } : (F(), { referencedName: dt, name: Mt } = ai(M.name), kt = { computed: !0, name: dt }, R()); + } + const cr = { + kind: nr, + name: kt, + static: Js(M), + private: Ai(M.name), + access: { + // 15.7.3 CreateDecoratorAccessObject (kind, name) + // 2. If _kind_ is ~field~, ~method~, ~accessor~, or ~getter~, then ... + get: os(M) || pp(M) || rc(M), + // 3. If _kind_ is ~field~, ~accessor~, or ~setter~, then ... + set: os(M) || z_(M) + }, + metadata: ye.metadataReference + }; + if (ax(M)) { + const fr = Js(M) ? ye.staticMethodExtraInitializersName : ye.instanceMethodExtraInitializersName; + E.assertIsDefined(fr); + let vr; + Du(M) && Q && (vr = Q(M, Ar(Pr, (Fs) => Bn(Fs, D4), Zs)), Jt.memberDescriptorName = Zr = ce(M, "descriptor"), vr = t.createAssignment(Zr, vr)); + const Xt = n().createESDecorateHelper(t.createThis(), vr ?? t.createNull(), rt, cr, t.createNull(), fr), oi = t.createExpressionStatement(Xt); + ha(oi, Ch(M)), _r.push(oi); + } else if (os(M)) { + ke = Jt.memberInitializersName ?? (Jt.memberInitializersName = ce(M, "initializers")), at = Jt.memberExtraInitializersName ?? (Jt.memberExtraInitializersName = ce(M, "extraInitializers")), Js(M) && (wt = ye.classThis); + let fr; + Du(M) && fm(M) && Q && (fr = Q( + M, + /*modifiers*/ + void 0 + ), Jt.memberDescriptorName = Zr = ce(M, "descriptor"), fr = t.createAssignment(Zr, fr)); + const vr = n().createESDecorateHelper( + b_(M) ? t.createThis() : t.createNull(), + fr ?? t.createNull(), + rt, + cr, + ke, + at + ), Xt = t.createExpressionStatement(vr); + ha(Xt, Ch(M)), _r.push(Xt); + } + } + return Mt === void 0 && (F(), Mt = fi(M.name), R()), !ot(Pr) && (rc(M) || os(M)) && un( + Mt, + 1024 + /* NoLeadingComments */ + ), { modifiers: Pr, referencedName: dt, name: Mt, initializersName: ke, extraInitializersName: at, descriptorName: Zr, thisArg: wt }; + } + function ne(M) { + A(M); + const { modifiers: ye, name: Q, descriptorName: dt } = Ye(M, u, Le); + if (dt) + return O(), Fe(qe(ye, Q, dt), M); + { + const Mt = Ar(M.parameters, W, Ii), ke = Qe(M.body, W, Ns); + return O(), Fe(t.updateMethodDeclaration( + M, + ye, + M.asteriskToken, + Q, + /*questionToken*/ + void 0, + /*typeParameters*/ + void 0, + Mt, + /*type*/ + void 0, + ke + ), M); + } + } + function Se(M) { + A(M); + const { modifiers: ye, name: Q, descriptorName: dt } = Ye(M, u, mt); + if (dt) + return O(), Fe(Lt(ye, Q, dt), M); + { + const Mt = Ar(M.parameters, W, Ii), ke = Qe(M.body, W, Ns); + return O(), Fe(t.updateGetAccessorDeclaration( + M, + ye, + Q, + Mt, + /*type*/ + void 0, + ke + ), M); + } + } + function ie(M) { + A(M); + const { modifiers: ye, name: Q, descriptorName: dt } = Ye(M, u, pt); + if (dt) + return O(), Fe(rn(ye, Q, dt), M); + { + const Mt = Ar(M.parameters, W, Ii), ke = Qe(M.body, W, Ns); + return O(), Fe(t.updateSetAccessorDeclaration(M, ye, Q, Mt, ke), M); + } + } + function Ne(M) { + A(M); + let ye; + if (ok(M)) + ye = br(M, W, e); + else if (tw(M)) { + const Q = g; + g = void 0, ye = br(M, W, e), g = Q; + } else if (M = br(M, W, e), ye = M, u && (u.hasStaticInitializers = !0, ot(u.pendingStaticInitializers))) { + const Q = []; + for (const ke of u.pendingStaticInitializers) { + const at = t.createExpressionStatement(ke); + ha(at, x0(ke)), Q.push(at); + } + const dt = t.createBlock( + Q, + /*multiLine*/ + !0 + ); + ye = [t.createClassStaticBlockDeclaration(dt), ye], u.pendingStaticInitializers = void 0; + } + return O(), ye; + } + function Ee(M) { + rf(M, st) && (M = lf(e, M, Wt(M.initializer))), A(M), E.assert(!dB(M), "Not yet implemented."); + const { modifiers: ye, name: Q, initializersName: dt, extraInitializersName: Mt, descriptorName: ke, thisArg: at } = Ye(M, u, fm(M) ? Ct : void 0); + i(); + let wt = Qe(M.initializer, W, ut); + dt && (wt = n().createRunInitializersHelper( + at ?? t.createThis(), + dt, + wt ?? t.createVoidZero() + )), Js(M) && u && wt && (u.hasStaticInitializers = !0); + const Zr = s(); + if (ot(Zr) && (wt = t.createImmediatelyInvokedArrowFunction([ + ...Zr, + t.createReturnStatement(wt) + ])), u && (Js(M) ? (wt = Ae( + u, + /*isStatic*/ + !0, + wt + ), Mt && (u.pendingStaticInitializers ?? (u.pendingStaticInitializers = []), u.pendingStaticInitializers.push( + n().createRunInitializersHelper( + u.classThis ?? t.createThis(), + Mt + ) + ))) : (wt = Ae( + u, + /*isStatic*/ + !1, + wt + ), Mt && (u.pendingInstanceInitializers ?? (u.pendingInstanceInitializers = []), u.pendingInstanceInitializers.push( + n().createRunInitializersHelper( + t.createThis(), + Mt + ) + )))), O(), fm(M) && ke) { + const Rr = hm(M), Pr = x0(M), rt = M.name; + let vt = rt, Nt = rt; + if (Gs(rt) && !rg(rt.expression)) { + const cr = UF(rt); + if (cr) + vt = t.updateComputedPropertyName(rt, Qe(rt.expression, W, ut)), Nt = t.updateComputedPropertyName(rt, cr.left); + else { + const fr = t.createTempVariable(o); + ha(fr, rt.expression); + const vr = Qe(rt.expression, W, ut), Xt = t.createAssignment(fr, vr); + ha(Xt, rt.expression), vt = t.updateComputedPropertyName(rt, Xt), Nt = t.updateComputedPropertyName(rt, fr); + } + } + const Jt = Ar(ye, (cr) => cr.kind !== 129 ? cr : void 0, Zs), _r = zz(t, M, Jt, wt); + Cn(_r, M), un( + _r, + 3072 + /* NoComments */ + ), ha(_r, Pr), ha(_r.name, M.name); + const nr = Lt(Jt, vt, ke); + Cn(nr, M), el(nr, Rr), ha(nr, Pr); + const kt = rn(Jt, Nt, ke); + return Cn(kt, M), un( + kt, + 3072 + /* NoComments */ + ), ha(kt, Pr), [_r, nr, kt]; + } + return Fe(t.updatePropertyDeclaration( + M, + ye, + Q, + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + wt + ), M); + } + function Ce(M) { + return g ?? M; + } + function Ve(M) { + if (j_(M.expression) && g) { + const ye = Qe(M.expression, W, ut), Q = Ar(M.arguments, W, ut), dt = t.createFunctionCallCall(ye, g, Q); + return Cn(dt, M), ct(dt, M), dt; + } + return br(M, W, e); + } + function St(M) { + if (j_(M.tag) && g) { + const ye = Qe(M.tag, W, ut), Q = t.createFunctionBindCall(ye, g, []); + Cn(Q, M), ct(Q, M); + const dt = Qe(M.template, W, ox); + return t.updateTaggedTemplateExpression( + M, + Q, + /*typeArguments*/ + void 0, + dt + ); + } + return br(M, W, e); + } + function Bt(M) { + if (j_(M) && Me(M.name) && g && m) { + const ye = t.createStringLiteralFromNode(M.name), Q = t.createReflectGetCall(m, ye, g); + return Cn(Q, M.expression), ct(Q, M.expression), Q; + } + return br(M, W, e); + } + function tr(M) { + if (j_(M) && g && m) { + const ye = Qe(M.argumentExpression, W, ut), Q = t.createReflectGetCall(m, ye, g); + return Cn(Q, M.expression), ct(Q, M.expression), Q; + } + return br(M, W, e); + } + function Nr(M) { + rf(M, st) && (M = lf(e, M, Wt(M.initializer))); + const ye = t.updateParameterDeclaration( + M, + /*modifiers*/ + void 0, + M.dotDotDotToken, + Qe(M.name, W, rS), + /*questionToken*/ + void 0, + /*type*/ + void 0, + Qe(M.initializer, W, ut) + ); + return ye !== M && (el(ye, M), ct(ye, dm(M)), ha(ye, dm(M)), un( + ye.name, + 64 + /* NoTrailingSourceMap */ + )), ye; + } + function st(M) { + return Rc(M) && !M.name && be(M); + } + function Wt(M) { + const ye = hc(M); + return Rc(ye) && !ye.name && !g0( + /*useLegacyDecorators*/ + !1, + ye + ); + } + function Jr(M) { + return t.updateForStatement( + M, + Qe(M.initializer, ae, ip), + Qe(M.condition, W, ut), + Qe(M.incrementor, ae, ut), + c_(M.statement, W, e) + ); + } + function ui(M) { + return br(M, ae, e); + } + function Ji(M, ye) { + if (y0(M)) { + const Q = bs(M.left), dt = Qe(M.right, W, ut); + return t.updateBinaryExpression(M, Q, M.operatorToken, dt); + } + if (Nl(M)) { + if (rf(M, st)) + return M = lf(e, M, Wt(M.right)), br(M, W, e); + if (j_(M.left) && g && m) { + let Q = uo(M.left) ? Qe(M.left.argumentExpression, W, ut) : Me(M.left.name) ? t.createStringLiteralFromNode(M.left.name) : void 0; + if (Q) { + let dt = Qe(M.right, W, ut); + if (Z4(M.operatorToken.kind)) { + let ke = Q; + rg(Q) || (ke = t.createTempVariable(o), Q = t.createAssignment(ke, Q)); + const at = t.createReflectGetCall( + m, + ke, + g + ); + Cn(at, M.left), ct(at, M.left), dt = t.createBinaryExpression( + at, + K4(M.operatorToken.kind), + dt + ), ct(dt, M); + } + const Mt = ye ? void 0 : t.createTempVariable(o); + return Mt && (dt = t.createAssignment(Mt, dt), ct(Mt, M)), dt = t.createReflectSetCall( + m, + Q, + dt, + g + ), Cn(dt, M), ct(dt, M), Mt && (dt = t.createComma(dt, Mt), ct(dt, M)), dt; + } + } + } + if (M.operatorToken.kind === 28) { + const Q = Qe(M.left, ae, ut), dt = Qe(M.right, ye ? ae : W, ut); + return t.updateBinaryExpression(M, Q, M.operatorToken, dt); + } + return br(M, W, e); + } + function Dt(M, ye) { + if (M.operator === 46 || M.operator === 47) { + const Q = Ba(M.operand); + if (j_(Q) && g && m) { + let dt = uo(Q) ? Qe(Q.argumentExpression, W, ut) : Me(Q.name) ? t.createStringLiteralFromNode(Q.name) : void 0; + if (dt) { + let Mt = dt; + rg(dt) || (Mt = t.createTempVariable(o), dt = t.createAssignment(Mt, dt)); + let ke = t.createReflectGetCall(m, Mt, g); + Cn(ke, M), ct(ke, M); + const at = ye ? void 0 : t.createTempVariable(o); + return ke = RF(t, M, ke, o, at), ke = t.createReflectSetCall(m, dt, ke, g), Cn(ke, M), ct(ke, M), at && (ke = t.createComma(ke, at), ct(ke, M)), ke; + } + } + } + return br(M, W, e); + } + function Mn(M, ye) { + const Q = ye ? SO(M.elements, ae) : SO(M.elements, W, ae); + return t.updateCommaListExpression(M, Q); + } + function ai(M) { + if (um(M) || Ai(M)) { + const ke = t.createStringLiteralFromNode(M), at = Qe(M, W, qc); + return { referencedName: ke, name: at }; + } + if (um(M.expression) && !Me(M.expression)) { + const ke = t.createStringLiteralFromNode(M.expression), at = Qe(M, W, qc); + return { referencedName: ke, name: at }; + } + const ye = t.getGeneratedNameForNode(M); + o(ye); + const Q = n().createPropKeyHelper(Qe(M.expression, W, ut)), dt = t.createAssignment(ye, Q), Mt = t.updateComputedPropertyName(M, Y(dt)); + return { referencedName: ye, name: Mt }; + } + function fi(M) { + return Gs(M) ? pn(M) : Qe(M, W, qc); + } + function pn(M) { + let ye = Qe(M.expression, W, ut); + return rg(ye) || (ye = Y(ye)), t.updateComputedPropertyName(M, ye); + } + function _i(M) { + return rf(M, st) && (M = lf(e, M, Wt(M.initializer))), br(M, W, e); + } + function Je(M) { + return rf(M, st) && (M = lf(e, M, Wt(M.initializer))), br(M, W, e); + } + function ft(M) { + return rf(M, st) && (M = lf(e, M, Wt(M.initializer))), br(M, W, e); + } + function er(M) { + if (_a(M) || nu(M)) + return bs(M); + if (j_(M) && g && m) { + const ye = uo(M) ? Qe(M.argumentExpression, W, ut) : Me(M.name) ? t.createStringLiteralFromNode(M.name) : void 0; + if (ye) { + const Q = t.createTempVariable( + /*recordTempVariable*/ + void 0 + ), dt = t.createAssignmentTargetWrapper( + Q, + t.createReflectSetCall( + m, + ye, + Q, + g + ) + ); + return Cn(dt, M), ct(dt, M), dt; + } + } + return br(M, W, e); + } + function qr(M) { + if (Nl( + M, + /*excludeCompoundAssignment*/ + !0 + )) { + rf(M, st) && (M = lf(e, M, Wt(M.right))); + const ye = er(M.left), Q = Qe(M.right, W, ut); + return t.updateBinaryExpression(M, ye, M.operatorToken, Q); + } else + return er(M); + } + function Jn(M) { + if (S_(M.expression)) { + const ye = er(M.expression); + return t.updateSpreadElement(M, ye); + } + return br(M, W, e); + } + function Un(M) { + return E.assertNode(M, _3), dp(M) ? Jn(M) : vl(M) ? br(M, W, e) : qr(M); + } + function ki(M) { + const ye = Qe(M.name, W, qc); + if (Nl( + M.initializer, + /*excludeCompoundAssignment*/ + !0 + )) { + const Q = qr(M.initializer); + return t.updatePropertyAssignment(M, ye, Q); + } + if (S_(M.initializer)) { + const Q = er(M.initializer); + return t.updatePropertyAssignment(M, ye, Q); + } + return br(M, W, e); + } + function Ds(M) { + return rf(M, st) && (M = lf(e, M, Wt(M.objectAssignmentInitializer))), br(M, W, e); + } + function Ks(M) { + if (S_(M.expression)) { + const ye = er(M.expression); + return t.updateSpreadAssignment(M, ye); + } + return br(M, W, e); + } + function yr(M) { + return E.assertNode(M, u3), Vg(M) ? Ks(M) : gu(M) ? Ds(M) : rl(M) ? ki(M) : br(M, W, e); + } + function bs(M) { + if (nu(M)) { + const ye = Ar(M.elements, Un, ut); + return t.updateArrayLiteralExpression(M, ye); + } else { + const ye = Ar(M.properties, yr, vh); + return t.updateObjectLiteralExpression(M, ye); + } + } + function Xe(M) { + return rf(M, st) && (M = lf(e, M, Wt(M.expression))), br(M, W, e); + } + function Et(M, ye) { + const Q = ye ? ae : W, dt = Qe(M.expression, Q, ut); + return t.updateParenthesizedExpression(M, dt); + } + function re(M, ye) { + const Q = W, dt = Qe(M.expression, Q, ut); + return t.updatePartiallyEmittedExpression(M, dt); + } + function it(M, ye) { + return ot(M) && (ye ? o_(ye) ? (M.push(ye.expression), ye = t.updateParenthesizedExpression(ye, t.inlineExpressions(M))) : (M.push(ye), ye = t.inlineExpressions(M)) : ye = t.inlineExpressions(M)), ye; + } + function Y(M) { + const ye = it(h, M); + return E.assertIsDefined(ye), ye !== M && (h = void 0), ye; + } + function Ae(M, ye, Q) { + const dt = it(ye ? M.pendingStaticInitializers : M.pendingInstanceInitializers, Q); + return dt !== Q && (ye ? M.pendingStaticInitializers = void 0 : M.pendingInstanceInitializers = void 0), dt; + } + function $e(M) { + if (!M) + return; + const ye = []; + return In(ye, hr(M.decorators, Ke)), ye; + } + function Ke(M) { + const ye = Qe(M.expression, W, ut); + un( + ye, + 3072 + /* NoComments */ + ); + const Q = hc(ye); + if (To(Q)) { + const { target: dt, thisArg: Mt } = t.createCallBinding( + ye, + o, + c, + /*cacheIdentifiers*/ + !0 + ); + return t.restoreOuterExpressions(ye, t.createFunctionBindCall(dt, Mt, [])); + } + return ye; + } + function Tt(M, ye, Q, dt, Mt, ke, at) { + const wt = t.createFunctionExpression( + Q, + dt, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + ke, + /*type*/ + void 0, + at ?? t.createBlock([]) + ); + Cn(wt, M), ha(wt, Ch(M)), un( + wt, + 3072 + /* NoComments */ + ); + const Zr = Mt === "get" || Mt === "set" ? Mt : void 0, Rr = t.createStringLiteralFromNode( + ye, + /*isSingleQuote*/ + void 0 + ), Pr = n().createSetFunctionNameHelper(wt, Rr, Zr), rt = t.createPropertyAssignment(t.createIdentifier(Mt), Pr); + return Cn(rt, M), ha(rt, Ch(M)), un( + rt, + 3072 + /* NoComments */ + ), rt; + } + function Le(M, ye) { + return t.createObjectLiteralExpression([ + Tt( + M, + M.name, + ye, + M.asteriskToken, + "value", + Ar(M.parameters, W, Ii), + Qe(M.body, W, Ns) + ) + ]); + } + function mt(M, ye) { + return t.createObjectLiteralExpression([ + Tt( + M, + M.name, + ye, + /*asteriskToken*/ + void 0, + "get", + [], + Qe(M.body, W, Ns) + ) + ]); + } + function pt(M, ye) { + return t.createObjectLiteralExpression([ + Tt( + M, + M.name, + ye, + /*asteriskToken*/ + void 0, + "set", + Ar(M.parameters, W, Ii), + Qe(M.body, W, Ns) + ) + ]); + } + function Ct(M, ye) { + return t.createObjectLiteralExpression([ + Tt( + M, + M.name, + ye, + /*asteriskToken*/ + void 0, + "get", + [], + t.createBlock([ + t.createReturnStatement( + t.createPropertyAccessExpression( + t.createThis(), + t.getGeneratedPrivateNameForNode(M.name) + ) + ) + ]) + ), + Tt( + M, + M.name, + ye, + /*asteriskToken*/ + void 0, + "set", + [t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "value" + )], + t.createBlock([ + t.createExpressionStatement( + t.createAssignment( + t.createPropertyAccessExpression( + t.createThis(), + t.getGeneratedPrivateNameForNode(M.name) + ), + t.createIdentifier("value") + ) + ) + ]) + ) + ]); + } + function qe(M, ye, Q) { + return M = Ar(M, (dt) => Wx(dt) ? dt : void 0, Zs), t.createGetAccessorDeclaration( + M, + ye, + [], + /*type*/ + void 0, + t.createBlock([ + t.createReturnStatement( + t.createPropertyAccessExpression( + Q, + t.createIdentifier("value") + ) + ) + ]) + ); + } + function Lt(M, ye, Q) { + return M = Ar(M, (dt) => Wx(dt) ? dt : void 0, Zs), t.createGetAccessorDeclaration( + M, + ye, + [], + /*type*/ + void 0, + t.createBlock([ + t.createReturnStatement( + t.createFunctionCallCall( + t.createPropertyAccessExpression( + Q, + t.createIdentifier("get") + ), + t.createThis(), + [] + ) + ) + ]) + ); + } + function rn(M, ye, Q) { + return M = Ar(M, (dt) => Wx(dt) ? dt : void 0, Zs), t.createSetAccessorDeclaration( + M, + ye, + [t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "value" + )], + t.createBlock([ + t.createReturnStatement( + t.createFunctionCallCall( + t.createPropertyAccessExpression( + Q, + t.createIdentifier("set") + ), + t.createThis(), + [t.createIdentifier("value")] + ) + ) + ]) + ); + } + function Pe(M, ye) { + const Q = t.createVariableDeclaration( + M, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createConditionalExpression( + t.createLogicalAnd( + t.createTypeCheck(t.createIdentifier("Symbol"), "function"), + t.createPropertyAccessExpression(t.createIdentifier("Symbol"), "metadata") + ), + t.createToken( + 58 + /* QuestionToken */ + ), + t.createCallExpression( + t.createPropertyAccessExpression(t.createIdentifier("Object"), "create"), + /*typeArguments*/ + void 0, + [ye ? ue(ye) : t.createNull()] + ), + t.createToken( + 59 + /* ColonToken */ + ), + t.createVoidZero() + ) + ); + return t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList( + [Q], + 2 + /* Const */ + ) + ); + } + function yt(M, ye) { + const Q = t.createObjectDefinePropertyCall( + M, + t.createPropertyAccessExpression(t.createIdentifier("Symbol"), "metadata"), + t.createPropertyDescriptor( + { configurable: !0, writable: !0, enumerable: !0, value: ye }, + /*singleLine*/ + !0 + ) + ); + return un( + t.createIfStatement(ye, t.createExpressionStatement(Q)), + 1 + /* SingleLine */ + ); + } + function ue(M) { + return t.createBinaryExpression( + t.createElementAccessExpression( + M, + t.createPropertyAccessExpression(t.createIdentifier("Symbol"), "metadata") + ), + 61, + t.createNull() + ); + } + } + function Yne(e) { + const { + factory: t, + getEmitHelperFactory: n, + resumeLexicalEnvironment: i, + endLexicalEnvironment: s, + hoistVariableDeclaration: o + } = e, c = e.getEmitResolver(), _ = e.getCompilerOptions(), u = da(_); + let g = 0, m = 0, h, S, T, k; + const D = []; + let P = 0; + const A = e.onEmitNode, O = e.onSubstituteNode; + return e.onEmitNode = ui, e.onSubstituteNode = Ji, Ld(e, F); + function F(Je) { + if (Je.isDeclarationFile) + return Je; + R(1, !1), R(2, !pB(Je, _)); + const ft = br(Je, V, e); + return Wg(ft, e.readEmitHelpers()), ft; + } + function R(Je, ft) { + P = ft ? P | Je : P & ~Je; + } + function B(Je) { + return (P & Je) !== 0; + } + function U() { + return !B( + 1 + /* NonTopLevel */ + ); + } + function $() { + return B( + 2 + /* HasLexicalThis */ + ); + } + function W(Je, ft, er) { + const qr = Je & ~P; + if (qr) { + R( + qr, + /*val*/ + !0 + ); + const Jn = ft(er); + return R( + qr, + /*val*/ + !1 + ), Jn; + } + return ft(er); + } + function _e(Je) { + return br(Je, V, e); + } + function K(Je) { + switch (Je.kind) { + case 219: + case 263: + case 175: + case 178: + case 179: + case 177: + return Je; + case 170: + case 209: + case 261: + break; + case 80: + if (k && c.isArgumentsLocalBinding(Je)) + return k; + break; + } + return br(Je, K, e); + } + function V(Je) { + if ((Je.transformFlags & 256) === 0) + return k ? K(Je) : Je; + switch (Je.kind) { + case 134: + return; + case 224: + return be(Je); + case 175: + return W(3, me, Je); + case 263: + return W(3, Te, Je); + case 219: + return W(3, Fe, Je); + case 220: + return W(1, Ye, Je); + case 212: + return S && wn(Je) && Je.expression.kind === 108 && S.add(Je.name.escapedText), br(Je, V, e); + case 213: + return S && Je.expression.kind === 108 && (T = !0), br(Je, V, e); + case 178: + return W(3, Z, Je); + case 179: + return W(3, pe, Je); + case 177: + return W(3, je, Je); + case 264: + case 232: + return W(3, _e, Je); + default: + return br(Je, V, e); + } + } + function ae(Je) { + if (MK(Je)) + switch (Je.kind) { + case 244: + return ce(Je); + case 249: + return q(Je); + case 250: + return fe(Je); + case 251: + return he(Je); + case 300: + return se(Je); + case 242: + case 256: + case 270: + case 297: + case 298: + case 259: + case 247: + case 248: + case 246: + case 255: + case 257: + return br(Je, ae, e); + default: + return E.assertNever(Je, "Unhandled node."); + } + return V(Je); + } + function se(Je) { + const ft = /* @__PURE__ */ new Set(); + ne(Je.variableDeclaration, ft); + let er; + if (ft.forEach((qr, Jn) => { + h.has(Jn) && (er || (er = new Set(h)), er.delete(Jn)); + }), er) { + const qr = h; + h = er; + const Jn = br(Je, ae, e); + return h = qr, Jn; + } else + return br(Je, ae, e); + } + function ce(Je) { + if (Se(Je.declarationList)) { + const ft = ie( + Je.declarationList, + /*hasReceiver*/ + !1 + ); + return ft ? t.createExpressionStatement(ft) : void 0; + } + return br(Je, V, e); + } + function fe(Je) { + return t.updateForInStatement( + Je, + Se(Je.initializer) ? ie( + Je.initializer, + /*hasReceiver*/ + !0 + ) : E.checkDefined(Qe(Je.initializer, V, ip)), + E.checkDefined(Qe(Je.expression, V, ut)), + c_(Je.statement, ae, e) + ); + } + function he(Je) { + return t.updateForOfStatement( + Je, + Qe(Je.awaitModifier, V, pz), + Se(Je.initializer) ? ie( + Je.initializer, + /*hasReceiver*/ + !0 + ) : E.checkDefined(Qe(Je.initializer, V, ip)), + E.checkDefined(Qe(Je.expression, V, ut)), + c_(Je.statement, ae, e) + ); + } + function q(Je) { + const ft = Je.initializer; + return t.updateForStatement( + Je, + Se(ft) ? ie( + ft, + /*hasReceiver*/ + !1 + ) : Qe(Je.initializer, V, ip), + Qe(Je.condition, V, ut), + Qe(Je.incrementor, V, ut), + c_(Je.statement, ae, e) + ); + } + function be(Je) { + return U() ? br(Je, V, e) : Cn( + ct( + t.createYieldExpression( + /*asteriskToken*/ + void 0, + Qe(Je.expression, V, ut) + ), + Je + ), + Je + ); + } + function je(Je) { + const ft = k; + k = void 0; + const er = t.updateConstructorDeclaration( + Je, + Ar(Je.modifiers, V, Zs), + _c(Je.parameters, V, e), + St(Je) + ); + return k = ft, er; + } + function me(Je) { + let ft; + const er = Mc(Je), qr = k; + k = void 0; + const Jn = t.updateMethodDeclaration( + Je, + Ar(Je.modifiers, V, Jo), + Je.asteriskToken, + Je.name, + /*questionToken*/ + void 0, + /*typeParameters*/ + void 0, + ft = er & 2 ? tr(Je) : _c(Je.parameters, V, e), + /*type*/ + void 0, + er & 2 ? Nr(Je, ft) : St(Je) + ); + return k = qr, Jn; + } + function Z(Je) { + const ft = k; + k = void 0; + const er = t.updateGetAccessorDeclaration( + Je, + Ar(Je.modifiers, V, Jo), + Je.name, + _c(Je.parameters, V, e), + /*type*/ + void 0, + St(Je) + ); + return k = ft, er; + } + function pe(Je) { + const ft = k; + k = void 0; + const er = t.updateSetAccessorDeclaration( + Je, + Ar(Je.modifiers, V, Jo), + Je.name, + _c(Je.parameters, V, e), + St(Je) + ); + return k = ft, er; + } + function Te(Je) { + let ft; + const er = k; + k = void 0; + const qr = Mc(Je), Jn = t.updateFunctionDeclaration( + Je, + Ar(Je.modifiers, V, Jo), + Je.asteriskToken, + Je.name, + /*typeParameters*/ + void 0, + ft = qr & 2 ? tr(Je) : _c(Je.parameters, V, e), + /*type*/ + void 0, + qr & 2 ? Nr(Je, ft) : jf(Je.body, V, e) + ); + return k = er, Jn; + } + function Fe(Je) { + let ft; + const er = k; + k = void 0; + const qr = Mc(Je), Jn = t.updateFunctionExpression( + Je, + Ar(Je.modifiers, V, Zs), + Je.asteriskToken, + Je.name, + /*typeParameters*/ + void 0, + ft = qr & 2 ? tr(Je) : _c(Je.parameters, V, e), + /*type*/ + void 0, + qr & 2 ? Nr(Je, ft) : jf(Je.body, V, e) + ); + return k = er, Jn; + } + function Ye(Je) { + let ft; + const er = Mc(Je); + return t.updateArrowFunction( + Je, + Ar(Je.modifiers, V, Zs), + /*typeParameters*/ + void 0, + ft = er & 2 ? tr(Je) : _c(Je.parameters, V, e), + /*type*/ + void 0, + Je.equalsGreaterThanToken, + er & 2 ? Nr(Je, ft) : jf(Je.body, V, e) + ); + } + function ne({ name: Je }, ft) { + if (Me(Je)) + ft.add(Je.escapedText); + else + for (const er of Je.elements) + vl(er) || ne(er, ft); + } + function Se(Je) { + return !!Je && Ul(Je) && !(Je.flags & 7) && Je.declarations.some(Ve); + } + function ie(Je, ft) { + Ne(Je); + const er = s4(Je); + return er.length === 0 ? ft ? Qe(t.converters.convertToAssignmentElementTarget(Je.declarations[0].name), V, ut) : void 0 : t.inlineExpressions(hr(er, Ce)); + } + function Ne(Je) { + lr(Je.declarations, Ee); + } + function Ee({ name: Je }) { + if (Me(Je)) + o(Je); + else + for (const ft of Je.elements) + vl(ft) || Ee(ft); + } + function Ce(Je) { + const ft = ha( + t.createAssignment( + t.converters.convertToAssignmentElementTarget(Je.name), + Je.initializer + ), + Je + ); + return E.checkDefined(Qe(ft, V, ut)); + } + function Ve({ name: Je }) { + if (Me(Je)) + return h.has(Je.escapedText); + for (const ft of Je.elements) + if (!vl(ft) && Ve(ft)) + return !0; + return !1; + } + function St(Je) { + E.assertIsDefined(Je.body); + const ft = S, er = T; + S = /* @__PURE__ */ new Set(), T = !1; + let qr = jf(Je.body, V, e); + const Jn = Vo(Je, io); + if (u >= 2 && (c.hasNodeCheckFlag( + Je, + 256 + /* MethodWithSuperPropertyAssignmentInAsync */ + ) || c.hasNodeCheckFlag( + Je, + 128 + /* MethodWithSuperPropertyAccessInAsync */ + )) && (Mc(Jn) & 3) !== 3) { + if (Jr(), S.size) { + const ki = NO(t, c, Je, S); + D[Ma(ki)] = !0; + const Ds = qr.statements.slice(); + Ig(Ds, [ki]), qr = t.updateBlock(qr, Ds); + } + T && (c.hasNodeCheckFlag( + Je, + 256 + /* MethodWithSuperPropertyAssignmentInAsync */ + ) ? jx(qr, bF) : c.hasNodeCheckFlag( + Je, + 128 + /* MethodWithSuperPropertyAccessInAsync */ + ) && jx(qr, vF)); + } + return S = ft, T = er, qr; + } + function Bt() { + E.assert(k); + const Je = t.createVariableDeclaration( + k, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createIdentifier("arguments") + ), ft = t.createVariableStatement( + /*modifiers*/ + void 0, + [Je] + ); + return Au(ft), gm( + ft, + 2097152 + /* CustomPrologue */ + ), ft; + } + function tr(Je) { + if (mA(Je.parameters)) + return _c(Je.parameters, V, e); + const ft = []; + for (const qr of Je.parameters) { + if (qr.initializer || qr.dotDotDotToken) { + if (Je.kind === 220) { + const Un = t.createParameterDeclaration( + /*modifiers*/ + void 0, + t.createToken( + 26 + /* DotDotDotToken */ + ), + t.createUniqueName( + "args", + 8 + /* ReservedInNestedScopes */ + ) + ); + ft.push(Un); + } + break; + } + const Jn = t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + t.getGeneratedNameForNode( + qr.name, + 8 + /* ReservedInNestedScopes */ + ) + ); + ft.push(Jn); + } + const er = t.createNodeArray(ft); + return ct(er, Je.parameters), er; + } + function Nr(Je, ft) { + const er = mA(Je.parameters) ? void 0 : _c(Je.parameters, V, e); + i(); + const Jn = Vo(Je, Es).type, Un = u < 2 ? Wt(Jn) : void 0, ki = Je.kind === 220, Ds = k, yr = c.hasNodeCheckFlag( + Je, + 512 + /* CaptureArguments */ + ) && !k; + yr && (k = t.createUniqueName("arguments")); + let bs; + if (er) + if (ki) { + const $e = []; + E.assert(ft.length <= Je.parameters.length); + for (let Ke = 0; Ke < Je.parameters.length; Ke++) { + E.assert(Ke < ft.length); + const Tt = Je.parameters[Ke], Le = ft[Ke]; + if (E.assertNode(Le.name, Me), Tt.initializer || Tt.dotDotDotToken) { + E.assert(Ke === ft.length - 1), $e.push(t.createSpreadElement(Le.name)); + break; + } + $e.push(Le.name); + } + bs = t.createArrayLiteralExpression($e); + } else + bs = t.createIdentifier("arguments"); + const Xe = h; + h = /* @__PURE__ */ new Set(); + for (const $e of Je.parameters) + ne($e, h); + const Et = S, re = T; + ki || (S = /* @__PURE__ */ new Set(), T = !1); + const it = $(); + let Y = st(Je.body); + Y = t.updateBlock(Y, t.mergeLexicalEnvironment(Y.statements, s())); + let Ae; + if (ki) { + if (Ae = n().createAwaiterHelper( + it, + bs, + Un, + er, + Y + ), yr) { + const $e = t.converters.convertToFunctionBlock(Ae); + Ae = t.updateBlock($e, t.mergeLexicalEnvironment($e.statements, [Bt()])); + } + } else { + const $e = []; + $e.push( + t.createReturnStatement( + n().createAwaiterHelper( + it, + bs, + Un, + er, + Y + ) + ) + ); + const Ke = u >= 2 && (c.hasNodeCheckFlag( + Je, + 256 + /* MethodWithSuperPropertyAssignmentInAsync */ + ) || c.hasNodeCheckFlag( + Je, + 128 + /* MethodWithSuperPropertyAccessInAsync */ + )); + if (Ke && (Jr(), S.size)) { + const Le = NO(t, c, Je, S); + D[Ma(Le)] = !0, Ig($e, [Le]); + } + yr && Ig($e, [Bt()]); + const Tt = t.createBlock( + $e, + /*multiLine*/ + !0 + ); + ct(Tt, Je.body), Ke && T && (c.hasNodeCheckFlag( + Je, + 256 + /* MethodWithSuperPropertyAssignmentInAsync */ + ) ? jx(Tt, bF) : c.hasNodeCheckFlag( + Je, + 128 + /* MethodWithSuperPropertyAccessInAsync */ + ) && jx(Tt, vF)), Ae = Tt; + } + return h = Xe, ki || (S = Et, T = re, k = Ds), Ae; + } + function st(Je, ft) { + return Ns(Je) ? t.updateBlock(Je, Ar(Je.statements, ae, Ti, ft)) : t.converters.convertToFunctionBlock(E.checkDefined(Qe(Je, ae, N7))); + } + function Wt(Je) { + const ft = Je && I3(Je); + if (ft && r_(ft)) { + const er = c.getTypeReferenceSerializationKind(ft); + if (er === 1 || er === 0) + return ft; + } + } + function Jr() { + (g & 1) === 0 && (g |= 1, e.enableSubstitution( + 214 + /* CallExpression */ + ), e.enableSubstitution( + 212 + /* PropertyAccessExpression */ + ), e.enableSubstitution( + 213 + /* ElementAccessExpression */ + ), e.enableEmitNotification( + 264 + /* ClassDeclaration */ + ), e.enableEmitNotification( + 175 + /* MethodDeclaration */ + ), e.enableEmitNotification( + 178 + /* GetAccessor */ + ), e.enableEmitNotification( + 179 + /* SetAccessor */ + ), e.enableEmitNotification( + 177 + /* Constructor */ + ), e.enableEmitNotification( + 244 + /* VariableStatement */ + )); + } + function ui(Je, ft, er) { + if (g & 1 && pn(ft)) { + const qr = (c.hasNodeCheckFlag( + ft, + 128 + /* MethodWithSuperPropertyAccessInAsync */ + ) ? 128 : 0) | (c.hasNodeCheckFlag( + ft, + 256 + /* MethodWithSuperPropertyAssignmentInAsync */ + ) ? 256 : 0); + if (qr !== m) { + const Jn = m; + m = qr, A(Je, ft, er), m = Jn; + return; + } + } else if (g && D[Ma(ft)]) { + const qr = m; + m = 0, A(Je, ft, er), m = qr; + return; + } + A(Je, ft, er); + } + function Ji(Je, ft) { + return ft = O(Je, ft), Je === 1 && m ? Dt(ft) : ft; + } + function Dt(Je) { + switch (Je.kind) { + case 212: + return Mn(Je); + case 213: + return ai(Je); + case 214: + return fi(Je); + } + return Je; + } + function Mn(Je) { + return Je.expression.kind === 108 ? ct( + t.createPropertyAccessExpression( + t.createUniqueName( + "_super", + 48 + /* FileLevel */ + ), + Je.name + ), + Je + ) : Je; + } + function ai(Je) { + return Je.expression.kind === 108 ? _i( + Je.argumentExpression, + Je + ) : Je; + } + function fi(Je) { + const ft = Je.expression; + if (j_(ft)) { + const er = wn(ft) ? Mn(ft) : ai(ft); + return t.createCallExpression( + t.createPropertyAccessExpression(er, "call"), + /*typeArguments*/ + void 0, + [ + t.createThis(), + ...Je.arguments + ] + ); + } + return Je; + } + function pn(Je) { + const ft = Je.kind; + return ft === 264 || ft === 177 || ft === 175 || ft === 178 || ft === 179; + } + function _i(Je, ft) { + return m & 256 ? ct( + t.createPropertyAccessExpression( + t.createCallExpression( + t.createUniqueName( + "_superIndex", + 48 + /* FileLevel */ + ), + /*typeArguments*/ + void 0, + [Je] + ), + "value" + ), + ft + ) : ct( + t.createCallExpression( + t.createUniqueName( + "_superIndex", + 48 + /* FileLevel */ + ), + /*typeArguments*/ + void 0, + [Je] + ), + ft + ); + } + } + function NO(e, t, n, i) { + const s = t.hasNodeCheckFlag( + n, + 256 + /* MethodWithSuperPropertyAssignmentInAsync */ + ), o = []; + return i.forEach((c, _) => { + const u = Si(_), g = []; + g.push(e.createPropertyAssignment( + "get", + e.createArrowFunction( + /*modifiers*/ + void 0, + /*typeParameters*/ + void 0, + /* parameters */ + [], + /*type*/ + void 0, + /*equalsGreaterThanToken*/ + void 0, + un( + e.createPropertyAccessExpression( + un( + e.createSuper(), + 8 + /* NoSubstitution */ + ), + u + ), + 8 + /* NoSubstitution */ + ) + ) + )), s && g.push( + e.createPropertyAssignment( + "set", + e.createArrowFunction( + /*modifiers*/ + void 0, + /*typeParameters*/ + void 0, + /* parameters */ + [ + e.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "v", + /*questionToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + ) + ], + /*type*/ + void 0, + /*equalsGreaterThanToken*/ + void 0, + e.createAssignment( + un( + e.createPropertyAccessExpression( + un( + e.createSuper(), + 8 + /* NoSubstitution */ + ), + u + ), + 8 + /* NoSubstitution */ + ), + e.createIdentifier("v") + ) + ) + ) + ), o.push( + e.createPropertyAssignment( + u, + e.createObjectLiteralExpression(g) + ) + ); + }), e.createVariableStatement( + /*modifiers*/ + void 0, + e.createVariableDeclarationList( + [ + e.createVariableDeclaration( + e.createUniqueName( + "_super", + 48 + /* FileLevel */ + ), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + e.createCallExpression( + e.createPropertyAccessExpression( + e.createIdentifier("Object"), + "create" + ), + /*typeArguments*/ + void 0, + [ + e.createNull(), + e.createObjectLiteralExpression( + o, + /*multiLine*/ + !0 + ) + ] + ) + ) + ], + 2 + /* Const */ + ) + ); + } + function Zne(e) { + const { + factory: t, + getEmitHelperFactory: n, + resumeLexicalEnvironment: i, + endLexicalEnvironment: s, + hoistVariableDeclaration: o + } = e, c = e.getEmitResolver(), _ = e.getCompilerOptions(), u = da(_), g = e.onEmitNode; + e.onEmitNode = Ds; + const m = e.onSubstituteNode; + e.onSubstituteNode = Ks; + let h = !1, S = 0, T, k, D = 0, P = 0, A, O, F, R; + const B = []; + return Ld(e, K); + function U(Y, Ae) { + return P !== (P & ~Y | Ae); + } + function $(Y, Ae) { + const $e = P; + return P = (P & ~Y | Ae) & 3, $e; + } + function W(Y) { + P = Y; + } + function _e(Y) { + O = Er( + O, + t.createVariableDeclaration(Y) + ); + } + function K(Y) { + if (Y.isDeclarationFile) + return Y; + A = Y; + const Ae = Ye(Y); + return Wg(Ae, e.readEmitHelpers()), A = void 0, O = void 0, Ae; + } + function V(Y) { + return he( + Y, + /*expressionResultIsUnused*/ + !1 + ); + } + function ae(Y) { + return he( + Y, + /*expressionResultIsUnused*/ + !0 + ); + } + function se(Y) { + if (Y.kind !== 134) + return Y; + } + function ce(Y, Ae, $e, Ke) { + if (U($e, Ke)) { + const Tt = $($e, Ke), Le = Y(Ae); + return W(Tt), Le; + } + return Y(Ae); + } + function fe(Y) { + return br(Y, V, e); + } + function he(Y, Ae) { + if ((Y.transformFlags & 128) === 0) + return Y; + switch (Y.kind) { + case 224: + return q(Y); + case 230: + return be(Y); + case 254: + return je(Y); + case 257: + return me(Y); + case 211: + return pe(Y); + case 227: + return Se(Y, Ae); + case 357: + return ie(Y, Ae); + case 300: + return Ne(Y); + case 244: + return Ee(Y); + case 261: + return Ce(Y); + case 247: + case 248: + case 250: + return ce( + fe, + Y, + 0, + 2 + /* IterationStatementIncludes */ + ); + case 251: + return tr( + Y, + /*outermostLabeledStatement*/ + void 0 + ); + case 249: + return ce( + St, + Y, + 0, + 2 + /* IterationStatementIncludes */ + ); + case 223: + return Bt(Y); + case 177: + return ce( + Mn, + Y, + 2, + 1 + /* ClassOrFunctionIncludes */ + ); + case 175: + return ce( + pn, + Y, + 2, + 1 + /* ClassOrFunctionIncludes */ + ); + case 178: + return ce( + ai, + Y, + 2, + 1 + /* ClassOrFunctionIncludes */ + ); + case 179: + return ce( + fi, + Y, + 2, + 1 + /* ClassOrFunctionIncludes */ + ); + case 263: + return ce( + _i, + Y, + 2, + 1 + /* ClassOrFunctionIncludes */ + ); + case 219: + return ce( + ft, + Y, + 2, + 1 + /* ClassOrFunctionIncludes */ + ); + case 220: + return ce( + Je, + Y, + 2, + 0 + /* ArrowFunctionIncludes */ + ); + case 170: + return Ji(Y); + case 245: + return Te(Y); + case 218: + return Fe(Y, Ae); + case 216: + return ne(Y); + case 212: + return F && wn(Y) && Y.expression.kind === 108 && F.add(Y.name.escapedText), br(Y, V, e); + case 213: + return F && Y.expression.kind === 108 && (R = !0), br(Y, V, e); + case 264: + case 232: + return ce( + fe, + Y, + 2, + 1 + /* ClassOrFunctionIncludes */ + ); + default: + return br(Y, V, e); + } + } + function q(Y) { + return T & 2 && T & 1 ? Cn( + ct( + t.createYieldExpression( + /*asteriskToken*/ + void 0, + n().createAwaitHelper(Qe(Y.expression, V, ut)) + ), + /*location*/ + Y + ), + Y + ) : br(Y, V, e); + } + function be(Y) { + if (T & 2 && T & 1) { + if (Y.asteriskToken) { + const Ae = Qe(E.checkDefined(Y.expression), V, ut); + return Cn( + ct( + t.createYieldExpression( + /*asteriskToken*/ + void 0, + n().createAwaitHelper( + t.updateYieldExpression( + Y, + Y.asteriskToken, + ct( + n().createAsyncDelegatorHelper( + ct( + n().createAsyncValuesHelper(Ae), + Ae + ) + ), + Ae + ) + ) + ) + ), + Y + ), + Y + ); + } + return Cn( + ct( + t.createYieldExpression( + /*asteriskToken*/ + void 0, + Wt( + Y.expression ? Qe(Y.expression, V, ut) : t.createVoidZero() + ) + ), + Y + ), + Y + ); + } + return br(Y, V, e); + } + function je(Y) { + return T & 2 && T & 1 ? t.updateReturnStatement( + Y, + Wt( + Y.expression ? Qe(Y.expression, V, ut) : t.createVoidZero() + ) + ) : br(Y, V, e); + } + function me(Y) { + if (T & 2) { + const Ae = TB(Y); + return Ae.kind === 251 && Ae.awaitModifier ? tr(Ae, Y) : t.restoreEnclosingLabel(Qe(Ae, V, Ti, t.liftToBlock), Y); + } + return br(Y, V, e); + } + function Z(Y) { + let Ae; + const $e = []; + for (const Ke of Y) + if (Ke.kind === 306) { + Ae && ($e.push(t.createObjectLiteralExpression(Ae)), Ae = void 0); + const Tt = Ke.expression; + $e.push(Qe(Tt, V, ut)); + } else + Ae = Er( + Ae, + Ke.kind === 304 ? t.createPropertyAssignment(Ke.name, Qe(Ke.initializer, V, ut)) : Qe(Ke, V, vh) + ); + return Ae && $e.push(t.createObjectLiteralExpression(Ae)), $e; + } + function pe(Y) { + if (Y.transformFlags & 65536) { + const Ae = Z(Y.properties); + Ae.length && Ae[0].kind !== 211 && Ae.unshift(t.createObjectLiteralExpression()); + let $e = Ae[0]; + if (Ae.length > 1) { + for (let Ke = 1; Ke < Ae.length; Ke++) + $e = n().createAssignHelper([$e, Ae[Ke]]); + return $e; + } else + return n().createAssignHelper(Ae); + } + return br(Y, V, e); + } + function Te(Y) { + return br(Y, ae, e); + } + function Fe(Y, Ae) { + return br(Y, Ae ? ae : V, e); + } + function Ye(Y) { + const Ae = $( + 2, + pB(Y, _) ? 0 : 1 + /* SourceFileIncludes */ + ); + h = !1; + const $e = br(Y, V, e), Ke = Bi( + $e.statements, + O && [ + t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList(O) + ) + ] + ), Tt = t.updateSourceFile($e, ct(t.createNodeArray(Ke), Y.statements)); + return W(Ae), Tt; + } + function ne(Y) { + return GW( + e, + Y, + V, + A, + _e, + 0 + /* LiftRestriction */ + ); + } + function Se(Y, Ae) { + return y0(Y) && YN(Y.left) ? BS( + Y, + V, + e, + 1, + !Ae + ) : Y.operatorToken.kind === 28 ? t.updateBinaryExpression( + Y, + Qe(Y.left, ae, ut), + Y.operatorToken, + Qe(Y.right, Ae ? ae : V, ut) + ) : br(Y, V, e); + } + function ie(Y, Ae) { + if (Ae) + return br(Y, ae, e); + let $e; + for (let Tt = 0; Tt < Y.elements.length; Tt++) { + const Le = Y.elements[Tt], mt = Qe(Le, Tt < Y.elements.length - 1 ? ae : V, ut); + ($e || mt !== Le) && ($e || ($e = Y.elements.slice(0, Tt)), $e.push(mt)); + } + const Ke = $e ? ct(t.createNodeArray($e), Y.elements) : Y.elements; + return t.updateCommaListExpression(Y, Ke); + } + function Ne(Y) { + if (Y.variableDeclaration && ws(Y.variableDeclaration.name) && Y.variableDeclaration.name.transformFlags & 65536) { + const Ae = t.getGeneratedNameForNode(Y.variableDeclaration.name), $e = t.updateVariableDeclaration( + Y.variableDeclaration, + Y.variableDeclaration.name, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + Ae + ), Ke = n2( + $e, + V, + e, + 1 + /* ObjectRest */ + ); + let Tt = Qe(Y.block, V, Ns); + return ot(Ke) && (Tt = t.updateBlock(Tt, [ + t.createVariableStatement( + /*modifiers*/ + void 0, + Ke + ), + ...Tt.statements + ])), t.updateCatchClause( + Y, + t.updateVariableDeclaration( + Y.variableDeclaration, + Ae, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + ), + Tt + ); + } + return br(Y, V, e); + } + function Ee(Y) { + if (Gn( + Y, + 32 + /* Export */ + )) { + const Ae = h; + h = !0; + const $e = br(Y, V, e); + return h = Ae, $e; + } + return br(Y, V, e); + } + function Ce(Y) { + if (h) { + const Ae = h; + h = !1; + const $e = Ve( + Y, + /*exportedVariableStatement*/ + !0 + ); + return h = Ae, $e; + } + return Ve( + Y, + /*exportedVariableStatement*/ + !1 + ); + } + function Ve(Y, Ae) { + return ws(Y.name) && Y.name.transformFlags & 65536 ? n2( + Y, + V, + e, + 1, + /*rval*/ + void 0, + Ae + ) : br(Y, V, e); + } + function St(Y) { + return t.updateForStatement( + Y, + Qe(Y.initializer, ae, ip), + Qe(Y.condition, V, ut), + Qe(Y.incrementor, ae, ut), + c_(Y.statement, V, e) + ); + } + function Bt(Y) { + return br(Y, ae, e); + } + function tr(Y, Ae) { + const $e = $( + 0, + 2 + /* IterationStatementIncludes */ + ); + (Y.initializer.transformFlags & 65536 || wD(Y.initializer) && YN(Y.initializer)) && (Y = Nr(Y)); + const Ke = Y.awaitModifier ? Jr(Y, Ae, $e) : t.restoreEnclosingLabel(br(Y, V, e), Ae); + return W($e), Ke; + } + function Nr(Y) { + const Ae = Ba(Y.initializer); + if (Ul(Ae) || wD(Ae)) { + let $e, Ke; + const Tt = t.createTempVariable( + /*recordTempVariable*/ + void 0 + ), Le = [Az(t, Ae, Tt)]; + return Ns(Y.statement) ? (In(Le, Y.statement.statements), $e = Y.statement, Ke = Y.statement.statements) : Y.statement && (Er(Le, Y.statement), $e = Y.statement, Ke = Y.statement), t.updateForOfStatement( + Y, + Y.awaitModifier, + ct( + t.createVariableDeclarationList( + [ + ct(t.createVariableDeclaration(Tt), Y.initializer) + ], + 1 + /* Let */ + ), + Y.initializer + ), + Y.expression, + ct( + t.createBlock( + ct(t.createNodeArray(Le), Ke), + /*multiLine*/ + !0 + ), + $e + ) + ); + } + return Y; + } + function st(Y, Ae, $e) { + const Ke = t.createTempVariable(o), Tt = t.createAssignment(Ke, Ae), Le = t.createExpressionStatement(Tt); + ha(Le, Y.expression); + const mt = t.createAssignment($e, t.createFalse()), pt = t.createExpressionStatement(mt); + ha(pt, Y.expression); + const Ct = [Le, pt], qe = Az(t, Y.initializer, Ke); + Ct.push(Qe(qe, V, Ti)); + let Lt, rn; + const Pe = c_(Y.statement, V, e); + return Ns(Pe) ? (In(Ct, Pe.statements), Lt = Pe, rn = Pe.statements) : Ct.push(Pe), ct( + t.createBlock( + ct(t.createNodeArray(Ct), rn), + /*multiLine*/ + !0 + ), + Lt + ); + } + function Wt(Y) { + return T & 1 ? t.createYieldExpression( + /*asteriskToken*/ + void 0, + n().createAwaitHelper(Y) + ) : t.createAwaitExpression(Y); + } + function Jr(Y, Ae, $e) { + const Ke = Qe(Y.expression, V, ut), Tt = Me(Ke) ? t.getGeneratedNameForNode(Ke) : t.createTempVariable( + /*recordTempVariable*/ + void 0 + ), Le = Me(Ke) ? t.getGeneratedNameForNode(Tt) : t.createTempVariable( + /*recordTempVariable*/ + void 0 + ), mt = t.createTempVariable( + /*recordTempVariable*/ + void 0 + ), pt = t.createTempVariable(o), Ct = t.createUniqueName("e"), qe = t.getGeneratedNameForNode(Ct), Lt = t.createTempVariable( + /*recordTempVariable*/ + void 0 + ), rn = ct(n().createAsyncValuesHelper(Ke), Y.expression), Pe = t.createCallExpression( + t.createPropertyAccessExpression(Tt, "next"), + /*typeArguments*/ + void 0, + [] + ), yt = t.createPropertyAccessExpression(Le, "done"), ue = t.createPropertyAccessExpression(Le, "value"), M = t.createFunctionCallCall(Lt, Tt, []); + o(Ct), o(Lt); + const ye = $e & 2 ? t.inlineExpressions([t.createAssignment(Ct, t.createVoidZero()), rn]) : rn, Q = un( + ct( + t.createForStatement( + /*initializer*/ + un( + ct( + t.createVariableDeclarationList([ + t.createVariableDeclaration( + mt, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createTrue() + ), + ct(t.createVariableDeclaration( + Tt, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + ye + ), Y.expression), + t.createVariableDeclaration(Le) + ]), + Y.expression + ), + 4194304 + /* NoHoisting */ + ), + /*condition*/ + t.inlineExpressions([ + t.createAssignment(Le, Wt(Pe)), + t.createAssignment(pt, yt), + t.createLogicalNot(pt) + ]), + /*incrementor*/ + t.createAssignment(mt, t.createTrue()), + /*statement*/ + st(Y, ue, mt) + ), + /*location*/ + Y + ), + 512 + /* NoTokenTrailingSourceMaps */ + ); + return Cn(Q, Y), t.createTryStatement( + t.createBlock([ + t.restoreEnclosingLabel( + Q, + Ae + ) + ]), + t.createCatchClause( + t.createVariableDeclaration(qe), + un( + t.createBlock([ + t.createExpressionStatement( + t.createAssignment( + Ct, + t.createObjectLiteralExpression([ + t.createPropertyAssignment("error", qe) + ]) + ) + ) + ]), + 1 + /* SingleLine */ + ) + ), + t.createBlock([ + t.createTryStatement( + /*tryBlock*/ + t.createBlock([ + un( + t.createIfStatement( + t.createLogicalAnd( + t.createLogicalAnd( + t.createLogicalNot(mt), + t.createLogicalNot(pt) + ), + t.createAssignment( + Lt, + t.createPropertyAccessExpression(Tt, "return") + ) + ), + t.createExpressionStatement(Wt(M)) + ), + 1 + /* SingleLine */ + ) + ]), + /*catchClause*/ + void 0, + /*finallyBlock*/ + un( + t.createBlock([ + un( + t.createIfStatement( + Ct, + t.createThrowStatement( + t.createPropertyAccessExpression(Ct, "error") + ) + ), + 1 + /* SingleLine */ + ) + ]), + 1 + /* SingleLine */ + ) + ) + ]) + ); + } + function ui(Y) { + return E.assertNode(Y, Ii), Ji(Y); + } + function Ji(Y) { + return k?.has(Y) ? t.updateParameterDeclaration( + Y, + /*modifiers*/ + void 0, + Y.dotDotDotToken, + ws(Y.name) ? t.getGeneratedNameForNode(Y) : Y.name, + /*questionToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + ) : Y.transformFlags & 65536 ? t.updateParameterDeclaration( + Y, + /*modifiers*/ + void 0, + Y.dotDotDotToken, + t.getGeneratedNameForNode(Y), + /*questionToken*/ + void 0, + /*type*/ + void 0, + Qe(Y.initializer, V, ut) + ) : br(Y, V, e); + } + function Dt(Y) { + let Ae; + for (const $e of Y.parameters) + Ae ? Ae.add($e) : $e.transformFlags & 65536 && (Ae = /* @__PURE__ */ new Set()); + return Ae; + } + function Mn(Y) { + const Ae = T, $e = k; + T = Mc(Y), k = Dt(Y); + const Ke = t.updateConstructorDeclaration( + Y, + Y.modifiers, + _c(Y.parameters, ui, e), + Jn(Y) + ); + return T = Ae, k = $e, Ke; + } + function ai(Y) { + const Ae = T, $e = k; + T = Mc(Y), k = Dt(Y); + const Ke = t.updateGetAccessorDeclaration( + Y, + Y.modifiers, + Qe(Y.name, V, qc), + _c(Y.parameters, ui, e), + /*type*/ + void 0, + Jn(Y) + ); + return T = Ae, k = $e, Ke; + } + function fi(Y) { + const Ae = T, $e = k; + T = Mc(Y), k = Dt(Y); + const Ke = t.updateSetAccessorDeclaration( + Y, + Y.modifiers, + Qe(Y.name, V, qc), + _c(Y.parameters, ui, e), + Jn(Y) + ); + return T = Ae, k = $e, Ke; + } + function pn(Y) { + const Ae = T, $e = k; + T = Mc(Y), k = Dt(Y); + const Ke = t.updateMethodDeclaration( + Y, + T & 1 ? Ar(Y.modifiers, se, Jo) : Y.modifiers, + T & 2 ? void 0 : Y.asteriskToken, + Qe(Y.name, V, qc), + Qe( + /*node*/ + void 0, + V, + Vy + ), + /*typeParameters*/ + void 0, + T & 2 && T & 1 ? er(Y) : _c(Y.parameters, ui, e), + /*type*/ + void 0, + T & 2 && T & 1 ? qr(Y) : Jn(Y) + ); + return T = Ae, k = $e, Ke; + } + function _i(Y) { + const Ae = T, $e = k; + T = Mc(Y), k = Dt(Y); + const Ke = t.updateFunctionDeclaration( + Y, + T & 1 ? Ar(Y.modifiers, se, Zs) : Y.modifiers, + T & 2 ? void 0 : Y.asteriskToken, + Y.name, + /*typeParameters*/ + void 0, + T & 2 && T & 1 ? er(Y) : _c(Y.parameters, ui, e), + /*type*/ + void 0, + T & 2 && T & 1 ? qr(Y) : Jn(Y) + ); + return T = Ae, k = $e, Ke; + } + function Je(Y) { + const Ae = T, $e = k; + T = Mc(Y), k = Dt(Y); + const Ke = t.updateArrowFunction( + Y, + Y.modifiers, + /*typeParameters*/ + void 0, + _c(Y.parameters, ui, e), + /*type*/ + void 0, + Y.equalsGreaterThanToken, + Jn(Y) + ); + return T = Ae, k = $e, Ke; + } + function ft(Y) { + const Ae = T, $e = k; + T = Mc(Y), k = Dt(Y); + const Ke = t.updateFunctionExpression( + Y, + T & 1 ? Ar(Y.modifiers, se, Zs) : Y.modifiers, + T & 2 ? void 0 : Y.asteriskToken, + Y.name, + /*typeParameters*/ + void 0, + T & 2 && T & 1 ? er(Y) : _c(Y.parameters, ui, e), + /*type*/ + void 0, + T & 2 && T & 1 ? qr(Y) : Jn(Y) + ); + return T = Ae, k = $e, Ke; + } + function er(Y) { + if (mA(Y.parameters)) + return _c(Y.parameters, V, e); + const Ae = []; + for (const Ke of Y.parameters) { + if (Ke.initializer || Ke.dotDotDotToken) + break; + const Tt = t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + t.getGeneratedNameForNode( + Ke.name, + 8 + /* ReservedInNestedScopes */ + ) + ); + Ae.push(Tt); + } + const $e = t.createNodeArray(Ae); + return ct($e, Y.parameters), $e; + } + function qr(Y) { + const Ae = mA(Y.parameters) ? void 0 : _c(Y.parameters, V, e); + i(); + const $e = F, Ke = R; + F = /* @__PURE__ */ new Set(), R = !1; + const Tt = []; + let Le = t.updateBlock(Y.body, Ar(Y.body.statements, V, Ti)); + Le = t.updateBlock(Le, t.mergeLexicalEnvironment(Le.statements, Un(s(), Y))); + const mt = t.createReturnStatement( + n().createAsyncGeneratorHelper( + t.createFunctionExpression( + /*modifiers*/ + void 0, + t.createToken( + 42 + /* AsteriskToken */ + ), + Y.name && t.getGeneratedNameForNode(Y.name), + /*typeParameters*/ + void 0, + Ae ?? [], + /*type*/ + void 0, + Le + ), + !!(P & 1) + ) + ), pt = u >= 2 && (c.hasNodeCheckFlag( + Y, + 256 + /* MethodWithSuperPropertyAssignmentInAsync */ + ) || c.hasNodeCheckFlag( + Y, + 128 + /* MethodWithSuperPropertyAccessInAsync */ + )); + if (pt) { + ki(); + const qe = NO(t, c, Y, F); + B[Ma(qe)] = !0, Ig(Tt, [qe]); + } + Tt.push(mt); + const Ct = t.updateBlock(Y.body, Tt); + return pt && R && (c.hasNodeCheckFlag( + Y, + 256 + /* MethodWithSuperPropertyAssignmentInAsync */ + ) ? jx(Ct, bF) : c.hasNodeCheckFlag( + Y, + 128 + /* MethodWithSuperPropertyAccessInAsync */ + ) && jx(Ct, vF)), F = $e, R = Ke, Ct; + } + function Jn(Y) { + i(); + let Ae = 0; + const $e = [], Ke = Qe(Y.body, V, N7) ?? t.createBlock([]); + Ns(Ke) && (Ae = t.copyPrologue( + Ke.statements, + $e, + /*ensureUseStrict*/ + !1, + V + )), In($e, Un( + /*statements*/ + void 0, + Y + )); + const Tt = s(); + if (Ae > 0 || ot($e) || ot(Tt)) { + const Le = t.converters.convertToFunctionBlock( + Ke, + /*multiLine*/ + !0 + ); + return Ig($e, Tt), In($e, Le.statements.slice(Ae)), t.updateBlock(Le, ct(t.createNodeArray($e), Le.statements)); + } + return Ke; + } + function Un(Y, Ae) { + let $e = !1; + for (const Ke of Ae.parameters) + if ($e) { + if (ws(Ke.name)) { + if (Ke.name.elements.length > 0) { + const Tt = n2( + Ke, + V, + e, + 0, + t.getGeneratedNameForNode(Ke) + ); + if (ot(Tt)) { + const Le = t.createVariableDeclarationList(Tt), mt = t.createVariableStatement( + /*modifiers*/ + void 0, + Le + ); + un( + mt, + 2097152 + /* CustomPrologue */ + ), Y = Er(Y, mt); + } + } else if (Ke.initializer) { + const Tt = t.getGeneratedNameForNode(Ke), Le = Qe(Ke.initializer, V, ut), mt = t.createAssignment(Tt, Le), pt = t.createExpressionStatement(mt); + un( + pt, + 2097152 + /* CustomPrologue */ + ), Y = Er(Y, pt); + } + } else if (Ke.initializer) { + const Tt = t.cloneNode(Ke.name); + ct(Tt, Ke.name), un( + Tt, + 96 + /* NoSourceMap */ + ); + const Le = Qe(Ke.initializer, V, ut); + gm( + Le, + 3168 + /* NoComments */ + ); + const mt = t.createAssignment(Tt, Le); + ct(mt, Ke), un( + mt, + 3072 + /* NoComments */ + ); + const pt = t.createBlock([t.createExpressionStatement(mt)]); + ct(pt, Ke), un( + pt, + 3905 + /* NoComments */ + ); + const Ct = t.createTypeCheck(t.cloneNode(Ke.name), "undefined"), qe = t.createIfStatement(Ct, pt); + Au(qe), ct(qe, Ke), un( + qe, + 2101056 + /* NoComments */ + ), Y = Er(Y, qe); + } + } else if (Ke.transformFlags & 65536) { + $e = !0; + const Tt = n2( + Ke, + V, + e, + 1, + t.getGeneratedNameForNode(Ke), + /*hoistTempVariables*/ + !1, + /*skipInitializer*/ + !0 + ); + if (ot(Tt)) { + const Le = t.createVariableDeclarationList(Tt), mt = t.createVariableStatement( + /*modifiers*/ + void 0, + Le + ); + un( + mt, + 2097152 + /* CustomPrologue */ + ), Y = Er(Y, mt); + } + } + return Y; + } + function ki() { + (S & 1) === 0 && (S |= 1, e.enableSubstitution( + 214 + /* CallExpression */ + ), e.enableSubstitution( + 212 + /* PropertyAccessExpression */ + ), e.enableSubstitution( + 213 + /* ElementAccessExpression */ + ), e.enableEmitNotification( + 264 + /* ClassDeclaration */ + ), e.enableEmitNotification( + 175 + /* MethodDeclaration */ + ), e.enableEmitNotification( + 178 + /* GetAccessor */ + ), e.enableEmitNotification( + 179 + /* SetAccessor */ + ), e.enableEmitNotification( + 177 + /* Constructor */ + ), e.enableEmitNotification( + 244 + /* VariableStatement */ + )); + } + function Ds(Y, Ae, $e) { + if (S & 1 && re(Ae)) { + const Ke = (c.hasNodeCheckFlag( + Ae, + 128 + /* MethodWithSuperPropertyAccessInAsync */ + ) ? 128 : 0) | (c.hasNodeCheckFlag( + Ae, + 256 + /* MethodWithSuperPropertyAssignmentInAsync */ + ) ? 256 : 0); + if (Ke !== D) { + const Tt = D; + D = Ke, g(Y, Ae, $e), D = Tt; + return; + } + } else if (S && B[Ma(Ae)]) { + const Ke = D; + D = 0, g(Y, Ae, $e), D = Ke; + return; + } + g(Y, Ae, $e); + } + function Ks(Y, Ae) { + return Ae = m(Y, Ae), Y === 1 && D ? yr(Ae) : Ae; + } + function yr(Y) { + switch (Y.kind) { + case 212: + return bs(Y); + case 213: + return Xe(Y); + case 214: + return Et(Y); + } + return Y; + } + function bs(Y) { + return Y.expression.kind === 108 ? ct( + t.createPropertyAccessExpression( + t.createUniqueName( + "_super", + 48 + /* FileLevel */ + ), + Y.name + ), + Y + ) : Y; + } + function Xe(Y) { + return Y.expression.kind === 108 ? it( + Y.argumentExpression, + Y + ) : Y; + } + function Et(Y) { + const Ae = Y.expression; + if (j_(Ae)) { + const $e = wn(Ae) ? bs(Ae) : Xe(Ae); + return t.createCallExpression( + t.createPropertyAccessExpression($e, "call"), + /*typeArguments*/ + void 0, + [ + t.createThis(), + ...Y.arguments + ] + ); + } + return Y; + } + function re(Y) { + const Ae = Y.kind; + return Ae === 264 || Ae === 177 || Ae === 175 || Ae === 178 || Ae === 179; + } + function it(Y, Ae) { + return D & 256 ? ct( + t.createPropertyAccessExpression( + t.createCallExpression( + t.createIdentifier("_superIndex"), + /*typeArguments*/ + void 0, + [Y] + ), + "value" + ), + Ae + ) : ct( + t.createCallExpression( + t.createIdentifier("_superIndex"), + /*typeArguments*/ + void 0, + [Y] + ), + Ae + ); + } + } + function Kne(e) { + const t = e.factory; + return Ld(e, n); + function n(o) { + return o.isDeclarationFile ? o : br(o, i, e); + } + function i(o) { + if ((o.transformFlags & 64) === 0) + return o; + switch (o.kind) { + case 300: + return s(o); + default: + return br(o, i, e); + } + } + function s(o) { + return o.variableDeclaration ? br(o, i, e) : t.updateCatchClause( + o, + t.createVariableDeclaration(t.createTempVariable( + /*recordTempVariable*/ + void 0 + )), + Qe(o.block, i, Ns) + ); + } + } + function eie(e) { + const { + factory: t, + hoistVariableDeclaration: n + } = e; + return Ld(e, i); + function i(k) { + return k.isDeclarationFile ? k : br(k, s, e); + } + function s(k) { + if ((k.transformFlags & 32) === 0) + return k; + switch (k.kind) { + case 214: { + const D = u( + k, + /*captureThisArg*/ + !1 + ); + return E.assertNotNode(D, Xx), D; + } + case 212: + case 213: + if (Eu(k)) { + const D = m( + k, + /*captureThisArg*/ + !1, + /*isDelete*/ + !1 + ); + return E.assertNotNode(D, Xx), D; + } + return br(k, s, e); + case 227: + return k.operatorToken.kind === 61 ? S(k) : br(k, s, e); + case 221: + return T(k); + default: + return br(k, s, e); + } + } + function o(k) { + E.assertNotNode(k, k7); + const D = [k]; + for (; !k.questionDotToken && !nv(k); ) + k = Us(id(k.expression), Eu), E.assertNotNode(k, k7), D.unshift(k); + return { expression: k.expression, chain: D }; + } + function c(k, D, P) { + const A = g(k.expression, D, P); + return Xx(A) ? t.createSyntheticReferenceExpression(t.updateParenthesizedExpression(k, A.expression), A.thisArg) : t.updateParenthesizedExpression(k, A); + } + function _(k, D, P) { + if (Eu(k)) + return m(k, D, P); + let A = Qe(k.expression, s, ut); + E.assertNotNode(A, Xx); + let O; + return D && (r2(A) ? O = A : (O = t.createTempVariable(n), A = t.createAssignment(O, A))), A = k.kind === 212 ? t.updatePropertyAccessExpression(k, A, Qe(k.name, s, Me)) : t.updateElementAccessExpression(k, A, Qe(k.argumentExpression, s, ut)), O ? t.createSyntheticReferenceExpression(A, O) : A; + } + function u(k, D) { + if (Eu(k)) + return m( + k, + D, + /*isDelete*/ + !1 + ); + if (o_(k.expression) && Eu(Ba(k.expression))) { + const P = c( + k.expression, + /*captureThisArg*/ + !0, + /*isDelete*/ + !1 + ), A = Ar(k.arguments, s, ut); + return Xx(P) ? ct(t.createFunctionCallCall(P.expression, P.thisArg, A), k) : t.updateCallExpression( + k, + P, + /*typeArguments*/ + void 0, + A + ); + } + return br(k, s, e); + } + function g(k, D, P) { + switch (k.kind) { + case 218: + return c(k, D, P); + case 212: + case 213: + return _(k, D, P); + case 214: + return u(k, D); + default: + return Qe(k, s, ut); + } + } + function m(k, D, P) { + const { expression: A, chain: O } = o(k), F = g( + id(A), + K2(O[0]), + /*isDelete*/ + !1 + ); + let R = Xx(F) ? F.thisArg : void 0, B = Xx(F) ? F.expression : F, U = t.restoreOuterExpressions( + A, + B, + 8 + /* PartiallyEmittedExpressions */ + ); + r2(B) || (B = t.createTempVariable(n), U = t.createAssignment(B, U)); + let $ = B, W; + for (let K = 0; K < O.length; K++) { + const V = O[K]; + switch (V.kind) { + case 212: + case 213: + K === O.length - 1 && D && (r2($) ? W = $ : (W = t.createTempVariable(n), $ = t.createAssignment(W, $))), $ = V.kind === 212 ? t.createPropertyAccessExpression($, Qe(V.name, s, Me)) : t.createElementAccessExpression($, Qe(V.argumentExpression, s, ut)); + break; + case 214: + K === 0 && R ? (Bo(R) || (R = t.cloneNode(R), gm( + R, + 3072 + /* NoComments */ + )), $ = t.createFunctionCallCall( + $, + R.kind === 108 ? t.createThis() : R, + Ar(V.arguments, s, ut) + )) : $ = t.createCallExpression( + $, + /*typeArguments*/ + void 0, + Ar(V.arguments, s, ut) + ); + break; + } + Cn($, V); + } + const _e = P ? t.createConditionalExpression( + h( + U, + B, + /*invert*/ + !0 + ), + /*questionToken*/ + void 0, + t.createTrue(), + /*colonToken*/ + void 0, + t.createDeleteExpression($) + ) : t.createConditionalExpression( + h( + U, + B, + /*invert*/ + !0 + ), + /*questionToken*/ + void 0, + t.createVoidZero(), + /*colonToken*/ + void 0, + $ + ); + return ct(_e, k), W ? t.createSyntheticReferenceExpression(_e, W) : _e; + } + function h(k, D, P) { + return t.createBinaryExpression( + t.createBinaryExpression( + k, + t.createToken( + P ? 37 : 38 + /* ExclamationEqualsEqualsToken */ + ), + t.createNull() + ), + t.createToken( + P ? 57 : 56 + /* AmpersandAmpersandToken */ + ), + t.createBinaryExpression( + D, + t.createToken( + P ? 37 : 38 + /* ExclamationEqualsEqualsToken */ + ), + t.createVoidZero() + ) + ); + } + function S(k) { + let D = Qe(k.left, s, ut), P = D; + return r2(D) || (P = t.createTempVariable(n), D = t.createAssignment(P, D)), ct( + t.createConditionalExpression( + h(D, P), + /*questionToken*/ + void 0, + P, + /*colonToken*/ + void 0, + Qe(k.right, s, ut) + ), + k + ); + } + function T(k) { + return Eu(Ba(k.expression)) ? Cn(g( + k.expression, + /*captureThisArg*/ + !1, + /*isDelete*/ + !0 + ), k) : t.updateDeleteExpression(k, Qe(k.expression, s, ut)); + } + } + function tie(e) { + const { + hoistVariableDeclaration: t, + factory: n + } = e; + return Ld(e, i); + function i(c) { + return c.isDeclarationFile ? c : br(c, s, e); + } + function s(c) { + return (c.transformFlags & 16) === 0 ? c : sJ(c) ? o(c) : br(c, s, e); + } + function o(c) { + const _ = c.operatorToken, u = K4(_.kind); + let g = Ba(Qe(c.left, s, S_)), m = g; + const h = Ba(Qe(c.right, s, ut)); + if (To(g)) { + const S = r2(g.expression), T = S ? g.expression : n.createTempVariable(t), k = S ? g.expression : n.createAssignment( + T, + g.expression + ); + if (wn(g)) + m = n.createPropertyAccessExpression( + T, + g.name + ), g = n.createPropertyAccessExpression( + k, + g.name + ); + else { + const D = r2(g.argumentExpression), P = D ? g.argumentExpression : n.createTempVariable(t); + m = n.createElementAccessExpression( + T, + P + ), g = n.createElementAccessExpression( + k, + D ? g.argumentExpression : n.createAssignment( + P, + g.argumentExpression + ) + ); + } + } + return n.createBinaryExpression( + g, + u, + n.createParenthesizedExpression( + n.createAssignment( + m, + h + ) + ) + ); + } + } + function rie(e) { + const { + factory: t, + getEmitHelperFactory: n, + hoistVariableDeclaration: i, + startLexicalEnvironment: s, + endLexicalEnvironment: o + } = e; + let c, _, u, g; + return Ld(e, m); + function m(ce) { + if (ce.isDeclarationFile) + return ce; + const fe = Qe(ce, h, Di); + return Wg(fe, e.readEmitHelpers()), _ = void 0, c = void 0, u = void 0, fe; + } + function h(ce) { + if ((ce.transformFlags & 4) === 0) + return ce; + switch (ce.kind) { + case 308: + return S(ce); + case 242: + return T(ce); + case 249: + return k(ce); + case 251: + return D(ce); + case 256: + return A(ce); + default: + return br(ce, h, e); + } + } + function S(ce) { + const fe = $W(ce.statements); + if (fe) { + s(), c = new L6(), _ = []; + const he = sve(ce.statements), q = []; + In(q, Q4(ce.statements, h, Ti, 0, he)); + let be = he; + for (; be < ce.statements.length; ) { + const Z = ce.statements[be]; + if (iie(Z) !== 0) { + be > he && In(q, Ar(ce.statements, h, Ti, he, be - he)); + break; + } + be++; + } + E.assert(be < ce.statements.length, "Should have encountered at least one 'using' statement."); + const je = ae(), me = O(ce.statements, be, ce.statements.length, je, q); + return c.size && Er( + q, + t.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + t.createNamedExports(is(c.values())) + ) + ), In(q, o()), _.length && q.push(t.createVariableStatement( + t.createModifiersFromModifierFlags( + 32 + /* Export */ + ), + t.createVariableDeclarationList( + _, + 1 + /* Let */ + ) + )), In(q, se( + me, + je, + fe === 2 + /* Async */ + )), g && q.push(t.createExportAssignment( + /*modifiers*/ + void 0, + /*isExportEquals*/ + !0, + g + )), t.updateSourceFile(ce, q); + } + return br(ce, h, e); + } + function T(ce) { + const fe = $W(ce.statements); + if (fe) { + const he = sve(ce.statements), q = ae(); + return t.updateBlock( + ce, + [ + ...Q4(ce.statements, h, Ti, 0, he), + ...se( + O( + ce.statements, + he, + ce.statements.length, + q, + /*topLevelStatements*/ + void 0 + ), + q, + fe === 2 + /* Async */ + ) + ] + ); + } + return br(ce, h, e); + } + function k(ce) { + return ce.initializer && ave(ce.initializer) ? Qe( + t.createBlock([ + t.createVariableStatement( + /*modifiers*/ + void 0, + ce.initializer + ), + t.updateForStatement( + ce, + /*initializer*/ + void 0, + ce.condition, + ce.incrementor, + ce.statement + ) + ]), + h, + Ti + ) : br(ce, h, e); + } + function D(ce) { + if (ave(ce.initializer)) { + const fe = ce.initializer, he = Yc(fe.declarations) || t.createVariableDeclaration(t.createTempVariable( + /*recordTempVariable*/ + void 0 + )), q = nie(fe) === 2, be = t.getGeneratedNameForNode(he.name), je = t.updateVariableDeclaration( + he, + he.name, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + be + ), me = t.createVariableDeclarationList( + [je], + q ? 6 : 4 + /* Using */ + ), Z = t.createVariableStatement( + /*modifiers*/ + void 0, + me + ); + return Qe( + t.updateForOfStatement( + ce, + ce.awaitModifier, + t.createVariableDeclarationList( + [ + t.createVariableDeclaration(be) + ], + 2 + /* Const */ + ), + ce.expression, + Ns(ce.statement) ? t.updateBlock(ce.statement, [ + Z, + ...ce.statement.statements + ]) : t.createBlock( + [ + Z, + ce.statement + ], + /*multiLine*/ + !0 + ) + ), + h, + Ti + ); + } + return br(ce, h, e); + } + function P(ce, fe) { + return $W(ce.statements) !== 0 ? y6(ce) ? t.updateCaseClause( + ce, + Qe(ce.expression, h, ut), + O( + ce.statements, + /*start*/ + 0, + ce.statements.length, + fe, + /*topLevelStatements*/ + void 0 + ) + ) : t.updateDefaultClause( + ce, + O( + ce.statements, + /*start*/ + 0, + ce.statements.length, + fe, + /*topLevelStatements*/ + void 0 + ) + ) : br(ce, h, e); + } + function A(ce) { + const fe = Nje(ce.caseBlock.clauses); + if (fe) { + const he = ae(); + return se( + [ + t.updateSwitchStatement( + ce, + Qe(ce.expression, h, ut), + t.updateCaseBlock( + ce.caseBlock, + ce.caseBlock.clauses.map((q) => P(q, he)) + ) + ) + ], + he, + fe === 2 + /* Async */ + ); + } + return br(ce, h, e); + } + function O(ce, fe, he, q, be) { + const je = []; + for (let pe = fe; pe < he; pe++) { + const Te = ce[pe], Fe = iie(Te); + if (Fe) { + E.assertNode(Te, Ic); + const ne = []; + for (let Se of Te.declarationList.declarations) { + if (!Me(Se.name)) { + ne.length = 0; + break; + } + rf(Se) && (Se = lf(e, Se)); + const ie = Qe(Se.initializer, h, ut) ?? t.createVoidZero(); + ne.push(t.updateVariableDeclaration( + Se, + Se.name, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + n().createAddDisposableResourceHelper( + q, + ie, + Fe === 2 + /* Async */ + ) + )); + } + if (ne.length) { + const Se = t.createVariableDeclarationList( + ne, + 2 + /* Const */ + ); + Cn(Se, Te.declarationList), ct(Se, Te.declarationList), me(t.updateVariableStatement( + Te, + /*modifiers*/ + void 0, + Se + )); + continue; + } + } + const Ye = h(Te); + as(Ye) ? Ye.forEach(me) : Ye && me(Ye); + } + return je; + function me(pe) { + E.assertNode(pe, Ti), Er(je, Z(pe)); + } + function Z(pe) { + if (!be) return pe; + switch (pe.kind) { + case 273: + case 272: + case 279: + case 263: + return F(pe, be); + case 278: + return R(pe); + case 264: + return $(pe); + case 244: + return W(pe); + } + return pe; + } + } + function F(ce, fe) { + fe.push(ce); + } + function R(ce) { + return ce.isExportEquals ? U(ce) : B(ce); + } + function B(ce) { + if (u) + return ce; + u = t.createUniqueName( + "_default", + 56 + /* Optimistic */ + ), V( + u, + /*isExport*/ + !0, + "default", + ce + ); + let fe = ce.expression, he = hc(fe); + rf(he) && (he = lf( + e, + he, + /*ignoreEmptyStringLiteral*/ + !1, + "default" + ), fe = t.restoreOuterExpressions(fe, he)); + const q = t.createAssignment(u, fe); + return t.createExpressionStatement(q); + } + function U(ce) { + if (g) + return ce; + g = t.createUniqueName( + "_default", + 56 + /* Optimistic */ + ), i(g); + const fe = t.createAssignment(g, ce.expression); + return t.createExpressionStatement(fe); + } + function $(ce) { + if (!ce.name && u) + return ce; + const fe = Gn( + ce, + 32 + /* Export */ + ), he = Gn( + ce, + 2048 + /* Default */ + ); + let q = t.converters.convertToClassExpression(ce); + return ce.name && (V( + t.getLocalName(ce), + fe && !he, + /*exportAlias*/ + void 0, + ce + ), q = t.createAssignment(t.getDeclarationName(ce), q), rf(q) && (q = lf( + e, + q, + /*ignoreEmptyStringLiteral*/ + !1 + )), Cn(q, ce), ha(q, ce), el(q, ce)), he && !u && (u = t.createUniqueName( + "_default", + 56 + /* Optimistic */ + ), V( + u, + /*isExport*/ + !0, + "default", + ce + ), q = t.createAssignment(u, q), rf(q) && (q = lf( + e, + q, + /*ignoreEmptyStringLiteral*/ + !1, + "default" + )), Cn(q, ce)), t.createExpressionStatement(q); + } + function W(ce) { + let fe; + const he = Gn( + ce, + 32 + /* Export */ + ); + for (const q of ce.declarationList.declarations) + K(q, he, q), q.initializer && (fe = Er(fe, _e(q))); + if (fe) { + const q = t.createExpressionStatement(t.inlineExpressions(fe)); + return Cn(q, ce), el(q, ce), ha(q, ce), q; + } + } + function _e(ce) { + E.assertIsDefined(ce.initializer); + let fe; + Me(ce.name) ? (fe = t.cloneNode(ce.name), un(fe, Ea(fe) & -114689)) : fe = t.converters.convertToAssignmentPattern(ce.name); + const he = t.createAssignment(fe, ce.initializer); + return Cn(he, ce), el(he, ce), ha(he, ce), he; + } + function K(ce, fe, he) { + if (ws(ce.name)) + for (const q of ce.name.elements) + vl(q) || K(q, fe, he); + else + V( + ce.name, + fe, + /*exportAlias*/ + void 0, + he + ); + } + function V(ce, fe, he, q) { + const be = Bo(ce) ? ce : t.cloneNode(ce); + if (fe) { + if (he === void 0 && !Nh(be)) { + const pe = t.createVariableDeclaration(be); + q && Cn(pe, q), _.push(pe); + return; + } + const je = he !== void 0 ? be : void 0, me = he !== void 0 ? he : be, Z = t.createExportSpecifier( + /*isTypeOnly*/ + !1, + je, + me + ); + q && Cn(Z, q), c.set(be, Z); + } + i(be); + } + function ae() { + return t.createUniqueName("env"); + } + function se(ce, fe, he) { + const q = [], be = t.createObjectLiteralExpression([ + t.createPropertyAssignment("stack", t.createArrayLiteralExpression()), + t.createPropertyAssignment("error", t.createVoidZero()), + t.createPropertyAssignment("hasError", t.createFalse()) + ]), je = t.createVariableDeclaration( + fe, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + be + ), me = t.createVariableDeclarationList( + [je], + 2 + /* Const */ + ), Z = t.createVariableStatement( + /*modifiers*/ + void 0, + me + ); + q.push(Z); + const pe = t.createBlock( + ce, + /*multiLine*/ + !0 + ), Te = t.createUniqueName("e"), Fe = t.createCatchClause( + Te, + t.createBlock( + [ + t.createExpressionStatement( + t.createAssignment( + t.createPropertyAccessExpression(fe, "error"), + Te + ) + ), + t.createExpressionStatement( + t.createAssignment( + t.createPropertyAccessExpression(fe, "hasError"), + t.createTrue() + ) + ) + ], + /*multiLine*/ + !0 + ) + ); + let Ye; + if (he) { + const Se = t.createUniqueName("result"); + Ye = t.createBlock( + [ + t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList( + [ + t.createVariableDeclaration( + Se, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + n().createDisposeResourcesHelper(fe) + ) + ], + 2 + /* Const */ + ) + ), + t.createIfStatement(Se, t.createExpressionStatement(t.createAwaitExpression(Se))) + ], + /*multiLine*/ + !0 + ); + } else + Ye = t.createBlock( + [ + t.createExpressionStatement( + n().createDisposeResourcesHelper(fe) + ) + ], + /*multiLine*/ + !0 + ); + const ne = t.createTryStatement(pe, Fe, Ye); + return q.push(ne), q; + } + } + function sve(e) { + for (let t = 0; t < e.length; t++) + if (!cm(e[t]) && !w3(e[t])) + return t; + return 0; + } + function ave(e) { + return Ul(e) && nie(e) !== 0; + } + function nie(e) { + return (e.flags & 7) === 6 ? 2 : (e.flags & 7) === 4 ? 1 : 0; + } + function Pje(e) { + return nie(e.declarationList); + } + function iie(e) { + return Ic(e) ? Pje(e) : 0; + } + function $W(e) { + let t = 0; + for (const n of e) { + const i = iie(n); + if (i === 2) return 2; + i > t && (t = i); + } + return t; + } + function Nje(e) { + let t = 0; + for (const n of e) { + const i = $W(n.statements); + if (i === 2) return 2; + i > t && (t = i); + } + return t; + } + function sie(e) { + const { + factory: t, + getEmitHelperFactory: n + } = e, i = e.getCompilerOptions(); + let s, o; + return Ld(e, h); + function c() { + if (o.filenameDeclaration) + return o.filenameDeclaration.name; + const ne = t.createVariableDeclaration( + t.createUniqueName( + "_jsxFileName", + 48 + /* FileLevel */ + ), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createStringLiteral(s.fileName) + ); + return o.filenameDeclaration = ne, o.filenameDeclaration.name; + } + function _(ne) { + return i.jsx === 5 ? "jsxDEV" : ne ? "jsxs" : "jsx"; + } + function u(ne) { + const Se = _(ne); + return m(Se); + } + function g() { + return m("Fragment"); + } + function m(ne) { + var Se, ie; + const Ne = ne === "createElement" ? o.importSpecifier : $5(o.importSpecifier, i), Ee = (ie = (Se = o.utilizedImplicitRuntimeImports) == null ? void 0 : Se.get(Ne)) == null ? void 0 : ie.get(ne); + if (Ee) + return Ee.name; + o.utilizedImplicitRuntimeImports || (o.utilizedImplicitRuntimeImports = /* @__PURE__ */ new Map()); + let Ce = o.utilizedImplicitRuntimeImports.get(Ne); + Ce || (Ce = /* @__PURE__ */ new Map(), o.utilizedImplicitRuntimeImports.set(Ne, Ce)); + const Ve = t.createUniqueName( + `_${ne}`, + 112 + /* AllowNameSubstitution */ + ), St = t.createImportSpecifier( + /*isTypeOnly*/ + !1, + t.createIdentifier(ne), + Ve + ); + return xte(Ve, St), Ce.set(ne, St), Ve; + } + function h(ne) { + if (ne.isDeclarationFile) + return ne; + s = ne, o = {}, o.importSpecifier = yN(i, ne); + let Se = br(ne, S, e); + Wg(Se, e.readEmitHelpers()); + let ie = Se.statements; + if (o.filenameDeclaration && (ie = sS(ie.slice(), t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList( + [o.filenameDeclaration], + 2 + /* Const */ + ) + ))), o.utilizedImplicitRuntimeImports) { + for (const [Ne, Ee] of is(o.utilizedImplicitRuntimeImports.entries())) + if (fl(ne)) { + const Ce = t.createImportDeclaration( + /*modifiers*/ + void 0, + t.createImportClause( + /*phaseModifier*/ + void 0, + /*name*/ + void 0, + t.createNamedImports(is(Ee.values())) + ), + t.createStringLiteral(Ne), + /*attributes*/ + void 0 + ); + ev( + Ce, + /*incremental*/ + !1 + ), ie = sS(ie.slice(), Ce); + } else if (tf(ne)) { + const Ce = t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList( + [ + t.createVariableDeclaration( + t.createObjectBindingPattern(is(Ee.values(), (Ve) => t.createBindingElement( + /*dotDotDotToken*/ + void 0, + Ve.propertyName, + Ve.name + ))), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createCallExpression( + t.createIdentifier("require"), + /*typeArguments*/ + void 0, + [t.createStringLiteral(Ne)] + ) + ) + ], + 2 + /* Const */ + ) + ); + ev( + Ce, + /*incremental*/ + !1 + ), ie = sS(ie.slice(), Ce); + } + } + return ie !== Se.statements && (Se = t.updateSourceFile(Se, ie)), o = void 0, Se; + } + function S(ne) { + return ne.transformFlags & 2 ? T(ne) : ne; + } + function T(ne) { + switch (ne.kind) { + case 285: + return O( + ne, + /*isChild*/ + !1 + ); + case 286: + return F( + ne, + /*isChild*/ + !1 + ); + case 289: + return R( + ne, + /*isChild*/ + !1 + ); + case 295: + return Ye(ne); + default: + return br(ne, S, e); + } + } + function k(ne) { + switch (ne.kind) { + case 12: + return be(ne); + case 295: + return Ye(ne); + case 285: + return O( + ne, + /*isChild*/ + !0 + ); + case 286: + return F( + ne, + /*isChild*/ + !0 + ); + case 289: + return R( + ne, + /*isChild*/ + !0 + ); + default: + return E.failBadSyntaxKind(ne); + } + } + function D(ne) { + return ne.properties.some( + (Se) => rl(Se) && (Me(Se.name) && An(Se.name) === "__proto__" || ca(Se.name) && Se.name.text === "__proto__") + ); + } + function P(ne) { + let Se = !1; + for (const ie of ne.attributes.properties) + if (Qx(ie) && (!_a(ie.expression) || ie.expression.properties.some(Vg))) + Se = !0; + else if (Se && Tm(ie) && Me(ie.name) && ie.name.escapedText === "key") + return !0; + return !1; + } + function A(ne) { + return o.importSpecifier === void 0 || P(ne); + } + function O(ne, Se) { + return (A(ne.openingElement) ? _e : $)( + ne.openingElement, + ne.children, + Se, + /*location*/ + ne + ); + } + function F(ne, Se) { + return (A(ne) ? _e : $)( + ne, + /*children*/ + void 0, + Se, + /*location*/ + ne + ); + } + function R(ne, Se) { + return (o.importSpecifier === void 0 ? V : K)( + ne.openingFragment, + ne.children, + Se, + /*location*/ + ne + ); + } + function B(ne) { + const Se = U(ne); + return Se && t.createObjectLiteralExpression([Se]); + } + function U(ne) { + const Se = QC(ne); + if (wr(Se) === 1 && !Se[0].dotDotDotToken) { + const Ne = k(Se[0]); + return Ne && t.createPropertyAssignment("children", Ne); + } + const ie = Fi(ne, k); + return wr(ie) ? t.createPropertyAssignment("children", t.createArrayLiteralExpression(ie)) : void 0; + } + function $(ne, Se, ie, Ne) { + const Ee = Te(ne), Ce = Se && Se.length ? U(Se) : void 0, Ve = Nn(ne.attributes.properties, (tr) => !!tr.name && Me(tr.name) && tr.name.escapedText === "key"), St = Ve ? kn(ne.attributes.properties, (tr) => tr !== Ve) : ne.attributes.properties, Bt = wr(St) ? se(St, Ce) : t.createObjectLiteralExpression(Ce ? [Ce] : Ge); + return W( + Ee, + Bt, + Ve, + Se || Ge, + ie, + Ne + ); + } + function W(ne, Se, ie, Ne, Ee, Ce) { + var Ve; + const St = QC(Ne), Bt = wr(St) > 1 || !!((Ve = St[0]) != null && Ve.dotDotDotToken), tr = [ne, Se]; + if (ie && tr.push(q(ie.initializer)), i.jsx === 5) { + const st = Vo(s); + if (st && Di(st)) { + ie === void 0 && tr.push(t.createVoidZero()), tr.push(Bt ? t.createTrue() : t.createFalse()); + const Wt = js(st, Ce.pos); + tr.push(t.createObjectLiteralExpression([ + t.createPropertyAssignment("fileName", c()), + t.createPropertyAssignment("lineNumber", t.createNumericLiteral(Wt.line + 1)), + t.createPropertyAssignment("columnNumber", t.createNumericLiteral(Wt.character + 1)) + ])), tr.push(t.createThis()); + } + } + const Nr = ct( + t.createCallExpression( + u(Bt), + /*typeArguments*/ + void 0, + tr + ), + Ce + ); + return Ee && Au(Nr), Nr; + } + function _e(ne, Se, ie, Ne) { + const Ee = Te(ne), Ce = ne.attributes.properties, Ve = wr(Ce) ? se(Ce) : t.createNull(), St = o.importSpecifier === void 0 ? Nz( + t, + e.getEmitResolver().getJsxFactoryEntity(s), + i.reactNamespace, + // TODO: GH#18217 + ne + ) : m("createElement"), Bt = nre( + t, + St, + Ee, + Ve, + Fi(Se, k), + Ne + ); + return ie && Au(Bt), Bt; + } + function K(ne, Se, ie, Ne) { + let Ee; + if (Se && Se.length) { + const Ce = B(Se); + Ce && (Ee = Ce); + } + return W( + g(), + Ee || t.createObjectLiteralExpression([]), + /*keyAttr*/ + void 0, + Se, + ie, + Ne + ); + } + function V(ne, Se, ie, Ne) { + const Ee = ire( + t, + e.getEmitResolver().getJsxFactoryEntity(s), + e.getEmitResolver().getJsxFragmentFactoryEntity(s), + i.reactNamespace, + // TODO: GH#18217 + Fi(Se, k), + ne, + Ne + ); + return ie && Au(Ee), Ee; + } + function ae(ne) { + return _a(ne.expression) && !D(ne.expression) ? Qc(ne.expression.properties, (Se) => E.checkDefined(Qe(Se, S, vh))) : t.createSpreadAssignment(E.checkDefined(Qe(ne.expression, S, ut))); + } + function se(ne, Se) { + const ie = da(i); + return ie && ie >= 5 ? t.createObjectLiteralExpression(ce(ne, Se)) : fe(ne, Se); + } + function ce(ne, Se) { + const ie = Ip(DR(ne, Qx, (Ne, Ee) => Ip(hr(Ne, (Ce) => Ee ? ae(Ce) : he(Ce))))); + return Se && ie.push(Se), ie; + } + function fe(ne, Se) { + const ie = []; + let Ne = []; + for (const Ce of ne) { + if (Qx(Ce)) { + if (_a(Ce.expression) && !D(Ce.expression)) { + for (const Ve of Ce.expression.properties) { + if (Vg(Ve)) { + Ee(), ie.push(E.checkDefined(Qe(Ve.expression, S, ut))); + continue; + } + Ne.push(E.checkDefined(Qe(Ve, S))); + } + continue; + } + Ee(), ie.push(E.checkDefined(Qe(Ce.expression, S, ut))); + continue; + } + Ne.push(he(Ce)); + } + return Se && Ne.push(Se), Ee(), ie.length && !_a(ie[0]) && ie.unshift(t.createObjectLiteralExpression()), xg(ie) || n().createAssignHelper(ie); + function Ee() { + Ne.length && (ie.push(t.createObjectLiteralExpression(Ne)), Ne = []); + } + } + function he(ne) { + const Se = Fe(ne), ie = q(ne.initializer); + return t.createPropertyAssignment(Se, ie); + } + function q(ne) { + if (ne === void 0) + return t.createTrue(); + if (ne.kind === 11) { + const Se = ne.singleQuote !== void 0 ? ne.singleQuote : !_5(ne, s), ie = t.createStringLiteral(pe(ne.text) || ne.text, Se); + return ct(ie, ne); + } + return ne.kind === 295 ? ne.expression === void 0 ? t.createTrue() : E.checkDefined(Qe(ne.expression, S, ut)) : Sm(ne) ? O( + ne, + /*isChild*/ + !1 + ) : NS(ne) ? F( + ne, + /*isChild*/ + !1 + ) : cv(ne) ? R( + ne, + /*isChild*/ + !1 + ) : E.failBadSyntaxKind(ne); + } + function be(ne) { + const Se = je(ne.text); + return Se === void 0 ? void 0 : t.createStringLiteral(Se); + } + function je(ne) { + let Se, ie = 0, Ne = -1; + for (let Ee = 0; Ee < ne.length; Ee++) { + const Ce = ne.charCodeAt(Ee); + Cu(Ce) ? (ie !== -1 && Ne !== -1 && (Se = me(Se, ne.substr(ie, Ne - ie + 1))), ie = -1) : im(Ce) || (Ne = Ee, ie === -1 && (ie = Ee)); + } + return ie !== -1 ? me(Se, ne.substr(ie)) : Se; + } + function me(ne, Se) { + const ie = Z(Se); + return ne === void 0 ? ie : ne + " " + ie; + } + function Z(ne) { + return ne.replace(/&((#((\d+)|x([\da-fA-F]+)))|(\w+));/g, (Se, ie, Ne, Ee, Ce, Ve, St) => { + if (Ce) + return yD(parseInt(Ce, 10)); + if (Ve) + return yD(parseInt(Ve, 16)); + { + const Bt = Aje.get(St); + return Bt ? yD(Bt) : Se; + } + }); + } + function pe(ne) { + const Se = Z(ne); + return Se === ne ? void 0 : Se; + } + function Te(ne) { + if (ne.kind === 285) + return Te(ne.openingElement); + { + const Se = ne.tagName; + return Me(Se) && YC(Se.escapedText) ? t.createStringLiteral(An(Se)) : Fd(Se) ? t.createStringLiteral(An(Se.namespace) + ":" + An(Se.name)) : VN(t, Se); + } + } + function Fe(ne) { + const Se = ne.name; + if (Me(Se)) { + const ie = An(Se); + return /^[A-Z_]\w*$/i.test(ie) ? Se : t.createStringLiteral(ie); + } + return t.createStringLiteral(An(Se.namespace) + ":" + An(Se.name)); + } + function Ye(ne) { + const Se = Qe(ne.expression, S, ut); + return ne.dotDotDotToken ? t.createSpreadElement(Se) : Se; + } + } + var Aje = new Map(Object.entries({ + quot: 34, + amp: 38, + apos: 39, + lt: 60, + gt: 62, + nbsp: 160, + iexcl: 161, + cent: 162, + pound: 163, + curren: 164, + yen: 165, + brvbar: 166, + sect: 167, + uml: 168, + copy: 169, + ordf: 170, + laquo: 171, + not: 172, + shy: 173, + reg: 174, + macr: 175, + deg: 176, + plusmn: 177, + sup2: 178, + sup3: 179, + acute: 180, + micro: 181, + para: 182, + middot: 183, + cedil: 184, + sup1: 185, + ordm: 186, + raquo: 187, + frac14: 188, + frac12: 189, + frac34: 190, + iquest: 191, + Agrave: 192, + Aacute: 193, + Acirc: 194, + Atilde: 195, + Auml: 196, + Aring: 197, + AElig: 198, + Ccedil: 199, + Egrave: 200, + Eacute: 201, + Ecirc: 202, + Euml: 203, + Igrave: 204, + Iacute: 205, + Icirc: 206, + Iuml: 207, + ETH: 208, + Ntilde: 209, + Ograve: 210, + Oacute: 211, + Ocirc: 212, + Otilde: 213, + Ouml: 214, + times: 215, + Oslash: 216, + Ugrave: 217, + Uacute: 218, + Ucirc: 219, + Uuml: 220, + Yacute: 221, + THORN: 222, + szlig: 223, + agrave: 224, + aacute: 225, + acirc: 226, + atilde: 227, + auml: 228, + aring: 229, + aelig: 230, + ccedil: 231, + egrave: 232, + eacute: 233, + ecirc: 234, + euml: 235, + igrave: 236, + iacute: 237, + icirc: 238, + iuml: 239, + eth: 240, + ntilde: 241, + ograve: 242, + oacute: 243, + ocirc: 244, + otilde: 245, + ouml: 246, + divide: 247, + oslash: 248, + ugrave: 249, + uacute: 250, + ucirc: 251, + uuml: 252, + yacute: 253, + thorn: 254, + yuml: 255, + OElig: 338, + oelig: 339, + Scaron: 352, + scaron: 353, + Yuml: 376, + fnof: 402, + circ: 710, + tilde: 732, + Alpha: 913, + Beta: 914, + Gamma: 915, + Delta: 916, + Epsilon: 917, + Zeta: 918, + Eta: 919, + Theta: 920, + Iota: 921, + Kappa: 922, + Lambda: 923, + Mu: 924, + Nu: 925, + Xi: 926, + Omicron: 927, + Pi: 928, + Rho: 929, + Sigma: 931, + Tau: 932, + Upsilon: 933, + Phi: 934, + Chi: 935, + Psi: 936, + Omega: 937, + alpha: 945, + beta: 946, + gamma: 947, + delta: 948, + epsilon: 949, + zeta: 950, + eta: 951, + theta: 952, + iota: 953, + kappa: 954, + lambda: 955, + mu: 956, + nu: 957, + xi: 958, + omicron: 959, + pi: 960, + rho: 961, + sigmaf: 962, + sigma: 963, + tau: 964, + upsilon: 965, + phi: 966, + chi: 967, + psi: 968, + omega: 969, + thetasym: 977, + upsih: 978, + piv: 982, + ensp: 8194, + emsp: 8195, + thinsp: 8201, + zwnj: 8204, + zwj: 8205, + lrm: 8206, + rlm: 8207, + ndash: 8211, + mdash: 8212, + lsquo: 8216, + rsquo: 8217, + sbquo: 8218, + ldquo: 8220, + rdquo: 8221, + bdquo: 8222, + dagger: 8224, + Dagger: 8225, + bull: 8226, + hellip: 8230, + permil: 8240, + prime: 8242, + Prime: 8243, + lsaquo: 8249, + rsaquo: 8250, + oline: 8254, + frasl: 8260, + euro: 8364, + image: 8465, + weierp: 8472, + real: 8476, + trade: 8482, + alefsym: 8501, + larr: 8592, + uarr: 8593, + rarr: 8594, + darr: 8595, + harr: 8596, + crarr: 8629, + lArr: 8656, + uArr: 8657, + rArr: 8658, + dArr: 8659, + hArr: 8660, + forall: 8704, + part: 8706, + exist: 8707, + empty: 8709, + nabla: 8711, + isin: 8712, + notin: 8713, + ni: 8715, + prod: 8719, + sum: 8721, + minus: 8722, + lowast: 8727, + radic: 8730, + prop: 8733, + infin: 8734, + ang: 8736, + and: 8743, + or: 8744, + cap: 8745, + cup: 8746, + int: 8747, + there4: 8756, + sim: 8764, + cong: 8773, + asymp: 8776, + ne: 8800, + equiv: 8801, + le: 8804, + ge: 8805, + sub: 8834, + sup: 8835, + nsub: 8836, + sube: 8838, + supe: 8839, + oplus: 8853, + otimes: 8855, + perp: 8869, + sdot: 8901, + lceil: 8968, + rceil: 8969, + lfloor: 8970, + rfloor: 8971, + lang: 9001, + rang: 9002, + loz: 9674, + spades: 9824, + clubs: 9827, + hearts: 9829, + diams: 9830 + })); + function aie(e) { + const { + factory: t, + hoistVariableDeclaration: n + } = e; + return Ld(e, i); + function i(u) { + return u.isDeclarationFile ? u : br(u, s, e); + } + function s(u) { + if ((u.transformFlags & 512) === 0) + return u; + switch (u.kind) { + case 227: + return o(u); + default: + return br(u, s, e); + } + } + function o(u) { + switch (u.operatorToken.kind) { + case 68: + return c(u); + case 43: + return _(u); + default: + return br(u, s, e); + } + } + function c(u) { + let g, m; + const h = Qe(u.left, s, ut), S = Qe(u.right, s, ut); + if (uo(h)) { + const T = t.createTempVariable(n), k = t.createTempVariable(n); + g = ct( + t.createElementAccessExpression( + ct(t.createAssignment(T, h.expression), h.expression), + ct(t.createAssignment(k, h.argumentExpression), h.argumentExpression) + ), + h + ), m = ct( + t.createElementAccessExpression( + T, + k + ), + h + ); + } else if (wn(h)) { + const T = t.createTempVariable(n); + g = ct( + t.createPropertyAccessExpression( + ct(t.createAssignment(T, h.expression), h.expression), + h.name + ), + h + ), m = ct( + t.createPropertyAccessExpression( + T, + h.name + ), + h + ); + } else + g = h, m = h; + return ct( + t.createAssignment( + g, + ct(t.createGlobalMethodCall("Math", "pow", [m, S]), u) + ), + u + ); + } + function _(u) { + const g = Qe(u.left, s, ut), m = Qe(u.right, s, ut); + return ct(t.createGlobalMethodCall("Math", "pow", [g, m]), u); + } + } + function ove(e, t) { + return { kind: e, expression: t }; + } + function oie(e) { + const { + factory: t, + getEmitHelperFactory: n, + startLexicalEnvironment: i, + resumeLexicalEnvironment: s, + endLexicalEnvironment: o, + hoistVariableDeclaration: c + } = e, _ = e.getCompilerOptions(), u = e.getEmitResolver(), g = e.onSubstituteNode, m = e.onEmitNode; + e.onEmitNode = Ol, e.onSubstituteNode = hp; + let h, S, T, k; + function D(ee) { + k = Er( + k, + t.createVariableDeclaration(ee) + ); + } + let P, A = 0; + return Ld(e, O); + function O(ee) { + if (ee.isDeclarationFile) + return ee; + h = ee, S = ee.text; + const et = se(ee); + return Wg(et, e.readEmitHelpers()), h = void 0, S = void 0, k = void 0, T = 0, et; + } + function F(ee, et) { + const Ut = T; + return T = (T & ~ee | et) & 32767, Ut; + } + function R(ee, et, Ut) { + T = (T & ~et | Ut) & -32768 | ee; + } + function B(ee) { + return (T & 8192) !== 0 && ee.kind === 254 && !ee.expression; + } + function U(ee) { + return ee.transformFlags & 4194304 && (Cf(ee) || sv(ee) || zte(ee) || F4(ee) || O4(ee) || y6(ee) || L4(ee) || wS(ee) || Zb(ee) || Gy(ee) || wy( + ee, + /*lookInLabeledStatements*/ + !1 + ) || Ns(ee)); + } + function $(ee) { + return (ee.transformFlags & 1024) !== 0 || P !== void 0 || T & 8192 && U(ee) || wy( + ee, + /*lookInLabeledStatements*/ + !1 + ) && zi(ee) || (sd(ee) & 1) !== 0; + } + function W(ee) { + return $(ee) ? ae( + ee, + /*expressionResultIsUnused*/ + !1 + ) : ee; + } + function _e(ee) { + return $(ee) ? ae( + ee, + /*expressionResultIsUnused*/ + !0 + ) : ee; + } + function K(ee) { + if ($(ee)) { + const et = Vo(ee); + if (os(et) && cl(et)) { + const Ut = F( + 32670, + 16449 + /* StaticInitializerIncludes */ + ), Gt = ae( + ee, + /*expressionResultIsUnused*/ + !1 + ); + return R( + Ut, + 229376, + 0 + /* None */ + ), Gt; + } + return ae( + ee, + /*expressionResultIsUnused*/ + !1 + ); + } + return ee; + } + function V(ee) { + return ee.kind === 108 ? Df( + ee, + /*isExpressionOfCall*/ + !0 + ) : W(ee); + } + function ae(ee, et) { + switch (ee.kind) { + case 126: + return; + // elide static keyword + case 264: + return Te(ee); + case 232: + return Fe(ee); + case 170: + return Ks(ee); + case 263: + return Lt(ee); + case 220: + return Ct(ee); + case 219: + return qe(ee); + case 261: + return Rr(ee); + case 80: + return Z(ee); + case 262: + return ke(ee); + case 256: + return ce(ee); + case 270: + return fe(ee); + case 242: + return yt( + ee + ); + case 253: + case 252: + return pe(ee); + case 257: + return vt(ee); + case 247: + case 248: + return _r( + ee, + /*outermostLabeledStatement*/ + void 0 + ); + case 249: + return nr( + ee, + /*outermostLabeledStatement*/ + void 0 + ); + case 250: + return cr( + ee, + /*outermostLabeledStatement*/ + void 0 + ); + case 251: + return fr( + ee, + /*outermostLabeledStatement*/ + void 0 + ); + case 245: + return ue(ee); + case 211: + return Rs(ee); + case 300: + return Li(ee); + case 305: + return Eo(ee); + case 168: + return $c(ee); + case 210: + return vo(ee); + case 214: + return ic(ee); + case 215: + return Ef(ee); + case 218: + return M(ee, et); + case 227: + return ye(ee, et); + case 357: + return Q(ee, et); + case 15: + case 16: + case 17: + case 18: + return wa(ee); + case 11: + return ma(ee); + case 9: + return il(ee); + case 216: + return Po(ee); + case 229: + return sc(ee); + case 230: + return Jc(ee); + case 231: + return Da(ee); + case 108: + return Df( + ee, + /*isExpressionOfCall*/ + !1 + ); + case 110: + return je(ee); + case 237: + return Gl(ee); + case 175: + return no(ee); + case 178: + case 179: + return ra(ee); + case 244: + return Mt(ee); + case 254: + return be(ee); + case 223: + return me(ee); + default: + return br(ee, W, e); + } + } + function se(ee) { + const et = F( + 8064, + 64 + /* SourceFileIncludes */ + ), Ut = [], Gt = []; + i(); + const Sr = t.copyPrologue( + ee.statements, + Ut, + /*ensureUseStrict*/ + !1, + W + ); + return In(Gt, Ar(ee.statements, W, Ti, Sr)), k && Gt.push( + t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList(k) + ) + ), t.mergeLexicalEnvironment(Ut, o()), Y(Ut, ee), R( + et, + 0, + 0 + /* None */ + ), t.updateSourceFile( + ee, + ct(t.createNodeArray(Bi(Ut, Gt)), ee.statements) + ); + } + function ce(ee) { + if (P !== void 0) { + const et = P.allowedNonLabeledJumps; + P.allowedNonLabeledJumps |= 2; + const Ut = br(ee, W, e); + return P.allowedNonLabeledJumps = et, Ut; + } + return br(ee, W, e); + } + function fe(ee) { + const et = F( + 7104, + 0 + /* BlockScopeIncludes */ + ), Ut = br(ee, W, e); + return R( + et, + 0, + 0 + /* None */ + ), Ut; + } + function he(ee) { + return Cn(t.createReturnStatement(q()), ee); + } + function q() { + return t.createUniqueName( + "_this", + 48 + /* FileLevel */ + ); + } + function be(ee) { + return P ? (P.nonLocalJumps |= 8, B(ee) && (ee = he(ee)), t.createReturnStatement( + t.createObjectLiteralExpression( + [ + t.createPropertyAssignment( + t.createIdentifier("value"), + ee.expression ? E.checkDefined(Qe(ee.expression, W, ut)) : t.createVoidZero() + ) + ] + ) + )) : B(ee) ? he(ee) : br(ee, W, e); + } + function je(ee) { + return T |= 65536, T & 2 && !(T & 16384) && (T |= 131072), P ? T & 2 ? (P.containsLexicalThis = !0, ee) : P.thisName || (P.thisName = t.createUniqueName("this")) : ee; + } + function me(ee) { + return br(ee, _e, e); + } + function Z(ee) { + return P && u.isArgumentsLocalBinding(ee) ? P.argumentsName || (P.argumentsName = t.createUniqueName("arguments")) : ee.flags & 256 ? Cn( + ct( + t.createIdentifier(Si(ee.escapedText)), + ee + ), + ee + ) : ee; + } + function pe(ee) { + if (P) { + const et = ee.kind === 253 ? 2 : 4; + if (!(ee.label && P.labels && P.labels.get(An(ee.label)) || !ee.label && P.allowedNonLabeledJumps & et)) { + let Gt; + const Sr = ee.label; + Sr ? ee.kind === 253 ? (Gt = `break-${Sr.escapedText}`, tt( + P, + /*isBreak*/ + !0, + An(Sr), + Gt + )) : (Gt = `continue-${Sr.escapedText}`, tt( + P, + /*isBreak*/ + !1, + An(Sr), + Gt + )) : ee.kind === 253 ? (P.nonLocalJumps |= 2, Gt = "break") : (P.nonLocalJumps |= 4, Gt = "continue"); + let zr = t.createStringLiteral(Gt); + if (P.loopOutParameters.length) { + const jn = P.loopOutParameters; + let ni; + for (let wi = 0; wi < jn.length; wi++) { + const L = Hl( + jn[wi], + 1 + /* ToOutParameter */ + ); + wi === 0 ? ni = L : ni = t.createBinaryExpression(ni, 28, L); + } + zr = t.createBinaryExpression(ni, 28, zr); + } + return t.createReturnStatement(zr); + } + } + return br(ee, W, e); + } + function Te(ee) { + const et = t.createVariableDeclaration( + t.getLocalName( + ee, + /*allowComments*/ + !0 + ), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + Ye(ee) + ); + Cn(et, ee); + const Ut = [], Gt = t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList([et]) + ); + if (Cn(Gt, ee), ct(Gt, ee), Au(Gt), Ut.push(Gt), Gn( + ee, + 32 + /* Export */ + )) { + const Sr = Gn( + ee, + 2048 + /* Default */ + ) ? t.createExportDefault(t.getLocalName(ee)) : t.createExternalModuleExport(t.getLocalName(ee)); + Cn(Sr, Gt), Ut.push(Sr); + } + return Wm(Ut); + } + function Fe(ee) { + return Ye(ee); + } + function Ye(ee) { + ee.name && pf(); + const et = Lb(ee), Ut = t.createFunctionExpression( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + et ? [t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + vc() + )] : [], + /*type*/ + void 0, + ne(ee, et) + ); + un( + Ut, + Ea(ee) & 131072 | 1048576 + /* ReuseTempVariableScope */ + ); + const Gt = t.createPartiallyEmittedExpression(Ut); + o6(Gt, ee.end), un( + Gt, + 3072 + /* NoComments */ + ); + const Sr = t.createPartiallyEmittedExpression(Gt); + o6(Sr, oa(S, ee.pos)), un( + Sr, + 3072 + /* NoComments */ + ); + const zr = t.createParenthesizedExpression( + t.createCallExpression( + Sr, + /*typeArguments*/ + void 0, + et ? [E.checkDefined(Qe(et.expression, W, ut))] : [] + ) + ); + return Uy(zr, 3, "* @class "), zr; + } + function ne(ee, et) { + const Ut = [], Gt = t.getInternalName(ee), Sr = BB(Gt) ? t.getGeneratedNameForNode(Gt) : Gt; + i(), Se(Ut, ee, et), ie(Ut, ee, Sr, et), Ke(Ut, ee); + const zr = _J( + oa(S, ee.members.end), + 20 + /* CloseBraceToken */ + ), jn = t.createPartiallyEmittedExpression(Sr); + o6(jn, zr.end), un( + jn, + 3072 + /* NoComments */ + ); + const ni = t.createReturnStatement(jn); + h4(ni, zr.pos), un( + ni, + 3840 + /* NoTokenSourceMaps */ + ), Ut.push(ni), Ig(Ut, o()); + const wi = t.createBlock( + ct( + t.createNodeArray(Ut), + /*location*/ + ee.members + ), + /*multiLine*/ + !0 + ); + return un( + wi, + 3072 + /* NoComments */ + ), wi; + } + function Se(ee, et, Ut) { + Ut && ee.push( + ct( + t.createExpressionStatement( + n().createExtendsHelper(t.getInternalName(et)) + ), + /*location*/ + Ut + ) + ); + } + function ie(ee, et, Ut, Gt) { + const Sr = P; + P = void 0; + const zr = F( + 32662, + 73 + /* ConstructorIncludes */ + ), jn = Mg(et), ni = Nm(jn, Gt !== void 0), wi = t.createFunctionDeclaration( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + Ut, + /*typeParameters*/ + void 0, + Ne(jn, ni), + /*type*/ + void 0, + St(jn, et, Gt, ni) + ); + ct(wi, jn || et), Gt && un( + wi, + 16 + /* CapturesThis */ + ), ee.push(wi), R( + zr, + 229376, + 0 + /* None */ + ), P = Sr; + } + function Ne(ee, et) { + return _c(ee && !et ? ee.parameters : void 0, W, e) || []; + } + function Ee(ee, et) { + const Ut = []; + s(), t.mergeLexicalEnvironment(Ut, o()), et && Ut.push(t.createReturnStatement(Ds())); + const Gt = t.createNodeArray(Ut); + ct(Gt, ee.members); + const Sr = t.createBlock( + Gt, + /*multiLine*/ + !0 + ); + return ct(Sr, ee), un( + Sr, + 3072 + /* NoComments */ + ), Sr; + } + function Ce(ee) { + return Ic(ee) && Ni(ee.declarationList.declarations, (et) => Me(et.name) && !et.initializer); + } + function Ve(ee) { + if (oS(ee)) + return !0; + if (!(ee.transformFlags & 134217728)) + return !1; + switch (ee.kind) { + // stop at function boundaries + case 220: + case 219: + case 263: + case 177: + case 176: + return !1; + // only step into computed property names for class and object literal elements + case 178: + case 179: + case 175: + case 173: { + const et = ee; + return Gs(et.name) ? !!xs(et.name, Ve) : !1; + } + } + return !!xs(ee, Ve); + } + function St(ee, et, Ut, Gt) { + const Sr = !!Ut && hc(Ut.expression).kind !== 106; + if (!ee) return Ee(et, Sr); + const zr = [], jn = []; + s(); + const ni = t.copyStandardPrologue( + ee.body.statements, + zr, + /*statementOffset*/ + 0 + ); + (Gt || Ve(ee.body)) && (T |= 8192), In(jn, Ar(ee.body.statements, W, Ti, ni)); + const wi = Sr || T & 8192; + bs(zr, ee), it(zr, ee, Gt), $e(zr, ee), wi ? Ae(zr, ee, ki()) : Y(zr, ee), t.mergeLexicalEnvironment(zr, o()), wi && !Un(ee.body) && jn.push(t.createReturnStatement(q())); + const L = t.createBlock( + ct( + t.createNodeArray( + [ + ...zr, + ...jn + ] + ), + /*location*/ + ee.body.statements + ), + /*multiLine*/ + !0 + ); + return ct(L, ee.body), Jn(L, ee.body, Gt); + } + function Bt(ee) { + return Bo(ee) && An(ee) === "_this"; + } + function tr(ee) { + return Bo(ee) && An(ee) === "_super"; + } + function Nr(ee) { + return Ic(ee) && ee.declarationList.declarations.length === 1 && st(ee.declarationList.declarations[0]); + } + function st(ee) { + return ei(ee) && Bt(ee.name) && !!ee.initializer; + } + function Wt(ee) { + return Nl( + ee, + /*excludeCompoundAssignment*/ + !0 + ) && Bt(ee.left); + } + function Jr(ee) { + return Ps(ee) && wn(ee.expression) && tr(ee.expression.expression) && Me(ee.expression.name) && (An(ee.expression.name) === "call" || An(ee.expression.name) === "apply") && ee.arguments.length >= 1 && ee.arguments[0].kind === 110; + } + function ui(ee) { + return _n(ee) && ee.operatorToken.kind === 57 && ee.right.kind === 110 && Jr(ee.left); + } + function Ji(ee) { + return _n(ee) && ee.operatorToken.kind === 56 && _n(ee.left) && ee.left.operatorToken.kind === 38 && tr(ee.left.left) && ee.left.right.kind === 106 && Jr(ee.right) && An(ee.right.expression.name) === "apply"; + } + function Dt(ee) { + return _n(ee) && ee.operatorToken.kind === 57 && ee.right.kind === 110 && Ji(ee.left); + } + function Mn(ee) { + return Wt(ee) && ui(ee.right); + } + function ai(ee) { + return Wt(ee) && Dt(ee.right); + } + function fi(ee) { + return Jr(ee) || ui(ee) || Mn(ee) || Ji(ee) || Dt(ee) || ai(ee); + } + function pn(ee) { + for (let et = 0; et < ee.statements.length - 1; et++) { + const Ut = ee.statements[et]; + if (!Nr(Ut)) + continue; + const Gt = Ut.declarationList.declarations[0]; + if (Gt.initializer.kind !== 110) + continue; + const Sr = et; + let zr = et + 1; + for (; zr < ee.statements.length; ) { + const Tr = ee.statements[zr]; + if (Al(Tr) && fi(hc(Tr.expression))) + break; + if (Ce(Tr)) { + zr++; + continue; + } + return ee; + } + const jn = ee.statements[zr]; + let ni = jn.expression; + Wt(ni) && (ni = ni.right); + const wi = t.updateVariableDeclaration( + Gt, + Gt.name, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + ni + ), L = t.updateVariableDeclarationList(Ut.declarationList, [wi]), Oe = t.createVariableStatement(Ut.modifiers, L); + Cn(Oe, jn), ct(Oe, jn); + const xt = t.createNodeArray([ + ...ee.statements.slice(0, Sr), + // copy statements preceding to `var _this` + ...ee.statements.slice(Sr + 1, zr), + // copy intervening temp variables + Oe, + ...ee.statements.slice(zr + 1) + // copy statements following `super.call(this, ...)` + ]); + return ct(xt, ee.statements), t.updateBlock(ee, xt); + } + return ee; + } + function _i(ee, et) { + for (const Gt of et.statements) + if (Gt.transformFlags & 134217728 && !xO(Gt)) + return ee; + const Ut = !(et.transformFlags & 16384) && !(T & 65536) && !(T & 131072); + for (let Gt = ee.statements.length - 1; Gt > 0; Gt--) { + const Sr = ee.statements[Gt]; + if (Cf(Sr) && Sr.expression && Bt(Sr.expression)) { + const zr = ee.statements[Gt - 1]; + let jn; + if (Al(zr) && Mn(hc(zr.expression))) + jn = zr.expression; + else if (Ut && Nr(zr)) { + const L = zr.declarationList.declarations[0]; + fi(hc(L.initializer)) && (jn = t.createAssignment( + q(), + L.initializer + )); + } + if (!jn) + break; + const ni = t.createReturnStatement(jn); + Cn(ni, zr), ct(ni, zr); + const wi = t.createNodeArray([ + ...ee.statements.slice(0, Gt - 1), + // copy all statements preceding `_super.call(this, ...)` + ni, + ...ee.statements.slice(Gt + 1) + // copy all statements following `return _this;` + ]); + return ct(wi, ee.statements), t.updateBlock(ee, wi); + } + } + return ee; + } + function Je(ee) { + if (Nr(ee)) { + if (ee.declarationList.declarations[0].initializer.kind === 110) + return; + } else if (Wt(ee)) + return t.createPartiallyEmittedExpression(ee.right, ee); + switch (ee.kind) { + // stop at function boundaries + case 220: + case 219: + case 263: + case 177: + case 176: + return ee; + // only step into computed property names for class and object literal elements + case 178: + case 179: + case 175: + case 173: { + const et = ee; + return Gs(et.name) ? t.replacePropertyName(et, br( + et.name, + Je, + /*context*/ + void 0 + )) : ee; + } + } + return br( + ee, + Je, + /*context*/ + void 0 + ); + } + function ft(ee, et) { + if (et.transformFlags & 16384 || T & 65536 || T & 131072) + return ee; + for (const Ut of et.statements) + if (Ut.transformFlags & 134217728 && !xO(Ut)) + return ee; + return t.updateBlock(ee, Ar(ee.statements, Je, Ti)); + } + function er(ee) { + if (Jr(ee) && ee.arguments.length === 2 && Me(ee.arguments[1]) && An(ee.arguments[1]) === "arguments") + return t.createLogicalAnd( + t.createStrictInequality( + vc(), + t.createNull() + ), + ee + ); + switch (ee.kind) { + // stop at function boundaries + case 220: + case 219: + case 263: + case 177: + case 176: + return ee; + // only step into computed property names for class and object literal elements + case 178: + case 179: + case 175: + case 173: { + const et = ee; + return Gs(et.name) ? t.replacePropertyName(et, br( + et.name, + er, + /*context*/ + void 0 + )) : ee; + } + } + return br( + ee, + er, + /*context*/ + void 0 + ); + } + function qr(ee) { + return t.updateBlock(ee, Ar(ee.statements, er, Ti)); + } + function Jn(ee, et, Ut) { + const Gt = ee; + return ee = pn(ee), ee = _i(ee, et), ee !== Gt && (ee = ft(ee, et)), Ut && (ee = qr(ee)), ee; + } + function Un(ee) { + if (ee.kind === 254) + return !0; + if (ee.kind === 246) { + const et = ee; + if (et.elseStatement) + return Un(et.thenStatement) && Un(et.elseStatement); + } else if (ee.kind === 242) { + const et = Do(ee.statements); + if (et && Un(et)) + return !0; + } + return !1; + } + function ki() { + return un( + t.createThis(), + 8 + /* NoSubstitution */ + ); + } + function Ds() { + return t.createLogicalOr( + t.createLogicalAnd( + t.createStrictInequality( + vc(), + t.createNull() + ), + t.createFunctionApplyCall( + vc(), + ki(), + t.createIdentifier("arguments") + ) + ), + ki() + ); + } + function Ks(ee) { + if (!ee.dotDotDotToken) + return ws(ee.name) ? Cn( + ct( + t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + t.getGeneratedNameForNode(ee), + /*questionToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + ), + /*location*/ + ee + ), + /*original*/ + ee + ) : ee.initializer ? Cn( + ct( + t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + ee.name, + /*questionToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + ), + /*location*/ + ee + ), + /*original*/ + ee + ) : ee; + } + function yr(ee) { + return ee.initializer !== void 0 || ws(ee.name); + } + function bs(ee, et) { + if (!ot(et.parameters, yr)) + return !1; + let Ut = !1; + for (const Gt of et.parameters) { + const { name: Sr, initializer: zr, dotDotDotToken: jn } = Gt; + jn || (ws(Sr) ? Ut = Xe(ee, Gt, Sr, zr) || Ut : zr && (Et(ee, Gt, Sr, zr), Ut = !0)); + } + return Ut; + } + function Xe(ee, et, Ut, Gt) { + return Ut.elements.length > 0 ? (sS( + ee, + un( + t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList( + n2( + et, + W, + e, + 0, + t.getGeneratedNameForNode(et) + ) + ) + ), + 2097152 + /* CustomPrologue */ + ) + ), !0) : Gt ? (sS( + ee, + un( + t.createExpressionStatement( + t.createAssignment( + t.getGeneratedNameForNode(et), + E.checkDefined(Qe(Gt, W, ut)) + ) + ), + 2097152 + /* CustomPrologue */ + ) + ), !0) : !1; + } + function Et(ee, et, Ut, Gt) { + Gt = E.checkDefined(Qe(Gt, W, ut)); + const Sr = t.createIfStatement( + t.createTypeCheck(t.cloneNode(Ut), "undefined"), + un( + ct( + t.createBlock([ + t.createExpressionStatement( + un( + ct( + t.createAssignment( + // TODO(rbuckton): Does this need to be parented? + un( + za(ct(t.cloneNode(Ut), Ut), Ut.parent), + 96 + /* NoSourceMap */ + ), + un( + Gt, + 96 | Ea(Gt) | 3072 + /* NoComments */ + ) + ), + et + ), + 3072 + /* NoComments */ + ) + ) + ]), + et + ), + 3905 + /* NoComments */ + ) + ); + Au(Sr), ct(Sr, et), un( + Sr, + 2101056 + /* NoComments */ + ), sS(ee, Sr); + } + function re(ee, et) { + return !!(ee && ee.dotDotDotToken && !et); + } + function it(ee, et, Ut) { + const Gt = [], Sr = Do(et.parameters); + if (!re(Sr, Ut)) + return !1; + const zr = Sr.name.kind === 80 ? za(ct(t.cloneNode(Sr.name), Sr.name), Sr.name.parent) : t.createTempVariable( + /*recordTempVariable*/ + void 0 + ); + un( + zr, + 96 + /* NoSourceMap */ + ); + const jn = Sr.name.kind === 80 ? t.cloneNode(Sr.name) : zr, ni = et.parameters.length - 1, wi = t.createLoopVariable(); + Gt.push( + un( + ct( + t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList([ + t.createVariableDeclaration( + zr, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createArrayLiteralExpression([]) + ) + ]) + ), + /*location*/ + Sr + ), + 2097152 + /* CustomPrologue */ + ) + ); + const L = t.createForStatement( + ct( + t.createVariableDeclarationList([ + t.createVariableDeclaration( + wi, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createNumericLiteral(ni) + ) + ]), + Sr + ), + ct( + t.createLessThan( + wi, + t.createPropertyAccessExpression(t.createIdentifier("arguments"), "length") + ), + Sr + ), + ct(t.createPostfixIncrement(wi), Sr), + t.createBlock([ + Au( + ct( + t.createExpressionStatement( + t.createAssignment( + t.createElementAccessExpression( + jn, + ni === 0 ? wi : t.createSubtract(wi, t.createNumericLiteral(ni)) + ), + t.createElementAccessExpression(t.createIdentifier("arguments"), wi) + ) + ), + /*location*/ + Sr + ) + ) + ]) + ); + return un( + L, + 2097152 + /* CustomPrologue */ + ), Au(L), Gt.push(L), Sr.name.kind !== 80 && Gt.push( + un( + ct( + t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList( + n2(Sr, W, e, 0, jn) + ) + ), + Sr + ), + 2097152 + /* CustomPrologue */ + ) + ), iB(ee, Gt), !0; + } + function Y(ee, et) { + return T & 131072 && et.kind !== 220 ? (Ae(ee, et, t.createThis()), !0) : !1; + } + function Ae(ee, et, Ut) { + Qu(); + const Gt = t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList([ + t.createVariableDeclaration( + q(), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + Ut + ) + ]) + ); + un( + Gt, + 2100224 + /* CustomPrologue */ + ), ha(Gt, et), sS(ee, Gt); + } + function $e(ee, et) { + if (T & 32768) { + let Ut; + switch (et.kind) { + case 220: + return ee; + case 175: + case 178: + case 179: + Ut = t.createVoidZero(); + break; + case 177: + Ut = t.createPropertyAccessExpression( + un( + t.createThis(), + 8 + /* NoSubstitution */ + ), + "constructor" + ); + break; + case 263: + case 219: + Ut = t.createConditionalExpression( + t.createLogicalAnd( + un( + t.createThis(), + 8 + /* NoSubstitution */ + ), + t.createBinaryExpression( + un( + t.createThis(), + 8 + /* NoSubstitution */ + ), + 104, + t.getLocalName(et) + ) + ), + /*questionToken*/ + void 0, + t.createPropertyAccessExpression( + un( + t.createThis(), + 8 + /* NoSubstitution */ + ), + "constructor" + ), + /*colonToken*/ + void 0, + t.createVoidZero() + ); + break; + default: + return E.failBadSyntaxKind(et); + } + const Gt = t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList([ + t.createVariableDeclaration( + t.createUniqueName( + "_newTarget", + 48 + /* FileLevel */ + ), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + Ut + ) + ]) + ); + un( + Gt, + 2100224 + /* CustomPrologue */ + ), sS(ee, Gt); + } + return ee; + } + function Ke(ee, et) { + for (const Ut of et.members) + switch (Ut.kind) { + case 241: + ee.push(Tt(Ut)); + break; + case 175: + ee.push(Le(Wf(et, Ut), Ut, et)); + break; + case 178: + case 179: + const Gt = Bb(et.members, Ut); + Ut === Gt.firstAccessor && ee.push(mt(Wf(et, Ut), Gt, et)); + break; + case 177: + case 176: + break; + default: + E.failBadSyntaxKind(Ut, h && h.fileName); + break; + } + } + function Tt(ee) { + return ct(t.createEmptyStatement(), ee); + } + function Le(ee, et, Ut) { + const Gt = hm(et), Sr = x0(et), zr = rn( + et, + /*location*/ + et, + /*name*/ + void 0, + Ut + ), jn = Qe(et.name, W, qc); + E.assert(jn); + let ni; + if (!Ai(jn) && gN(e.getCompilerOptions())) { + const L = Gs(jn) ? jn.expression : Me(jn) ? t.createStringLiteral(Si(jn.escapedText)) : jn; + ni = t.createObjectDefinePropertyCall(ee, L, t.createPropertyDescriptor({ value: zr, enumerable: !1, writable: !0, configurable: !0 })); + } else { + const L = FS( + t, + ee, + jn, + /*location*/ + et.name + ); + ni = t.createAssignment(L, zr); + } + un( + zr, + 3072 + /* NoComments */ + ), ha(zr, Sr); + const wi = ct( + t.createExpressionStatement(ni), + /*location*/ + et + ); + return Cn(wi, et), el(wi, Gt), un( + wi, + 96 + /* NoSourceMap */ + ), wi; + } + function mt(ee, et, Ut) { + const Gt = t.createExpressionStatement(pt( + ee, + et, + Ut, + /*startsOnNewLine*/ + !1 + )); + return un( + Gt, + 3072 + /* NoComments */ + ), ha(Gt, x0(et.firstAccessor)), Gt; + } + function pt(ee, { firstAccessor: et, getAccessor: Ut, setAccessor: Gt }, Sr, zr) { + const jn = za(ct(t.cloneNode(ee), ee), ee.parent); + un( + jn, + 3136 + /* NoTrailingSourceMap */ + ), ha(jn, et.name); + const ni = Qe(et.name, W, qc); + if (E.assert(ni), Ai(ni)) + return E.failBadSyntaxKind(ni, "Encountered unhandled private identifier while transforming ES2015."); + const wi = Iz(t, ni); + un( + wi, + 3104 + /* NoLeadingSourceMap */ + ), ha(wi, et.name); + const L = []; + if (Ut) { + const xt = rn( + Ut, + /*location*/ + void 0, + /*name*/ + void 0, + Sr + ); + ha(xt, x0(Ut)), un( + xt, + 1024 + /* NoLeadingComments */ + ); + const Tr = t.createPropertyAssignment("get", xt); + el(Tr, hm(Ut)), L.push(Tr); + } + if (Gt) { + const xt = rn( + Gt, + /*location*/ + void 0, + /*name*/ + void 0, + Sr + ); + ha(xt, x0(Gt)), un( + xt, + 1024 + /* NoLeadingComments */ + ); + const Tr = t.createPropertyAssignment("set", xt); + el(Tr, hm(Gt)), L.push(Tr); + } + L.push( + t.createPropertyAssignment("enumerable", Ut || Gt ? t.createFalse() : t.createTrue()), + t.createPropertyAssignment("configurable", t.createTrue()) + ); + const Oe = t.createCallExpression( + t.createPropertyAccessExpression(t.createIdentifier("Object"), "defineProperty"), + /*typeArguments*/ + void 0, + [ + jn, + wi, + t.createObjectLiteralExpression( + L, + /*multiLine*/ + !0 + ) + ] + ); + return zr && Au(Oe), Oe; + } + function Ct(ee) { + ee.transformFlags & 16384 && !(T & 16384) && (T |= 131072); + const et = P; + P = void 0; + const Ut = F( + 15232, + 66 + /* ArrowFunctionIncludes */ + ), Gt = t.createFunctionExpression( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + _c(ee.parameters, W, e), + /*type*/ + void 0, + Pe(ee) + ); + return ct(Gt, ee), Cn(Gt, ee), un( + Gt, + 16 + /* CapturesThis */ + ), R( + Ut, + 0, + 0 + /* None */ + ), P = et, Gt; + } + function qe(ee) { + const et = Ea(ee) & 524288 ? F( + 32662, + 69 + /* AsyncFunctionBodyIncludes */ + ) : F( + 32670, + 65 + /* FunctionIncludes */ + ), Ut = P; + P = void 0; + const Gt = _c(ee.parameters, W, e), Sr = Pe(ee), zr = T & 32768 ? t.getLocalName(ee) : ee.name; + return R( + et, + 229376, + 0 + /* None */ + ), P = Ut, t.updateFunctionExpression( + ee, + /*modifiers*/ + void 0, + ee.asteriskToken, + zr, + /*typeParameters*/ + void 0, + Gt, + /*type*/ + void 0, + Sr + ); + } + function Lt(ee) { + const et = P; + P = void 0; + const Ut = F( + 32670, + 65 + /* FunctionIncludes */ + ), Gt = _c(ee.parameters, W, e), Sr = Pe(ee), zr = T & 32768 ? t.getLocalName(ee) : ee.name; + return R( + Ut, + 229376, + 0 + /* None */ + ), P = et, t.updateFunctionDeclaration( + ee, + Ar(ee.modifiers, W, Zs), + ee.asteriskToken, + zr, + /*typeParameters*/ + void 0, + Gt, + /*type*/ + void 0, + Sr + ); + } + function rn(ee, et, Ut, Gt) { + const Sr = P; + P = void 0; + const zr = Gt && $n(Gt) && !Js(ee) ? F( + 32670, + 73 + /* NonStaticClassElement */ + ) : F( + 32670, + 65 + /* FunctionIncludes */ + ), jn = _c(ee.parameters, W, e), ni = Pe(ee); + return T & 32768 && !Ut && (ee.kind === 263 || ee.kind === 219) && (Ut = t.getGeneratedNameForNode(ee)), R( + zr, + 229376, + 0 + /* None */ + ), P = Sr, Cn( + ct( + t.createFunctionExpression( + /*modifiers*/ + void 0, + ee.asteriskToken, + Ut, + /*typeParameters*/ + void 0, + jn, + /*type*/ + void 0, + ni + ), + et + ), + /*original*/ + ee + ); + } + function Pe(ee) { + let et = !1, Ut = !1, Gt, Sr; + const zr = [], jn = [], ni = ee.body; + let wi; + if (s(), Ns(ni) && (wi = t.copyStandardPrologue( + ni.statements, + zr, + 0, + /*ensureUseStrict*/ + !1 + ), wi = t.copyCustomPrologue(ni.statements, jn, wi, W, Q7), wi = t.copyCustomPrologue(ni.statements, jn, wi, W, Y7)), et = bs(jn, ee) || et, et = it( + jn, + ee, + /*inConstructorWithSynthesizedSuper*/ + !1 + ) || et, Ns(ni)) + wi = t.copyCustomPrologue(ni.statements, jn, wi, W), Gt = ni.statements, In(jn, Ar(ni.statements, W, Ti, wi)), !et && ni.multiLine && (et = !0); + else { + E.assert( + ee.kind === 220 + /* ArrowFunction */ + ), Gt = L5(ni, -1); + const Oe = ee.equalsGreaterThanToken; + !lo(Oe) && !lo(ni) && (uN(Oe, ni, h) ? Ut = !0 : et = !0); + const xt = Qe(ni, W, ut), Tr = t.createReturnStatement(xt); + ct(Tr, ni), hte(Tr, ni), un( + Tr, + 2880 + /* NoTrailingComments */ + ), jn.push(Tr), Sr = ni; + } + if (t.mergeLexicalEnvironment(zr, o()), $e(zr, ee), Y(zr, ee), ot(zr) && (et = !0), jn.unshift(...zr), Ns(ni) && Tf(jn, ni.statements)) + return ni; + const L = t.createBlock(ct(t.createNodeArray(jn), Gt), et); + return ct(L, ee.body), !et && Ut && un( + L, + 1 + /* SingleLine */ + ), Sr && gte(L, 20, Sr), Cn(L, ee.body), L; + } + function yt(ee, et) { + const Ut = T & 256 ? F( + 7104, + 512 + /* IterationStatementBlockIncludes */ + ) : F( + 6976, + 128 + /* BlockIncludes */ + ), Gt = br(ee, W, e); + return R( + Ut, + 0, + 0 + /* None */ + ), Gt; + } + function ue(ee) { + return br(ee, _e, e); + } + function M(ee, et) { + return br(ee, et ? _e : W, e); + } + function ye(ee, et) { + return y0(ee) ? BS( + ee, + W, + e, + 0, + !et + ) : ee.operatorToken.kind === 28 ? t.updateBinaryExpression( + ee, + E.checkDefined(Qe(ee.left, _e, ut)), + ee.operatorToken, + E.checkDefined(Qe(ee.right, et ? _e : W, ut)) + ) : br(ee, W, e); + } + function Q(ee, et) { + if (et) + return br(ee, _e, e); + let Ut; + for (let Sr = 0; Sr < ee.elements.length; Sr++) { + const zr = ee.elements[Sr], jn = Qe(zr, Sr < ee.elements.length - 1 ? _e : W, ut); + (Ut || jn !== zr) && (Ut || (Ut = ee.elements.slice(0, Sr)), E.assert(jn), Ut.push(jn)); + } + const Gt = Ut ? ct(t.createNodeArray(Ut), ee.elements) : ee.elements; + return t.updateCommaListExpression(ee, Gt); + } + function dt(ee) { + return ee.declarationList.declarations.length === 1 && !!ee.declarationList.declarations[0].initializer && !!(sd(ee.declarationList.declarations[0].initializer) & 1); + } + function Mt(ee) { + const et = F( + 0, + Gn( + ee, + 32 + /* Export */ + ) ? 32 : 0 + /* None */ + ); + let Ut; + if (P && (ee.declarationList.flags & 7) === 0 && !dt(ee)) { + let Gt; + for (const Sr of ee.declarationList.declarations) + if (Gc(P, Sr), Sr.initializer) { + let zr; + ws(Sr.name) ? zr = BS( + Sr, + W, + e, + 0 + /* All */ + ) : (zr = t.createBinaryExpression(Sr.name, 64, E.checkDefined(Qe(Sr.initializer, W, ut))), ct(zr, Sr)), Gt = Er(Gt, zr); + } + Gt ? Ut = ct(t.createExpressionStatement(t.inlineExpressions(Gt)), ee) : Ut = void 0; + } else + Ut = br(ee, W, e); + return R( + et, + 0, + 0 + /* None */ + ), Ut; + } + function ke(ee) { + if (ee.flags & 7 || ee.transformFlags & 524288) { + ee.flags & 7 && pf(); + const et = Ar( + ee.declarations, + ee.flags & 1 ? Zr : Rr, + ei + ), Ut = t.createVariableDeclarationList(et); + return Cn(Ut, ee), ct(Ut, ee), el(Ut, ee), ee.transformFlags & 524288 && (ws(ee.declarations[0].name) || ws(pa(ee.declarations).name)) && ha(Ut, at(et)), Ut; + } + return br(ee, W, e); + } + function at(ee) { + let et = -1, Ut = -1; + for (const Gt of ee) + et = et === -1 ? Gt.pos : Gt.pos === -1 ? et : Math.min(et, Gt.pos), Ut = Math.max(Ut, Gt.end); + return cp(et, Ut); + } + function wt(ee) { + const et = u.hasNodeCheckFlag( + ee, + 16384 + /* CapturedBlockScopedBinding */ + ), Ut = u.hasNodeCheckFlag( + ee, + 32768 + /* BlockScopedBindingInLoop */ + ); + return !((T & 64) !== 0 || et && Ut && (T & 512) !== 0) && (T & 4096) === 0 && (!u.isDeclarationWithCollidingName(ee) || Ut && !et && (T & 6144) === 0); + } + function Zr(ee) { + const et = ee.name; + return ws(et) ? Rr(ee) : !ee.initializer && wt(ee) ? t.updateVariableDeclaration( + ee, + ee.name, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createVoidZero() + ) : br(ee, W, e); + } + function Rr(ee) { + const et = F( + 32, + 0 + /* None */ + ); + let Ut; + return ws(ee.name) ? Ut = n2( + ee, + W, + e, + 0, + /*rval*/ + void 0, + (et & 32) !== 0 + ) : Ut = br(ee, W, e), R( + et, + 0, + 0 + /* None */ + ), Ut; + } + function Pr(ee) { + P.labels.set(An(ee.label), !0); + } + function rt(ee) { + P.labels.set(An(ee.label), !1); + } + function vt(ee) { + P && !P.labels && (P.labels = /* @__PURE__ */ new Map()); + const et = TB(ee, P && Pr); + return wy( + et, + /*lookInLabeledStatements*/ + !1 + ) ? Nt( + et, + /*outermostLabeledStatement*/ + ee + ) : t.restoreEnclosingLabel(Qe(et, W, Ti, t.liftToBlock) ?? ct(t.createEmptyStatement(), et), ee, P && rt); + } + function Nt(ee, et) { + switch (ee.kind) { + case 247: + case 248: + return _r(ee, et); + case 249: + return nr(ee, et); + case 250: + return cr(ee, et); + case 251: + return fr(ee, et); + } + } + function Jt(ee, et, Ut, Gt, Sr) { + const zr = F(ee, et), jn = Co(Ut, Gt, zr, Sr); + return R( + zr, + 0, + 0 + /* None */ + ), jn; + } + function _r(ee, et) { + return Jt( + 0, + 1280, + ee, + et + ); + } + function nr(ee, et) { + return Jt( + 5056, + 3328, + ee, + et + ); + } + function kt(ee) { + return t.updateForStatement( + ee, + Qe(ee.initializer, _e, ip), + Qe(ee.condition, W, ut), + Qe(ee.incrementor, _e, ut), + E.checkDefined(Qe(ee.statement, W, Ti, t.liftToBlock)) + ); + } + function cr(ee, et) { + return Jt( + 3008, + 5376, + ee, + et + ); + } + function fr(ee, et) { + return Jt( + 3008, + 5376, + ee, + et, + _.downlevelIteration ? Fs : oi + ); + } + function vr(ee, et, Ut) { + const Gt = [], Sr = ee.initializer; + if (Ul(Sr)) { + ee.initializer.flags & 7 && pf(); + const zr = Yc(Sr.declarations); + if (zr && ws(zr.name)) { + const jn = n2( + zr, + W, + e, + 0, + et + ), ni = ct(t.createVariableDeclarationList(jn), ee.initializer); + Cn(ni, ee.initializer), ha(ni, cp(jn[0].pos, pa(jn).end)), Gt.push( + t.createVariableStatement( + /*modifiers*/ + void 0, + ni + ) + ); + } else + Gt.push( + ct( + t.createVariableStatement( + /*modifiers*/ + void 0, + Cn( + ct( + t.createVariableDeclarationList([ + t.createVariableDeclaration( + zr ? zr.name : t.createTempVariable( + /*recordTempVariable*/ + void 0 + ), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + et + ) + ]), + Z1(Sr, -1) + ), + Sr + ) + ), + L5(Sr, -1) + ) + ); + } else { + const zr = t.createAssignment(Sr, et); + y0(zr) ? Gt.push(t.createExpressionStatement(ye( + zr, + /*expressionResultIsUnused*/ + !0 + ))) : (o6(zr, Sr.end), Gt.push(ct(t.createExpressionStatement(E.checkDefined(Qe(zr, W, ut))), L5(Sr, -1)))); + } + if (Ut) + return Xt(In(Gt, Ut)); + { + const zr = Qe(ee.statement, W, Ti, t.liftToBlock); + return E.assert(zr), Ns(zr) ? t.updateBlock(zr, ct(t.createNodeArray(Bi(Gt, zr.statements)), zr.statements)) : (Gt.push(zr), Xt(Gt)); + } + } + function Xt(ee) { + return un( + t.createBlock( + t.createNodeArray(ee), + /*multiLine*/ + !0 + ), + 864 + /* NoTokenSourceMaps */ + ); + } + function oi(ee, et, Ut) { + const Gt = Qe(ee.expression, W, ut); + E.assert(Gt); + const Sr = t.createLoopVariable(), zr = Me(Gt) ? t.getGeneratedNameForNode(Gt) : t.createTempVariable( + /*recordTempVariable*/ + void 0 + ); + un(Gt, 96 | Ea(Gt)); + const jn = ct( + t.createForStatement( + /*initializer*/ + un( + ct( + t.createVariableDeclarationList([ + ct(t.createVariableDeclaration( + Sr, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createNumericLiteral(0) + ), Z1(ee.expression, -1)), + ct(t.createVariableDeclaration( + zr, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + Gt + ), ee.expression) + ]), + ee.expression + ), + 4194304 + /* NoHoisting */ + ), + /*condition*/ + ct( + t.createLessThan( + Sr, + t.createPropertyAccessExpression(zr, "length") + ), + ee.expression + ), + /*incrementor*/ + ct(t.createPostfixIncrement(Sr), ee.expression), + /*statement*/ + vr( + ee, + t.createElementAccessExpression(zr, Sr), + Ut + ) + ), + /*location*/ + ee + ); + return un( + jn, + 512 + /* NoTokenTrailingSourceMaps */ + ), ct(jn, ee), t.restoreEnclosingLabel(jn, et, P && rt); + } + function Fs(ee, et, Ut, Gt) { + const Sr = Qe(ee.expression, W, ut); + E.assert(Sr); + const zr = Me(Sr) ? t.getGeneratedNameForNode(Sr) : t.createTempVariable( + /*recordTempVariable*/ + void 0 + ), jn = Me(Sr) ? t.getGeneratedNameForNode(zr) : t.createTempVariable( + /*recordTempVariable*/ + void 0 + ), ni = t.createUniqueName("e"), wi = t.getGeneratedNameForNode(ni), L = t.createTempVariable( + /*recordTempVariable*/ + void 0 + ), Oe = ct(n().createValuesHelper(Sr), ee.expression), xt = t.createCallExpression( + t.createPropertyAccessExpression(zr, "next"), + /*typeArguments*/ + void 0, + [] + ); + c(ni), c(L); + const Tr = Gt & 1024 ? t.inlineExpressions([t.createAssignment(ni, t.createVoidZero()), Oe]) : Oe, $i = un( + ct( + t.createForStatement( + /*initializer*/ + un( + ct( + t.createVariableDeclarationList([ + ct(t.createVariableDeclaration( + zr, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + Tr + ), ee.expression), + t.createVariableDeclaration( + jn, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + xt + ) + ]), + ee.expression + ), + 4194304 + /* NoHoisting */ + ), + /*condition*/ + t.createLogicalNot(t.createPropertyAccessExpression(jn, "done")), + /*incrementor*/ + t.createAssignment(jn, xt), + /*statement*/ + vr( + ee, + t.createPropertyAccessExpression(jn, "value"), + Ut + ) + ), + /*location*/ + ee + ), + 512 + /* NoTokenTrailingSourceMaps */ + ); + return t.createTryStatement( + t.createBlock([ + t.restoreEnclosingLabel( + $i, + et, + P && rt + ) + ]), + t.createCatchClause( + t.createVariableDeclaration(wi), + un( + t.createBlock([ + t.createExpressionStatement( + t.createAssignment( + ni, + t.createObjectLiteralExpression([ + t.createPropertyAssignment("error", wi) + ]) + ) + ) + ]), + 1 + /* SingleLine */ + ) + ), + t.createBlock([ + t.createTryStatement( + /*tryBlock*/ + t.createBlock([ + un( + t.createIfStatement( + t.createLogicalAnd( + t.createLogicalAnd( + jn, + t.createLogicalNot( + t.createPropertyAccessExpression(jn, "done") + ) + ), + t.createAssignment( + L, + t.createPropertyAccessExpression(zr, "return") + ) + ), + t.createExpressionStatement( + t.createFunctionCallCall(L, zr, []) + ) + ), + 1 + /* SingleLine */ + ) + ]), + /*catchClause*/ + void 0, + /*finallyBlock*/ + un( + t.createBlock([ + un( + t.createIfStatement( + ni, + t.createThrowStatement( + t.createPropertyAccessExpression(ni, "error") + ) + ), + 1 + /* SingleLine */ + ) + ]), + 1 + /* SingleLine */ + ) + ) + ]) + ); + } + function Rs(ee) { + const et = ee.properties; + let Ut = -1, Gt = !1; + for (let ni = 0; ni < et.length; ni++) { + const wi = et[ni]; + if (wi.transformFlags & 1048576 && T & 4 || (Gt = E.checkDefined(wi.name).kind === 168)) { + Ut = ni; + break; + } + } + if (Ut < 0) + return br(ee, W, e); + const Sr = t.createTempVariable(c), zr = [], jn = t.createAssignment( + Sr, + un( + t.createObjectLiteralExpression( + Ar(et, W, vh, 0, Ut), + ee.multiLine + ), + Gt ? 131072 : 0 + ) + ); + return ee.multiLine && Au(jn), zr.push(jn), Hr(zr, ee, Sr, Ut), zr.push(ee.multiLine ? Au(za(ct(t.cloneNode(Sr), Sr), Sr.parent)) : Sr), t.inlineExpressions(zr); + } + function ds(ee) { + return u.hasNodeCheckFlag( + ee, + 8192 + /* ContainsCapturedBlockScopeBinding */ + ); + } + function pc(ee) { + return av(ee) && !!ee.initializer && ds(ee.initializer); + } + function Zo(ee) { + return av(ee) && !!ee.condition && ds(ee.condition); + } + function so(ee) { + return av(ee) && !!ee.incrementor && ds(ee.incrementor); + } + function zi(ee) { + return hs(ee) || pc(ee); + } + function hs(ee) { + return u.hasNodeCheckFlag( + ee, + 4096 + /* LoopWithCapturedBlockScopedBinding */ + ); + } + function Gc(ee, et) { + ee.hoistedLocalVariables || (ee.hoistedLocalVariables = []), Ut(et.name); + function Ut(Gt) { + if (Gt.kind === 80) + ee.hoistedLocalVariables.push(Gt); + else + for (const Sr of Gt.elements) + vl(Sr) || Ut(Sr.name); + } + } + function Co(ee, et, Ut, Gt) { + if (!zi(ee)) { + let Oe; + P && (Oe = P.allowedNonLabeledJumps, P.allowedNonLabeledJumps = 6); + const xt = Gt ? Gt( + ee, + et, + /*convertedLoopBodyStatements*/ + void 0, + Ut + ) : t.restoreEnclosingLabel( + av(ee) ? kt(ee) : br(ee, W, e), + et, + P && rt + ); + return P && (P.allowedNonLabeledJumps = Oe), xt; + } + const Sr = va(ee), zr = [], jn = P; + P = Sr; + const ni = pc(ee) ? yc(ee, Sr) : void 0, wi = hs(ee) ? Fc(ee, Sr, jn) : void 0; + P = jn, ni && zr.push(ni.functionDeclaration), wi && zr.push(wi.functionDeclaration), zt(zr, Sr, jn), ni && zr.push(ge(ni.functionName, ni.containsYield)); + let L; + if (wi) + if (Gt) + L = Gt(ee, et, wi.part, Ut); + else { + const Oe = ta(ee, ni, t.createBlock( + wi.part, + /*multiLine*/ + !0 + )); + L = t.restoreEnclosingLabel(Oe, et, P && rt); + } + else { + const Oe = ta(ee, ni, E.checkDefined(Qe(ee.statement, W, Ti, t.liftToBlock))); + L = t.restoreEnclosingLabel(Oe, et, P && rt); + } + return zr.push(L), zr; + } + function ta(ee, et, Ut) { + switch (ee.kind) { + case 249: + return Ec(ee, et, Ut); + case 250: + return cs(ee, Ut); + case 251: + return zf(ee, Ut); + case 247: + return Ws(ee, Ut); + case 248: + return Fa(ee, Ut); + default: + return E.failBadSyntaxKind(ee, "IterationStatement expected"); + } + } + function Ec(ee, et, Ut) { + const Gt = ee.condition && ds(ee.condition), Sr = Gt || ee.incrementor && ds(ee.incrementor); + return t.updateForStatement( + ee, + Qe(et ? et.part : ee.initializer, _e, ip), + Qe(Gt ? void 0 : ee.condition, W, ut), + Qe(Sr ? void 0 : ee.incrementor, _e, ut), + Ut + ); + } + function zf(ee, et) { + return t.updateForOfStatement( + ee, + /*awaitModifier*/ + void 0, + E.checkDefined(Qe(ee.initializer, W, ip)), + E.checkDefined(Qe(ee.expression, W, ut)), + et + ); + } + function cs(ee, et) { + return t.updateForInStatement( + ee, + E.checkDefined(Qe(ee.initializer, W, ip)), + E.checkDefined(Qe(ee.expression, W, ut)), + et + ); + } + function Ws(ee, et) { + return t.updateDoStatement( + ee, + et, + E.checkDefined(Qe(ee.expression, W, ut)) + ); + } + function Fa(ee, et) { + return t.updateWhileStatement( + ee, + E.checkDefined(Qe(ee.expression, W, ut)), + et + ); + } + function va(ee) { + let et; + switch (ee.kind) { + case 249: + case 250: + case 251: + const zr = ee.initializer; + zr && zr.kind === 262 && (et = zr); + break; + } + const Ut = [], Gt = []; + if (et && yh(et) & 7) { + const zr = pc(ee) || Zo(ee) || so(ee); + for (const jn of et.declarations) + Kt(ee, jn, Ut, Gt, zr); + } + const Sr = { loopParameters: Ut, loopOutParameters: Gt }; + return P && (P.argumentsName && (Sr.argumentsName = P.argumentsName), P.thisName && (Sr.thisName = P.thisName), P.hoistedLocalVariables && (Sr.hoistedLocalVariables = P.hoistedLocalVariables)), Sr; + } + function zt(ee, et, Ut) { + let Gt; + if (et.argumentsName && (Ut ? Ut.argumentsName = et.argumentsName : (Gt || (Gt = [])).push( + t.createVariableDeclaration( + et.argumentsName, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createIdentifier("arguments") + ) + )), et.thisName && (Ut ? Ut.thisName = et.thisName : (Gt || (Gt = [])).push( + t.createVariableDeclaration( + et.thisName, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createIdentifier("this") + ) + )), et.hoistedLocalVariables) + if (Ut) + Ut.hoistedLocalVariables = et.hoistedLocalVariables; + else { + Gt || (Gt = []); + for (const Sr of et.hoistedLocalVariables) + Gt.push(t.createVariableDeclaration(Sr)); + } + if (et.loopOutParameters.length) { + Gt || (Gt = []); + for (const Sr of et.loopOutParameters) + Gt.push(t.createVariableDeclaration(Sr.outParamName)); + } + et.conditionVariable && (Gt || (Gt = []), Gt.push(t.createVariableDeclaration( + et.conditionVariable, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createFalse() + ))), Gt && ee.push(t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList(Gt) + )); + } + function Za(ee) { + return t.createVariableDeclaration( + ee.originalName, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + ee.outParamName + ); + } + function yc(ee, et) { + const Ut = t.createUniqueName("_loop_init"), Gt = (ee.initializer.transformFlags & 1048576) !== 0; + let Sr = 0; + et.containsLexicalThis && (Sr |= 16), Gt && T & 4 && (Sr |= 524288); + const zr = []; + zr.push(t.createVariableStatement( + /*modifiers*/ + void 0, + ee.initializer + )), _o(et.loopOutParameters, 2, 1, zr); + const jn = t.createVariableStatement( + /*modifiers*/ + void 0, + un( + t.createVariableDeclarationList([ + t.createVariableDeclaration( + Ut, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + un( + t.createFunctionExpression( + /*modifiers*/ + void 0, + Gt ? t.createToken( + 42 + /* AsteriskToken */ + ) : void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + /*parameters*/ + void 0, + /*type*/ + void 0, + E.checkDefined(Qe( + t.createBlock( + zr, + /*multiLine*/ + !0 + ), + W, + Ns + )) + ), + Sr + ) + ) + ]), + 4194304 + /* NoHoisting */ + ) + ), ni = t.createVariableDeclarationList(hr(et.loopOutParameters, Za)); + return { functionName: Ut, containsYield: Gt, functionDeclaration: jn, part: ni }; + } + function Fc(ee, et, Ut) { + const Gt = t.createUniqueName("_loop"); + i(); + const Sr = Qe(ee.statement, W, Ti, t.liftToBlock), zr = o(), jn = []; + (Zo(ee) || so(ee)) && (et.conditionVariable = t.createUniqueName("inc"), ee.incrementor ? jn.push(t.createIfStatement( + et.conditionVariable, + t.createExpressionStatement(E.checkDefined(Qe(ee.incrementor, W, ut))), + t.createExpressionStatement(t.createAssignment(et.conditionVariable, t.createTrue())) + )) : jn.push(t.createIfStatement( + t.createLogicalNot(et.conditionVariable), + t.createExpressionStatement(t.createAssignment(et.conditionVariable, t.createTrue())) + )), Zo(ee) && jn.push(t.createIfStatement( + t.createPrefixUnaryExpression(54, E.checkDefined(Qe(ee.condition, W, ut))), + E.checkDefined(Qe(t.createBreakStatement(), W, Ti)) + ))), E.assert(Sr), Ns(Sr) ? In(jn, Sr.statements) : jn.push(Sr), _o(et.loopOutParameters, 1, 1, jn), Ig(jn, zr); + const ni = t.createBlock( + jn, + /*multiLine*/ + !0 + ); + Ns(Sr) && Cn(ni, Sr); + const wi = (ee.statement.transformFlags & 1048576) !== 0; + let L = 1048576; + et.containsLexicalThis && (L |= 16), wi && (T & 4) !== 0 && (L |= 524288); + const Oe = t.createVariableStatement( + /*modifiers*/ + void 0, + un( + t.createVariableDeclarationList( + [ + t.createVariableDeclaration( + Gt, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + un( + t.createFunctionExpression( + /*modifiers*/ + void 0, + wi ? t.createToken( + 42 + /* AsteriskToken */ + ) : void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + et.loopParameters, + /*type*/ + void 0, + ni + ), + L + ) + ) + ] + ), + 4194304 + /* NoHoisting */ + ) + ), xt = H(Gt, et, Ut, wi); + return { functionName: Gt, containsYield: wi, functionDeclaration: Oe, part: xt }; + } + function Hl(ee, et) { + const Ut = et === 0 ? ee.outParamName : ee.originalName, Gt = et === 0 ? ee.originalName : ee.outParamName; + return t.createBinaryExpression(Gt, 64, Ut); + } + function _o(ee, et, Ut, Gt) { + for (const Sr of ee) + Sr.flags & et && Gt.push(t.createExpressionStatement(Hl(Sr, Ut))); + } + function ge(ee, et) { + const Ut = t.createCallExpression( + ee, + /*typeArguments*/ + void 0, + [] + ), Gt = et ? t.createYieldExpression( + t.createToken( + 42 + /* AsteriskToken */ + ), + un( + Ut, + 8388608 + /* Iterator */ + ) + ) : Ut; + return t.createExpressionStatement(Gt); + } + function H(ee, et, Ut, Gt) { + const Sr = [], zr = !(et.nonLocalJumps & -5) && !et.labeledNonLocalBreaks && !et.labeledNonLocalContinues, jn = t.createCallExpression( + ee, + /*typeArguments*/ + void 0, + hr(et.loopParameters, (wi) => wi.name) + ), ni = Gt ? t.createYieldExpression( + t.createToken( + 42 + /* AsteriskToken */ + ), + un( + jn, + 8388608 + /* Iterator */ + ) + ) : jn; + if (zr) + Sr.push(t.createExpressionStatement(ni)), _o(et.loopOutParameters, 1, 0, Sr); + else { + const wi = t.createUniqueName("state"), L = t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList( + [t.createVariableDeclaration( + wi, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + ni + )] + ) + ); + if (Sr.push(L), _o(et.loopOutParameters, 1, 0, Sr), et.nonLocalJumps & 8) { + let Oe; + Ut ? (Ut.nonLocalJumps |= 8, Oe = t.createReturnStatement(wi)) : Oe = t.createReturnStatement(t.createPropertyAccessExpression(wi, "value")), Sr.push( + t.createIfStatement( + t.createTypeCheck(wi, "object"), + Oe + ) + ); + } + if (et.nonLocalJumps & 2 && Sr.push( + t.createIfStatement( + t.createStrictEquality( + wi, + t.createStringLiteral("break") + ), + t.createBreakStatement() + ) + ), et.labeledNonLocalBreaks || et.labeledNonLocalContinues) { + const Oe = []; + Ft( + et.labeledNonLocalBreaks, + /*isBreak*/ + !0, + wi, + Ut, + Oe + ), Ft( + et.labeledNonLocalContinues, + /*isBreak*/ + !1, + wi, + Ut, + Oe + ), Sr.push( + t.createSwitchStatement( + wi, + t.createCaseBlock(Oe) + ) + ); + } + } + return Sr; + } + function tt(ee, et, Ut, Gt) { + et ? (ee.labeledNonLocalBreaks || (ee.labeledNonLocalBreaks = /* @__PURE__ */ new Map()), ee.labeledNonLocalBreaks.set(Ut, Gt)) : (ee.labeledNonLocalContinues || (ee.labeledNonLocalContinues = /* @__PURE__ */ new Map()), ee.labeledNonLocalContinues.set(Ut, Gt)); + } + function Ft(ee, et, Ut, Gt, Sr) { + ee && ee.forEach((zr, jn) => { + const ni = []; + if (!Gt || Gt.labels && Gt.labels.get(jn)) { + const wi = t.createIdentifier(jn); + ni.push(et ? t.createBreakStatement(wi) : t.createContinueStatement(wi)); + } else + tt(Gt, et, jn, zr), ni.push(t.createReturnStatement(Ut)); + Sr.push(t.createCaseClause(t.createStringLiteral(zr), ni)); + }); + } + function Kt(ee, et, Ut, Gt, Sr) { + const zr = et.name; + if (ws(zr)) + for (const jn of zr.elements) + vl(jn) || Kt(ee, jn, Ut, Gt, Sr); + else { + Ut.push(t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + zr + )); + const jn = u.hasNodeCheckFlag( + et, + 65536 + /* NeedsLoopOutParameter */ + ); + if (jn || Sr) { + const ni = t.createUniqueName("out_" + An(zr)); + let wi = 0; + jn && (wi |= 1), av(ee) && (ee.initializer && u.isBindingCapturedByNode(ee.initializer, et) && (wi |= 2), (ee.condition && u.isBindingCapturedByNode(ee.condition, et) || ee.incrementor && u.isBindingCapturedByNode(ee.incrementor, et)) && (wi |= 1)), Gt.push({ flags: wi, originalName: zr, outParamName: ni }); + } + } + } + function Hr(ee, et, Ut, Gt) { + const Sr = et.properties, zr = Sr.length; + for (let jn = Gt; jn < zr; jn++) { + const ni = Sr[jn]; + switch (ni.kind) { + case 178: + case 179: + const wi = Bb(et.properties, ni); + ni === wi.firstAccessor && ee.push(pt(Ut, wi, et, !!et.multiLine)); + break; + case 175: + ee.push(kr(ni, Ut, et, et.multiLine)); + break; + case 304: + ee.push(Vn(ni, Ut, et.multiLine)); + break; + case 305: + ee.push(ln(ni, Ut, et.multiLine)); + break; + default: + E.failBadSyntaxKind(et); + break; + } + } + } + function Vn(ee, et, Ut) { + const Gt = t.createAssignment( + FS( + t, + et, + E.checkDefined(Qe(ee.name, W, qc)) + ), + E.checkDefined(Qe(ee.initializer, W, ut)) + ); + return ct(Gt, ee), Ut && Au(Gt), Gt; + } + function ln(ee, et, Ut) { + const Gt = t.createAssignment( + FS( + t, + et, + E.checkDefined(Qe(ee.name, W, qc)) + ), + t.cloneNode(ee.name) + ); + return ct(Gt, ee), Ut && Au(Gt), Gt; + } + function kr(ee, et, Ut, Gt) { + const Sr = t.createAssignment( + FS( + t, + et, + E.checkDefined(Qe(ee.name, W, qc)) + ), + rn( + ee, + /*location*/ + ee, + /*name*/ + void 0, + Ut + ) + ); + return ct(Sr, ee), Gt && Au(Sr), Sr; + } + function Li(ee) { + const et = F( + 7104, + 0 + /* BlockScopeIncludes */ + ); + let Ut; + if (E.assert(!!ee.variableDeclaration, "Catch clause variable should always be present when downleveling ES2015."), ws(ee.variableDeclaration.name)) { + const Gt = t.createTempVariable( + /*recordTempVariable*/ + void 0 + ), Sr = t.createVariableDeclaration(Gt); + ct(Sr, ee.variableDeclaration); + const zr = n2( + ee.variableDeclaration, + W, + e, + 0, + Gt + ), jn = t.createVariableDeclarationList(zr); + ct(jn, ee.variableDeclaration); + const ni = t.createVariableStatement( + /*modifiers*/ + void 0, + jn + ); + Ut = t.updateCatchClause(ee, Sr, Yi(ee.block, ni)); + } else + Ut = br(ee, W, e); + return R( + et, + 0, + 0 + /* None */ + ), Ut; + } + function Yi(ee, et) { + const Ut = Ar(ee.statements, W, Ti); + return t.updateBlock(ee, [et, ...Ut]); + } + function no(ee) { + E.assert(!Gs(ee.name)); + const et = rn( + ee, + /*location*/ + Z1(ee, -1), + /*name*/ + void 0, + /*container*/ + void 0 + ); + return un(et, 1024 | Ea(et)), ct( + t.createPropertyAssignment( + ee.name, + et + ), + /*location*/ + ee + ); + } + function ra(ee) { + E.assert(!Gs(ee.name)); + const et = P; + P = void 0; + const Ut = F( + 32670, + 65 + /* FunctionIncludes */ + ); + let Gt; + const Sr = _c(ee.parameters, W, e), zr = Pe(ee); + return ee.kind === 178 ? Gt = t.updateGetAccessorDeclaration(ee, ee.modifiers, ee.name, Sr, ee.type, zr) : Gt = t.updateSetAccessorDeclaration(ee, ee.modifiers, ee.name, Sr, zr), R( + Ut, + 229376, + 0 + /* None */ + ), P = et, Gt; + } + function Eo(ee) { + return ct( + t.createPropertyAssignment( + ee.name, + Z(t.cloneNode(ee.name)) + ), + /*location*/ + ee + ); + } + function $c(ee) { + return br(ee, W, e); + } + function Jc(ee) { + return br(ee, W, e); + } + function vo(ee) { + return ot(ee.elements, dp) ? P_( + ee.elements, + /*isArgumentList*/ + !1, + !!ee.multiLine, + /*hasTrailingComma*/ + !!ee.elements.hasTrailingComma + ) : br(ee, W, e); + } + function ic(ee) { + if (sd(ee) & 1) + return Bd(ee); + const et = hc(ee.expression); + return et.kind === 108 || j_(et) || ot(ee.arguments, dp) ? au( + ee + ) : t.updateCallExpression( + ee, + E.checkDefined(Qe(ee.expression, V, ut)), + /*typeArguments*/ + void 0, + Ar(ee.arguments, W, ut) + ); + } + function Bd(ee) { + const et = Us(Us(hc(ee.expression), xo).body, Ns), Ut = (na) => Ic(na) && !!Ca(na.declarationList.declarations).initializer, Gt = P; + P = void 0; + const Sr = Ar(et.statements, K, Ti); + P = Gt; + const zr = kn(Sr, Ut), jn = kn(Sr, (na) => !Ut(na)), wi = Us(Ca(zr), Ic).declarationList.declarations[0], L = hc(wi.initializer); + let Oe = Bn(L, Nl); + !Oe && _n(L) && L.operatorToken.kind === 28 && (Oe = Bn(L.left, Nl)); + const xt = Us(Oe ? hc(Oe.right) : L, Ps), Tr = Us(hc(xt.expression), yo), $i = Tr.body.statements; + let As = 0, Zi = -1; + const ys = []; + if (Oe) { + const na = Bn($i[As], Al); + na && (ys.push(na), As++), ys.push($i[As]), As++, ys.push( + t.createExpressionStatement( + t.createAssignment( + Oe.left, + Us(wi.name, Me) + ) + ) + ); + } + for (; !Cf(fy($i, Zi)); ) + Zi--; + In(ys, $i, As, Zi), Zi < -1 && In(ys, $i, Zi + 1); + const zo = Bn(fy($i, Zi), Cf); + for (const na of jn) + Cf(na) && zo?.expression && !Me(zo.expression) ? ys.push(zo) : ys.push(na); + return In( + ys, + zr, + /*start*/ + 1 + ), t.restoreOuterExpressions( + ee.expression, + t.restoreOuterExpressions( + wi.initializer, + t.restoreOuterExpressions( + Oe && Oe.right, + t.updateCallExpression( + xt, + t.restoreOuterExpressions( + xt.expression, + t.updateFunctionExpression( + Tr, + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + Tr.parameters, + /*type*/ + void 0, + t.updateBlock( + Tr.body, + ys + ) + ) + ), + /*typeArguments*/ + void 0, + xt.arguments + ) + ) + ) + ); + } + function au(ee, et) { + if (ee.transformFlags & 32768 || ee.expression.kind === 108 || j_(hc(ee.expression))) { + const { target: Ut, thisArg: Gt } = t.createCallBinding(ee.expression, c); + ee.expression.kind === 108 && un( + Gt, + 8 + /* NoSubstitution */ + ); + let Sr; + if (ee.transformFlags & 32768 ? Sr = t.createFunctionApplyCall( + E.checkDefined(Qe(Ut, V, ut)), + ee.expression.kind === 108 ? Gt : E.checkDefined(Qe(Gt, W, ut)), + P_( + ee.arguments, + /*isArgumentList*/ + !0, + /*multiLine*/ + !1, + /*hasTrailingComma*/ + !1 + ) + ) : Sr = ct( + t.createFunctionCallCall( + E.checkDefined(Qe(Ut, V, ut)), + ee.expression.kind === 108 ? Gt : E.checkDefined(Qe(Gt, W, ut)), + Ar(ee.arguments, W, ut) + ), + ee + ), ee.expression.kind === 108) { + const zr = t.createLogicalOr( + Sr, + ki() + ); + Sr = t.createAssignment(q(), zr); + } + return Cn(Sr, ee); + } + return oS(ee) && (T |= 131072), br(ee, W, e); + } + function Ef(ee) { + if (ot(ee.arguments, dp)) { + const { target: et, thisArg: Ut } = t.createCallBinding(t.createPropertyAccessExpression(ee.expression, "bind"), c); + return t.createNewExpression( + t.createFunctionApplyCall( + E.checkDefined(Qe(et, W, ut)), + Ut, + P_( + t.createNodeArray([t.createVoidZero(), ...ee.arguments]), + /*isArgumentList*/ + !0, + /*multiLine*/ + !1, + /*hasTrailingComma*/ + !1 + ) + ), + /*typeArguments*/ + void 0, + [] + ); + } + return br(ee, W, e); + } + function P_(ee, et, Ut, Gt) { + const Sr = ee.length, zr = Ip( + // As we visit each element, we return one of two functions to use as the "key": + // - `visitSpanOfSpreads` for one or more contiguous `...` spread expressions, i.e. `...a, ...b` in `[1, 2, ...a, ...b]` + // - `visitSpanOfNonSpreads` for one or more contiguous non-spread elements, i.e. `1, 2`, in `[1, 2, ...a, ...b]` + DR(ee, Ie, (L, Oe, xt, Tr) => Oe(L, Ut, Gt && Tr === Sr)) + ); + if (zr.length === 1) { + const L = zr[0]; + if (et && !_.downlevelIteration || zJ(L.expression) || E4(L.expression, "___spreadArray")) + return L.expression; + } + const jn = n(), ni = zr[0].kind !== 0; + let wi = ni ? t.createArrayLiteralExpression() : zr[0].expression; + for (let L = ni ? 0 : 1; L < zr.length; L++) { + const Oe = zr[L]; + wi = jn.createSpreadArrayHelper( + wi, + Oe.expression, + Oe.kind === 1 && !et + ); + } + return wi; + } + function Ie(ee) { + return dp(ee) ? Ot : Gi; + } + function Ot(ee) { + return hr(ee, Mr); + } + function Mr(ee) { + E.assertNode(ee, dp); + let et = Qe(ee.expression, W, ut); + E.assert(et); + const Ut = E4(et, "___read"); + let Gt = Ut || zJ(et) ? 2 : 1; + return _.downlevelIteration && Gt === 1 && !nu(et) && !Ut && (et = n().createReadHelper( + et, + /*count*/ + void 0 + ), Gt = 2), ove(Gt, et); + } + function Gi(ee, et, Ut) { + const Gt = t.createArrayLiteralExpression( + Ar(t.createNodeArray(ee, Ut), W, ut), + et + ); + return ove(0, Gt); + } + function Da(ee) { + return Qe(ee.expression, W, ut); + } + function wa(ee) { + return ct(t.createStringLiteral(ee.text), ee); + } + function ma(ee) { + return ee.hasExtendedUnicodeEscape ? ct(t.createStringLiteral(ee.text), ee) : ee; + } + function il(ee) { + return ee.numericLiteralFlags & 384 ? ct(t.createNumericLiteral(ee.text), ee) : ee; + } + function Po(ee) { + return GW( + e, + ee, + W, + h, + D, + 1 + /* All */ + ); + } + function sc(ee) { + let et = t.createStringLiteral(ee.head.text); + for (const Ut of ee.templateSpans) { + const Gt = [E.checkDefined(Qe(Ut.expression, W, ut))]; + Ut.literal.text.length > 0 && Gt.push(t.createStringLiteral(Ut.literal.text)), et = t.createCallExpression( + t.createPropertyAccessExpression(et, "concat"), + /*typeArguments*/ + void 0, + Gt + ); + } + return ct(et, ee); + } + function vc() { + return t.createUniqueName( + "_super", + 48 + /* FileLevel */ + ); + } + function Df(ee, et) { + const Ut = T & 8 && !et ? t.createPropertyAccessExpression(Cn(vc(), ee), "prototype") : vc(); + return Cn(Ut, ee), el(Ut, ee), ha(Ut, ee), Ut; + } + function Gl(ee) { + return ee.keywordToken === 105 && ee.name.escapedText === "target" ? (T |= 32768, t.createUniqueName( + "_newTarget", + 48 + /* FileLevel */ + )) : ee; + } + function Ol(ee, et, Ut) { + if (A & 1 && Es(et)) { + const Gt = F( + 32670, + Ea(et) & 16 ? 81 : 65 + /* FunctionIncludes */ + ); + m(ee, et, Ut), R( + Gt, + 0, + 0 + /* None */ + ); + return; + } + m(ee, et, Ut); + } + function pf() { + (A & 2) === 0 && (A |= 2, e.enableSubstitution( + 80 + /* Identifier */ + )); + } + function Qu() { + (A & 1) === 0 && (A |= 1, e.enableSubstitution( + 110 + /* ThisKeyword */ + ), e.enableEmitNotification( + 177 + /* Constructor */ + ), e.enableEmitNotification( + 175 + /* MethodDeclaration */ + ), e.enableEmitNotification( + 178 + /* GetAccessor */ + ), e.enableEmitNotification( + 179 + /* SetAccessor */ + ), e.enableEmitNotification( + 220 + /* ArrowFunction */ + ), e.enableEmitNotification( + 219 + /* FunctionExpression */ + ), e.enableEmitNotification( + 263 + /* FunctionDeclaration */ + )); + } + function hp(ee, et) { + return et = g(ee, et), ee === 1 ? $g(et) : Me(et) ? ig(et) : et; + } + function ig(ee) { + if (A & 2 && !Fz(ee)) { + const et = vs(ee, Me); + if (et && Gg(et)) + return ct(t.getGeneratedNameForNode(et), ee); + } + return ee; + } + function Gg(ee) { + switch (ee.parent.kind) { + case 209: + case 264: + case 267: + case 261: + return ee.parent.name === ee && u.isDeclarationWithCollidingName(ee.parent); + } + return !1; + } + function $g(ee) { + switch (ee.kind) { + case 80: + return N_(ee); + case 110: + return Jd(ee); + } + return ee; + } + function N_(ee) { + if (A & 2 && !Fz(ee)) { + const et = u.getReferencedDeclarationWithCollidingName(ee); + if (et && !($n(et) && Sl(et, ee))) + return ct(t.getGeneratedNameForNode(_s(et)), ee); + } + return ee; + } + function Sl(ee, et) { + let Ut = vs(et); + if (!Ut || Ut === ee || Ut.end <= ee.pos || Ut.pos >= ee.end) + return !1; + const Gt = Dd(ee); + for (; Ut; ) { + if (Ut === Gt || Ut === ee) + return !1; + if (Hc(Ut) && Ut.parent === ee) + return !0; + Ut = Ut.parent; + } + return !1; + } + function Jd(ee) { + return A & 1 && T & 16 ? ct(q(), ee) : ee; + } + function Wf(ee, et) { + return Js(et) ? t.getInternalName(ee) : t.createPropertyAccessExpression(t.getInternalName(ee), "prototype"); + } + function Nm(ee, et) { + if (!ee || !et || ot(ee.parameters)) + return !1; + const Ut = Yc(ee.body.statements); + if (!Ut || !lo(Ut) || Ut.kind !== 245) + return !1; + const Gt = Ut.expression; + if (!lo(Gt) || Gt.kind !== 214) + return !1; + const Sr = Gt.expression; + if (!lo(Sr) || Sr.kind !== 108) + return !1; + const zr = xg(Gt.arguments); + if (!zr || !lo(zr) || zr.kind !== 231) + return !1; + const jn = zr.expression; + return Me(jn) && jn.escapedText === "arguments"; + } + } + function Ije(e) { + switch (e) { + case 2: + return "return"; + case 3: + return "break"; + case 4: + return "yield"; + case 5: + return "yield*"; + case 7: + return "endfinally"; + default: + return; + } + } + function cie(e) { + const { + factory: t, + getEmitHelperFactory: n, + resumeLexicalEnvironment: i, + endLexicalEnvironment: s, + hoistFunctionDeclaration: o, + hoistVariableDeclaration: c + } = e, _ = e.getCompilerOptions(), u = da(_), g = e.getEmitResolver(), m = e.onSubstituteNode; + e.onSubstituteNode = ue; + let h, S, T, k, D, P, A, O, F, R, B = 1, U, $, W, _e, K = 0, V = 0, ae, se, ce, fe, he, q, be, je; + return Ld(e, me); + function me(Ie) { + if (Ie.isDeclarationFile || (Ie.transformFlags & 2048) === 0) + return Ie; + const Ot = br(Ie, Z, e); + return Wg(Ot, e.readEmitHelpers()), Ot; + } + function Z(Ie) { + const Ot = Ie.transformFlags; + return k ? pe(Ie) : T ? Te(Ie) : io(Ie) && Ie.asteriskToken ? Ye(Ie) : Ot & 2048 ? br(Ie, Z, e) : Ie; + } + function pe(Ie) { + switch (Ie.kind) { + case 247: + return Ds(Ie); + case 248: + return yr(Ie); + case 256: + return pt(Ie); + case 257: + return qe(Ie); + default: + return Te(Ie); + } + } + function Te(Ie) { + switch (Ie.kind) { + case 263: + return ne(Ie); + case 219: + return Se(Ie); + case 178: + case 179: + return ie(Ie); + case 244: + return Ee(Ie); + case 249: + return Xe(Ie); + case 250: + return re(Ie); + case 253: + return $e(Ie); + case 252: + return Y(Ie); + case 254: + return Tt(Ie); + default: + return Ie.transformFlags & 1048576 ? Fe(Ie) : Ie.transformFlags & 4196352 ? br(Ie, Z, e) : Ie; + } + } + function Fe(Ie) { + switch (Ie.kind) { + case 227: + return Ce(Ie); + case 357: + return tr(Ie); + case 228: + return st(Ie); + case 230: + return Wt(Ie); + case 210: + return Jr(Ie); + case 211: + return Ji(Ie); + case 213: + return Dt(Ie); + case 214: + return Mn(Ie); + case 215: + return ai(Ie); + default: + return br(Ie, Z, e); + } + } + function Ye(Ie) { + switch (Ie.kind) { + case 263: + return ne(Ie); + case 219: + return Se(Ie); + default: + return E.failBadSyntaxKind(Ie); + } + } + function ne(Ie) { + if (Ie.asteriskToken) + Ie = Cn( + ct( + t.createFunctionDeclaration( + Ie.modifiers, + /*asteriskToken*/ + void 0, + Ie.name, + /*typeParameters*/ + void 0, + _c(Ie.parameters, Z, e), + /*type*/ + void 0, + Ne(Ie.body) + ), + /*location*/ + Ie + ), + Ie + ); + else { + const Ot = T, Mr = k; + T = !1, k = !1, Ie = br(Ie, Z, e), T = Ot, k = Mr; + } + if (T) { + o(Ie); + return; + } else + return Ie; + } + function Se(Ie) { + if (Ie.asteriskToken) + Ie = Cn( + ct( + t.createFunctionExpression( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + Ie.name, + /*typeParameters*/ + void 0, + _c(Ie.parameters, Z, e), + /*type*/ + void 0, + Ne(Ie.body) + ), + /*location*/ + Ie + ), + Ie + ); + else { + const Ot = T, Mr = k; + T = !1, k = !1, Ie = br(Ie, Z, e), T = Ot, k = Mr; + } + return Ie; + } + function ie(Ie) { + const Ot = T, Mr = k; + return T = !1, k = !1, Ie = br(Ie, Z, e), T = Ot, k = Mr, Ie; + } + function Ne(Ie) { + const Ot = [], Mr = T, Gi = k, Da = D, wa = P, ma = A, il = O, Po = F, sc = R, vc = B, Df = U, Gl = $, Ol = W, pf = _e; + T = !0, k = !1, D = void 0, P = void 0, A = void 0, O = void 0, F = void 0, R = void 0, B = 1, U = void 0, $ = void 0, W = void 0, _e = t.createTempVariable( + /*recordTempVariable*/ + void 0 + ), i(); + const Qu = t.copyPrologue( + Ie.statements, + Ot, + /*ensureUseStrict*/ + !1, + Z + ); + fi(Ie.statements, Qu); + const hp = tt(); + return Ig(Ot, s()), Ot.push(t.createReturnStatement(hp)), T = Mr, k = Gi, D = Da, P = wa, A = ma, O = il, F = Po, R = sc, B = vc, U = Df, $ = Gl, W = Ol, _e = pf, ct(t.createBlock(Ot, Ie.multiLine), Ie); + } + function Ee(Ie) { + if (Ie.transformFlags & 1048576) { + qr(Ie.declarationList); + return; + } else { + if (Ea(Ie) & 2097152) + return Ie; + for (const Mr of Ie.declarationList.declarations) + c(Mr.name); + const Ot = s4(Ie.declarationList); + return Ot.length === 0 ? void 0 : ha( + t.createExpressionStatement( + t.inlineExpressions( + hr(Ot, Jn) + ) + ), + Ie + ); + } + } + function Ce(Ie) { + const Ot = UB(Ie); + switch (Ot) { + case 0: + return St(Ie); + case 1: + return Ve(Ie); + default: + return E.assertNever(Ot); + } + } + function Ve(Ie) { + const { left: Ot, right: Mr } = Ie; + if (Pe(Mr)) { + let Gi; + switch (Ot.kind) { + case 212: + Gi = t.updatePropertyAccessExpression( + Ot, + Q(E.checkDefined(Qe(Ot.expression, Z, S_))), + Ot.name + ); + break; + case 213: + Gi = t.updateElementAccessExpression(Ot, Q(E.checkDefined(Qe(Ot.expression, Z, S_))), Q(E.checkDefined(Qe(Ot.argumentExpression, Z, ut)))); + break; + default: + Gi = E.checkDefined(Qe(Ot, Z, ut)); + break; + } + const Da = Ie.operatorToken.kind; + return Z4(Da) ? ct( + t.createAssignment( + Gi, + ct( + t.createBinaryExpression( + Q(Gi), + K4(Da), + E.checkDefined(Qe(Mr, Z, ut)) + ), + Ie + ) + ), + Ie + ) : t.updateBinaryExpression(Ie, Gi, Ie.operatorToken, E.checkDefined(Qe(Mr, Z, ut))); + } + return br(Ie, Z, e); + } + function St(Ie) { + return Pe(Ie.right) ? iee(Ie.operatorToken.kind) ? Nr(Ie) : Ie.operatorToken.kind === 28 ? Bt(Ie) : t.updateBinaryExpression(Ie, Q(E.checkDefined(Qe(Ie.left, Z, ut))), Ie.operatorToken, E.checkDefined(Qe(Ie.right, Z, ut))) : br(Ie, Z, e); + } + function Bt(Ie) { + let Ot = []; + return Mr(Ie.left), Mr(Ie.right), t.inlineExpressions(Ot); + function Mr(Gi) { + _n(Gi) && Gi.operatorToken.kind === 28 ? (Mr(Gi.left), Mr(Gi.right)) : (Pe(Gi) && Ot.length > 0 && (H(1, [t.createExpressionStatement(t.inlineExpressions(Ot))]), Ot = []), Ot.push(E.checkDefined(Qe(Gi, Z, ut)))); + } + } + function tr(Ie) { + let Ot = []; + for (const Mr of Ie.elements) + _n(Mr) && Mr.operatorToken.kind === 28 ? Ot.push(Bt(Mr)) : (Pe(Mr) && Ot.length > 0 && (H(1, [t.createExpressionStatement(t.inlineExpressions(Ot))]), Ot = []), Ot.push(E.checkDefined(Qe(Mr, Z, ut)))); + return t.inlineExpressions(Ot); + } + function Nr(Ie) { + const Ot = Mt(), Mr = dt(); + return Fa( + Mr, + E.checkDefined(Qe(Ie.left, Z, ut)), + /*location*/ + Ie.left + ), Ie.operatorToken.kind === 56 ? Za( + Ot, + Mr, + /*location*/ + Ie.left + ) : zt( + Ot, + Mr, + /*location*/ + Ie.left + ), Fa( + Mr, + E.checkDefined(Qe(Ie.right, Z, ut)), + /*location*/ + Ie.right + ), ke(Ot), Mr; + } + function st(Ie) { + if (Pe(Ie.whenTrue) || Pe(Ie.whenFalse)) { + const Ot = Mt(), Mr = Mt(), Gi = dt(); + return Za( + Ot, + E.checkDefined(Qe(Ie.condition, Z, ut)), + /*location*/ + Ie.condition + ), Fa( + Gi, + E.checkDefined(Qe(Ie.whenTrue, Z, ut)), + /*location*/ + Ie.whenTrue + ), va(Mr), ke(Ot), Fa( + Gi, + E.checkDefined(Qe(Ie.whenFalse, Z, ut)), + /*location*/ + Ie.whenFalse + ), ke(Mr), Gi; + } + return br(Ie, Z, e); + } + function Wt(Ie) { + const Ot = Mt(), Mr = Qe(Ie.expression, Z, ut); + if (Ie.asteriskToken) { + const Gi = (Ea(Ie.expression) & 8388608) === 0 ? ct(n().createValuesHelper(Mr), Ie) : Mr; + yc( + Gi, + /*location*/ + Ie + ); + } else + Fc( + Mr, + /*location*/ + Ie + ); + return ke(Ot), zf( + /*location*/ + Ie + ); + } + function Jr(Ie) { + return ui( + Ie.elements, + /*leadingElement*/ + void 0, + /*location*/ + void 0, + Ie.multiLine + ); + } + function ui(Ie, Ot, Mr, Gi) { + const Da = yt(Ie); + let wa; + if (Da > 0) { + wa = dt(); + const Po = Ar(Ie, Z, ut, 0, Da); + Fa( + wa, + t.createArrayLiteralExpression( + Ot ? [Ot, ...Po] : Po + ) + ), Ot = void 0; + } + const ma = Wu(Ie, il, [], Da); + return wa ? t.createArrayConcatCall(wa, [t.createArrayLiteralExpression(ma, Gi)]) : ct( + t.createArrayLiteralExpression(Ot ? [Ot, ...ma] : ma, Gi), + Mr + ); + function il(Po, sc) { + if (Pe(sc) && Po.length > 0) { + const vc = wa !== void 0; + wa || (wa = dt()), Fa( + wa, + vc ? t.createArrayConcatCall( + wa, + [t.createArrayLiteralExpression(Po, Gi)] + ) : t.createArrayLiteralExpression( + Ot ? [Ot, ...Po] : Po, + Gi + ) + ), Ot = void 0, Po = []; + } + return Po.push(E.checkDefined(Qe(sc, Z, ut))), Po; + } + } + function Ji(Ie) { + const Ot = Ie.properties, Mr = Ie.multiLine, Gi = yt(Ot), Da = dt(); + Fa( + Da, + t.createObjectLiteralExpression( + Ar(Ot, Z, vh, 0, Gi), + Mr + ) + ); + const wa = Wu(Ot, ma, [], Gi); + return wa.push(Mr ? Au(za(ct(t.cloneNode(Da), Da), Da.parent)) : Da), t.inlineExpressions(wa); + function ma(il, Po) { + Pe(Po) && il.length > 0 && (Ws(t.createExpressionStatement(t.inlineExpressions(il))), il = []); + const sc = sre(t, Ie, Po, Da), vc = Qe(sc, Z, ut); + return vc && (Mr && Au(vc), il.push(vc)), il; + } + } + function Dt(Ie) { + return Pe(Ie.argumentExpression) ? t.updateElementAccessExpression(Ie, Q(E.checkDefined(Qe(Ie.expression, Z, S_))), E.checkDefined(Qe(Ie.argumentExpression, Z, ut))) : br(Ie, Z, e); + } + function Mn(Ie) { + if (!T_(Ie) && lr(Ie.arguments, Pe)) { + const { target: Ot, thisArg: Mr } = t.createCallBinding( + Ie.expression, + c, + u, + /*cacheIdentifiers*/ + !0 + ); + return Cn( + ct( + t.createFunctionApplyCall( + Q(E.checkDefined(Qe(Ot, Z, S_))), + Mr, + ui(Ie.arguments) + ), + Ie + ), + Ie + ); + } + return br(Ie, Z, e); + } + function ai(Ie) { + if (lr(Ie.arguments, Pe)) { + const { target: Ot, thisArg: Mr } = t.createCallBinding(t.createPropertyAccessExpression(Ie.expression, "bind"), c); + return Cn( + ct( + t.createNewExpression( + t.createFunctionApplyCall( + Q(E.checkDefined(Qe(Ot, Z, ut))), + Mr, + ui( + Ie.arguments, + /*leadingElement*/ + t.createVoidZero() + ) + ), + /*typeArguments*/ + void 0, + [] + ), + Ie + ), + Ie + ); + } + return br(Ie, Z, e); + } + function fi(Ie, Ot = 0) { + const Mr = Ie.length; + for (let Gi = Ot; Gi < Mr; Gi++) + _i(Ie[Gi]); + } + function pn(Ie) { + Ns(Ie) ? fi(Ie.statements) : _i(Ie); + } + function _i(Ie) { + const Ot = k; + k || (k = Pe(Ie)), Je(Ie), k = Ot; + } + function Je(Ie) { + switch (Ie.kind) { + case 242: + return ft(Ie); + case 245: + return er(Ie); + case 246: + return Un(Ie); + case 247: + return ki(Ie); + case 248: + return Ks(Ie); + case 249: + return bs(Ie); + case 250: + return Et(Ie); + case 252: + return it(Ie); + case 253: + return Ae(Ie); + case 254: + return Ke(Ie); + case 255: + return Le(Ie); + case 256: + return mt(Ie); + case 257: + return Ct(Ie); + case 258: + return Lt(Ie); + case 259: + return rn(Ie); + default: + return Ws(Qe(Ie, Z, Ti)); + } + } + function ft(Ie) { + Pe(Ie) ? fi(Ie.statements) : Ws(Qe(Ie, Z, Ti)); + } + function er(Ie) { + Ws(Qe(Ie, Z, Ti)); + } + function qr(Ie) { + for (const wa of Ie.declarations) { + const ma = t.cloneNode(wa.name); + el(ma, wa.name), c(ma); + } + const Ot = s4(Ie), Mr = Ot.length; + let Gi = 0, Da = []; + for (; Gi < Mr; ) { + for (let wa = Gi; wa < Mr; wa++) { + const ma = Ot[wa]; + if (Pe(ma.initializer) && Da.length > 0) + break; + Da.push(Jn(ma)); + } + Da.length && (Ws(t.createExpressionStatement(t.inlineExpressions(Da))), Gi += Da.length, Da = []); + } + } + function Jn(Ie) { + return ha( + t.createAssignment( + ha(t.cloneNode(Ie.name), Ie.name), + E.checkDefined(Qe(Ie.initializer, Z, ut)) + ), + Ie + ); + } + function Un(Ie) { + if (Pe(Ie)) + if (Pe(Ie.thenStatement) || Pe(Ie.elseStatement)) { + const Ot = Mt(), Mr = Ie.elseStatement ? Mt() : void 0; + Za( + Ie.elseStatement ? Mr : Ot, + E.checkDefined(Qe(Ie.expression, Z, ut)), + /*location*/ + Ie.expression + ), pn(Ie.thenStatement), Ie.elseStatement && (va(Ot), ke(Mr), pn(Ie.elseStatement)), ke(Ot); + } else + Ws(Qe(Ie, Z, Ti)); + else + Ws(Qe(Ie, Z, Ti)); + } + function ki(Ie) { + if (Pe(Ie)) { + const Ot = Mt(), Mr = Mt(); + kt( + /*continueLabel*/ + Ot + ), ke(Mr), pn(Ie.statement), ke(Ot), zt(Mr, E.checkDefined(Qe(Ie.expression, Z, ut))), cr(); + } else + Ws(Qe(Ie, Z, Ti)); + } + function Ds(Ie) { + return k ? (nr(), Ie = br(Ie, Z, e), cr(), Ie) : br(Ie, Z, e); + } + function Ks(Ie) { + if (Pe(Ie)) { + const Ot = Mt(), Mr = kt(Ot); + ke(Ot), Za(Mr, E.checkDefined(Qe(Ie.expression, Z, ut))), pn(Ie.statement), va(Ot), cr(); + } else + Ws(Qe(Ie, Z, Ti)); + } + function yr(Ie) { + return k ? (nr(), Ie = br(Ie, Z, e), cr(), Ie) : br(Ie, Z, e); + } + function bs(Ie) { + if (Pe(Ie)) { + const Ot = Mt(), Mr = Mt(), Gi = kt(Mr); + if (Ie.initializer) { + const Da = Ie.initializer; + Ul(Da) ? qr(Da) : Ws( + ct( + t.createExpressionStatement( + E.checkDefined(Qe(Da, Z, ut)) + ), + Da + ) + ); + } + ke(Ot), Ie.condition && Za(Gi, E.checkDefined(Qe(Ie.condition, Z, ut))), pn(Ie.statement), ke(Mr), Ie.incrementor && Ws( + ct( + t.createExpressionStatement( + E.checkDefined(Qe(Ie.incrementor, Z, ut)) + ), + Ie.incrementor + ) + ), va(Ot), cr(); + } else + Ws(Qe(Ie, Z, Ti)); + } + function Xe(Ie) { + k && nr(); + const Ot = Ie.initializer; + if (Ot && Ul(Ot)) { + for (const Gi of Ot.declarations) + c(Gi.name); + const Mr = s4(Ot); + Ie = t.updateForStatement( + Ie, + Mr.length > 0 ? t.inlineExpressions(hr(Mr, Jn)) : void 0, + Qe(Ie.condition, Z, ut), + Qe(Ie.incrementor, Z, ut), + c_(Ie.statement, Z, e) + ); + } else + Ie = br(Ie, Z, e); + return k && cr(), Ie; + } + function Et(Ie) { + if (Pe(Ie)) { + const Ot = dt(), Mr = dt(), Gi = dt(), Da = t.createLoopVariable(), wa = Ie.initializer; + c(Da), Fa(Ot, E.checkDefined(Qe(Ie.expression, Z, ut))), Fa(Mr, t.createArrayLiteralExpression()), Ws( + t.createForInStatement( + Gi, + Ot, + t.createExpressionStatement( + t.createCallExpression( + t.createPropertyAccessExpression(Mr, "push"), + /*typeArguments*/ + void 0, + [Gi] + ) + ) + ) + ), Fa(Da, t.createNumericLiteral(0)); + const ma = Mt(), il = Mt(), Po = kt(il); + ke(ma), Za(Po, t.createLessThan(Da, t.createPropertyAccessExpression(Mr, "length"))), Fa(Gi, t.createElementAccessExpression(Mr, Da)), Za(il, t.createBinaryExpression(Gi, 103, Ot)); + let sc; + if (Ul(wa)) { + for (const vc of wa.declarations) + c(vc.name); + sc = t.cloneNode(wa.declarations[0].name); + } else + sc = E.checkDefined(Qe(wa, Z, ut)), E.assert(S_(sc)); + Fa(sc, Gi), pn(Ie.statement), ke(il), Ws(t.createExpressionStatement(t.createPostfixIncrement(Da))), va(ma), cr(); + } else + Ws(Qe(Ie, Z, Ti)); + } + function re(Ie) { + k && nr(); + const Ot = Ie.initializer; + if (Ul(Ot)) { + for (const Mr of Ot.declarations) + c(Mr.name); + Ie = t.updateForInStatement(Ie, Ot.declarations[0].name, E.checkDefined(Qe(Ie.expression, Z, ut)), E.checkDefined(Qe(Ie.statement, Z, Ti, t.liftToBlock))); + } else + Ie = br(Ie, Z, e); + return k && cr(), Ie; + } + function it(Ie) { + const Ot = hs(Ie.label ? An(Ie.label) : void 0); + Ot > 0 ? va( + Ot, + /*location*/ + Ie + ) : Ws(Ie); + } + function Y(Ie) { + if (k) { + const Ot = hs(Ie.label && An(Ie.label)); + if (Ot > 0) + return ta( + Ot, + /*location*/ + Ie + ); + } + return br(Ie, Z, e); + } + function Ae(Ie) { + const Ot = zi(Ie.label ? An(Ie.label) : void 0); + Ot > 0 ? va( + Ot, + /*location*/ + Ie + ) : Ws(Ie); + } + function $e(Ie) { + if (k) { + const Ot = zi(Ie.label && An(Ie.label)); + if (Ot > 0) + return ta( + Ot, + /*location*/ + Ie + ); + } + return br(Ie, Z, e); + } + function Ke(Ie) { + Hl( + Qe(Ie.expression, Z, ut), + /*location*/ + Ie + ); + } + function Tt(Ie) { + return Ec( + Qe(Ie.expression, Z, ut), + /*location*/ + Ie + ); + } + function Le(Ie) { + Pe(Ie) ? (Pr(Q(E.checkDefined(Qe(Ie.expression, Z, ut)))), pn(Ie.statement), rt()) : Ws(Qe(Ie, Z, Ti)); + } + function mt(Ie) { + if (Pe(Ie.caseBlock)) { + const Ot = Ie.caseBlock, Mr = Ot.clauses.length, Gi = vr(), Da = Q(E.checkDefined(Qe(Ie.expression, Z, ut))), wa = []; + let ma = -1; + for (let sc = 0; sc < Mr; sc++) { + const vc = Ot.clauses[sc]; + wa.push(Mt()), vc.kind === 298 && ma === -1 && (ma = sc); + } + let il = 0, Po = []; + for (; il < Mr; ) { + let sc = 0; + for (let vc = il; vc < Mr; vc++) { + const Df = Ot.clauses[vc]; + if (Df.kind === 297) { + if (Pe(Df.expression) && Po.length > 0) + break; + Po.push( + t.createCaseClause( + E.checkDefined(Qe(Df.expression, Z, ut)), + [ + ta( + wa[vc], + /*location*/ + Df.expression + ) + ] + ) + ); + } else + sc++; + } + Po.length && (Ws(t.createSwitchStatement(Da, t.createCaseBlock(Po))), il += Po.length, Po = []), sc > 0 && (il += sc, sc = 0); + } + ma >= 0 ? va(wa[ma]) : va(Gi); + for (let sc = 0; sc < Mr; sc++) + ke(wa[sc]), fi(Ot.clauses[sc].statements); + Xt(); + } else + Ws(Qe(Ie, Z, Ti)); + } + function pt(Ie) { + return k && fr(), Ie = br(Ie, Z, e), k && Xt(), Ie; + } + function Ct(Ie) { + Pe(Ie) ? (Fs(An(Ie.label)), pn(Ie.statement), Rs()) : Ws(Qe(Ie, Z, Ti)); + } + function qe(Ie) { + return k && oi(An(Ie.label)), Ie = br(Ie, Z, e), k && Rs(), Ie; + } + function Lt(Ie) { + _o( + E.checkDefined(Qe(Ie.expression ?? t.createVoidZero(), Z, ut)), + /*location*/ + Ie + ); + } + function rn(Ie) { + Pe(Ie) ? (vt(), pn(Ie.tryBlock), Ie.catchClause && (Nt(Ie.catchClause.variableDeclaration), pn(Ie.catchClause.block)), Ie.finallyBlock && (Jt(), pn(Ie.finallyBlock)), _r()) : Ws(br(Ie, Z, e)); + } + function Pe(Ie) { + return !!Ie && (Ie.transformFlags & 1048576) !== 0; + } + function yt(Ie) { + const Ot = Ie.length; + for (let Mr = 0; Mr < Ot; Mr++) + if (Pe(Ie[Mr])) + return Mr; + return -1; + } + function ue(Ie, Ot) { + return Ot = m(Ie, Ot), Ie === 1 ? M(Ot) : Ot; + } + function M(Ie) { + return Me(Ie) ? ye(Ie) : Ie; + } + function ye(Ie) { + if (!Bo(Ie) && h && h.has(An(Ie))) { + const Ot = Vo(Ie); + if (Me(Ot) && Ot.parent) { + const Mr = g.getReferencedValueDeclaration(Ot); + if (Mr) { + const Gi = S[l_(Mr)]; + if (Gi) { + const Da = za(ct(t.cloneNode(Gi), Gi), Gi.parent); + return ha(Da, Ie), el(Da, Ie), Da; + } + } + } + } + return Ie; + } + function Q(Ie) { + if (Bo(Ie) || Ea(Ie) & 8192) + return Ie; + const Ot = t.createTempVariable(c); + return Fa( + Ot, + Ie, + /*location*/ + Ie + ), Ot; + } + function dt(Ie) { + const Ot = Ie ? t.createUniqueName(Ie) : t.createTempVariable( + /*recordTempVariable*/ + void 0 + ); + return c(Ot), Ot; + } + function Mt() { + F || (F = []); + const Ie = B; + return B++, F[Ie] = -1, Ie; + } + function ke(Ie) { + E.assert(F !== void 0, "No labels were defined."), F[Ie] = U ? U.length : 0; + } + function at(Ie) { + D || (D = [], A = [], P = [], O = []); + const Ot = A.length; + return A[Ot] = 0, P[Ot] = U ? U.length : 0, D[Ot] = Ie, O.push(Ie), Ot; + } + function wt() { + const Ie = Zr(); + if (Ie === void 0) return E.fail("beginBlock was never called."); + const Ot = A.length; + return A[Ot] = 1, P[Ot] = U ? U.length : 0, D[Ot] = Ie, O.pop(), Ie; + } + function Zr() { + return Do(O); + } + function Rr() { + const Ie = Zr(); + return Ie && Ie.kind; + } + function Pr(Ie) { + const Ot = Mt(), Mr = Mt(); + ke(Ot), at({ + kind: 1, + expression: Ie, + startLabel: Ot, + endLabel: Mr + }); + } + function rt() { + E.assert( + Rr() === 1 + /* With */ + ); + const Ie = wt(); + ke(Ie.endLabel); + } + function vt() { + const Ie = Mt(), Ot = Mt(); + return ke(Ie), at({ + kind: 0, + state: 0, + startLabel: Ie, + endLabel: Ot + }), cs(), Ot; + } + function Nt(Ie) { + E.assert( + Rr() === 0 + /* Exception */ + ); + let Ot; + if (Bo(Ie.name)) + Ot = Ie.name, c(Ie.name); + else { + const wa = An(Ie.name); + Ot = dt(wa), h || (h = /* @__PURE__ */ new Map(), S = [], e.enableSubstitution( + 80 + /* Identifier */ + )), h.set(wa, !0), S[l_(Ie)] = Ot; + } + const Mr = Zr(); + E.assert( + Mr.state < 1 + /* Catch */ + ); + const Gi = Mr.endLabel; + va(Gi); + const Da = Mt(); + ke(Da), Mr.state = 1, Mr.catchVariable = Ot, Mr.catchLabel = Da, Fa(Ot, t.createCallExpression( + t.createPropertyAccessExpression(_e, "sent"), + /*typeArguments*/ + void 0, + [] + )), cs(); + } + function Jt() { + E.assert( + Rr() === 0 + /* Exception */ + ); + const Ie = Zr(); + E.assert( + Ie.state < 2 + /* Finally */ + ); + const Ot = Ie.endLabel; + va(Ot); + const Mr = Mt(); + ke(Mr), Ie.state = 2, Ie.finallyLabel = Mr; + } + function _r() { + E.assert( + Rr() === 0 + /* Exception */ + ); + const Ie = wt(); + Ie.state < 2 ? va(Ie.endLabel) : ge(), ke(Ie.endLabel), cs(), Ie.state = 3; + } + function nr() { + at({ + kind: 3, + isScript: !0, + breakLabel: -1, + continueLabel: -1 + }); + } + function kt(Ie) { + const Ot = Mt(); + return at({ + kind: 3, + isScript: !1, + breakLabel: Ot, + continueLabel: Ie + }), Ot; + } + function cr() { + E.assert( + Rr() === 3 + /* Loop */ + ); + const Ie = wt(), Ot = Ie.breakLabel; + Ie.isScript || ke(Ot); + } + function fr() { + at({ + kind: 2, + isScript: !0, + breakLabel: -1 + }); + } + function vr() { + const Ie = Mt(); + return at({ + kind: 2, + isScript: !1, + breakLabel: Ie + }), Ie; + } + function Xt() { + E.assert( + Rr() === 2 + /* Switch */ + ); + const Ie = wt(), Ot = Ie.breakLabel; + Ie.isScript || ke(Ot); + } + function oi(Ie) { + at({ + kind: 4, + isScript: !0, + labelText: Ie, + breakLabel: -1 + }); + } + function Fs(Ie) { + const Ot = Mt(); + at({ + kind: 4, + isScript: !1, + labelText: Ie, + breakLabel: Ot + }); + } + function Rs() { + E.assert( + Rr() === 4 + /* Labeled */ + ); + const Ie = wt(); + Ie.isScript || ke(Ie.breakLabel); + } + function ds(Ie) { + return Ie.kind === 2 || Ie.kind === 3; + } + function pc(Ie) { + return Ie.kind === 4; + } + function Zo(Ie) { + return Ie.kind === 3; + } + function so(Ie, Ot) { + for (let Mr = Ot; Mr >= 0; Mr--) { + const Gi = O[Mr]; + if (pc(Gi)) { + if (Gi.labelText === Ie) + return !0; + } else + break; + } + return !1; + } + function zi(Ie) { + if (O) + if (Ie) + for (let Ot = O.length - 1; Ot >= 0; Ot--) { + const Mr = O[Ot]; + if (pc(Mr) && Mr.labelText === Ie) + return Mr.breakLabel; + if (ds(Mr) && so(Ie, Ot - 1)) + return Mr.breakLabel; + } + else + for (let Ot = O.length - 1; Ot >= 0; Ot--) { + const Mr = O[Ot]; + if (ds(Mr)) + return Mr.breakLabel; + } + return 0; + } + function hs(Ie) { + if (O) + if (Ie) + for (let Ot = O.length - 1; Ot >= 0; Ot--) { + const Mr = O[Ot]; + if (Zo(Mr) && so(Ie, Ot - 1)) + return Mr.continueLabel; + } + else + for (let Ot = O.length - 1; Ot >= 0; Ot--) { + const Mr = O[Ot]; + if (Zo(Mr)) + return Mr.continueLabel; + } + return 0; + } + function Gc(Ie) { + if (Ie !== void 0 && Ie > 0) { + R === void 0 && (R = []); + const Ot = t.createNumericLiteral(Number.MAX_SAFE_INTEGER); + return R[Ie] === void 0 ? R[Ie] = [Ot] : R[Ie].push(Ot), Ot; + } + return t.createOmittedExpression(); + } + function Co(Ie) { + const Ot = t.createNumericLiteral(Ie); + return C4(Ot, 3, Ije(Ie)), Ot; + } + function ta(Ie, Ot) { + return E.assertLessThan(0, Ie, "Invalid label"), ct( + t.createReturnStatement( + t.createArrayLiteralExpression([ + Co( + 3 + /* Break */ + ), + Gc(Ie) + ]) + ), + Ot + ); + } + function Ec(Ie, Ot) { + return ct( + t.createReturnStatement( + t.createArrayLiteralExpression( + Ie ? [Co( + 2 + /* Return */ + ), Ie] : [Co( + 2 + /* Return */ + )] + ) + ), + Ot + ); + } + function zf(Ie) { + return ct( + t.createCallExpression( + t.createPropertyAccessExpression(_e, "sent"), + /*typeArguments*/ + void 0, + [] + ), + Ie + ); + } + function cs() { + H( + 0 + /* Nop */ + ); + } + function Ws(Ie) { + Ie ? H(1, [Ie]) : cs(); + } + function Fa(Ie, Ot, Mr) { + H(2, [Ie, Ot], Mr); + } + function va(Ie, Ot) { + H(3, [Ie], Ot); + } + function zt(Ie, Ot, Mr) { + H(4, [Ie, Ot], Mr); + } + function Za(Ie, Ot, Mr) { + H(5, [Ie, Ot], Mr); + } + function yc(Ie, Ot) { + H(7, [Ie], Ot); + } + function Fc(Ie, Ot) { + H(6, [Ie], Ot); + } + function Hl(Ie, Ot) { + H(8, [Ie], Ot); + } + function _o(Ie, Ot) { + H(9, [Ie], Ot); + } + function ge() { + H( + 10 + /* Endfinally */ + ); + } + function H(Ie, Ot, Mr) { + U === void 0 && (U = [], $ = [], W = []), F === void 0 && ke(Mt()); + const Gi = U.length; + U[Gi] = Ie, $[Gi] = Ot, W[Gi] = Mr; + } + function tt() { + K = 0, V = 0, ae = void 0, se = !1, ce = !1, fe = void 0, he = void 0, q = void 0, be = void 0, je = void 0; + const Ie = Ft(); + return n().createGeneratorHelper( + un( + t.createFunctionExpression( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + [t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + _e + )], + /*type*/ + void 0, + t.createBlock( + Ie, + /*multiLine*/ + Ie.length > 0 + ) + ), + 1048576 + /* ReuseTempVariableScope */ + ) + ); + } + function Ft() { + if (U) { + for (let Ie = 0; Ie < U.length; Ie++) + no(Ie); + Hr(U.length); + } else + Hr(0); + if (fe) { + const Ie = t.createPropertyAccessExpression(_e, "label"), Ot = t.createSwitchStatement(Ie, t.createCaseBlock(fe)); + return [Au(Ot)]; + } + return he || []; + } + function Kt() { + he && (ln( + /*markLabelEnd*/ + !se + ), se = !1, ce = !1, V++); + } + function Hr(Ie) { + Vn(Ie) && (kr(Ie), je = void 0, Jc( + /*expression*/ + void 0, + /*operationLocation*/ + void 0 + )), he && fe && ln( + /*markLabelEnd*/ + !1 + ), Li(); + } + function Vn(Ie) { + if (!ce) + return !0; + if (!F || !R) + return !1; + for (let Ot = 0; Ot < F.length; Ot++) + if (F[Ot] === Ie && R[Ot]) + return !0; + return !1; + } + function ln(Ie) { + if (fe || (fe = []), he) { + if (je) + for (let Ot = je.length - 1; Ot >= 0; Ot--) { + const Mr = je[Ot]; + he = [t.createWithStatement(Mr.expression, t.createBlock(he))]; + } + if (be) { + const { startLabel: Ot, catchLabel: Mr, finallyLabel: Gi, endLabel: Da } = be; + he.unshift( + t.createExpressionStatement( + t.createCallExpression( + t.createPropertyAccessExpression(t.createPropertyAccessExpression(_e, "trys"), "push"), + /*typeArguments*/ + void 0, + [ + t.createArrayLiteralExpression([ + Gc(Ot), + Gc(Mr), + Gc(Gi), + Gc(Da) + ]) + ] + ) + ) + ), be = void 0; + } + Ie && he.push( + t.createExpressionStatement( + t.createAssignment( + t.createPropertyAccessExpression(_e, "label"), + t.createNumericLiteral(V + 1) + ) + ) + ); + } + fe.push( + t.createCaseClause( + t.createNumericLiteral(V), + he || [] + ) + ), he = void 0; + } + function kr(Ie) { + if (F) + for (let Ot = 0; Ot < F.length; Ot++) + F[Ot] === Ie && (Kt(), ae === void 0 && (ae = []), ae[V] === void 0 ? ae[V] = [Ot] : ae[V].push(Ot)); + } + function Li() { + if (R !== void 0 && ae !== void 0) + for (let Ie = 0; Ie < ae.length; Ie++) { + const Ot = ae[Ie]; + if (Ot !== void 0) + for (const Mr of Ot) { + const Gi = R[Mr]; + if (Gi !== void 0) + for (const Da of Gi) + Da.text = String(Ie); + } + } + } + function Yi(Ie) { + if (D) + for (; K < A.length && P[K] <= Ie; K++) { + const Ot = D[K], Mr = A[K]; + switch (Ot.kind) { + case 0: + Mr === 0 ? (q || (q = []), he || (he = []), q.push(be), be = Ot) : Mr === 1 && (be = q.pop()); + break; + case 1: + Mr === 0 ? (je || (je = []), je.push(Ot)) : Mr === 1 && je.pop(); + break; + } + } + } + function no(Ie) { + if (kr(Ie), Yi(Ie), se) + return; + se = !1, ce = !1; + const Ot = U[Ie]; + if (Ot === 0) + return; + if (Ot === 10) + return P_(); + const Mr = $[Ie]; + if (Ot === 1) + return ra(Mr[0]); + const Gi = W[Ie]; + switch (Ot) { + case 2: + return Eo(Mr[0], Mr[1], Gi); + case 3: + return vo(Mr[0], Gi); + case 4: + return ic(Mr[0], Mr[1], Gi); + case 5: + return Bd(Mr[0], Mr[1], Gi); + case 6: + return au(Mr[0], Gi); + case 7: + return Ef(Mr[0], Gi); + case 8: + return Jc(Mr[0], Gi); + case 9: + return $c(Mr[0], Gi); + } + } + function ra(Ie) { + Ie && (he ? he.push(Ie) : he = [Ie]); + } + function Eo(Ie, Ot, Mr) { + ra(ct(t.createExpressionStatement(t.createAssignment(Ie, Ot)), Mr)); + } + function $c(Ie, Ot) { + se = !0, ce = !0, ra(ct(t.createThrowStatement(Ie), Ot)); + } + function Jc(Ie, Ot) { + se = !0, ce = !0, ra( + un( + ct( + t.createReturnStatement( + t.createArrayLiteralExpression( + Ie ? [Co( + 2 + /* Return */ + ), Ie] : [Co( + 2 + /* Return */ + )] + ) + ), + Ot + ), + 768 + /* NoTokenSourceMaps */ + ) + ); + } + function vo(Ie, Ot) { + se = !0, ra( + un( + ct( + t.createReturnStatement( + t.createArrayLiteralExpression([ + Co( + 3 + /* Break */ + ), + Gc(Ie) + ]) + ), + Ot + ), + 768 + /* NoTokenSourceMaps */ + ) + ); + } + function ic(Ie, Ot, Mr) { + ra( + un( + t.createIfStatement( + Ot, + un( + ct( + t.createReturnStatement( + t.createArrayLiteralExpression([ + Co( + 3 + /* Break */ + ), + Gc(Ie) + ]) + ), + Mr + ), + 768 + /* NoTokenSourceMaps */ + ) + ), + 1 + /* SingleLine */ + ) + ); + } + function Bd(Ie, Ot, Mr) { + ra( + un( + t.createIfStatement( + t.createLogicalNot(Ot), + un( + ct( + t.createReturnStatement( + t.createArrayLiteralExpression([ + Co( + 3 + /* Break */ + ), + Gc(Ie) + ]) + ), + Mr + ), + 768 + /* NoTokenSourceMaps */ + ) + ), + 1 + /* SingleLine */ + ) + ); + } + function au(Ie, Ot) { + se = !0, ra( + un( + ct( + t.createReturnStatement( + t.createArrayLiteralExpression( + Ie ? [Co( + 4 + /* Yield */ + ), Ie] : [Co( + 4 + /* Yield */ + )] + ) + ), + Ot + ), + 768 + /* NoTokenSourceMaps */ + ) + ); + } + function Ef(Ie, Ot) { + se = !0, ra( + un( + ct( + t.createReturnStatement( + t.createArrayLiteralExpression([ + Co( + 5 + /* YieldStar */ + ), + Ie + ]) + ), + Ot + ), + 768 + /* NoTokenSourceMaps */ + ) + ); + } + function P_() { + se = !0, ra( + t.createReturnStatement( + t.createArrayLiteralExpression([ + Co( + 7 + /* Endfinally */ + ) + ]) + ) + ); + } + } + function XW(e) { + function t(ue) { + switch (ue) { + case 2: + return $; + case 3: + return W; + default: + return U; + } + } + const { + factory: n, + getEmitHelperFactory: i, + startLexicalEnvironment: s, + endLexicalEnvironment: o, + hoistVariableDeclaration: c + } = e, _ = e.getCompilerOptions(), u = e.getEmitResolver(), g = e.getEmitHost(), m = da(_), h = Hu(_), S = e.onSubstituteNode, T = e.onEmitNode; + e.onSubstituteNode = mt, e.onEmitNode = Le, e.enableSubstitution( + 214 + /* CallExpression */ + ), e.enableSubstitution( + 216 + /* TaggedTemplateExpression */ + ), e.enableSubstitution( + 80 + /* Identifier */ + ), e.enableSubstitution( + 227 + /* BinaryExpression */ + ), e.enableSubstitution( + 305 + /* ShorthandPropertyAssignment */ + ), e.enableEmitNotification( + 308 + /* SourceFile */ + ); + const k = []; + let D, P, A; + const O = []; + let F; + return Ld(e, R); + function R(ue) { + if (ue.isDeclarationFile || !(RC(ue, _) || ue.transformFlags & 8388608 || ap(ue) && V5(_) && _.outFile)) + return ue; + D = ue, P = zW(e, ue), k[l_(ue)] = P, _.rewriteRelativeImportExtensions && dF( + ue, + /*includeTypeSpaceImports*/ + !1, + /*requireStringLiteralLikeArgument*/ + !1, + (Q) => { + (!ja(Q.arguments[0]) || V3(Q.arguments[0].text, _)) && (A = Er(A, Q)); + } + ); + const ye = t(h)(ue); + return D = void 0, P = void 0, F = !1, ye; + } + function B() { + return Bg(D.fileName) && D.commonJsModuleIndicator && (!D.externalModuleIndicator || D.externalModuleIndicator === !0) ? !1 : !!(!P.exportEquals && fl(D)); + } + function U(ue) { + s(); + const M = [], ye = du(_, "alwaysStrict") || fl(D), Q = n.copyPrologue(ue.statements, M, ye && !ap(ue), se); + if (B() && Er(M, Ae()), ot(P.exportedNames)) + for (let ke = 0; ke < P.exportedNames.length; ke += 50) + Er( + M, + n.createExpressionStatement( + Wu( + P.exportedNames.slice(ke, ke + 50), + (at, wt) => wt.kind === 11 ? n.createAssignment(n.createElementAccessExpression(n.createIdentifier("exports"), n.createStringLiteral(wt.text)), at) : n.createAssignment(n.createPropertyAccessExpression(n.createIdentifier("exports"), n.createIdentifier(An(wt))), at), + n.createVoidZero() + ) + ) + ); + for (const Mt of P.exportedFunctions) + re(M, Mt); + Er(M, Qe(P.externalHelpersImportDeclaration, se, Ti)), In(M, Ar(ue.statements, se, Ti, Q)), ae( + M, + /*emitAsReturn*/ + !1 + ), Ig(M, o()); + const dt = n.updateSourceFile(ue, ct(n.createNodeArray(M), ue.statements)); + return Wg(dt, e.readEmitHelpers()), dt; + } + function $(ue) { + const M = n.createIdentifier("define"), ye = GN(n, ue, g, _), Q = ap(ue) && ue, { aliasedModuleNames: dt, unaliasedModuleNames: Mt, importAliasNames: ke } = _e( + ue, + /*includeNonAmdDependencies*/ + !0 + ), at = n.updateSourceFile( + ue, + ct( + n.createNodeArray([ + n.createExpressionStatement( + n.createCallExpression( + M, + /*typeArguments*/ + void 0, + [ + // Add the module name (if provided). + ...ye ? [ye] : [], + // Add the dependency array argument: + // + // ["require", "exports", module1", "module2", ...] + n.createArrayLiteralExpression( + Q ? Ge : [ + n.createStringLiteral("require"), + n.createStringLiteral("exports"), + ...dt, + ...Mt + ] + ), + // Add the module body function argument: + // + // function (require, exports, module1, module2) ... + Q ? Q.statements.length ? Q.statements[0].expression : n.createObjectLiteralExpression() : n.createFunctionExpression( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + [ + n.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "require" + ), + n.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "exports" + ), + ...ke + ], + /*type*/ + void 0, + V(ue) + ) + ] + ) + ) + ]), + /*location*/ + ue.statements + ) + ); + return Wg(at, e.readEmitHelpers()), at; + } + function W(ue) { + const { aliasedModuleNames: M, unaliasedModuleNames: ye, importAliasNames: Q } = _e( + ue, + /*includeNonAmdDependencies*/ + !1 + ), dt = GN(n, ue, g, _), Mt = n.createFunctionExpression( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + [n.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "factory" + )], + /*type*/ + void 0, + ct( + n.createBlock( + [ + n.createIfStatement( + n.createLogicalAnd( + n.createTypeCheck(n.createIdentifier("module"), "object"), + n.createTypeCheck(n.createPropertyAccessExpression(n.createIdentifier("module"), "exports"), "object") + ), + n.createBlock([ + n.createVariableStatement( + /*modifiers*/ + void 0, + [ + n.createVariableDeclaration( + "v", + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + n.createCallExpression( + n.createIdentifier("factory"), + /*typeArguments*/ + void 0, + [ + n.createIdentifier("require"), + n.createIdentifier("exports") + ] + ) + ) + ] + ), + un( + n.createIfStatement( + n.createStrictInequality( + n.createIdentifier("v"), + n.createIdentifier("undefined") + ), + n.createExpressionStatement( + n.createAssignment( + n.createPropertyAccessExpression(n.createIdentifier("module"), "exports"), + n.createIdentifier("v") + ) + ) + ), + 1 + /* SingleLine */ + ) + ]), + n.createIfStatement( + n.createLogicalAnd( + n.createTypeCheck(n.createIdentifier("define"), "function"), + n.createPropertyAccessExpression(n.createIdentifier("define"), "amd") + ), + n.createBlock([ + n.createExpressionStatement( + n.createCallExpression( + n.createIdentifier("define"), + /*typeArguments*/ + void 0, + [ + // Add the module name (if provided). + ...dt ? [dt] : [], + n.createArrayLiteralExpression([ + n.createStringLiteral("require"), + n.createStringLiteral("exports"), + ...M, + ...ye + ]), + n.createIdentifier("factory") + ] + ) + ) + ]) + ) + ) + ], + /*multiLine*/ + !0 + ), + /*location*/ + void 0 + ) + ), ke = n.updateSourceFile( + ue, + ct( + n.createNodeArray([ + n.createExpressionStatement( + n.createCallExpression( + Mt, + /*typeArguments*/ + void 0, + [ + // Add the module body function argument: + // + // function (require, exports) ... + n.createFunctionExpression( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + [ + n.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "require" + ), + n.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "exports" + ), + ...Q + ], + /*type*/ + void 0, + V(ue) + ) + ] + ) + ) + ]), + /*location*/ + ue.statements + ) + ); + return Wg(ke, e.readEmitHelpers()), ke; + } + function _e(ue, M) { + const ye = [], Q = [], dt = []; + for (const Mt of ue.amdDependencies) + Mt.name ? (ye.push(n.createStringLiteral(Mt.path)), dt.push(n.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + Mt.name + ))) : Q.push(n.createStringLiteral(Mt.path)); + for (const Mt of P.externalImports) { + const ke = Zx(n, Mt, D, g, u, _), at = k6(n, Mt, D); + ke && (M && at ? (un( + at, + 8 + /* NoSubstitution */ + ), ye.push(ke), dt.push(n.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + at + ))) : Q.push(ke)); + } + return { aliasedModuleNames: ye, unaliasedModuleNames: Q, importAliasNames: dt }; + } + function K(ue) { + if (_l(ue) || Bc(ue) || !Zx(n, ue, D, g, u, _)) + return; + const M = k6(n, ue, D), ye = fi(ue, M); + if (ye !== M) + return n.createExpressionStatement(n.createAssignment(M, ye)); + } + function V(ue) { + s(); + const M = [], ye = n.copyPrologue( + ue.statements, + M, + /*ensureUseStrict*/ + !0, + se + ); + B() && Er(M, Ae()), ot(P.exportedNames) && Er( + M, + n.createExpressionStatement(Wu(P.exportedNames, (dt, Mt) => Mt.kind === 11 ? n.createAssignment(n.createElementAccessExpression(n.createIdentifier("exports"), n.createStringLiteral(Mt.text)), dt) : n.createAssignment(n.createPropertyAccessExpression(n.createIdentifier("exports"), n.createIdentifier(An(Mt))), dt), n.createVoidZero())) + ); + for (const dt of P.exportedFunctions) + re(M, dt); + Er(M, Qe(P.externalHelpersImportDeclaration, se, Ti)), h === 2 && In(M, Fi(P.externalImports, K)), In(M, Ar(ue.statements, se, Ti, ye)), ae( + M, + /*emitAsReturn*/ + !0 + ), Ig(M, o()); + const Q = n.createBlock( + M, + /*multiLine*/ + !0 + ); + return F && jx(Q, Fje), Q; + } + function ae(ue, M) { + if (P.exportEquals) { + const ye = Qe(P.exportEquals.expression, he, ut); + if (ye) + if (M) { + const Q = n.createReturnStatement(ye); + ct(Q, P.exportEquals), un( + Q, + 3840 + /* NoComments */ + ), ue.push(Q); + } else { + const Q = n.createExpressionStatement( + n.createAssignment( + n.createPropertyAccessExpression( + n.createIdentifier("module"), + "exports" + ), + ye + ) + ); + ct(Q, P.exportEquals), un( + Q, + 3072 + /* NoComments */ + ), ue.push(Q); + } + } + } + function se(ue) { + switch (ue.kind) { + case 273: + return pn(ue); + case 272: + return Je(ue); + case 279: + return ft(ue); + case 278: + return er(ue); + default: + return ce(ue); + } + } + function ce(ue) { + switch (ue.kind) { + case 244: + return Un(ue); + case 263: + return qr(ue); + case 264: + return Jn(ue); + case 249: + return me( + ue, + /*isTopLevel*/ + !0 + ); + case 250: + return Z(ue); + case 251: + return pe(ue); + case 247: + return Te(ue); + case 248: + return Fe(ue); + case 257: + return Ye(ue); + case 255: + return ne(ue); + case 246: + return Se(ue); + case 256: + return ie(ue); + case 270: + return Ne(ue); + case 297: + return Ee(ue); + case 298: + return Ce(ue); + case 259: + return Ve(ue); + case 300: + return St(ue); + case 242: + return Bt(ue); + default: + return he(ue); + } + } + function fe(ue, M) { + if (!(ue.transformFlags & 276828160) && !A?.length) + return ue; + switch (ue.kind) { + case 249: + return me( + ue, + /*isTopLevel*/ + !1 + ); + case 245: + return tr(ue); + case 218: + return Nr(ue, M); + case 356: + return st(ue, M); + case 214: + const ye = ue === Yc(A); + if (ye && A.shift(), T_(ue) && g.shouldTransformImportCall(D)) + return ui(ue, ye); + if (ye) + return Jr(ue); + break; + case 227: + if (y0(ue)) + return je(ue, M); + break; + case 225: + case 226: + return Wt(ue, M); + } + return br(ue, he, e); + } + function he(ue) { + return fe( + ue, + /*valueIsDiscarded*/ + !1 + ); + } + function q(ue) { + return fe( + ue, + /*valueIsDiscarded*/ + !0 + ); + } + function be(ue) { + if (_a(ue)) + for (const M of ue.properties) + switch (M.kind) { + case 304: + if (be(M.initializer)) + return !0; + break; + case 305: + if (be(M.name)) + return !0; + break; + case 306: + if (be(M.expression)) + return !0; + break; + case 175: + case 178: + case 179: + return !1; + default: + E.assertNever(M, "Unhandled object member kind"); + } + else if (nu(ue)) { + for (const M of ue.elements) + if (dp(M)) { + if (be(M.expression)) + return !0; + } else if (be(M)) + return !0; + } else if (Me(ue)) + return wr(yt(ue)) > (jF(ue) ? 1 : 0); + return !1; + } + function je(ue, M) { + return be(ue.left) ? BS(ue, he, e, 0, !M, ki) : br(ue, he, e); + } + function me(ue, M) { + if (M && ue.initializer && Ul(ue.initializer) && !(ue.initializer.flags & 7)) { + const ye = Xe( + /*statements*/ + void 0, + ue.initializer, + /*isForInOrOfInitializer*/ + !1 + ); + if (ye) { + const Q = [], dt = Qe(ue.initializer, q, Ul), Mt = n.createVariableStatement( + /*modifiers*/ + void 0, + dt + ); + Q.push(Mt), In(Q, ye); + const ke = Qe(ue.condition, he, ut), at = Qe(ue.incrementor, q, ut), wt = c_(ue.statement, M ? ce : he, e); + return Q.push(n.updateForStatement( + ue, + /*initializer*/ + void 0, + ke, + at, + wt + )), Q; + } + } + return n.updateForStatement( + ue, + Qe(ue.initializer, q, ip), + Qe(ue.condition, he, ut), + Qe(ue.incrementor, q, ut), + c_(ue.statement, M ? ce : he, e) + ); + } + function Z(ue) { + if (Ul(ue.initializer) && !(ue.initializer.flags & 7)) { + const M = Xe( + /*statements*/ + void 0, + ue.initializer, + /*isForInOrOfInitializer*/ + !0 + ); + if (ot(M)) { + const ye = Qe(ue.initializer, q, ip), Q = Qe(ue.expression, he, ut), dt = c_(ue.statement, ce, e), Mt = Ns(dt) ? n.updateBlock(dt, [...M, ...dt.statements]) : n.createBlock( + [...M, dt], + /*multiLine*/ + !0 + ); + return n.updateForInStatement(ue, ye, Q, Mt); + } + } + return n.updateForInStatement( + ue, + Qe(ue.initializer, q, ip), + Qe(ue.expression, he, ut), + c_(ue.statement, ce, e) + ); + } + function pe(ue) { + if (Ul(ue.initializer) && !(ue.initializer.flags & 7)) { + const M = Xe( + /*statements*/ + void 0, + ue.initializer, + /*isForInOrOfInitializer*/ + !0 + ), ye = Qe(ue.initializer, q, ip), Q = Qe(ue.expression, he, ut); + let dt = c_(ue.statement, ce, e); + return ot(M) && (dt = Ns(dt) ? n.updateBlock(dt, [...M, ...dt.statements]) : n.createBlock( + [...M, dt], + /*multiLine*/ + !0 + )), n.updateForOfStatement(ue, ue.awaitModifier, ye, Q, dt); + } + return n.updateForOfStatement( + ue, + ue.awaitModifier, + Qe(ue.initializer, q, ip), + Qe(ue.expression, he, ut), + c_(ue.statement, ce, e) + ); + } + function Te(ue) { + return n.updateDoStatement( + ue, + c_(ue.statement, ce, e), + Qe(ue.expression, he, ut) + ); + } + function Fe(ue) { + return n.updateWhileStatement( + ue, + Qe(ue.expression, he, ut), + c_(ue.statement, ce, e) + ); + } + function Ye(ue) { + return n.updateLabeledStatement( + ue, + ue.label, + Qe(ue.statement, ce, Ti, n.liftToBlock) ?? ct(n.createEmptyStatement(), ue.statement) + ); + } + function ne(ue) { + return n.updateWithStatement( + ue, + Qe(ue.expression, he, ut), + E.checkDefined(Qe(ue.statement, ce, Ti, n.liftToBlock)) + ); + } + function Se(ue) { + return n.updateIfStatement( + ue, + Qe(ue.expression, he, ut), + Qe(ue.thenStatement, ce, Ti, n.liftToBlock) ?? n.createBlock([]), + Qe(ue.elseStatement, ce, Ti, n.liftToBlock) + ); + } + function ie(ue) { + return n.updateSwitchStatement( + ue, + Qe(ue.expression, he, ut), + E.checkDefined(Qe(ue.caseBlock, ce, O4)) + ); + } + function Ne(ue) { + return n.updateCaseBlock( + ue, + Ar(ue.clauses, ce, I7) + ); + } + function Ee(ue) { + return n.updateCaseClause( + ue, + Qe(ue.expression, he, ut), + Ar(ue.statements, ce, Ti) + ); + } + function Ce(ue) { + return br(ue, ce, e); + } + function Ve(ue) { + return br(ue, ce, e); + } + function St(ue) { + return n.updateCatchClause( + ue, + ue.variableDeclaration, + E.checkDefined(Qe(ue.block, ce, Ns)) + ); + } + function Bt(ue) { + return ue = br(ue, ce, e), ue; + } + function tr(ue) { + return n.updateExpressionStatement( + ue, + Qe(ue.expression, q, ut) + ); + } + function Nr(ue, M) { + return n.updateParenthesizedExpression(ue, Qe(ue.expression, M ? q : he, ut)); + } + function st(ue, M) { + return n.updatePartiallyEmittedExpression(ue, Qe(ue.expression, M ? q : he, ut)); + } + function Wt(ue, M) { + if ((ue.operator === 46 || ue.operator === 47) && Me(ue.operand) && !Bo(ue.operand) && !Nh(ue.operand) && !dJ(ue.operand)) { + const ye = yt(ue.operand); + if (ye) { + let Q, dt = Qe(ue.operand, he, ut); + iv(ue) ? dt = n.updatePrefixUnaryExpression(ue, dt) : (dt = n.updatePostfixUnaryExpression(ue, dt), M || (Q = n.createTempVariable(c), dt = n.createAssignment(Q, dt), ct(dt, ue)), dt = n.createComma(dt, n.cloneNode(ue.operand)), ct(dt, ue)); + for (const Mt of ye) + O[Ma(dt)] = !0, dt = Ke(Mt, dt), ct(dt, ue); + return Q && (O[Ma(dt)] = !0, dt = n.createComma(dt, Q), ct(dt, ue)), dt; + } + } + return br(ue, he, e); + } + function Jr(ue) { + return n.updateCallExpression( + ue, + ue.expression, + /*typeArguments*/ + void 0, + Ar(ue.arguments, (M) => M === ue.arguments[0] ? ja(M) ? sk(M, _) : i().createRewriteRelativeImportExtensionsHelper(M) : he(M), ut) + ); + } + function ui(ue, M) { + if (h === 0 && m >= 7) + return br(ue, he, e); + const ye = Zx(n, ue, D, g, u, _), Q = Qe(Yc(ue.arguments), he, ut), dt = ye && (!Q || !ca(Q) || Q.text !== ye.text) ? ye : Q && M ? ca(Q) ? sk(Q, _) : i().createRewriteRelativeImportExtensionsHelper(Q) : Q, Mt = !!(ue.transformFlags & 16384); + switch (_.module) { + case 2: + return Dt(dt, Mt); + case 3: + return Ji(dt ?? n.createVoidZero(), Mt); + case 1: + default: + return Mn(dt); + } + } + function Ji(ue, M) { + if (F = !0, r2(ue)) { + const ye = Bo(ue) ? ue : ca(ue) ? n.createStringLiteralFromNode(ue) : un( + ct(n.cloneNode(ue), ue), + 3072 + /* NoComments */ + ); + return n.createConditionalExpression( + /*condition*/ + n.createIdentifier("__syncRequire"), + /*questionToken*/ + void 0, + /*whenTrue*/ + Mn(ue), + /*colonToken*/ + void 0, + /*whenFalse*/ + Dt(ye, M) + ); + } else { + const ye = n.createTempVariable(c); + return n.createComma( + n.createAssignment(ye, ue), + n.createConditionalExpression( + /*condition*/ + n.createIdentifier("__syncRequire"), + /*questionToken*/ + void 0, + /*whenTrue*/ + Mn( + ye, + /*isInlineable*/ + !0 + ), + /*colonToken*/ + void 0, + /*whenFalse*/ + Dt(ye, M) + ) + ); + } + } + function Dt(ue, M) { + const ye = n.createUniqueName("resolve"), Q = n.createUniqueName("reject"), dt = [ + n.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + /*name*/ + ye + ), + n.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + /*name*/ + Q + ) + ], Mt = n.createBlock([ + n.createExpressionStatement( + n.createCallExpression( + n.createIdentifier("require"), + /*typeArguments*/ + void 0, + [n.createArrayLiteralExpression([ue || n.createOmittedExpression()]), ye, Q] + ) + ) + ]); + let ke; + m >= 2 ? ke = n.createArrowFunction( + /*modifiers*/ + void 0, + /*typeParameters*/ + void 0, + dt, + /*type*/ + void 0, + /*equalsGreaterThanToken*/ + void 0, + Mt + ) : (ke = n.createFunctionExpression( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + dt, + /*type*/ + void 0, + Mt + ), M && un( + ke, + 16 + /* CapturesThis */ + )); + const at = n.createNewExpression( + n.createIdentifier("Promise"), + /*typeArguments*/ + void 0, + [ke] + ); + return mm(_) ? n.createCallExpression( + n.createPropertyAccessExpression(at, n.createIdentifier("then")), + /*typeArguments*/ + void 0, + [i().createImportStarCallbackHelper()] + ) : at; + } + function Mn(ue, M) { + const ye = ue && !rg(ue) && !M, Q = n.createCallExpression( + n.createPropertyAccessExpression(n.createIdentifier("Promise"), "resolve"), + /*typeArguments*/ + void 0, + /*argumentsArray*/ + ye ? m >= 2 ? [ + n.createTemplateExpression(n.createTemplateHead(""), [ + n.createTemplateSpan(ue, n.createTemplateTail("")) + ]) + ] : [ + n.createCallExpression( + n.createPropertyAccessExpression(n.createStringLiteral(""), "concat"), + /*typeArguments*/ + void 0, + [ue] + ) + ] : [] + ); + let dt = n.createCallExpression( + n.createIdentifier("require"), + /*typeArguments*/ + void 0, + ye ? [n.createIdentifier("s")] : ue ? [ue] : [] + ); + mm(_) && (dt = i().createImportStarHelper(dt)); + const Mt = ye ? [ + n.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + /*name*/ + "s" + ) + ] : []; + let ke; + return m >= 2 ? ke = n.createArrowFunction( + /*modifiers*/ + void 0, + /*typeParameters*/ + void 0, + /*parameters*/ + Mt, + /*type*/ + void 0, + /*equalsGreaterThanToken*/ + void 0, + dt + ) : ke = n.createFunctionExpression( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + /*parameters*/ + Mt, + /*type*/ + void 0, + n.createBlock([n.createReturnStatement(dt)]) + ), n.createCallExpression( + n.createPropertyAccessExpression(Q, "then"), + /*typeArguments*/ + void 0, + [ke] + ); + } + function ai(ue, M) { + return !mm(_) || sd(ue) & 2 ? M : One(ue) ? i().createImportStarHelper(M) : M; + } + function fi(ue, M) { + return !mm(_) || sd(ue) & 2 ? M : TO(ue) ? i().createImportStarHelper(M) : JW(ue) ? i().createImportDefaultHelper(M) : M; + } + function pn(ue) { + let M; + const ye = qC(ue); + if (h !== 2) + if (ue.importClause) { + const Q = []; + ye && !fS(ue) ? Q.push( + n.createVariableDeclaration( + n.cloneNode(ye.name), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + fi(ue, _i(ue)) + ) + ) : (Q.push( + n.createVariableDeclaration( + n.getGeneratedNameForNode(ue), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + fi(ue, _i(ue)) + ) + ), ye && fS(ue) && Q.push( + n.createVariableDeclaration( + n.cloneNode(ye.name), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + n.getGeneratedNameForNode(ue) + ) + )), M = Er( + M, + Cn( + ct( + n.createVariableStatement( + /*modifiers*/ + void 0, + n.createVariableDeclarationList( + Q, + m >= 2 ? 2 : 0 + /* None */ + ) + ), + /*location*/ + ue + ), + /*original*/ + ue + ) + ); + } else + return Cn(ct(n.createExpressionStatement(_i(ue)), ue), ue); + else ye && fS(ue) && (M = Er( + M, + n.createVariableStatement( + /*modifiers*/ + void 0, + n.createVariableDeclarationList( + [ + Cn( + ct( + n.createVariableDeclaration( + n.cloneNode(ye.name), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + n.getGeneratedNameForNode(ue) + ), + /*location*/ + ue + ), + /*original*/ + ue + ) + ], + m >= 2 ? 2 : 0 + /* None */ + ) + ) + )); + return M = Ks(M, ue), Wm(M); + } + function _i(ue) { + const M = Zx(n, ue, D, g, u, _), ye = []; + return M && ye.push(sk(M, _)), n.createCallExpression( + n.createIdentifier("require"), + /*typeArguments*/ + void 0, + ye + ); + } + function Je(ue) { + E.assert(H1(ue), "import= for internal module references should be handled in an earlier transformer."); + let M; + return h !== 2 ? Gn( + ue, + 32 + /* Export */ + ) ? M = Er( + M, + Cn( + ct( + n.createExpressionStatement( + Ke( + ue.name, + _i(ue) + ) + ), + ue + ), + ue + ) + ) : M = Er( + M, + Cn( + ct( + n.createVariableStatement( + /*modifiers*/ + void 0, + n.createVariableDeclarationList( + [ + n.createVariableDeclaration( + n.cloneNode(ue.name), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + _i(ue) + ) + ], + /*flags*/ + m >= 2 ? 2 : 0 + /* None */ + ) + ), + ue + ), + ue + ) + ) : Gn( + ue, + 32 + /* Export */ + ) && (M = Er( + M, + Cn( + ct( + n.createExpressionStatement( + Ke(n.getExportName(ue), n.getLocalName(ue)) + ), + ue + ), + ue + ) + )), M = yr(M, ue), Wm(M); + } + function ft(ue) { + if (!ue.moduleSpecifier) + return; + const M = n.getGeneratedNameForNode(ue); + if (ue.exportClause && mp(ue.exportClause)) { + const ye = []; + h !== 2 && ye.push( + Cn( + ct( + n.createVariableStatement( + /*modifiers*/ + void 0, + n.createVariableDeclarationList([ + n.createVariableDeclaration( + M, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + _i(ue) + ) + ]) + ), + /*location*/ + ue + ), + /* original */ + ue + ) + ); + for (const Q of ue.exportClause.elements) { + const dt = Q.propertyName || Q.name, ke = !!mm(_) && !(sd(ue) & 2) && Gm(dt) ? i().createImportDefaultHelper(M) : M, at = dt.kind === 11 ? n.createElementAccessExpression(ke, dt) : n.createPropertyAccessExpression(ke, dt); + ye.push( + Cn( + ct( + n.createExpressionStatement( + Ke( + Q.name.kind === 11 ? n.cloneNode(Q.name) : n.getExportName(Q), + at, + /*location*/ + void 0, + /*liveBinding*/ + !0 + ) + ), + Q + ), + Q + ) + ); + } + return Wm(ye); + } else if (ue.exportClause) { + const ye = []; + return ye.push( + Cn( + ct( + n.createExpressionStatement( + Ke( + n.cloneNode(ue.exportClause.name), + ai( + ue, + h !== 2 ? _i(ue) : V7(ue) || ue.exportClause.name.kind === 11 ? M : n.createIdentifier(An(ue.exportClause.name)) + ) + ) + ), + ue + ), + ue + ) + ), Wm(ye); + } else + return Cn( + ct( + n.createExpressionStatement( + i().createExportStarHelper(h !== 2 ? _i(ue) : M) + ), + ue + ), + ue + ); + } + function er(ue) { + if (!ue.isExportEquals) + return $e( + n.createIdentifier("default"), + Qe(ue.expression, he, ut), + /*location*/ + ue, + /*allowComments*/ + !0 + ); + } + function qr(ue) { + let M; + return Gn( + ue, + 32 + /* Export */ + ) ? M = Er( + M, + Cn( + ct( + n.createFunctionDeclaration( + Ar(ue.modifiers, Tt, Zs), + ue.asteriskToken, + n.getDeclarationName( + ue, + /*allowComments*/ + !0, + /*allowSourceMaps*/ + !0 + ), + /*typeParameters*/ + void 0, + Ar(ue.parameters, he, Ii), + /*type*/ + void 0, + br(ue.body, he, e) + ), + /*location*/ + ue + ), + /*original*/ + ue + ) + ) : M = Er(M, br(ue, he, e)), Wm(M); + } + function Jn(ue) { + let M; + return Gn( + ue, + 32 + /* Export */ + ) ? M = Er( + M, + Cn( + ct( + n.createClassDeclaration( + Ar(ue.modifiers, Tt, Jo), + n.getDeclarationName( + ue, + /*allowComments*/ + !0, + /*allowSourceMaps*/ + !0 + ), + /*typeParameters*/ + void 0, + Ar(ue.heritageClauses, he, cf), + Ar(ue.members, he, Hc) + ), + ue + ), + ue + ) + ) : M = Er(M, br(ue, he, e)), M = re(M, ue), Wm(M); + } + function Un(ue) { + let M, ye, Q; + if (Gn( + ue, + 32 + /* Export */ + )) { + let dt, Mt = !1; + for (const ke of ue.declarationList.declarations) + if (Me(ke.name) && Nh(ke.name)) + if (dt || (dt = Ar(ue.modifiers, Tt, Zs)), ke.initializer) { + const at = n.updateVariableDeclaration( + ke, + ke.name, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + Ke( + ke.name, + Qe(ke.initializer, he, ut) + ) + ); + ye = Er(ye, at); + } else + ye = Er(ye, ke); + else if (ke.initializer) + if (!ws(ke.name) && (xo(ke.initializer) || yo(ke.initializer) || Rc(ke.initializer))) { + const at = n.createAssignment( + ct( + n.createPropertyAccessExpression( + n.createIdentifier("exports"), + ke.name + ), + /*location*/ + ke.name + ), + n.createIdentifier(op(ke.name)) + ), wt = n.createVariableDeclaration( + ke.name, + ke.exclamationToken, + ke.type, + Qe(ke.initializer, he, ut) + ); + ye = Er(ye, wt), Q = Er(Q, at), Mt = !0; + } else + Q = Er(Q, Ds(ke)); + if (ye && (M = Er(M, n.updateVariableStatement(ue, dt, n.updateVariableDeclarationList(ue.declarationList, ye)))), Q) { + const ke = Cn(ct(n.createExpressionStatement(n.inlineExpressions(Q)), ue), ue); + Mt && IN(ke), M = Er(M, ke); + } + } else + M = Er(M, br(ue, he, e)); + return M = bs(M, ue), Wm(M); + } + function ki(ue, M, ye) { + const Q = yt(ue); + if (Q) { + let dt = jF(ue) ? M : n.createAssignment(ue, M); + for (const Mt of Q) + un( + dt, + 8 + /* NoSubstitution */ + ), dt = Ke( + Mt, + dt, + /*location*/ + ye + ); + return dt; + } + return n.createAssignment(ue, M); + } + function Ds(ue) { + return ws(ue.name) ? BS( + Qe(ue, he, _N), + he, + e, + 0, + /*needsValue*/ + !1, + ki + ) : n.createAssignment( + ct( + n.createPropertyAccessExpression( + n.createIdentifier("exports"), + ue.name + ), + /*location*/ + ue.name + ), + ue.initializer ? Qe(ue.initializer, he, ut) : n.createVoidZero() + ); + } + function Ks(ue, M) { + if (P.exportEquals) + return ue; + const ye = M.importClause; + if (!ye) + return ue; + const Q = new L6(); + ye.name && (ue = it(ue, Q, ye)); + const dt = ye.namedBindings; + if (dt) + switch (dt.kind) { + case 275: + ue = it(ue, Q, dt); + break; + case 276: + for (const Mt of dt.elements) + ue = it( + ue, + Q, + Mt, + /*liveBinding*/ + !0 + ); + break; + } + return ue; + } + function yr(ue, M) { + return P.exportEquals ? ue : it(ue, new L6(), M); + } + function bs(ue, M) { + return Xe( + ue, + M.declarationList, + /*isForInOrOfInitializer*/ + !1 + ); + } + function Xe(ue, M, ye) { + if (P.exportEquals) + return ue; + for (const Q of M.declarations) + ue = Et(ue, Q, ye); + return ue; + } + function Et(ue, M, ye) { + if (P.exportEquals) + return ue; + if (ws(M.name)) + for (const Q of M.name.elements) + vl(Q) || (ue = Et(ue, Q, ye)); + else !Bo(M.name) && (!ei(M) || M.initializer || ye) && (ue = it(ue, new L6(), M)); + return ue; + } + function re(ue, M) { + if (P.exportEquals) + return ue; + const ye = new L6(); + if (Gn( + M, + 32 + /* Export */ + )) { + const Q = Gn( + M, + 2048 + /* Default */ + ) ? n.createIdentifier("default") : n.getDeclarationName(M); + ue = Y( + ue, + ye, + Q, + n.getLocalName(M), + /*location*/ + M + ); + } + return M.name && (ue = it(ue, ye, M)), ue; + } + function it(ue, M, ye, Q) { + const dt = n.getDeclarationName(ye), Mt = P.exportSpecifiers.get(dt); + if (Mt) + for (const ke of Mt) + ue = Y( + ue, + M, + ke.name, + dt, + /*location*/ + ke.name, + /*allowComments*/ + void 0, + Q + ); + return ue; + } + function Y(ue, M, ye, Q, dt, Mt, ke) { + if (ye.kind !== 11) { + if (M.has(ye)) + return ue; + M.set(ye, !0); + } + return ue = Er(ue, $e(ye, Q, dt, Mt, ke)), ue; + } + function Ae() { + const ue = n.createExpressionStatement( + n.createCallExpression( + n.createPropertyAccessExpression(n.createIdentifier("Object"), "defineProperty"), + /*typeArguments*/ + void 0, + [ + n.createIdentifier("exports"), + n.createStringLiteral("__esModule"), + n.createObjectLiteralExpression([ + n.createPropertyAssignment("value", n.createTrue()) + ]) + ] + ) + ); + return un( + ue, + 2097152 + /* CustomPrologue */ + ), ue; + } + function $e(ue, M, ye, Q, dt) { + const Mt = ct(n.createExpressionStatement(Ke( + ue, + M, + /*location*/ + void 0, + dt + )), ye); + return Au(Mt), Q || un( + Mt, + 3072 + /* NoComments */ + ), Mt; + } + function Ke(ue, M, ye, Q) { + return ct( + Q ? n.createCallExpression( + n.createPropertyAccessExpression( + n.createIdentifier("Object"), + "defineProperty" + ), + /*typeArguments*/ + void 0, + [ + n.createIdentifier("exports"), + n.createStringLiteralFromNode(ue), + n.createObjectLiteralExpression([ + n.createPropertyAssignment("enumerable", n.createTrue()), + n.createPropertyAssignment( + "get", + n.createFunctionExpression( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + /*parameters*/ + [], + /*type*/ + void 0, + n.createBlock([n.createReturnStatement(M)]) + ) + ) + ]) + ] + ) : n.createAssignment( + ue.kind === 11 ? n.createElementAccessExpression( + n.createIdentifier("exports"), + n.cloneNode(ue) + ) : n.createPropertyAccessExpression( + n.createIdentifier("exports"), + n.cloneNode(ue) + ), + M + ), + ye + ); + } + function Tt(ue) { + switch (ue.kind) { + case 95: + case 90: + return; + } + return ue; + } + function Le(ue, M, ye) { + M.kind === 308 ? (D = M, P = k[l_(D)], T(ue, M, ye), D = void 0, P = void 0) : T(ue, M, ye); + } + function mt(ue, M) { + return M = S(ue, M), M.id && O[M.id] ? M : ue === 1 ? Ct(M) : gu(M) ? pt(M) : M; + } + function pt(ue) { + const M = ue.name, ye = rn(M); + if (ye !== M) { + if (ue.objectAssignmentInitializer) { + const Q = n.createAssignment(ye, ue.objectAssignmentInitializer); + return ct(n.createPropertyAssignment(M, Q), ue); + } + return ct(n.createPropertyAssignment(M, ye), ue); + } + return ue; + } + function Ct(ue) { + switch (ue.kind) { + case 80: + return rn(ue); + case 214: + return qe(ue); + case 216: + return Lt(ue); + case 227: + return Pe(ue); + } + return ue; + } + function qe(ue) { + if (Me(ue.expression)) { + const M = rn(ue.expression); + if (O[Ma(M)] = !0, !Me(M) && !(Ea(ue.expression) & 8192)) + return bS( + n.updateCallExpression( + ue, + M, + /*typeArguments*/ + void 0, + ue.arguments + ), + 16 + /* IndirectCall */ + ); + } + return ue; + } + function Lt(ue) { + if (Me(ue.tag)) { + const M = rn(ue.tag); + if (O[Ma(M)] = !0, !Me(M) && !(Ea(ue.tag) & 8192)) + return bS( + n.updateTaggedTemplateExpression( + ue, + M, + /*typeArguments*/ + void 0, + ue.template + ), + 16 + /* IndirectCall */ + ); + } + return ue; + } + function rn(ue) { + var M, ye; + if (Ea(ue) & 8192) { + const Q = HN(D); + return Q ? n.createPropertyAccessExpression(Q, ue) : ue; + } else if (!(Bo(ue) && !(ue.emitNode.autoGenerate.flags & 64)) && !Nh(ue)) { + const Q = u.getReferencedExportContainer(ue, jF(ue)); + if (Q && Q.kind === 308) + return ct( + n.createPropertyAccessExpression( + n.createIdentifier("exports"), + n.cloneNode(ue) + ), + /*location*/ + ue + ); + const dt = u.getReferencedImportDeclaration(ue); + if (dt) { + if (ld(dt)) + return ct( + n.createPropertyAccessExpression( + n.getGeneratedNameForNode(dt.parent), + n.createIdentifier("default") + ), + /*location*/ + ue + ); + if (Xu(dt)) { + const Mt = dt.propertyName || dt.name, ke = n.getGeneratedNameForNode(((ye = (M = dt.parent) == null ? void 0 : M.parent) == null ? void 0 : ye.parent) || dt); + return ct( + Mt.kind === 11 ? n.createElementAccessExpression(ke, n.cloneNode(Mt)) : n.createPropertyAccessExpression(ke, n.cloneNode(Mt)), + /*location*/ + ue + ); + } + } + } + return ue; + } + function Pe(ue) { + if (kh(ue.operatorToken.kind) && Me(ue.left) && (!Bo(ue.left) || o3(ue.left)) && !Nh(ue.left)) { + const M = yt(ue.left); + if (M) { + let ye = ue; + for (const Q of M) + O[Ma(ye)] = !0, ye = Ke( + Q, + ye, + /*location*/ + ue + ); + return ye; + } + } + return ue; + } + function yt(ue) { + if (Bo(ue)) { + if (o3(ue)) { + const M = P?.exportSpecifiers.get(ue); + if (M) { + const ye = []; + for (const Q of M) + ye.push(Q.name); + return ye; + } + } + } else { + const M = u.getReferencedImportDeclaration(ue); + if (M) + return P?.exportedBindings[l_(M)]; + const ye = /* @__PURE__ */ new Set(), Q = u.getReferencedValueDeclarations(ue); + if (Q) { + for (const dt of Q) { + const Mt = P?.exportedBindings[l_(dt)]; + if (Mt) + for (const ke of Mt) + ye.add(ke); + } + if (ye.size) + return is(ye); + } + } + } + } + var Fje = { + name: "typescript:dynamicimport-sync-require", + scoped: !0, + text: ` + var __syncRequire = typeof module === "object" && typeof module.exports === "object";` + }; + function lie(e) { + const { + factory: t, + startLexicalEnvironment: n, + endLexicalEnvironment: i, + hoistVariableDeclaration: s + } = e, o = e.getCompilerOptions(), c = e.getEmitResolver(), _ = e.getEmitHost(), u = e.onSubstituteNode, g = e.onEmitNode; + e.onSubstituteNode = Ae, e.onEmitNode = Y, e.enableSubstitution( + 80 + /* Identifier */ + ), e.enableSubstitution( + 305 + /* ShorthandPropertyAssignment */ + ), e.enableSubstitution( + 227 + /* BinaryExpression */ + ), e.enableSubstitution( + 237 + /* MetaProperty */ + ), e.enableEmitNotification( + 308 + /* SourceFile */ + ); + const m = [], h = [], S = [], T = []; + let k, D, P, A, O, F, R; + return Ld(e, B); + function B(Pe) { + if (Pe.isDeclarationFile || !(RC(Pe, o) || Pe.transformFlags & 8388608)) + return Pe; + const yt = l_(Pe); + k = Pe, F = Pe, D = m[yt] = zW(e, Pe), P = t.createUniqueName("exports"), h[yt] = P, A = T[yt] = t.createUniqueName("context"); + const ue = U(D.externalImports), M = $(Pe, ue), ye = t.createFunctionExpression( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + [ + t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + P + ), + t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + A + ) + ], + /*type*/ + void 0, + M + ), Q = GN(t, Pe, _, o), dt = t.createArrayLiteralExpression(hr(ue, (ke) => ke.name)), Mt = un( + t.updateSourceFile( + Pe, + ct( + t.createNodeArray([ + t.createExpressionStatement( + t.createCallExpression( + t.createPropertyAccessExpression(t.createIdentifier("System"), "register"), + /*typeArguments*/ + void 0, + Q ? [Q, dt, ye] : [dt, ye] + ) + ) + ]), + Pe.statements + ) + ), + 2048 + /* NoTrailingComments */ + ); + return o.outFile || bte(Mt, M, (ke) => !ke.scoped), R && (S[yt] = R, R = void 0), k = void 0, D = void 0, P = void 0, A = void 0, O = void 0, F = void 0, Mt; + } + function U(Pe) { + const yt = /* @__PURE__ */ new Map(), ue = []; + for (const M of Pe) { + const ye = Zx(t, M, k, _, c, o); + if (ye) { + const Q = ye.text, dt = yt.get(Q); + dt !== void 0 ? ue[dt].externalImports.push(M) : (yt.set(Q, ue.length), ue.push({ + name: ye, + externalImports: [M] + })); + } + } + return ue; + } + function $(Pe, yt) { + const ue = []; + n(); + const M = du(o, "alwaysStrict") || fl(k), ye = t.copyPrologue(Pe.statements, ue, M, V); + ue.push( + t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList([ + t.createVariableDeclaration( + "__moduleName", + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createLogicalAnd( + A, + t.createPropertyAccessExpression(A, "id") + ) + ) + ]) + ) + ), Qe(D.externalHelpersImportDeclaration, V, Ti); + const Q = Ar(Pe.statements, V, Ti, ye); + In(ue, O), Ig(ue, i()); + const dt = W(ue), Mt = Pe.transformFlags & 2097152 ? t.createModifiersFromModifierFlags( + 1024 + /* Async */ + ) : void 0, ke = t.createObjectLiteralExpression( + [ + t.createPropertyAssignment("setters", K(dt, yt)), + t.createPropertyAssignment( + "execute", + t.createFunctionExpression( + Mt, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + /*parameters*/ + [], + /*type*/ + void 0, + t.createBlock( + Q, + /*multiLine*/ + !0 + ) + ) + ) + ], + /*multiLine*/ + !0 + ); + return ue.push(t.createReturnStatement(ke)), t.createBlock( + ue, + /*multiLine*/ + !0 + ); + } + function W(Pe) { + if (!D.hasExportStarsToExportValues) + return; + if (!ot(D.exportedNames) && D.exportedFunctions.size === 0 && D.exportSpecifiers.size === 0) { + let ye = !1; + for (const Q of D.externalImports) + if (Q.kind === 279 && Q.exportClause) { + ye = !0; + break; + } + if (!ye) { + const Q = _e( + /*localNames*/ + void 0 + ); + return Pe.push(Q), Q.name; + } + } + const yt = []; + if (D.exportedNames) + for (const ye of D.exportedNames) + Gm(ye) || yt.push( + t.createPropertyAssignment( + t.createStringLiteralFromNode(ye), + t.createTrue() + ) + ); + for (const ye of D.exportedFunctions) + Gn( + ye, + 2048 + /* Default */ + ) || (E.assert(!!ye.name), yt.push( + t.createPropertyAssignment( + t.createStringLiteralFromNode(ye.name), + t.createTrue() + ) + )); + const ue = t.createUniqueName("exportedNames"); + Pe.push( + t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList([ + t.createVariableDeclaration( + ue, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createObjectLiteralExpression( + yt, + /*multiLine*/ + !0 + ) + ) + ]) + ) + ); + const M = _e(ue); + return Pe.push(M), M.name; + } + function _e(Pe) { + const yt = t.createUniqueName("exportStar"), ue = t.createIdentifier("m"), M = t.createIdentifier("n"), ye = t.createIdentifier("exports"); + let Q = t.createStrictInequality(M, t.createStringLiteral("default")); + return Pe && (Q = t.createLogicalAnd( + Q, + t.createLogicalNot( + t.createCallExpression( + t.createPropertyAccessExpression(Pe, "hasOwnProperty"), + /*typeArguments*/ + void 0, + [M] + ) + ) + )), t.createFunctionDeclaration( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + yt, + /*typeParameters*/ + void 0, + [t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + ue + )], + /*type*/ + void 0, + t.createBlock( + [ + t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList([ + t.createVariableDeclaration( + ye, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createObjectLiteralExpression([]) + ) + ]) + ), + t.createForInStatement( + t.createVariableDeclarationList([ + t.createVariableDeclaration(M) + ]), + ue, + t.createBlock([ + un( + t.createIfStatement( + Q, + t.createExpressionStatement( + t.createAssignment( + t.createElementAccessExpression(ye, M), + t.createElementAccessExpression(ue, M) + ) + ) + ), + 1 + /* SingleLine */ + ) + ]) + ), + t.createExpressionStatement( + t.createCallExpression( + P, + /*typeArguments*/ + void 0, + [ye] + ) + ) + ], + /*multiLine*/ + !0 + ) + ); + } + function K(Pe, yt) { + const ue = []; + for (const M of yt) { + const ye = lr(M.externalImports, (Mt) => k6(t, Mt, k)), Q = ye ? t.getGeneratedNameForNode(ye) : t.createUniqueName(""), dt = []; + for (const Mt of M.externalImports) { + const ke = k6(t, Mt, k); + switch (Mt.kind) { + case 273: + if (!Mt.importClause) + break; + // falls through + case 272: + E.assert(ke !== void 0), dt.push( + t.createExpressionStatement( + t.createAssignment(ke, Q) + ) + ), Gn( + Mt, + 32 + /* Export */ + ) && dt.push( + t.createExpressionStatement( + t.createCallExpression( + P, + /*typeArguments*/ + void 0, + [ + t.createStringLiteral(An(ke)), + Q + ] + ) + ) + ); + break; + case 279: + if (E.assert(ke !== void 0), Mt.exportClause) + if (mp(Mt.exportClause)) { + const at = []; + for (const wt of Mt.exportClause.elements) + at.push( + t.createPropertyAssignment( + t.createStringLiteral(Iy(wt.name)), + t.createElementAccessExpression( + Q, + t.createStringLiteral(Iy(wt.propertyName || wt.name)) + ) + ) + ); + dt.push( + t.createExpressionStatement( + t.createCallExpression( + P, + /*typeArguments*/ + void 0, + [t.createObjectLiteralExpression( + at, + /*multiLine*/ + !0 + )] + ) + ) + ); + } else + dt.push( + t.createExpressionStatement( + t.createCallExpression( + P, + /*typeArguments*/ + void 0, + [ + t.createStringLiteral(Iy(Mt.exportClause.name)), + Q + ] + ) + ) + ); + else + dt.push( + t.createExpressionStatement( + t.createCallExpression( + Pe, + /*typeArguments*/ + void 0, + [Q] + ) + ) + ); + break; + } + } + ue.push( + t.createFunctionExpression( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + /*name*/ + void 0, + /*typeParameters*/ + void 0, + [t.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + Q + )], + /*type*/ + void 0, + t.createBlock( + dt, + /*multiLine*/ + !0 + ) + ) + ); + } + return t.createArrayLiteralExpression( + ue, + /*multiLine*/ + !0 + ); + } + function V(Pe) { + switch (Pe.kind) { + case 273: + return ae(Pe); + case 272: + return ce(Pe); + case 279: + return se(Pe); + case 278: + return fe(Pe); + default: + return Bt(Pe); + } + } + function ae(Pe) { + let yt; + return Pe.importClause && s(k6(t, Pe, k)), Wm(Ye(yt, Pe)); + } + function se(Pe) { + E.assertIsDefined(Pe); + } + function ce(Pe) { + E.assert(H1(Pe), "import= for internal module references should be handled in an earlier transformer."); + let yt; + return s(k6(t, Pe, k)), Wm(ne(yt, Pe)); + } + function fe(Pe) { + if (Pe.isExportEquals) + return; + const yt = Qe(Pe.expression, Un, ut); + return Ve( + t.createIdentifier("default"), + yt, + /*allowComments*/ + !0 + ); + } + function he(Pe) { + Gn( + Pe, + 32 + /* Export */ + ) ? O = Er( + O, + t.updateFunctionDeclaration( + Pe, + Ar(Pe.modifiers, it, Jo), + Pe.asteriskToken, + t.getDeclarationName( + Pe, + /*allowComments*/ + !0, + /*allowSourceMaps*/ + !0 + ), + /*typeParameters*/ + void 0, + Ar(Pe.parameters, Un, Ii), + /*type*/ + void 0, + Qe(Pe.body, Un, Ns) + ) + ) : O = Er(O, br(Pe, Un, e)), O = Ne(O, Pe); + } + function q(Pe) { + let yt; + const ue = t.getLocalName(Pe); + return s(ue), yt = Er( + yt, + ct( + t.createExpressionStatement( + t.createAssignment( + ue, + ct( + t.createClassExpression( + Ar(Pe.modifiers, it, Jo), + Pe.name, + /*typeParameters*/ + void 0, + Ar(Pe.heritageClauses, Un, cf), + Ar(Pe.members, Un, Hc) + ), + Pe + ) + ) + ), + Pe + ) + ), yt = Ne(yt, Pe), Wm(yt); + } + function be(Pe) { + if (!me(Pe.declarationList)) + return Qe(Pe, Un, Ti); + let yt; + if (D3(Pe.declarationList) || E3(Pe.declarationList)) { + const ue = Ar(Pe.modifiers, it, Jo), M = []; + for (const Q of Pe.declarationList.declarations) + M.push(t.updateVariableDeclaration( + Q, + t.getGeneratedNameForNode(Q.name), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + Z( + Q, + /*isExportedDeclaration*/ + !1 + ) + )); + const ye = t.updateVariableDeclarationList( + Pe.declarationList, + M + ); + yt = Er(yt, t.updateVariableStatement(Pe, ue, ye)); + } else { + let ue; + const M = Gn( + Pe, + 32 + /* Export */ + ); + for (const ye of Pe.declarationList.declarations) + ye.initializer ? ue = Er(ue, Z(ye, M)) : je(ye); + ue && (yt = Er(yt, ct(t.createExpressionStatement(t.inlineExpressions(ue)), Pe))); + } + return yt = Se( + yt, + Pe, + /*exportSelf*/ + !1 + ), Wm(yt); + } + function je(Pe) { + if (ws(Pe.name)) + for (const yt of Pe.name.elements) + vl(yt) || je(yt); + else + s(t.cloneNode(Pe.name)); + } + function me(Pe) { + return (Ea(Pe) & 4194304) === 0 && (F.kind === 308 || (Vo(Pe).flags & 7) === 0); + } + function Z(Pe, yt) { + const ue = yt ? pe : Te; + return ws(Pe.name) ? BS( + Pe, + Un, + e, + 0, + /*needsValue*/ + !1, + ue + ) : Pe.initializer ? ue(Pe.name, Qe(Pe.initializer, Un, ut)) : Pe.name; + } + function pe(Pe, yt, ue) { + return Fe( + Pe, + yt, + ue, + /*isExportedDeclaration*/ + !0 + ); + } + function Te(Pe, yt, ue) { + return Fe( + Pe, + yt, + ue, + /*isExportedDeclaration*/ + !1 + ); + } + function Fe(Pe, yt, ue, M) { + return s(t.cloneNode(Pe)), M ? St(Pe, Lt(ct(t.createAssignment(Pe, yt), ue))) : Lt(ct(t.createAssignment(Pe, yt), ue)); + } + function Ye(Pe, yt) { + if (D.exportEquals) + return Pe; + const ue = yt.importClause; + if (!ue) + return Pe; + ue.name && (Pe = Ee(Pe, ue)); + const M = ue.namedBindings; + if (M) + switch (M.kind) { + case 275: + Pe = Ee(Pe, M); + break; + case 276: + for (const ye of M.elements) + Pe = Ee(Pe, ye); + break; + } + return Pe; + } + function ne(Pe, yt) { + return D.exportEquals ? Pe : Ee(Pe, yt); + } + function Se(Pe, yt, ue) { + if (D.exportEquals) + return Pe; + for (const M of yt.declarationList.declarations) + (M.initializer || ue) && (Pe = ie(Pe, M)); + return Pe; + } + function ie(Pe, yt, ue) { + if (D.exportEquals) + return Pe; + if (ws(yt.name)) + for (const M of yt.name.elements) + vl(M) || (Pe = ie(Pe, M)); + else Bo(yt.name) || (Pe = Ee(Pe, yt, void 0)); + return Pe; + } + function Ne(Pe, yt) { + if (D.exportEquals) + return Pe; + let ue; + if (Gn( + yt, + 32 + /* Export */ + )) { + const M = Gn( + yt, + 2048 + /* Default */ + ) ? t.createStringLiteral("default") : yt.name; + Pe = Ce(Pe, M, t.getLocalName(yt)), ue = op(M); + } + return yt.name && (Pe = Ee(Pe, yt, ue)), Pe; + } + function Ee(Pe, yt, ue) { + if (D.exportEquals) + return Pe; + const M = t.getDeclarationName(yt), ye = D.exportSpecifiers.get(M); + if (ye) + for (const Q of ye) + Iy(Q.name) !== ue && (Pe = Ce(Pe, Q.name, M)); + return Pe; + } + function Ce(Pe, yt, ue, M) { + return Pe = Er(Pe, Ve(yt, ue, M)), Pe; + } + function Ve(Pe, yt, ue) { + const M = t.createExpressionStatement(St(Pe, yt)); + return Au(M), ue || un( + M, + 3072 + /* NoComments */ + ), M; + } + function St(Pe, yt) { + const ue = Me(Pe) ? t.createStringLiteralFromNode(Pe) : Pe; + return un( + yt, + Ea(yt) | 3072 + /* NoComments */ + ), el(t.createCallExpression( + P, + /*typeArguments*/ + void 0, + [ue, yt] + ), yt); + } + function Bt(Pe) { + switch (Pe.kind) { + case 244: + return be(Pe); + case 263: + return he(Pe); + case 264: + return q(Pe); + case 249: + return tr( + Pe, + /*isTopLevel*/ + !0 + ); + case 250: + return Nr(Pe); + case 251: + return st(Pe); + case 247: + return ui(Pe); + case 248: + return Ji(Pe); + case 257: + return Dt(Pe); + case 255: + return Mn(Pe); + case 246: + return ai(Pe); + case 256: + return fi(Pe); + case 270: + return pn(Pe); + case 297: + return _i(Pe); + case 298: + return Je(Pe); + case 259: + return ft(Pe); + case 300: + return er(Pe); + case 242: + return qr(Pe); + default: + return Un(Pe); + } + } + function tr(Pe, yt) { + const ue = F; + return F = Pe, Pe = t.updateForStatement( + Pe, + Qe(Pe.initializer, yt ? Jr : ki, ip), + Qe(Pe.condition, Un, ut), + Qe(Pe.incrementor, ki, ut), + c_(Pe.statement, yt ? Bt : Un, e) + ), F = ue, Pe; + } + function Nr(Pe) { + const yt = F; + return F = Pe, Pe = t.updateForInStatement( + Pe, + Jr(Pe.initializer), + Qe(Pe.expression, Un, ut), + c_(Pe.statement, Bt, e) + ), F = yt, Pe; + } + function st(Pe) { + const yt = F; + return F = Pe, Pe = t.updateForOfStatement( + Pe, + Pe.awaitModifier, + Jr(Pe.initializer), + Qe(Pe.expression, Un, ut), + c_(Pe.statement, Bt, e) + ), F = yt, Pe; + } + function Wt(Pe) { + return Ul(Pe) && me(Pe); + } + function Jr(Pe) { + if (Wt(Pe)) { + let yt; + for (const ue of Pe.declarations) + yt = Er(yt, Z( + ue, + /*isExportedDeclaration*/ + !1 + )), ue.initializer || je(ue); + return yt ? t.inlineExpressions(yt) : t.createOmittedExpression(); + } else + return Qe(Pe, ki, ip); + } + function ui(Pe) { + return t.updateDoStatement( + Pe, + c_(Pe.statement, Bt, e), + Qe(Pe.expression, Un, ut) + ); + } + function Ji(Pe) { + return t.updateWhileStatement( + Pe, + Qe(Pe.expression, Un, ut), + c_(Pe.statement, Bt, e) + ); + } + function Dt(Pe) { + return t.updateLabeledStatement( + Pe, + Pe.label, + Qe(Pe.statement, Bt, Ti, t.liftToBlock) ?? t.createExpressionStatement(t.createIdentifier("")) + ); + } + function Mn(Pe) { + return t.updateWithStatement( + Pe, + Qe(Pe.expression, Un, ut), + E.checkDefined(Qe(Pe.statement, Bt, Ti, t.liftToBlock)) + ); + } + function ai(Pe) { + return t.updateIfStatement( + Pe, + Qe(Pe.expression, Un, ut), + Qe(Pe.thenStatement, Bt, Ti, t.liftToBlock) ?? t.createBlock([]), + Qe(Pe.elseStatement, Bt, Ti, t.liftToBlock) + ); + } + function fi(Pe) { + return t.updateSwitchStatement( + Pe, + Qe(Pe.expression, Un, ut), + E.checkDefined(Qe(Pe.caseBlock, Bt, O4)) + ); + } + function pn(Pe) { + const yt = F; + return F = Pe, Pe = t.updateCaseBlock( + Pe, + Ar(Pe.clauses, Bt, I7) + ), F = yt, Pe; + } + function _i(Pe) { + return t.updateCaseClause( + Pe, + Qe(Pe.expression, Un, ut), + Ar(Pe.statements, Bt, Ti) + ); + } + function Je(Pe) { + return br(Pe, Bt, e); + } + function ft(Pe) { + return br(Pe, Bt, e); + } + function er(Pe) { + const yt = F; + return F = Pe, Pe = t.updateCatchClause( + Pe, + Pe.variableDeclaration, + E.checkDefined(Qe(Pe.block, Bt, Ns)) + ), F = yt, Pe; + } + function qr(Pe) { + const yt = F; + return F = Pe, Pe = br(Pe, Bt, e), F = yt, Pe; + } + function Jn(Pe, yt) { + if (!(Pe.transformFlags & 276828160)) + return Pe; + switch (Pe.kind) { + case 249: + return tr( + Pe, + /*isTopLevel*/ + !1 + ); + case 245: + return Ds(Pe); + case 218: + return Ks(Pe, yt); + case 356: + return yr(Pe, yt); + case 227: + if (y0(Pe)) + return Xe(Pe, yt); + break; + case 214: + if (T_(Pe)) + return bs(Pe); + break; + case 225: + case 226: + return re(Pe, yt); + } + return br(Pe, Un, e); + } + function Un(Pe) { + return Jn( + Pe, + /*valueIsDiscarded*/ + !1 + ); + } + function ki(Pe) { + return Jn( + Pe, + /*valueIsDiscarded*/ + !0 + ); + } + function Ds(Pe) { + return t.updateExpressionStatement(Pe, Qe(Pe.expression, ki, ut)); + } + function Ks(Pe, yt) { + return t.updateParenthesizedExpression(Pe, Qe(Pe.expression, yt ? ki : Un, ut)); + } + function yr(Pe, yt) { + return t.updatePartiallyEmittedExpression(Pe, Qe(Pe.expression, yt ? ki : Un, ut)); + } + function bs(Pe) { + const yt = Zx(t, Pe, k, _, c, o), ue = Qe(Yc(Pe.arguments), Un, ut), M = yt && (!ue || !ca(ue) || ue.text !== yt.text) ? yt : ue; + return t.createCallExpression( + t.createPropertyAccessExpression( + A, + t.createIdentifier("import") + ), + /*typeArguments*/ + void 0, + M ? [M] : [] + ); + } + function Xe(Pe, yt) { + return Et(Pe.left) ? BS( + Pe, + Un, + e, + 0, + !yt + ) : br(Pe, Un, e); + } + function Et(Pe) { + if (Nl( + Pe, + /*excludeCompoundAssignment*/ + !0 + )) + return Et(Pe.left); + if (dp(Pe)) + return Et(Pe.expression); + if (_a(Pe)) + return ot(Pe.properties, Et); + if (nu(Pe)) + return ot(Pe.elements, Et); + if (gu(Pe)) + return Et(Pe.name); + if (rl(Pe)) + return Et(Pe.initializer); + if (Me(Pe)) { + const yt = c.getReferencedExportContainer(Pe); + return yt !== void 0 && yt.kind === 308; + } else + return !1; + } + function re(Pe, yt) { + if ((Pe.operator === 46 || Pe.operator === 47) && Me(Pe.operand) && !Bo(Pe.operand) && !Nh(Pe.operand) && !dJ(Pe.operand)) { + const ue = Ct(Pe.operand); + if (ue) { + let M, ye = Qe(Pe.operand, Un, ut); + iv(Pe) ? ye = t.updatePrefixUnaryExpression(Pe, ye) : (ye = t.updatePostfixUnaryExpression(Pe, ye), yt || (M = t.createTempVariable(s), ye = t.createAssignment(M, ye), ct(ye, Pe)), ye = t.createComma(ye, t.cloneNode(Pe.operand)), ct(ye, Pe)); + for (const Q of ue) + ye = St(Q, Lt(ye)); + return M && (ye = t.createComma(ye, M), ct(ye, Pe)), ye; + } + } + return br(Pe, Un, e); + } + function it(Pe) { + switch (Pe.kind) { + case 95: + case 90: + return; + } + return Pe; + } + function Y(Pe, yt, ue) { + if (yt.kind === 308) { + const M = l_(yt); + k = yt, D = m[M], P = h[M], R = S[M], A = T[M], R && delete S[M], g(Pe, yt, ue), k = void 0, D = void 0, P = void 0, A = void 0, R = void 0; + } else + g(Pe, yt, ue); + } + function Ae(Pe, yt) { + return yt = u(Pe, yt), rn(yt) ? yt : Pe === 1 ? Tt(yt) : Pe === 4 ? $e(yt) : yt; + } + function $e(Pe) { + switch (Pe.kind) { + case 305: + return Ke(Pe); + } + return Pe; + } + function Ke(Pe) { + var yt, ue; + const M = Pe.name; + if (!Bo(M) && !Nh(M)) { + const ye = c.getReferencedImportDeclaration(M); + if (ye) { + if (ld(ye)) + return ct( + t.createPropertyAssignment( + t.cloneNode(M), + t.createPropertyAccessExpression( + t.getGeneratedNameForNode(ye.parent), + t.createIdentifier("default") + ) + ), + /*location*/ + Pe + ); + if (Xu(ye)) { + const Q = ye.propertyName || ye.name, dt = t.getGeneratedNameForNode(((ue = (yt = ye.parent) == null ? void 0 : yt.parent) == null ? void 0 : ue.parent) || ye); + return ct( + t.createPropertyAssignment( + t.cloneNode(M), + Q.kind === 11 ? t.createElementAccessExpression(dt, t.cloneNode(Q)) : t.createPropertyAccessExpression(dt, t.cloneNode(Q)) + ), + /*location*/ + Pe + ); + } + } + } + return Pe; + } + function Tt(Pe) { + switch (Pe.kind) { + case 80: + return Le(Pe); + case 227: + return mt(Pe); + case 237: + return pt(Pe); + } + return Pe; + } + function Le(Pe) { + var yt, ue; + if (Ea(Pe) & 8192) { + const M = HN(k); + return M ? t.createPropertyAccessExpression(M, Pe) : Pe; + } + if (!Bo(Pe) && !Nh(Pe)) { + const M = c.getReferencedImportDeclaration(Pe); + if (M) { + if (ld(M)) + return ct( + t.createPropertyAccessExpression( + t.getGeneratedNameForNode(M.parent), + t.createIdentifier("default") + ), + /*location*/ + Pe + ); + if (Xu(M)) { + const ye = M.propertyName || M.name, Q = t.getGeneratedNameForNode(((ue = (yt = M.parent) == null ? void 0 : yt.parent) == null ? void 0 : ue.parent) || M); + return ct( + ye.kind === 11 ? t.createElementAccessExpression(Q, t.cloneNode(ye)) : t.createPropertyAccessExpression(Q, t.cloneNode(ye)), + /*location*/ + Pe + ); + } + } + } + return Pe; + } + function mt(Pe) { + if (kh(Pe.operatorToken.kind) && Me(Pe.left) && (!Bo(Pe.left) || o3(Pe.left)) && !Nh(Pe.left)) { + const yt = Ct(Pe.left); + if (yt) { + let ue = Pe; + for (const M of yt) + ue = St(M, Lt(ue)); + return ue; + } + } + return Pe; + } + function pt(Pe) { + return JC(Pe) ? t.createPropertyAccessExpression(A, t.createIdentifier("meta")) : Pe; + } + function Ct(Pe) { + let yt; + const ue = qe(Pe); + if (ue) { + const M = c.getReferencedExportContainer( + Pe, + /*prefixLocals*/ + !1 + ); + M && M.kind === 308 && (yt = Er(yt, t.getDeclarationName(ue))), yt = In(yt, D?.exportedBindings[l_(ue)]); + } else if (Bo(Pe) && o3(Pe)) { + const M = D?.exportSpecifiers.get(Pe); + if (M) { + const ye = []; + for (const Q of M) + ye.push(Q.name); + return ye; + } + } + return yt; + } + function qe(Pe) { + if (!Bo(Pe)) { + const yt = c.getReferencedImportDeclaration(Pe); + if (yt) return yt; + const ue = c.getReferencedValueDeclaration(Pe); + if (ue && D?.exportedBindings[l_(ue)]) return ue; + const M = c.getReferencedValueDeclarations(Pe); + if (M) { + for (const ye of M) + if (ye !== ue && D?.exportedBindings[l_(ye)]) return ye; + } + return ue; + } + } + function Lt(Pe) { + return R === void 0 && (R = []), R[Ma(Pe)] = !0, Pe; + } + function rn(Pe) { + return R && Pe.id && R[Pe.id]; + } + } + function QW(e) { + const { + factory: t, + getEmitHelperFactory: n + } = e, i = e.getEmitHost(), s = e.getEmitResolver(), o = e.getCompilerOptions(), c = da(o), _ = e.onEmitNode, u = e.onSubstituteNode; + e.onEmitNode = W, e.onSubstituteNode = _e, e.enableEmitNotification( + 308 + /* SourceFile */ + ), e.enableSubstitution( + 80 + /* Identifier */ + ); + const g = /* @__PURE__ */ new Set(); + let m, h, S, T; + return Ld(e, k); + function k(V) { + if (V.isDeclarationFile) + return V; + if (fl(V) || zp(o)) { + S = V, T = void 0, o.rewriteRelativeImportExtensions && (S.flags & 4194304 || an(V)) && dF( + V, + /*includeTypeSpaceImports*/ + !1, + /*requireStringLiteralLikeArgument*/ + !1, + (se) => { + (!ja(se.arguments[0]) || V3(se.arguments[0].text, o)) && (m = Er(m, se)); + } + ); + let ae = D(V); + return Wg(ae, e.readEmitHelpers()), S = void 0, T && (ae = t.updateSourceFile( + ae, + ct(t.createNodeArray(iB(ae.statements.slice(), T)), ae.statements) + )), !fl(V) || Hu(o) === 200 || ot(ae.statements, p3) ? ae : t.updateSourceFile( + ae, + ct(t.createNodeArray([...ae.statements, UN(t)]), ae.statements) + ); + } + return V; + } + function D(V) { + const ae = Lz(t, n(), V, o); + if (ae) { + const se = [], ce = t.copyPrologue(V.statements, se); + return In(se, Q4([ae], P, Ti)), In(se, Ar(V.statements, P, Ti, ce)), t.updateSourceFile( + V, + ct(t.createNodeArray(se), V.statements) + ); + } else + return br(V, P, e); + } + function P(V) { + switch (V.kind) { + case 272: + return Hu(o) >= 100 ? R(V) : void 0; + case 278: + return U(V); + case 279: + return $(V); + case 273: + return A(V); + case 214: + if (V === m?.[0]) + return O(m.shift()); + // fallthrough + default: + if (m?.length && C_(V, m[0])) + return br(V, P, e); + } + return V; + } + function A(V) { + if (!o.rewriteRelativeImportExtensions) + return V; + const ae = sk(V.moduleSpecifier, o); + return ae === V.moduleSpecifier ? V : t.updateImportDeclaration( + V, + V.modifiers, + V.importClause, + ae, + V.attributes + ); + } + function O(V) { + return t.updateCallExpression( + V, + V.expression, + V.typeArguments, + [ + ja(V.arguments[0]) ? sk(V.arguments[0], o) : n().createRewriteRelativeImportExtensionsHelper(V.arguments[0]), + ...V.arguments.slice(1) + ] + ); + } + function F(V) { + const ae = Zx(t, V, E.checkDefined(S), i, s, o), se = []; + if (ae && se.push(sk(ae, o)), Hu(o) === 200) + return t.createCallExpression( + t.createIdentifier("require"), + /*typeArguments*/ + void 0, + se + ); + if (!T) { + const fe = t.createUniqueName( + "_createRequire", + 48 + /* FileLevel */ + ), he = t.createImportDeclaration( + /*modifiers*/ + void 0, + t.createImportClause( + /*phaseModifier*/ + void 0, + /*name*/ + void 0, + t.createNamedImports([ + t.createImportSpecifier( + /*isTypeOnly*/ + !1, + t.createIdentifier("createRequire"), + fe + ) + ]) + ), + t.createStringLiteral("module"), + /*attributes*/ + void 0 + ), q = t.createUniqueName( + "__require", + 48 + /* FileLevel */ + ), be = t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList( + [ + t.createVariableDeclaration( + q, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + t.createCallExpression( + t.cloneNode(fe), + /*typeArguments*/ + void 0, + [ + t.createPropertyAccessExpression(t.createMetaProperty(102, t.createIdentifier("meta")), t.createIdentifier("url")) + ] + ) + ) + ], + /*flags*/ + c >= 2 ? 2 : 0 + /* None */ + ) + ); + T = [he, be]; + } + const ce = T[1].declarationList.declarations[0].name; + return E.assertNode(ce, Me), t.createCallExpression( + t.cloneNode(ce), + /*typeArguments*/ + void 0, + se + ); + } + function R(V) { + E.assert(H1(V), "import= for internal module references should be handled in an earlier transformer."); + let ae; + return ae = Er( + ae, + Cn( + ct( + t.createVariableStatement( + /*modifiers*/ + void 0, + t.createVariableDeclarationList( + [ + t.createVariableDeclaration( + t.cloneNode(V.name), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + F(V) + ) + ], + /*flags*/ + c >= 2 ? 2 : 0 + /* None */ + ) + ), + V + ), + V + ) + ), ae = B(ae, V), Wm(ae); + } + function B(V, ae) { + return Gn( + ae, + 32 + /* Export */ + ) && (V = Er( + V, + t.createExportDeclaration( + /*modifiers*/ + void 0, + ae.isTypeOnly, + t.createNamedExports([t.createExportSpecifier( + /*isTypeOnly*/ + !1, + /*propertyName*/ + void 0, + An(ae.name) + )]) + ) + )), V; + } + function U(V) { + return V.isExportEquals ? Hu(o) === 200 ? Cn( + t.createExpressionStatement( + t.createAssignment( + t.createPropertyAccessExpression( + t.createIdentifier("module"), + "exports" + ), + V.expression + ) + ), + V + ) : void 0 : V; + } + function $(V) { + const ae = sk(V.moduleSpecifier, o); + if (o.module !== void 0 && o.module > 5 || !V.exportClause || !Km(V.exportClause) || !V.moduleSpecifier) + return !V.moduleSpecifier || ae === V.moduleSpecifier ? V : t.updateExportDeclaration( + V, + V.modifiers, + V.isTypeOnly, + V.exportClause, + ae, + V.attributes + ); + const se = V.exportClause.name, ce = t.getGeneratedNameForNode(se), fe = t.createImportDeclaration( + /*modifiers*/ + void 0, + t.createImportClause( + /*phaseModifier*/ + void 0, + /*name*/ + void 0, + t.createNamespaceImport( + ce + ) + ), + ae, + V.attributes + ); + Cn(fe, V.exportClause); + const he = V7(V) ? t.createExportDefault(ce) : t.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + t.createNamedExports([t.createExportSpecifier( + /*isTypeOnly*/ + !1, + ce, + se + )]) + ); + return Cn(he, V), [fe, he]; + } + function W(V, ae, se) { + Di(ae) ? ((fl(ae) || zp(o)) && o.importHelpers && (h = /* @__PURE__ */ new Map()), S = ae, _(V, ae, se), S = void 0, h = void 0) : _(V, ae, se); + } + function _e(V, ae) { + return ae = u(V, ae), ae.id && g.has(ae.id) ? ae : Me(ae) && Ea(ae) & 8192 ? K(ae) : ae; + } + function K(V) { + const ae = S && HN(S); + if (ae) + return g.add(Ma(V)), t.createPropertyAccessExpression(ae, V); + if (h) { + const se = An(V); + let ce = h.get(se); + return ce || h.set(se, ce = t.createUniqueName( + se, + 48 + /* FileLevel */ + )), ce; + } + return V; + } + } + function uie(e) { + const t = e.onSubstituteNode, n = e.onEmitNode, i = QW(e), s = e.onSubstituteNode, o = e.onEmitNode; + e.onSubstituteNode = t, e.onEmitNode = n; + const c = XW(e), _ = e.onSubstituteNode, u = e.onEmitNode, g = (A) => e.getEmitHost().getEmitModuleFormatOfFile(A); + e.onSubstituteNode = h, e.onEmitNode = S, e.enableSubstitution( + 308 + /* SourceFile */ + ), e.enableEmitNotification( + 308 + /* SourceFile */ + ); + let m; + return D; + function h(A, O) { + return Di(O) ? (m = O, t(A, O)) : m ? g(m) >= 5 ? s(A, O) : _(A, O) : t(A, O); + } + function S(A, O, F) { + return Di(O) && (m = O), m ? g(m) >= 5 ? o(A, O, F) : u(A, O, F) : n(A, O, F); + } + function T(A) { + return g(A) >= 5 ? i : c; + } + function k(A) { + if (A.isDeclarationFile) + return A; + m = A; + const O = T(A)(A); + return m = void 0, E.assert(Di(O)), O; + } + function D(A) { + return A.kind === 308 ? k(A) : P(A); + } + function P(A) { + return e.factory.createBundle(hr(A.sourceFiles, k)); + } + } + function gA(e) { + return ei(e) || os(e) || $u(e) || ya(e) || am(e) || Pg(e) || N4(e) || Ux(e) || rc(e) || cd(e) || Cc(e) || Ii(e) || Lo(e) || Dh(e) || _l(e) || Wp(e) || nc(e) || qy(e) || wn(e) || uo(e) || _n(e) || jp(e); + } + function _ie(e) { + if (am(e) || Pg(e)) + return t; + return cd(e) || rc(e) ? i : gv(e); + function t(o) { + const c = n(o); + return c !== void 0 ? { + diagnosticMessage: c, + errorNode: e, + typeName: e.name + } : void 0; + } + function n(o) { + return Js(e) ? o.errorModuleName ? o.accessibility === 2 ? p.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : p.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : p.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1 : e.parent.kind === 264 ? o.errorModuleName ? o.accessibility === 2 ? p.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : p.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : p.Public_property_0_of_exported_class_has_or_is_using_private_name_1 : o.errorModuleName ? p.Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : p.Property_0_of_exported_interface_has_or_is_using_private_name_1; + } + function i(o) { + const c = s(o); + return c !== void 0 ? { + diagnosticMessage: c, + errorNode: e, + typeName: e.name + } : void 0; + } + function s(o) { + return Js(e) ? o.errorModuleName ? o.accessibility === 2 ? p.Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : p.Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : p.Public_static_method_0_of_exported_class_has_or_is_using_private_name_1 : e.parent.kind === 264 ? o.errorModuleName ? o.accessibility === 2 ? p.Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : p.Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : p.Public_method_0_of_exported_class_has_or_is_using_private_name_1 : o.errorModuleName ? p.Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : p.Method_0_of_exported_interface_has_or_is_using_private_name_1; + } + } + function gv(e) { + if (ei(e) || os(e) || $u(e) || wn(e) || uo(e) || _n(e) || ya(e) || nc(e)) + return n; + return am(e) || Pg(e) ? i : N4(e) || Ux(e) || rc(e) || cd(e) || Cc(e) || qy(e) ? s : Ii(e) ? K_(e, e.parent) && Gn( + e.parent, + 2 + /* Private */ + ) ? n : o : Lo(e) ? _ : Dh(e) ? u : _l(e) ? g : Wp(e) || jp(e) ? m : E.assertNever(e, `Attempted to set a declaration diagnostic context for unhandled node kind: ${E.formatSyntaxKind(e.kind)}`); + function t(h) { + if (e.kind === 261 || e.kind === 209) + return h.errorModuleName ? h.accessibility === 2 ? p.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : p.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 : p.Exported_variable_0_has_or_is_using_private_name_1; + if (e.kind === 173 || e.kind === 212 || e.kind === 213 || e.kind === 227 || e.kind === 172 || e.kind === 170 && Gn( + e.parent, + 2 + /* Private */ + )) + return Js(e) ? h.errorModuleName ? h.accessibility === 2 ? p.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : p.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : p.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1 : e.parent.kind === 264 || e.kind === 170 ? h.errorModuleName ? h.accessibility === 2 ? p.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : p.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : p.Public_property_0_of_exported_class_has_or_is_using_private_name_1 : h.errorModuleName ? p.Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : p.Property_0_of_exported_interface_has_or_is_using_private_name_1; + } + function n(h) { + const S = t(h); + return S !== void 0 ? { + diagnosticMessage: S, + errorNode: e, + typeName: e.name + } : void 0; + } + function i(h) { + let S; + return e.kind === 179 ? Js(e) ? S = h.errorModuleName ? p.Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : p.Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1 : S = h.errorModuleName ? p.Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : p.Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1 : Js(e) ? S = h.errorModuleName ? h.accessibility === 2 ? p.Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : p.Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : p.Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1 : S = h.errorModuleName ? h.accessibility === 2 ? p.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : p.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : p.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1, { + diagnosticMessage: S, + errorNode: e.name, + typeName: e.name + }; + } + function s(h) { + let S; + switch (e.kind) { + case 181: + S = h.errorModuleName ? p.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : p.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0; + break; + case 180: + S = h.errorModuleName ? p.Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : p.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0; + break; + case 182: + S = h.errorModuleName ? p.Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : p.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0; + break; + case 175: + case 174: + Js(e) ? S = h.errorModuleName ? h.accessibility === 2 ? p.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : p.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : p.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0 : e.parent.kind === 264 ? S = h.errorModuleName ? h.accessibility === 2 ? p.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : p.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : p.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0 : S = h.errorModuleName ? p.Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : p.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0; + break; + case 263: + S = h.errorModuleName ? h.accessibility === 2 ? p.Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : p.Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1 : p.Return_type_of_exported_function_has_or_is_using_private_name_0; + break; + default: + return E.fail("This is unknown kind for signature: " + e.kind); + } + return { + diagnosticMessage: S, + errorNode: e.name || e + }; + } + function o(h) { + const S = c(h); + return S !== void 0 ? { + diagnosticMessage: S, + errorNode: e, + typeName: e.name + } : void 0; + } + function c(h) { + switch (e.parent.kind) { + case 177: + return h.errorModuleName ? h.accessibility === 2 ? p.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : p.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 : p.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1; + case 181: + case 186: + return h.errorModuleName ? p.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : p.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; + case 180: + return h.errorModuleName ? p.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : p.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; + case 182: + return h.errorModuleName ? p.Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : p.Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1; + case 175: + case 174: + return Js(e.parent) ? h.errorModuleName ? h.accessibility === 2 ? p.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : p.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : p.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1 : e.parent.parent.kind === 264 ? h.errorModuleName ? h.accessibility === 2 ? p.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : p.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : p.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1 : h.errorModuleName ? p.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : p.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; + case 263: + case 185: + return h.errorModuleName ? h.accessibility === 2 ? p.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : p.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 : p.Parameter_0_of_exported_function_has_or_is_using_private_name_1; + case 179: + case 178: + return h.errorModuleName ? h.accessibility === 2 ? p.Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : p.Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2 : p.Parameter_0_of_accessor_has_or_is_using_private_name_1; + default: + return E.fail(`Unknown parent for parameter: ${E.formatSyntaxKind(e.parent.kind)}`); + } + } + function _() { + let h; + switch (e.parent.kind) { + case 264: + h = p.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1; + break; + case 265: + h = p.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1; + break; + case 201: + h = p.Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1; + break; + case 186: + case 181: + h = p.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; + break; + case 180: + h = p.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; + break; + case 175: + case 174: + Js(e.parent) ? h = p.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1 : e.parent.parent.kind === 264 ? h = p.Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1 : h = p.Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; + break; + case 185: + case 263: + h = p.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1; + break; + case 196: + h = p.Extends_clause_for_inferred_type_0_has_or_is_using_private_name_1; + break; + case 266: + h = p.Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1; + break; + default: + return E.fail("This is unknown parent for type parameter: " + e.parent.kind); + } + return { + diagnosticMessage: h, + errorNode: e, + typeName: e.name + }; + } + function u() { + let h; + return tl(e.parent.parent) ? h = cf(e.parent) && e.parent.token === 119 ? p.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 : e.parent.parent.name ? p.extends_clause_of_exported_class_0_has_or_is_using_private_name_1 : p.extends_clause_of_exported_class_has_or_is_using_private_name_0 : h = p.extends_clause_of_exported_interface_0_has_or_is_using_private_name_1, { + diagnosticMessage: h, + errorNode: e, + typeName: _s(e.parent.parent) + }; + } + function g() { + return { + diagnosticMessage: p.Import_declaration_0_is_using_private_name_1, + errorNode: e, + typeName: e.name + }; + } + function m(h) { + return { + diagnosticMessage: h.errorModuleName ? p.Exported_type_alias_0_has_or_is_using_private_name_1_from_module_2 : p.Exported_type_alias_0_has_or_is_using_private_name_1, + errorNode: jp(e) ? E.checkDefined(e.typeExpression) : e.type, + typeName: jp(e) ? _s(e) : e.name + }; + } + } + function fie(e) { + const t = { + 220: p.Add_a_return_type_to_the_function_expression, + 219: p.Add_a_return_type_to_the_function_expression, + 175: p.Add_a_return_type_to_the_method, + 178: p.Add_a_return_type_to_the_get_accessor_declaration, + 179: p.Add_a_type_to_parameter_of_the_set_accessor_declaration, + 263: p.Add_a_return_type_to_the_function_declaration, + 181: p.Add_a_return_type_to_the_function_declaration, + 170: p.Add_a_type_annotation_to_the_parameter_0, + 261: p.Add_a_type_annotation_to_the_variable_0, + 173: p.Add_a_type_annotation_to_the_property_0, + 172: p.Add_a_type_annotation_to_the_property_0, + 278: p.Move_the_expression_in_default_export_to_a_variable_and_add_a_type_annotation_to_it + }, n = { + 219: p.Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations, + 263: p.Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations, + 220: p.Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations, + 175: p.Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations, + 181: p.Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations, + 178: p.At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations, + 179: p.At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations, + 170: p.Parameter_must_have_an_explicit_type_annotation_with_isolatedDeclarations, + 261: p.Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations, + 173: p.Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations, + 172: p.Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations, + 168: p.Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations, + 306: p.Objects_that_contain_spread_assignments_can_t_be_inferred_with_isolatedDeclarations, + 305: p.Objects_that_contain_shorthand_properties_can_t_be_inferred_with_isolatedDeclarations, + 210: p.Only_const_arrays_can_be_inferred_with_isolatedDeclarations, + 278: p.Default_exports_can_t_be_inferred_with_isolatedDeclarations, + 231: p.Arrays_with_spread_elements_can_t_inferred_with_isolatedDeclarations + }; + return i; + function i(P) { + if (dr(P, cf)) + return sn(P, p.Extends_clause_can_t_contain_an_expression_with_isolatedDeclarations); + if ((lm(P) || Hb(P.parent)) && (r_(P) || to(P))) + return k(P); + switch (E.type(P), P.kind) { + case 178: + case 179: + return o(P); + case 168: + case 305: + case 306: + return _(P); + case 210: + case 231: + return u(P); + case 175: + case 181: + case 219: + case 220: + case 263: + return g(P); + case 209: + return m(P); + case 173: + case 261: + return h(P); + case 170: + return S(P); + case 304: + return D(P.initializer); + case 232: + return T(P); + default: + return D(P); + } + } + function s(P) { + const A = dr(P, (O) => Mo(O) || Ti(O) || ei(O) || os(O) || Ii(O)); + if (A) + return Mo(A) ? A : Cf(A) ? dr(A, (O) => io(O) && !nc(O)) : Ti(A) ? void 0 : A; + } + function o(P) { + const { getAccessor: A, setAccessor: O } = Bb(P.symbol.declarations, P), F = (am(P) ? P.parameters[0] : P) ?? P, R = sn(F, n[P.kind]); + return O && zs(R, sn(O, t[O.kind])), A && zs(R, sn(A, t[A.kind])), R; + } + function c(P, A) { + const O = s(P); + if (O) { + const F = Mo(O) || !O.name ? "" : Qo( + O.name, + /*includeTrivia*/ + !1 + ); + zs(A, sn(O, t[O.kind], F)); + } + return A; + } + function _(P) { + const A = sn(P, n[P.kind]); + return c(P, A), A; + } + function u(P) { + const A = sn(P, n[P.kind]); + return c(P, A), A; + } + function g(P) { + const A = sn(P, n[P.kind]); + return c(P, A), zs(A, sn(P, t[P.kind])), A; + } + function m(P) { + return sn(P, p.Binding_elements_can_t_be_exported_directly_with_isolatedDeclarations); + } + function h(P) { + const A = sn(P, n[P.kind]), O = Qo( + P.name, + /*includeTrivia*/ + !1 + ); + return zs(A, sn(P, t[P.kind], O)), A; + } + function S(P) { + if (am(P.parent)) + return o(P.parent); + const A = e.requiresAddingImplicitUndefined(P, P.parent); + if (!A && P.initializer) + return D(P.initializer); + const O = A ? p.Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_supported_with_isolatedDeclarations : n[P.kind], F = sn(P, O), R = Qo( + P.name, + /*includeTrivia*/ + !1 + ); + return zs(F, sn(P, t[P.kind], R)), F; + } + function T(P) { + return D(P, p.Inference_from_class_expressions_is_not_supported_with_isolatedDeclarations); + } + function k(P) { + const A = sn(P, p.Type_containing_private_name_0_can_t_be_used_with_isolatedDeclarations, Qo( + P, + /*includeTrivia*/ + !1 + )); + return c(P, A), A; + } + function D(P, A) { + const O = s(P); + let F; + if (O) { + const R = Mo(O) || !O.name ? "" : Qo( + O.name, + /*includeTrivia*/ + !1 + ), B = dr(P.parent, (U) => Mo(U) || (Ti(U) ? "quit" : !o_(U) && !DF(U) && !d6(U))); + O === B ? (F = sn(P, A ?? n[O.kind]), zs(F, sn(O, t[O.kind], R))) : (F = sn(P, A ?? p.Expression_type_can_t_be_inferred_with_isolatedDeclarations), zs(F, sn(O, t[O.kind], R)), zs(F, sn(P, p.Add_satisfies_and_a_type_assertion_to_this_expression_satisfies_T_as_T_to_make_the_type_explicit))); + } else + F = sn(P, A ?? p.Expression_type_can_t_be_inferred_with_isolatedDeclarations); + return F; + } + } + function pie(e, t, n) { + const i = e.getCompilerOptions(), s = kn(E5(e, n), l5); + return ms(s, n) ? bA( + t, + e, + N, + i, + [n], + [YW], + /*allowDtsFiles*/ + !1 + ).diagnostics : void 0; + } + var hA = 531469, yA = 8; + function YW(e) { + const t = () => E.fail("Diagnostic emitted without context"); + let n = t, i = !0, s = !1, o = !1, c = !1, _ = !1, u, g, m, h; + const { factory: S } = e, T = e.getEmitHost(); + let k = () => { + }; + const D = { + trackSymbol: ce, + reportInaccessibleThisError: je, + reportInaccessibleUniqueSymbolError: q, + reportCyclicStructureError: be, + reportPrivateInBaseOfClassExpression: fe, + reportLikelyUnsafeImportRequiredError: me, + reportTruncationError: Z, + moduleResolverHost: T, + reportNonlocalAugmentation: pe, + reportNonSerializableProperty: Te, + reportInferenceFallback: ae, + pushErrorFallbackNode(re) { + const it = A, Y = k; + k = () => { + k = Y, A = it; + }, A = re; + }, + popErrorFallbackNode() { + k(); + } + }; + let P, A, O, F, R, B; + const U = e.getEmitResolver(), $ = e.getCompilerOptions(), W = fie(U), { stripInternal: _e, isolatedDeclarations: K } = $; + return Ye; + function V(re) { + U.getPropertiesOfContainerFunction(re).forEach((it) => { + if (Mx(it.valueDeclaration)) { + const Y = _n(it.valueDeclaration) ? it.valueDeclaration.left : it.valueDeclaration; + e.addDiagnostic(sn( + Y, + p.Assigning_properties_to_functions_without_declaring_them_is_not_supported_with_isolatedDeclarations_Add_an_explicit_declaration_for_the_properties_assigned_to_this_function + )); + } + }); + } + function ae(re) { + !K || n_(O) || xr(re) === O && (ei(re) && U.isExpandoFunctionDeclaration(re) ? V(re) : e.addDiagnostic(W(re))); + } + function se(re) { + if (re.accessibility === 0) { + if (re.aliasesToMakeVisible) + if (!g) + g = re.aliasesToMakeVisible; + else + for (const it of re.aliasesToMakeVisible) + tp(g, it); + } else if (re.accessibility !== 3) { + const it = n(re); + if (it) + return it.typeName ? e.addDiagnostic(sn(re.errorNode || it.errorNode, it.diagnosticMessage, Qo(it.typeName), re.errorSymbolName, re.errorModuleName)) : e.addDiagnostic(sn(re.errorNode || it.errorNode, it.diagnosticMessage, re.errorSymbolName, re.errorModuleName)), !0; + } + return !1; + } + function ce(re, it, Y) { + return re.flags & 262144 ? !1 : se(U.isSymbolAccessible( + re, + it, + Y, + /*shouldComputeAliasToMarkVisible*/ + !0 + )); + } + function fe(re) { + (P || A) && e.addDiagnostic( + zs( + sn(P || A, p.Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected, re), + ...ei((P || A).parent) ? [sn(P || A, p.Add_a_type_annotation_to_the_variable_0, he())] : [] + ) + ); + } + function he() { + return P ? co(P) : A && _s(A) ? co(_s(A)) : A && Mo(A) ? A.isExportEquals ? "export=" : "default" : "(Missing)"; + } + function q() { + (P || A) && e.addDiagnostic(sn(P || A, p.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary, he(), "unique symbol")); + } + function be() { + (P || A) && e.addDiagnostic(sn(P || A, p.The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialized_A_type_annotation_is_necessary, he())); + } + function je() { + (P || A) && e.addDiagnostic(sn(P || A, p.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary, he(), "this")); + } + function me(re) { + (P || A) && e.addDiagnostic(sn(P || A, p.The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary, he(), re)); + } + function Z() { + (P || A) && e.addDiagnostic(sn(P || A, p.The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_type_annotation_is_needed)); + } + function pe(re, it, Y) { + var Ae; + const $e = (Ae = it.declarations) == null ? void 0 : Ae.find((Tt) => xr(Tt) === re), Ke = kn(Y.declarations, (Tt) => xr(Tt) !== re); + if ($e && Ke) + for (const Tt of Ke) + e.addDiagnostic(zs( + sn(Tt, p.Declaration_augments_declaration_in_another_file_This_cannot_be_serialized), + sn($e, p.This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_file) + )); + } + function Te(re) { + (P || A) && e.addDiagnostic(sn(P || A, p.The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized, re)); + } + function Fe(re) { + const it = n; + n = (Ae) => Ae.errorNode && gA(Ae.errorNode) ? gv(Ae.errorNode)(Ae) : { + diagnosticMessage: Ae.errorModuleName ? p.Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit : p.Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit, + errorNode: Ae.errorNode || re + }; + const Y = U.getDeclarationStatementsForSourceFile(re, hA, yA, D); + return n = it, Y; + } + function Ye(re) { + if (re.kind === 308 && re.isDeclarationFile) + return re; + if (re.kind === 309) { + s = !0, F = [], R = [], B = []; + let mt = !1; + const pt = S.createBundle( + hr(re.sourceFiles, (qe) => { + if (qe.isDeclarationFile) return; + if (mt = mt || qe.hasNoDefaultLib, O = qe, u = qe, g = void 0, h = !1, m = /* @__PURE__ */ new Map(), n = t, c = !1, _ = !1, Ae(qe), tf(qe) || ap(qe)) { + o = !1, i = !1; + const rn = n_(qe) ? S.createNodeArray(Fe(qe)) : Ar(qe.statements, _i, Ti); + return S.updateSourceFile( + qe, + [S.createModuleDeclaration( + [S.createModifier( + 138 + /* DeclareKeyword */ + )], + S.createStringLiteral(XB(e.getEmitHost(), qe)), + S.createModuleBlock(ct(S.createNodeArray(ai(rn)), qe.statements)) + )], + /*isDeclarationFile*/ + !0, + /*referencedFiles*/ + [], + /*typeReferences*/ + [], + /*hasNoDefaultLib*/ + !1, + /*libReferences*/ + [] + ); + } + i = !0; + const Lt = n_(qe) ? S.createNodeArray(Fe(qe)) : Ar(qe.statements, _i, Ti); + return S.updateSourceFile( + qe, + ai(Lt), + /*isDeclarationFile*/ + !0, + /*referencedFiles*/ + [], + /*typeReferences*/ + [], + /*hasNoDefaultLib*/ + !1, + /*libReferences*/ + [] + ); + }) + ), Ct = Hn(zl(iw( + re, + T, + /*forceDtsPaths*/ + !0 + ).declarationFilePath)); + return pt.syntheticFileReferences = Le(Ct), pt.syntheticTypeReferences = Ke(), pt.syntheticLibReferences = Tt(), pt.hasNoDefaultLib = mt, pt; + } + i = !0, c = !1, _ = !1, u = re, O = re, n = t, s = !1, o = !1, h = !1, g = void 0, m = /* @__PURE__ */ new Map(), F = [], R = [], B = [], Ae(O); + let it; + if (n_(O)) + it = S.createNodeArray(Fe(re)); + else { + const mt = Ar(re.statements, _i, Ti); + it = ct(S.createNodeArray(ai(mt)), re.statements), fl(re) && (!o || c && !_) && (it = ct(S.createNodeArray([...it, UN(S)]), it)); + } + const Y = Hn(zl(iw( + re, + T, + /*forceDtsPaths*/ + !0 + ).declarationFilePath)); + return S.updateSourceFile( + re, + it, + /*isDeclarationFile*/ + !0, + Le(Y), + Ke(), + re.hasNoDefaultLib, + Tt() + ); + function Ae(mt) { + F = Bi(F, hr(mt.referencedFiles, (pt) => [mt, pt])), R = Bi(R, mt.typeReferenceDirectives), B = Bi(B, mt.libReferenceDirectives); + } + function $e(mt) { + const pt = { ...mt }; + return pt.pos = -1, pt.end = -1, pt; + } + function Ke() { + return Fi(R, (mt) => { + if (mt.preserve) + return $e(mt); + }); + } + function Tt() { + return Fi(B, (mt) => { + if (mt.preserve) + return $e(mt); + }); + } + function Le(mt) { + return Fi(F, ([pt, Ct]) => { + if (!Ct.preserve) return; + const qe = T.getSourceFileFromReference(pt, Ct); + if (!qe) + return; + let Lt; + if (qe.isDeclarationFile) + Lt = qe.fileName; + else { + if (s && ms(re.sourceFiles, qe)) return; + const yt = iw( + qe, + T, + /*forceDtsPaths*/ + !0 + ); + Lt = yt.declarationFilePath || yt.jsFilePath || qe.fileName; + } + if (!Lt) return; + const rn = rx( + mt, + Lt, + T.getCurrentDirectory(), + T.getCanonicalFileName, + /*isAbsolutePathAnUrl*/ + !1 + ), Pe = $e(Ct); + return Pe.fileName = rn, Pe; + }); + } + } + function ne(re) { + if (re.kind === 80) + return re; + return re.kind === 208 ? S.updateArrayBindingPattern(re, Ar(re.elements, it, w7)) : S.updateObjectBindingPattern(re, Ar(re.elements, it, ya)); + function it(Y) { + return Y.kind === 233 ? Y : (Y.propertyName && Gs(Y.propertyName) && to(Y.propertyName.expression) && Wt(Y.propertyName.expression, u), S.updateBindingElement( + Y, + Y.dotDotDotToken, + Y.propertyName, + ne(Y.name), + /*initializer*/ + void 0 + )); + } + } + function Se(re, it) { + let Y; + h || (Y = n, n = gv(re)); + const Ae = S.updateParameterDeclaration( + re, + Lje(S, re, it), + re.dotDotDotToken, + ne(re.name), + U.isOptionalParameter(re) ? re.questionToken || S.createToken( + 58 + /* QuestionToken */ + ) : void 0, + Ee( + re, + /*ignorePrivate*/ + !0 + ), + // Ignore private param props, since this type is going straight back into a param + Ne(re) + ); + return h || (n = Y), Ae; + } + function ie(re) { + return lve(re) && !!re.initializer && U.isLiteralConstDeclaration(vs(re)); + } + function Ne(re) { + if (ie(re)) { + const it = nte(re.initializer); + return _F(it) || ae(re), U.createLiteralConstValue(vs(re, lve), D); + } + } + function Ee(re, it) { + if (!it && sf( + re, + 2 + /* Private */ + ) || ie(re)) + return; + if (!Mo(re) && !ya(re) && re.type && (!Ii(re) || !U.requiresAddingImplicitUndefined(re, u))) + return Qe(re.type, fi, li); + const Y = P; + P = re.name; + let Ae; + h || (Ae = n, gA(re) && (n = gv(re))); + let $e; + return fF(re) ? $e = U.createTypeOfDeclaration(re, u, hA, yA, D) : Es(re) ? $e = U.createReturnTypeOfSignatureDeclaration(re, u, hA, yA, D) : E.assertNever(re), P = Y, h || (n = Ae), $e ?? S.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ); + } + function Ce(re) { + switch (re = vs(re), re.kind) { + case 263: + case 268: + case 265: + case 264: + case 266: + case 267: + return !U.isDeclarationVisible(re); + // The following should be doing their own visibility checks based on filtering their members + case 261: + return !St(re); + case 272: + case 273: + case 279: + case 278: + return !1; + case 176: + return !0; + } + return !1; + } + function Ve(re) { + var it; + if (re.body) + return !0; + const Y = (it = re.symbol.declarations) == null ? void 0 : it.filter((Ae) => Cc(Ae) && !Ae.body); + return !Y || Y.indexOf(re) === Y.length - 1; + } + function St(re) { + return vl(re) ? !1 : ws(re.name) ? ot(re.name.elements, St) : U.isDeclarationVisible(re); + } + function Bt(re, it, Y) { + if (sf( + re, + 2 + /* Private */ + )) + return S.createNodeArray(); + const Ae = hr(it, ($e) => Se($e, Y)); + return Ae ? S.createNodeArray(Ae, it.hasTrailingComma) : S.createNodeArray(); + } + function tr(re, it) { + let Y; + if (!it) { + const Ae = Rb(re); + Ae && (Y = [Se(Ae)]); + } + if (z_(re)) { + let Ae; + if (!it) { + const $e = e4(re); + $e && (Ae = Se($e)); + } + Ae || (Ae = S.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "value" + )), Y = Er(Y, Ae); + } + return S.createNodeArray(Y || Ge); + } + function Nr(re, it) { + return sf( + re, + 2 + /* Private */ + ) ? void 0 : Ar(it, fi, Lo); + } + function st(re) { + return Di(re) || Wp(re) || jc(re) || tl(re) || Vl(re) || Es(re) || qy(re) || CS(re); + } + function Wt(re, it) { + const Y = U.isEntityNameVisible(re, it); + se(Y); + } + function Jr(re, it) { + return kf(re) && kf(it) && (re.jsDoc = it.jsDoc), el(re, hm(it)); + } + function ui(re, it) { + if (it) { + if (o = o || re.kind !== 268 && re.kind !== 206, ja(it) && s) { + const Y = qK(e.getEmitHost(), U, re); + if (Y) + return S.createStringLiteral(Y); + } + return it; + } + } + function Ji(re) { + if (U.isDeclarationVisible(re)) + if (re.moduleReference.kind === 284) { + const it = jD(re); + return S.updateImportEqualsDeclaration( + re, + re.modifiers, + re.isTypeOnly, + re.name, + S.updateExternalModuleReference(re.moduleReference, ui(re, it)) + ); + } else { + const it = n; + return n = gv(re), Wt(re.moduleReference, u), n = it, re; + } + } + function Dt(re) { + if (!re.importClause) + return S.updateImportDeclaration( + re, + re.modifiers, + re.importClause, + ui(re, re.moduleSpecifier), + Mn(re.attributes) + ); + const it = re.importClause.phaseModifier === 166 ? void 0 : re.importClause.phaseModifier, Y = re.importClause && re.importClause.name && U.isDeclarationVisible(re.importClause) ? re.importClause.name : void 0; + if (!re.importClause.namedBindings) + return Y && S.updateImportDeclaration( + re, + re.modifiers, + S.updateImportClause( + re.importClause, + it, + Y, + /*namedBindings*/ + void 0 + ), + ui(re, re.moduleSpecifier), + Mn(re.attributes) + ); + if (re.importClause.namedBindings.kind === 275) { + const $e = U.isDeclarationVisible(re.importClause.namedBindings) ? re.importClause.namedBindings : ( + /*namedBindings*/ + void 0 + ); + return Y || $e ? S.updateImportDeclaration( + re, + re.modifiers, + S.updateImportClause( + re.importClause, + it, + Y, + $e + ), + ui(re, re.moduleSpecifier), + Mn(re.attributes) + ) : void 0; + } + const Ae = Fi(re.importClause.namedBindings.elements, ($e) => U.isDeclarationVisible($e) ? $e : void 0); + if (Ae && Ae.length || Y) + return S.updateImportDeclaration( + re, + re.modifiers, + S.updateImportClause( + re.importClause, + it, + Y, + Ae && Ae.length ? S.updateNamedImports(re.importClause.namedBindings, Ae) : void 0 + ), + ui(re, re.moduleSpecifier), + Mn(re.attributes) + ); + if (U.isImportRequiredByAugmentation(re)) + return K && e.addDiagnostic(sn(re, p.Declaration_emit_for_this_file_requires_preserving_this_import_for_augmentations_This_is_not_supported_with_isolatedDeclarations)), S.updateImportDeclaration( + re, + re.modifiers, + /*importClause*/ + void 0, + ui(re, re.moduleSpecifier), + Mn(re.attributes) + ); + } + function Mn(re) { + const it = R6(re); + return re && it !== void 0 ? re : void 0; + } + function ai(re) { + for (; wr(g); ) { + const Y = g.shift(); + if (!H7(Y)) + return E.fail(`Late replaced statement was found which is not handled by the declaration transformer!: ${E.formatSyntaxKind(Y.kind)}`); + const Ae = i; + i = Y.parent && Di(Y.parent) && !(fl(Y.parent) && s); + const $e = er(Y); + i = Ae, m.set(l_(Y), $e); + } + return Ar(re, it, Ti); + function it(Y) { + if (H7(Y)) { + const Ae = l_(Y); + if (m.has(Ae)) { + const $e = m.get(Ae); + return m.delete(Ae), $e && ((as($e) ? ot($e, P7) : P7($e)) && (c = !0), Di(Y.parent) && (as($e) ? ot($e, p3) : p3($e)) && (o = !0)), $e; + } + } + return Y; + } + } + function fi(re) { + if (Ds(re)) return; + if (Pl(re)) { + if (Ce(re)) return; + if (Th(re)) { + if (K) { + if (!U.isDefinitelyReferenceToGlobalSymbolObject(re.name.expression)) { + if (tl(re.parent) || _a(re.parent)) { + e.addDiagnostic(sn(re, p.Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations)); + return; + } else if ( + // Type declarations just need to double-check that the input computed name is an entity name expression + (Vl(re.parent) || a_(re.parent)) && !to(re.name.expression) + ) { + e.addDiagnostic(sn(re, p.Computed_properties_must_be_number_or_string_literals_variables_or_dotted_expressions_with_isolatedDeclarations)); + return; + } + } + } else if (!U.isLateBound(vs(re)) || !to(re.name.expression)) + return; + } + } + if (Es(re) && U.isImplementationOfOverload(re) || Jte(re)) return; + let it; + st(re) && (it = u, u = re); + const Y = n, Ae = gA(re), $e = h; + let Ke = (re.kind === 188 || re.kind === 201) && re.parent.kind !== 266; + if ((rc(re) || cd(re)) && sf( + re, + 2 + /* Private */ + )) + return re.symbol && re.symbol.declarations && re.symbol.declarations[0] !== re ? void 0 : Tt(S.createPropertyDeclaration( + bs(re), + re.name, + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + )); + if (Ae && !h && (n = gv(re)), Hb(re) && Wt(re.exprName, u), Ke && (h = !0), Rje(re)) + switch (re.kind) { + case 234: { + (r_(re.expression) || to(re.expression)) && Wt(re.expression, u); + const Le = br(re, fi, e); + return Tt(S.updateExpressionWithTypeArguments(Le, Le.expression, Le.typeArguments)); + } + case 184: { + Wt(re.typeName, u); + const Le = br(re, fi, e); + return Tt(S.updateTypeReferenceNode(Le, Le.typeName, Le.typeArguments)); + } + case 181: + return Tt(S.updateConstructSignature( + re, + Nr(re, re.typeParameters), + Bt(re, re.parameters), + Ee(re) + )); + case 177: { + const Le = S.createConstructorDeclaration( + /*modifiers*/ + bs(re), + Bt( + re, + re.parameters, + 0 + /* None */ + ), + /*body*/ + void 0 + ); + return Tt(Le); + } + case 175: { + if (Ai(re.name)) + return Tt( + /*returnValue*/ + void 0 + ); + const Le = S.createMethodDeclaration( + bs(re), + /*asteriskToken*/ + void 0, + re.name, + re.questionToken, + Nr(re, re.typeParameters), + Bt(re, re.parameters), + Ee(re), + /*body*/ + void 0 + ); + return Tt(Le); + } + case 178: + return Ai(re.name) ? Tt( + /*returnValue*/ + void 0 + ) : Tt(S.updateGetAccessorDeclaration( + re, + bs(re), + re.name, + tr(re, sf( + re, + 2 + /* Private */ + )), + Ee(re), + /*body*/ + void 0 + )); + case 179: + return Ai(re.name) ? Tt( + /*returnValue*/ + void 0 + ) : Tt(S.updateSetAccessorDeclaration( + re, + bs(re), + re.name, + tr(re, sf( + re, + 2 + /* Private */ + )), + /*body*/ + void 0 + )); + case 173: + return Ai(re.name) ? Tt( + /*returnValue*/ + void 0 + ) : Tt(S.updatePropertyDeclaration( + re, + bs(re), + re.name, + re.questionToken, + Ee(re), + Ne(re) + )); + case 172: + return Ai(re.name) ? Tt( + /*returnValue*/ + void 0 + ) : Tt(S.updatePropertySignature( + re, + bs(re), + re.name, + re.questionToken, + Ee(re) + )); + case 174: + return Ai(re.name) ? Tt( + /*returnValue*/ + void 0 + ) : Tt(S.updateMethodSignature( + re, + bs(re), + re.name, + re.questionToken, + Nr(re, re.typeParameters), + Bt(re, re.parameters), + Ee(re) + )); + case 180: + return Tt( + S.updateCallSignature( + re, + Nr(re, re.typeParameters), + Bt(re, re.parameters), + Ee(re) + ) + ); + case 182: + return Tt(S.updateIndexSignature( + re, + bs(re), + Bt(re, re.parameters), + Qe(re.type, fi, li) || S.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ) + )); + case 261: + return ws(re.name) ? Jn(re.name) : (Ke = !0, h = !0, Tt(S.updateVariableDeclaration( + re, + re.name, + /*exclamationToken*/ + void 0, + Ee(re), + Ne(re) + ))); + case 169: + return pn(re) && (re.default || re.constraint) ? Tt(S.updateTypeParameterDeclaration( + re, + re.modifiers, + re.name, + /*constraint*/ + void 0, + /*defaultType*/ + void 0 + )) : Tt(br(re, fi, e)); + case 195: { + const Le = Qe(re.checkType, fi, li), mt = Qe(re.extendsType, fi, li), pt = u; + u = re.trueType; + const Ct = Qe(re.trueType, fi, li); + u = pt; + const qe = Qe(re.falseType, fi, li); + return E.assert(Le), E.assert(mt), E.assert(Ct), E.assert(qe), Tt(S.updateConditionalTypeNode(re, Le, mt, Ct, qe)); + } + case 185: + return Tt(S.updateFunctionTypeNode( + re, + Ar(re.typeParameters, fi, Lo), + Bt(re, re.parameters), + E.checkDefined(Qe(re.type, fi, li)) + )); + case 186: + return Tt(S.updateConstructorTypeNode( + re, + bs(re), + Ar(re.typeParameters, fi, Lo), + Bt(re, re.parameters), + E.checkDefined(Qe(re.type, fi, li)) + )); + case 206: + return bh(re) ? Tt(S.updateImportTypeNode( + re, + S.updateLiteralTypeNode(re.argument, ui(re, re.argument.literal)), + re.attributes, + re.qualifier, + Ar(re.typeArguments, fi, li), + re.isTypeOf + )) : Tt(re); + default: + E.assertNever(re, `Attempted to process unhandled node kind: ${E.formatSyntaxKind(re.kind)}`); + } + return qx(re) && js(O, re.pos).line === js(O, re.end).line && un( + re, + 1 + /* SingleLine */ + ), Tt(br(re, fi, e)); + function Tt(Le) { + return Le && Ae && Th(re) && ki(re), st(re) && (u = it), Ae && !h && (n = Y), Ke && (h = $e), Le === re ? Le : Le && Cn(Jr(Le, re), re); + } + } + function pn(re) { + return re.parent.kind === 175 && sf( + re.parent, + 2 + /* Private */ + ); + } + function _i(re) { + if (!Mje(re) || Ds(re)) return; + switch (re.kind) { + case 279: + return Di(re.parent) && (o = !0), _ = !0, S.updateExportDeclaration( + re, + re.modifiers, + re.isTypeOnly, + re.exportClause, + ui(re, re.moduleSpecifier), + Mn(re.attributes) + ); + case 278: { + if (Di(re.parent) && (o = !0), _ = !0, re.expression.kind === 80) + return re; + { + const Y = S.createUniqueName( + "_default", + 16 + /* Optimistic */ + ); + n = () => ({ + diagnosticMessage: p.Default_export_of_the_module_has_or_is_using_private_name_0, + errorNode: re + }), A = re; + const Ae = Ee(re), $e = S.createVariableDeclaration( + Y, + /*exclamationToken*/ + void 0, + Ae, + /*initializer*/ + void 0 + ); + A = void 0; + const Ke = S.createVariableStatement(i ? [S.createModifier( + 138 + /* DeclareKeyword */ + )] : [], S.createVariableDeclarationList( + [$e], + 2 + /* Const */ + )); + return Jr(Ke, re), IN(re), [Ke, S.updateExportAssignment(re, re.modifiers, Y)]; + } + } + } + const it = er(re); + return m.set(l_(re), it), re; + } + function Je(re) { + if (_l(re) || sf( + re, + 2048 + /* Default */ + ) || !Vp(re)) + return re; + const it = S.createModifiersFromModifierFlags(pu(re) & 131039); + return S.replaceModifiers(re, it); + } + function ft(re, it, Y, Ae) { + const $e = S.updateModuleDeclaration(re, it, Y, Ae); + if (Vu($e) || $e.flags & 32) + return $e; + const Ke = S.createModuleDeclaration( + $e.modifiers, + $e.name, + $e.body, + $e.flags | 32 + /* Namespace */ + ); + return Cn(Ke, $e), ct(Ke, $e), Ke; + } + function er(re) { + if (g) + for (; rD(g, re); ) ; + if (Ds(re)) return; + switch (re.kind) { + case 272: + return Ji(re); + case 273: + return Dt(re); + } + if (Pl(re) && Ce(re) || xm(re) || Es(re) && U.isImplementationOfOverload(re)) return; + let it; + st(re) && (it = u, u = re); + const Y = gA(re), Ae = n; + Y && (n = gv(re)); + const $e = i; + switch (re.kind) { + case 266: { + i = !1; + const Tt = Ke(S.updateTypeAliasDeclaration( + re, + bs(re), + re.name, + Ar(re.typeParameters, fi, Lo), + E.checkDefined(Qe(re.type, fi, li)) + )); + return i = $e, Tt; + } + case 265: + return Ke(S.updateInterfaceDeclaration( + re, + bs(re), + re.name, + Nr(re, re.typeParameters), + Et(re.heritageClauses), + Ar(re.members, fi, kb) + )); + case 263: { + const Tt = Ke(S.updateFunctionDeclaration( + re, + bs(re), + /*asteriskToken*/ + void 0, + re.name, + Nr(re, re.typeParameters), + Bt(re, re.parameters), + Ee(re), + /*body*/ + void 0 + )); + if (Tt && U.isExpandoFunctionDeclaration(re) && Ve(re)) { + const Le = U.getPropertiesOfContainerFunction(re); + K && V(re); + const mt = fv.createModuleDeclaration( + /*modifiers*/ + void 0, + Tt.name || S.createIdentifier("_default"), + S.createModuleBlock([]), + 32 + /* Namespace */ + ); + za(mt, u), mt.locals = Bs(Le), mt.symbol = Le[0].parent; + const pt = []; + let Ct = Fi(Le, (ue) => { + if (!Mx(ue.valueDeclaration)) + return; + const M = Si(ue.escapedName); + if (!R_( + M, + 99 + /* ESNext */ + )) + return; + n = gv(ue.valueDeclaration); + const ye = U.createTypeOfDeclaration(ue.valueDeclaration, mt, hA, yA | 2, D); + n = Ae; + const Q = Sx(M), dt = Q ? S.getGeneratedNameForNode(ue.valueDeclaration) : S.createIdentifier(M); + Q && pt.push([dt, M]); + const Mt = S.createVariableDeclaration( + dt, + /*exclamationToken*/ + void 0, + ye, + /*initializer*/ + void 0 + ); + return S.createVariableStatement(Q ? void 0 : [S.createToken( + 95 + /* ExportKeyword */ + )], S.createVariableDeclarationList([Mt])); + }); + pt.length ? Ct.push(S.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + S.createNamedExports(hr(pt, ([ue, M]) => S.createExportSpecifier( + /*isTypeOnly*/ + !1, + ue, + M + ))) + )) : Ct = Fi(Ct, (ue) => S.replaceModifiers( + ue, + 0 + /* None */ + )); + const qe = S.createModuleDeclaration( + bs(re), + re.name, + S.createModuleBlock(Ct), + 32 + /* Namespace */ + ); + if (!sf( + Tt, + 2048 + /* Default */ + )) + return [Tt, qe]; + const Lt = S.createModifiersFromModifierFlags( + pu(Tt) & -2081 | 128 + /* Ambient */ + ), rn = S.updateFunctionDeclaration( + Tt, + Lt, + /*asteriskToken*/ + void 0, + Tt.name, + Tt.typeParameters, + Tt.parameters, + Tt.type, + /*body*/ + void 0 + ), Pe = S.updateModuleDeclaration( + qe, + Lt, + qe.name, + qe.body + ), yt = S.createExportAssignment( + /*modifiers*/ + void 0, + /*isExportEquals*/ + !1, + qe.name + ); + return Di(re.parent) && (o = !0), _ = !0, [rn, Pe, yt]; + } else + return Tt; + } + case 268: { + i = !1; + const Tt = re.body; + if (Tt && Tt.kind === 269) { + const Le = c, mt = _; + _ = !1, c = !1; + const pt = Ar(Tt.statements, _i, Ti); + let Ct = ai(pt); + re.flags & 33554432 && (c = !1), !$m(re) && !yr(Ct) && !_ && (c ? Ct = S.createNodeArray([...Ct, UN(S)]) : Ct = Ar(Ct, Je, Ti)); + const qe = S.updateModuleBlock(Tt, Ct); + i = $e, c = Le, _ = mt; + const Lt = bs(re); + return Ke(ft( + re, + Lt, + Pb(re) ? ui(re, re.name) : re.name, + qe + )); + } else { + i = $e; + const Le = bs(re); + i = !1, Qe(Tt, _i); + const mt = l_(Tt), pt = m.get(mt); + return m.delete(mt), Ke(ft( + re, + Le, + re.name, + pt + )); + } + } + case 264: { + P = re.name, A = re; + const Tt = S.createNodeArray(bs(re)), Le = Nr(re, re.typeParameters), mt = Mg(re); + let pt; + if (mt) { + const ue = n; + pt = RP(ka(mt.parameters, (M) => { + if (!Gn( + M, + 31 + /* ParameterPropertyModifier */ + ) || Ds(M)) return; + if (n = gv(M), M.name.kind === 80) + return Jr( + S.createPropertyDeclaration( + bs(M), + M.name, + M.questionToken, + Ee(M), + Ne(M) + ), + M + ); + return ye(M.name); + function ye(Q) { + let dt; + for (const Mt of Q.elements) + vl(Mt) || (ws(Mt.name) && (dt = Bi(dt, ye(Mt.name))), dt = dt || [], dt.push(S.createPropertyDeclaration( + bs(M), + Mt.name, + /*questionOrExclamationToken*/ + void 0, + Ee(Mt), + /*initializer*/ + void 0 + ))); + return dt; + } + })), n = ue; + } + const qe = ot(re.members, (ue) => !!ue.name && Ai(ue.name)) ? [ + S.createPropertyDeclaration( + /*modifiers*/ + void 0, + S.createPrivateIdentifier("#private"), + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + ) + ] : void 0, Lt = U.createLateBoundIndexSignatures(re, u, hA, yA, D), rn = Bi(Bi(Bi(qe, Lt), pt), Ar(re.members, fi, Hc)), Pe = S.createNodeArray(rn), yt = wd(re); + if (yt && !to(yt.expression) && yt.expression.kind !== 106) { + const ue = re.name ? Si(re.name.escapedText) : "default", M = S.createUniqueName( + `${ue}_base`, + 16 + /* Optimistic */ + ); + n = () => ({ + diagnosticMessage: p.extends_clause_of_exported_class_0_has_or_is_using_private_name_1, + errorNode: yt, + typeName: re.name + }); + const ye = S.createVariableDeclaration( + M, + /*exclamationToken*/ + void 0, + U.createTypeOfExpression(yt.expression, re, hA, yA, D), + /*initializer*/ + void 0 + ), Q = S.createVariableStatement(i ? [S.createModifier( + 138 + /* DeclareKeyword */ + )] : [], S.createVariableDeclarationList( + [ye], + 2 + /* Const */ + )), dt = S.createNodeArray(hr(re.heritageClauses, (Mt) => { + if (Mt.token === 96) { + const ke = n; + n = gv(Mt.types[0]); + const at = S.updateHeritageClause(Mt, hr(Mt.types, (wt) => S.updateExpressionWithTypeArguments(wt, M, Ar(wt.typeArguments, fi, li)))); + return n = ke, at; + } + return S.updateHeritageClause(Mt, Ar(S.createNodeArray(kn( + Mt.types, + (ke) => to(ke.expression) || ke.expression.kind === 106 + /* NullKeyword */ + )), fi, Dh)); + })); + return [ + Q, + Ke(S.updateClassDeclaration( + re, + Tt, + re.name, + Le, + dt, + Pe + )) + ]; + } else { + const ue = Et(re.heritageClauses); + return Ke(S.updateClassDeclaration( + re, + Tt, + re.name, + Le, + ue, + Pe + )); + } + } + case 244: + return Ke(qr(re)); + case 267: + return Ke(S.updateEnumDeclaration( + re, + S.createNodeArray(bs(re)), + re.name, + S.createNodeArray(Fi(re.members, (Tt) => { + if (Ds(Tt)) return; + const Le = U.getEnumMemberValue(Tt), mt = Le?.value; + K && Tt.initializer && Le?.hasExternalReferences && // This will be its own compiler error instead, so don't report. + !Gs(Tt.name) && e.addDiagnostic(sn(Tt, p.Enum_member_initializers_must_be_computable_without_references_to_external_symbols_with_isolatedDeclarations)); + const pt = mt === void 0 ? void 0 : typeof mt == "string" ? S.createStringLiteral(mt) : mt < 0 ? S.createPrefixUnaryExpression(41, S.createNumericLiteral(-mt)) : S.createNumericLiteral(mt); + return Jr(S.updateEnumMember(Tt, Tt.name, pt), Tt); + })) + )); + } + return E.assertNever(re, `Unhandled top-level node in declaration emit: ${E.formatSyntaxKind(re.kind)}`); + function Ke(Tt) { + return st(re) && (u = it), Y && (n = Ae), re.kind === 268 && (i = $e), Tt === re ? Tt : (A = void 0, P = void 0, Tt && Cn(Jr(Tt, re), re)); + } + } + function qr(re) { + if (!lr(re.declarationList.declarations, St)) return; + const it = Ar(re.declarationList.declarations, fi, ei); + if (!wr(it)) return; + const Y = S.createNodeArray(bs(re)); + let Ae; + return D3(re.declarationList) || E3(re.declarationList) ? (Ae = S.createVariableDeclarationList( + it, + 2 + /* Const */ + ), Cn(Ae, re.declarationList), ct(Ae, re.declarationList), el(Ae, re.declarationList)) : Ae = S.updateVariableDeclarationList(re.declarationList, it), S.updateVariableStatement(re, Y, Ae); + } + function Jn(re) { + return Ip(Fi(re.elements, (it) => Un(it))); + } + function Un(re) { + if (re.kind !== 233 && re.name) + return St(re) ? ws(re.name) ? Jn(re.name) : S.createVariableDeclaration( + re.name, + /*exclamationToken*/ + void 0, + Ee(re), + /*initializer*/ + void 0 + ) : void 0; + } + function ki(re) { + let it; + h || (it = n, n = _ie(re)), P = re.name, E.assert(Th(re)); + const Ae = re.name.expression; + Wt(Ae, u), h || (n = it), P = void 0; + } + function Ds(re) { + return !!_e && !!re && JZ(re, O); + } + function Ks(re) { + return Mo(re) || Bc(re); + } + function yr(re) { + return ot(re, Ks); + } + function bs(re) { + const it = pu(re), Y = Xe(re); + return it === Y ? Q4(re.modifiers, (Ae) => Bn(Ae, Zs), Zs) : S.createModifiersFromModifierFlags(Y); + } + function Xe(re) { + let it = 130030, Y = i && !Oje(re) ? 128 : 0; + const Ae = re.parent.kind === 308; + return (!Ae || s && Ae && fl(re.parent)) && (it ^= 128, Y = 0), cve(re, it, Y); + } + function Et(re) { + return S.createNodeArray(kn( + hr(re, (it) => S.updateHeritageClause( + it, + Ar( + S.createNodeArray(kn(it.types, (Y) => to(Y.expression) || it.token === 96 && Y.expression.kind === 106)), + fi, + Dh + ) + )), + (it) => it.types && !!it.types.length + )); + } + } + function Oje(e) { + return e.kind === 265; + } + function Lje(e, t, n, i) { + return e.createModifiersFromModifierFlags(cve(t, n, i)); + } + function cve(e, t = 131070, n = 0) { + let i = pu(e) & t | n; + return i & 2048 && !(i & 32) && (i ^= 32), i & 2048 && i & 128 && (i ^= 128), i; + } + function lve(e) { + switch (e.kind) { + case 173: + case 172: + return !sf( + e, + 2 + /* Private */ + ); + case 170: + case 261: + return !0; + } + return !1; + } + function Mje(e) { + switch (e.kind) { + case 263: + case 268: + case 272: + case 265: + case 264: + case 266: + case 267: + case 244: + case 273: + case 279: + case 278: + return !0; + } + return !1; + } + function Rje(e) { + switch (e.kind) { + case 181: + case 177: + case 175: + case 178: + case 179: + case 173: + case 172: + case 174: + case 180: + case 182: + case 261: + case 169: + case 234: + case 184: + case 195: + case 185: + case 186: + case 206: + return !0; + } + return !1; + } + function jje(e) { + switch (e) { + case 200: + return QW; + case 99: + case 7: + case 6: + case 5: + case 100: + case 101: + case 102: + case 199: + case 1: + return uie; + case 4: + return lie; + default: + return XW; + } + } + var die = { scriptTransformers: Ge, declarationTransformers: Ge }; + function mie(e, t, n) { + return { + scriptTransformers: Bje(e, t, n), + declarationTransformers: Jje(t) + }; + } + function Bje(e, t, n) { + if (n) return Ge; + const i = da(e), s = Hu(e), o = gN(e), c = []; + return In(c, t && hr(t.before, _ve)), c.push(Hne), e.experimentalDecorators && c.push(Xne), G5(e) && c.push(sie), i < 99 && c.push(rie), !e.experimentalDecorators && (i < 99 || !o) && c.push(Qne), c.push(Gne), i < 8 && c.push(tie), i < 7 && c.push(eie), i < 6 && c.push(Kne), i < 5 && c.push(Zne), i < 4 && c.push(Yne), i < 3 && c.push(aie), i < 2 && (c.push(oie), c.push(cie)), c.push(jje(s)), In(c, t && hr(t.after, _ve)), c; + } + function Jje(e) { + const t = []; + return t.push(YW), In(t, e && hr(e.afterDeclarations, Wje)), t; + } + function zje(e) { + return (t) => Hte(t) ? e.transformBundle(t) : e.transformSourceFile(t); + } + function uve(e, t) { + return (n) => { + const i = e(n); + return typeof i == "function" ? t(n, i) : zje(i); + }; + } + function _ve(e) { + return uve(e, Ld); + } + function Wje(e) { + return uve(e, (t, n) => n); + } + function nw(e, t) { + return t; + } + function vA(e, t, n) { + n(e, t); + } + function bA(e, t, n, i, s, o, c) { + var _, u; + const g = new Array( + 359 + /* Count */ + ); + let m, h, S, T = 0, k = [], D = [], P = [], A = [], O = 0, F = !1, R = [], B = 0, U, $, W = nw, _e = vA, K = 0; + const V = [], ae = { + factory: n, + getCompilerOptions: () => i, + getEmitResolver: () => e, + // TODO: GH#18217 + getEmitHost: () => t, + // TODO: GH#18217 + getEmitHelperFactory: Uu(() => Ete(ae)), + startLexicalEnvironment: ne, + suspendLexicalEnvironment: Se, + resumeLexicalEnvironment: ie, + endLexicalEnvironment: Ne, + setLexicalEnvironmentFlags: Ee, + getLexicalEnvironmentFlags: Ce, + hoistVariableDeclaration: Te, + hoistFunctionDeclaration: Fe, + addInitializationStatement: Ye, + startBlockScope: Ve, + endBlockScope: St, + addBlockScopedVariable: Bt, + requestEmitHelper: tr, + readEmitHelpers: Nr, + enableSubstitution: q, + enableEmitNotification: me, + isSubstitutionEnabled: be, + isEmitNotificationEnabled: Z, + get onSubstituteNode() { + return W; + }, + set onSubstituteNode(Wt) { + E.assert(K < 1, "Cannot modify transformation hooks after initialization has completed."), E.assert(Wt !== void 0, "Value must not be 'undefined'"), W = Wt; + }, + get onEmitNode() { + return _e; + }, + set onEmitNode(Wt) { + E.assert(K < 1, "Cannot modify transformation hooks after initialization has completed."), E.assert(Wt !== void 0, "Value must not be 'undefined'"), _e = Wt; + }, + addDiagnostic(Wt) { + V.push(Wt); + } + }; + for (const Wt of s) + iz(xr(vs(Wt))); + Ko("beforeTransform"); + const se = o.map((Wt) => Wt(ae)), ce = (Wt) => { + for (const Jr of se) + Wt = Jr(Wt); + return Wt; + }; + K = 1; + const fe = []; + for (const Wt of s) + (_ = on) == null || _.push(on.Phase.Emit, "transformNodes", Wt.kind === 308 ? { path: Wt.path } : { kind: Wt.kind, pos: Wt.pos, end: Wt.end }), fe.push((c ? ce : he)(Wt)), (u = on) == null || u.pop(); + return K = 2, Ko("afterTransform"), rp("transformTime", "beforeTransform", "afterTransform"), { + transformed: fe, + substituteNode: je, + emitNodeWithNotification: pe, + isEmitNotificationEnabled: Z, + dispose: st, + diagnostics: V + }; + function he(Wt) { + return Wt && (!Di(Wt) || !Wt.isDeclarationFile) ? ce(Wt) : Wt; + } + function q(Wt) { + E.assert(K < 2, "Cannot modify the transformation context after transformation has completed."), g[Wt] |= 1; + } + function be(Wt) { + return (g[Wt.kind] & 1) !== 0 && (Ea(Wt) & 8) === 0; + } + function je(Wt, Jr) { + return E.assert(K < 3, "Cannot substitute a node after the result is disposed."), Jr && be(Jr) && W(Wt, Jr) || Jr; + } + function me(Wt) { + E.assert(K < 2, "Cannot modify the transformation context after transformation has completed."), g[Wt] |= 2; + } + function Z(Wt) { + return (g[Wt.kind] & 2) !== 0 || (Ea(Wt) & 4) !== 0; + } + function pe(Wt, Jr, ui) { + E.assert(K < 3, "Cannot invoke TransformationResult callbacks after the result is disposed."), Jr && (Z(Jr) ? _e(Wt, Jr, ui) : ui(Wt, Jr)); + } + function Te(Wt) { + E.assert(K > 0, "Cannot modify the lexical environment during initialization."), E.assert(K < 2, "Cannot modify the lexical environment after transformation has completed."); + const Jr = un( + n.createVariableDeclaration(Wt), + 128 + /* NoNestedSourceMaps */ + ); + m ? m.push(Jr) : m = [Jr], T & 1 && (T |= 2); + } + function Fe(Wt) { + E.assert(K > 0, "Cannot modify the lexical environment during initialization."), E.assert(K < 2, "Cannot modify the lexical environment after transformation has completed."), un( + Wt, + 2097152 + /* CustomPrologue */ + ), h ? h.push(Wt) : h = [Wt]; + } + function Ye(Wt) { + E.assert(K > 0, "Cannot modify the lexical environment during initialization."), E.assert(K < 2, "Cannot modify the lexical environment after transformation has completed."), un( + Wt, + 2097152 + /* CustomPrologue */ + ), S ? S.push(Wt) : S = [Wt]; + } + function ne() { + E.assert(K > 0, "Cannot modify the lexical environment during initialization."), E.assert(K < 2, "Cannot modify the lexical environment after transformation has completed."), E.assert(!F, "Lexical environment is suspended."), k[O] = m, D[O] = h, P[O] = S, A[O] = T, O++, m = void 0, h = void 0, S = void 0, T = 0; + } + function Se() { + E.assert(K > 0, "Cannot modify the lexical environment during initialization."), E.assert(K < 2, "Cannot modify the lexical environment after transformation has completed."), E.assert(!F, "Lexical environment is already suspended."), F = !0; + } + function ie() { + E.assert(K > 0, "Cannot modify the lexical environment during initialization."), E.assert(K < 2, "Cannot modify the lexical environment after transformation has completed."), E.assert(F, "Lexical environment is not suspended."), F = !1; + } + function Ne() { + E.assert(K > 0, "Cannot modify the lexical environment during initialization."), E.assert(K < 2, "Cannot modify the lexical environment after transformation has completed."), E.assert(!F, "Lexical environment is suspended."); + let Wt; + if (m || h || S) { + if (h && (Wt = [...h]), m) { + const Jr = n.createVariableStatement( + /*modifiers*/ + void 0, + n.createVariableDeclarationList(m) + ); + un( + Jr, + 2097152 + /* CustomPrologue */ + ), Wt ? Wt.push(Jr) : Wt = [Jr]; + } + S && (Wt ? Wt = [...Wt, ...S] : Wt = [...S]); + } + return O--, m = k[O], h = D[O], S = P[O], T = A[O], O === 0 && (k = [], D = [], P = [], A = []), Wt; + } + function Ee(Wt, Jr) { + T = Jr ? T | Wt : T & ~Wt; + } + function Ce() { + return T; + } + function Ve() { + E.assert(K > 0, "Cannot start a block scope during initialization."), E.assert(K < 2, "Cannot start a block scope after transformation has completed."), R[B] = U, B++, U = void 0; + } + function St() { + E.assert(K > 0, "Cannot end a block scope during initialization."), E.assert(K < 2, "Cannot end a block scope after transformation has completed."); + const Wt = ot(U) ? [ + n.createVariableStatement( + /*modifiers*/ + void 0, + n.createVariableDeclarationList( + U.map((Jr) => n.createVariableDeclaration(Jr)), + 1 + /* Let */ + ) + ) + ] : void 0; + return B--, U = R[B], B === 0 && (R = []), Wt; + } + function Bt(Wt) { + E.assert(B > 0, "Cannot add a block scoped variable outside of an iteration body."), (U || (U = [])).push(Wt); + } + function tr(Wt) { + if (E.assert(K > 0, "Cannot modify the transformation context during initialization."), E.assert(K < 2, "Cannot modify the transformation context after transformation has completed."), E.assert(!Wt.scoped, "Cannot request a scoped emit helper."), Wt.dependencies) + for (const Jr of Wt.dependencies) + tr(Jr); + $ = Er($, Wt); + } + function Nr() { + E.assert(K > 0, "Cannot modify the transformation context during initialization."), E.assert(K < 2, "Cannot modify the transformation context after transformation has completed."); + const Wt = $; + return $ = void 0, Wt; + } + function st() { + if (K < 3) { + for (const Wt of s) + iz(xr(vs(Wt))); + m = void 0, k = void 0, h = void 0, D = void 0, W = void 0, _e = void 0, $ = void 0, K = 3; + } + } + } + var SA = { + factory: N, + // eslint-disable-line object-shorthand + getCompilerOptions: () => ({}), + getEmitResolver: Vs, + getEmitHost: Vs, + getEmitHelperFactory: Vs, + startLexicalEnvironment: Ha, + resumeLexicalEnvironment: Ha, + suspendLexicalEnvironment: Ha, + endLexicalEnvironment: vb, + setLexicalEnvironmentFlags: Ha, + getLexicalEnvironmentFlags: () => 0, + hoistVariableDeclaration: Ha, + hoistFunctionDeclaration: Ha, + addInitializationStatement: Ha, + startBlockScope: Ha, + endBlockScope: vb, + addBlockScopedVariable: Ha, + requestEmitHelper: Ha, + readEmitHelpers: Vs, + enableSubstitution: Ha, + enableEmitNotification: Ha, + isSubstitutionEnabled: Vs, + isEmitNotificationEnabled: Vs, + onSubstituteNode: nw, + onEmitNode: vA, + addDiagnostic: Ha + }, fve = Vje(); + function gie(e) { + return Xo( + e, + ".tsbuildinfo" + /* TsBuildInfo */ + ); + } + function ZW(e, t, n, i = !1, s, o) { + const c = as(n) ? n : E5(e, n, i), _ = e.getCompilerOptions(); + if (!s) + if (_.outFile) { + if (c.length) { + const u = N.createBundle(c), g = t(iw(u, e, i), u); + if (g) + return g; + } + } else + for (const u of c) { + const g = t(iw(u, e, i), u); + if (g) + return g; + } + if (o) { + const u = hv(_); + if (u) return t( + { buildInfoPath: u }, + /*sourceFileOrBundle*/ + void 0 + ); + } + } + function hv(e) { + const t = e.configFilePath; + if (!Uje(e)) return; + if (e.tsBuildInfoFile) return e.tsBuildInfoFile; + const n = e.outFile; + let i; + if (n) + i = Gu(n); + else { + if (!t) return; + const s = Gu(t); + i = e.outDir ? e.rootDir ? by(e.outDir, Nf( + e.rootDir, + s, + /*ignoreCase*/ + !0 + )) : On(e.outDir, Zc(s)) : s; + } + return i + ".tsbuildinfo"; + } + function Uje(e) { + return Wb(e) || !!e.tscBuild; + } + function hie(e, t) { + const n = e.outFile, i = e.emitDeclarationOnly ? void 0 : n, s = i && pve(i, e), o = t || J_(e) ? Gu(n) + ".d.ts" : void 0, c = o && U5(e) ? o + ".map" : void 0; + return { jsFilePath: i, sourceMapFilePath: s, declarationFilePath: o, declarationMapPath: c }; + } + function iw(e, t, n) { + const i = t.getCompilerOptions(); + if (e.kind === 309) + return hie(i, n); + { + const s = HK(e.fileName, t, TA(e.fileName, i)), o = ap(e), c = o && gh(e.fileName, s, t.getCurrentDirectory(), !t.useCaseSensitiveFileNames()) === 0, _ = i.emitDeclarationOnly || c ? void 0 : s, u = !_ || ap(e) ? void 0 : pve(_, i), g = n || J_(i) && !o ? GK(e.fileName, t) : void 0, m = g && U5(i) ? g + ".map" : void 0; + return { jsFilePath: _, sourceMapFilePath: u, declarationFilePath: g, declarationMapPath: m }; + } + } + function pve(e, t) { + return t.sourceMap && !t.inlineSourceMap ? e + ".map" : void 0; + } + function TA(e, t) { + return Xo( + e, + ".json" + /* Json */ + ) ? ".json" : t.jsx === 1 && xc(e, [ + ".jsx", + ".tsx" + /* Tsx */ + ]) ? ".jsx" : xc(e, [ + ".mts", + ".mjs" + /* Mjs */ + ]) ? ".mjs" : xc(e, [ + ".cts", + ".cjs" + /* Cjs */ + ]) ? ".cjs" : ".js"; + } + function dve(e, t, n, i) { + return n ? by( + n, + Nf(i(), e, t) + ) : e; + } + function sw(e, t, n, i = () => JS(t, n)) { + return KW(e, t.options, n, i); + } + function KW(e, t, n, i) { + return S0( + dve(e, n, t.declarationDir || t.outDir, i), + k5(e) + ); + } + function mve(e, t, n, i = () => JS(t, n)) { + if (t.options.emitDeclarationOnly) return; + const s = Xo( + e, + ".json" + /* Json */ + ), o = eU(e, t.options, n, i); + return !s || gh(e, o, E.checkDefined(t.options.configFilePath), n) !== 0 ? o : void 0; + } + function eU(e, t, n, i) { + return S0( + dve(e, n, t.outDir, i), + TA(e, t) + ); + } + function gve() { + let e; + return { addOutput: t, getOutputs: n }; + function t(i) { + i && (e || (e = [])).push(i); + } + function n() { + return e || Ge; + } + } + function hve(e, t) { + const { jsFilePath: n, sourceMapFilePath: i, declarationFilePath: s, declarationMapPath: o } = hie( + e.options, + /*forceDtsPaths*/ + !1 + ); + t(n), t(i), t(s), t(o); + } + function yve(e, t, n, i, s) { + if (Il(t)) return; + const o = mve(t, e, n, s); + if (i(o), !Xo( + t, + ".json" + /* Json */ + ) && (o && e.options.sourceMap && i(`${o}.map`), J_(e.options))) { + const c = sw(t, e, n, s); + i(c), e.options.declarationMap && i(`${c}.map`); + } + } + function aw(e, t, n, i, s) { + let o; + return e.rootDir ? (o = Qi(e.rootDir, n), s?.(e.rootDir)) : e.composite && e.configFilePath ? (o = Hn(zl(e.configFilePath)), s?.(o)) : o = Cie(t(), n, i), o && o[o.length - 1] !== So && (o += So), o; + } + function JS({ options: e, fileNames: t }, n) { + return aw( + e, + () => kn(t, (i) => !(e.noEmitForJsFiles && xc(i, s6)) && !Il(i)), + Hn(zl(E.checkDefined(e.configFilePath))), + Zl(!n) + ); + } + function AO(e, t) { + const { addOutput: n, getOutputs: i } = gve(); + if (e.options.outFile) + hve(e, n); + else { + const s = Uu(() => JS(e, t)); + for (const o of e.fileNames) + yve(e, o, t, n, s); + } + return n(hv(e.options)), i(); + } + function vve(e, t, n) { + t = Hs(t), E.assert(ms(e.fileNames, t), "Expected fileName to be present in command line"); + const { addOutput: i, getOutputs: s } = gve(); + return e.options.outFile ? hve(e, i) : yve(e, t, n, i), s(); + } + function tU(e, t) { + if (e.options.outFile) { + const { jsFilePath: s, declarationFilePath: o } = hie( + e.options, + /*forceDtsPaths*/ + !1 + ); + return E.checkDefined(s || o, `project ${e.options.configFilePath} expected to have at least one output`); + } + const n = Uu(() => JS(e, t)); + for (const s of e.fileNames) { + if (Il(s)) continue; + const o = mve(s, e, t, n); + if (o) return o; + if (!Xo( + s, + ".json" + /* Json */ + ) && J_(e.options)) + return sw(s, e, t, n); + } + const i = hv(e.options); + return i || E.fail(`project ${e.options.configFilePath} expected to have at least one output`); + } + function rU(e, t) { + return !!t && !!e; + } + function nU(e, t, n, { scriptTransformers: i, declarationTransformers: s }, o, c, _, u) { + var g = t.getCompilerOptions(), m = g.sourceMap || g.inlineSourceMap || U5(g) ? [] : void 0, h = g.listEmittedFiles ? [] : void 0, S = ZD(), T = v0(g), k = nN(T), { enter: D, exit: P } = $R("printTime", "beforePrint", "afterPrint"), A = !1; + return D(), ZW( + t, + O, + E5(t, n, _), + _, + c, + !n && !u + ), P(), { + emitSkipped: A, + diagnostics: S.getDiagnostics(), + emittedFiles: h, + sourceMaps: m + }; + function O({ jsFilePath: se, sourceMapFilePath: ce, declarationFilePath: fe, declarationMapPath: he, buildInfoPath: q }, be) { + var je, me, Z, pe, Te, Fe; + (je = on) == null || je.push(on.Phase.Emit, "emitJsFileOrBundle", { jsFilePath: se }), R(be, se, ce), (me = on) == null || me.pop(), (Z = on) == null || Z.push(on.Phase.Emit, "emitDeclarationFileOrBundle", { declarationFilePath: fe }), B(be, fe, he), (pe = on) == null || pe.pop(), (Te = on) == null || Te.push(on.Phase.Emit, "emitBuildInfo", { buildInfoPath: q }), F(q), (Fe = on) == null || Fe.pop(); + } + function F(se) { + if (!se || n) return; + if (t.isEmitBlocked(se)) { + A = !0; + return; + } + const ce = t.getBuildInfo() || { version: ep }; + w5( + t, + S, + se, + yie(ce), + /*writeByteOrderMark*/ + !1, + /*sourceFiles*/ + void 0, + { buildInfo: ce } + ), h?.push(se); + } + function R(se, ce, fe) { + if (!se || o || !ce) + return; + if (t.isEmitBlocked(ce) || g.noEmit) { + A = !0; + return; + } + (Di(se) ? [se] : kn(se.sourceFiles, l5)).forEach( + (je) => { + (g.noCheck || !m4(je, g)) && $(je); + } + ); + const he = bA( + e, + t, + N, + g, + [se], + i, + /*allowDtsFiles*/ + !1 + ), q = { + removeComments: g.removeComments, + newLine: g.newLine, + noEmitHelpers: g.noEmitHelpers, + module: Hu(g), + moduleResolution: Pu(g), + target: da(g), + sourceMap: g.sourceMap, + inlineSourceMap: g.inlineSourceMap, + inlineSources: g.inlineSources, + extendedDiagnostics: g.extendedDiagnostics + }, be = Ky(q, { + // resolver hooks + hasGlobalName: e.hasGlobalName, + // transform hooks + onEmitNode: he.emitNodeWithNotification, + isEmitNotificationEnabled: he.isEmitNotificationEnabled, + substituteNode: he.substituteNode + }); + E.assert(he.transformed.length === 1, "Should only see one output from the transform"), W(ce, fe, he, be, g), he.dispose(), h && (h.push(ce), fe && h.push(fe)); + } + function B(se, ce, fe) { + if (!se || o === 0) return; + if (!ce) { + (o || g.emitDeclarationOnly) && (A = !0); + return; + } + const he = Di(se) ? [se] : se.sourceFiles, q = _ ? he : kn(he, l5), be = g.outFile ? [N.createBundle(q)] : q; + q.forEach((Z) => { + (o && !J_(g) || g.noCheck || rU(o, _) || !m4(Z, g)) && U(Z); + }); + const je = bA( + e, + t, + N, + g, + be, + s, + /*allowDtsFiles*/ + !1 + ); + if (wr(je.diagnostics)) + for (const Z of je.diagnostics) + S.add(Z); + const me = !!je.diagnostics && !!je.diagnostics.length || !!t.isEmitBlocked(ce) || !!g.noEmit; + if (A = A || me, !me || _) { + E.assert(je.transformed.length === 1, "Should only see one output from the decl transform"); + const Z = { + removeComments: g.removeComments, + newLine: g.newLine, + noEmitHelpers: !0, + module: g.module, + moduleResolution: g.moduleResolution, + target: g.target, + sourceMap: o !== 2 && g.declarationMap, + inlineSourceMap: g.inlineSourceMap, + extendedDiagnostics: g.extendedDiagnostics, + onlyPrintJsDocStyle: !0, + omitBraceSourceMapPositions: !0 + }, pe = Ky(Z, { + // resolver hooks + hasGlobalName: e.hasGlobalName, + // transform hooks + onEmitNode: je.emitNodeWithNotification, + isEmitNotificationEnabled: je.isEmitNotificationEnabled, + substituteNode: je.substituteNode + }), Te = W( + ce, + fe, + je, + pe, + { + sourceMap: Z.sourceMap, + sourceRoot: g.sourceRoot, + mapRoot: g.mapRoot, + extendedDiagnostics: g.extendedDiagnostics + // Explicitly do not passthru either `inline` option + } + ); + h && (Te && h.push(ce), fe && h.push(fe)); + } + je.dispose(); + } + function U(se) { + if (Mo(se)) { + se.expression.kind === 80 && e.collectLinkedAliases( + se.expression, + /*setVisibility*/ + !0 + ); + return; + } else if (Nu(se)) { + e.collectLinkedAliases( + se.propertyName || se.name, + /*setVisibility*/ + !0 + ); + return; + } + xs(se, U); + } + function $(se) { + n_(se) || Kx(se, (ce) => { + if (_l(ce) && !(h0(ce) & 32) || qo(ce)) return "skip"; + e.markLinkedReferences(ce); + }); + } + function W(se, ce, fe, he, q) { + const be = fe.transformed[0], je = be.kind === 309 ? be : void 0, me = be.kind === 308 ? be : void 0, Z = je ? je.sourceFiles : [me]; + let pe; + _e(q, be) && (pe = wne( + t, + Zc(zl(se)), + K(q), + V(q, se, me), + q + )), je ? he.writeBundle(je, k, pe) : he.writeFile(me, k, pe); + let Te; + if (pe) { + m && m.push({ + inputSourceFileNames: pe.getSources(), + sourceMap: pe.toJSON() + }); + const ne = ae( + q, + pe, + se, + ce, + me + ); + if (ne && (k.isAtStartOfLine() || k.rawWrite(T), Te = k.getTextPos(), k.writeComment(`//# sourceMappingURL=${ne}`)), ce) { + const Se = pe.toString(); + w5( + t, + S, + ce, + Se, + /*writeByteOrderMark*/ + !1, + Z + ); + } + } else + k.writeLine(); + const Fe = k.getText(), Ye = { sourceMapUrlPos: Te, diagnostics: fe.diagnostics }; + return w5(t, S, se, Fe, !!g.emitBOM, Z, Ye), k.clear(), !Ye.skippedDtsWrite; + } + function _e(se, ce) { + return (se.sourceMap || se.inlineSourceMap) && (ce.kind !== 308 || !Xo( + ce.fileName, + ".json" + /* Json */ + )); + } + function K(se) { + const ce = zl(se.sourceRoot || ""); + return ce && gl(ce); + } + function V(se, ce, fe) { + if (se.sourceRoot) return t.getCommonSourceDirectory(); + if (se.mapRoot) { + let he = zl(se.mapRoot); + return fe && (he = Hn(D5(fe.fileName, t, he))), kd(he) === 0 && (he = On(t.getCommonSourceDirectory(), he)), he; + } + return Hn(Hs(ce)); + } + function ae(se, ce, fe, he, q) { + if (se.inlineSourceMap) { + const je = ce.toString(); + return `data:application/json;base64,${lee(ml, je)}`; + } + const be = Zc(zl(E.checkDefined(he))); + if (se.mapRoot) { + let je = zl(se.mapRoot); + return q && (je = Hn(D5(q.fileName, t, je))), kd(je) === 0 ? (je = On(t.getCommonSourceDirectory(), je), encodeURI( + rx( + Hn(Hs(fe)), + // get the relative sourceMapDir path based on jsFilePath + On(je, be), + // this is where user expects to see sourceMap + t.getCurrentDirectory(), + t.getCanonicalFileName, + /*isAbsolutePathAnUrl*/ + !0 + ) + )) : encodeURI(On(je, be)); + } + return encodeURI(be); + } + } + function yie(e) { + return JSON.stringify(e); + } + function iU(e, t) { + return uJ(e, t); + } + var vie = { + hasGlobalName: Vs, + getReferencedExportContainer: Vs, + getReferencedImportDeclaration: Vs, + getReferencedDeclarationWithCollidingName: Vs, + isDeclarationWithCollidingName: Vs, + isValueAliasDeclaration: Vs, + isReferencedAliasDeclaration: Vs, + isTopLevelValueImportEqualsWithEntityName: Vs, + hasNodeCheckFlag: Vs, + isDeclarationVisible: Vs, + isLateBound: (e) => !1, + collectLinkedAliases: Vs, + markLinkedReferences: Vs, + isImplementationOfOverload: Vs, + requiresAddingImplicitUndefined: Vs, + isExpandoFunctionDeclaration: Vs, + getPropertiesOfContainerFunction: Vs, + createTypeOfDeclaration: Vs, + createReturnTypeOfSignatureDeclaration: Vs, + createTypeOfExpression: Vs, + createLiteralConstValue: Vs, + isSymbolAccessible: Vs, + isEntityNameVisible: Vs, + // Returns the constant value this property access resolves to: notImplemented, or 'undefined' for a non-constant + getConstantValue: Vs, + getEnumMemberValue: Vs, + getReferencedValueDeclaration: Vs, + getReferencedValueDeclarations: Vs, + getTypeReferenceSerializationKind: Vs, + isOptionalParameter: Vs, + isArgumentsLocalBinding: Vs, + getExternalModuleFileFromDeclaration: Vs, + isLiteralConstDeclaration: Vs, + getJsxFactoryEntity: Vs, + getJsxFragmentFactoryEntity: Vs, + isBindingCapturedByNode: Vs, + getDeclarationStatementsForSourceFile: Vs, + isImportRequiredByAugmentation: Vs, + isDefinitelyReferenceToGlobalSymbolObject: Vs, + createLateBoundIndexSignatures: Vs, + symbolToDeclarations: Vs + }, bie = /* @__PURE__ */ Uu(() => Ky({})), i2 = /* @__PURE__ */ Uu(() => Ky({ removeComments: !0 })), Sie = /* @__PURE__ */ Uu(() => Ky({ removeComments: !0, neverAsciiEscape: !0 })), sU = /* @__PURE__ */ Uu(() => Ky({ removeComments: !0, omitTrailingSemicolon: !0 })); + function Ky(e = {}, t = {}) { + var { + hasGlobalName: n, + onEmitNode: i = vA, + isEmitNotificationEnabled: s, + substituteNode: o = nw, + onBeforeEmitNode: c, + onAfterEmitNode: _, + onBeforeEmitNodeArray: u, + onAfterEmitNodeArray: g, + onBeforeEmitToken: m, + onAfterEmitToken: h + } = t, S = !!e.extendedDiagnostics, T = !!e.omitBraceSourceMapPositions, k = v0(e), D = Hu(e), P = /* @__PURE__ */ new Map(), A, O, F, R, B, U, $, W, _e, K, V, ae, se, ce, fe, he = e.preserveSourceNewlines, q, be, je, me = yE, Z, pe = !0, Te, Fe, Ye = -1, ne, Se = -1, ie = -1, Ne = -1, Ee = -1, Ce, Ve, St = !1, Bt = !!e.removeComments, tr, Nr, { enter: st, exit: Wt } = Ege(S, "commentTime", "beforeComment", "afterComment"), Jr = N.parenthesizer, ui = { + select: (C) => C === 0 ? Jr.parenthesizeLeadingTypeArgument : void 0 + }, Ji = il(); + return Ds(), { + // public API + printNode: Dt, + printList: Mn, + printFile: fi, + printBundle: ai, + // internal API + writeNode: pn, + writeList: _i, + writeFile: ft, + writeBundle: Je + }; + function Dt(C, le, _t) { + switch (C) { + case 0: + E.assert(Di(le), "Expected a SourceFile node."); + break; + case 2: + E.assert(Me(le), "Expected an Identifier node."); + break; + case 1: + E.assert(ut(le), "Expected an Expression node."); + break; + } + switch (le.kind) { + case 308: + return fi(le); + case 309: + return ai(le); + } + return pn(C, le, _t, er()), qr(); + } + function Mn(C, le, _t) { + return _i(C, le, _t, er()), qr(); + } + function ai(C) { + return Je( + C, + er(), + /*sourceMapGenerator*/ + void 0 + ), qr(); + } + function fi(C) { + return ft( + C, + er(), + /*sourceMapGenerator*/ + void 0 + ), qr(); + } + function pn(C, le, _t, ur) { + const ti = be; + ki( + ur, + /*_sourceMapGenerator*/ + void 0 + ), Jn(C, le, _t), Ds(), be = ti; + } + function _i(C, le, _t, ur) { + const ti = be; + ki( + ur, + /*_sourceMapGenerator*/ + void 0 + ), _t && Un(_t), Pn( + /*parentNode*/ + void 0, + le, + C + ), Ds(), be = ti; + } + function Je(C, le, _t) { + Z = !1; + const ur = be; + ki(le, _t), J0(C), dd(C), Lt(C), Hw(C); + for (const ti of C.sourceFiles) + Jn(0, ti, ti); + Ds(), be = ur; + } + function ft(C, le, _t) { + Z = !0; + const ur = be; + ki(le, _t), J0(C), dd(C), Jn(0, C, C), Ds(), be = ur; + } + function er() { + return je || (je = nN(k)); + } + function qr() { + const C = je.getText(); + return je.clear(), C; + } + function Jn(C, le, _t) { + _t && Un(_t), Y( + C, + le, + /*parenthesizerRule*/ + void 0 + ); + } + function Un(C) { + A = C, Ce = void 0, Ve = void 0, C && C2(C); + } + function ki(C, le) { + C && e.omitTrailingSemicolon && (C = $B(C)), be = C, Te = le, pe = !be || !Te; + } + function Ds() { + O = [], F = [], R = [], B = /* @__PURE__ */ new Set(), U = [], $ = /* @__PURE__ */ new Map(), W = [], _e = 0, K = [], V = 0, ae = [], se = void 0, ce = [], fe = void 0, A = void 0, Ce = void 0, Ve = void 0, ki( + /*output*/ + void 0, + /*_sourceMapGenerator*/ + void 0 + ); + } + function Ks() { + return Ce || (Ce = kg(E.checkDefined(A))); + } + function yr(C, le) { + C !== void 0 && Y(4, C, le); + } + function bs(C) { + C !== void 0 && Y( + 2, + C, + /*parenthesizerRule*/ + void 0 + ); + } + function Xe(C, le) { + C !== void 0 && Y(1, C, le); + } + function Et(C) { + Y(ca(C) ? 6 : 4, C); + } + function re(C) { + he && sd(C) & 4 && (he = !1); + } + function it(C) { + he = C; + } + function Y(C, le, _t) { + Nr = _t, Ke(0, C, le)(C, le), Nr = void 0; + } + function Ae(C) { + return !Bt && !Di(C); + } + function $e(C) { + return !pe && !Di(C) && !c5(C); + } + function Ke(C, le, _t) { + switch (C) { + case 0: + if (i !== vA && (!s || s(_t))) + return Le; + // falls through + case 1: + if (o !== nw && (tr = o(le, _t) || _t) !== _t) + return Nr && (tr = Nr(tr)), qe; + // falls through + case 2: + if (Ae(_t)) + return x2; + // falls through + case 3: + if ($e(_t)) + return gT; + // falls through + case 4: + return mt; + default: + return E.assertNever(C); + } + } + function Tt(C, le, _t) { + return Ke(C + 1, le, _t); + } + function Le(C, le) { + const _t = Tt(0, C, le); + i(C, le, _t); + } + function mt(C, le) { + if (c?.(le), he) { + const _t = he; + re(le), pt(C, le), it(_t); + } else + pt(C, le); + _?.(le), Nr = void 0; + } + function pt(C, le, _t = !0) { + if (_t) { + const ur = az(le); + if (ur) + return ue(C, le, ur); + } + if (C === 0) return Mv(Us(le, Di)); + if (C === 2) return Q(Us(le, Me)); + if (C === 6) return yt( + Us(le, ca), + /*jsxAttributeEscape*/ + !0 + ); + if (C === 3) return Ct(Us(le, Lo)); + if (C === 7) return Am(Us(le, PS)); + if (C === 5) + return E.assertNode(le, hz), Jd( + /*isEmbeddedStatement*/ + !0 + ); + if (C === 4) { + switch (le.kind) { + // Pseudo-literals + case 16: + case 17: + case 18: + return yt( + le, + /*jsxAttributeEscape*/ + !1 + ); + // Identifiers + case 80: + return Q(le); + // PrivateIdentifiers + case 81: + return dt(le); + // Parse tree nodes + // Names + case 167: + return Mt(le); + case 168: + return at(le); + // Signature elements + case 169: + return wt(le); + case 170: + return Zr(le); + case 171: + return Rr(le); + // Type members + case 172: + return Pr(le); + case 173: + return rt(le); + case 174: + return vt(le); + case 175: + return Nt(le); + case 176: + return Jt(le); + case 177: + return _r(le); + case 178: + case 179: + return nr(le); + case 180: + return kt(le); + case 181: + return cr(le); + case 182: + return fr(le); + // Types + case 183: + return oi(le); + case 184: + return Fs(le); + case 185: + return Rs(le); + case 186: + return Gc(le); + case 187: + return Co(le); + case 188: + return ta(le); + case 189: + return Ec(le); + case 190: + return cs(le); + case 191: + return Fa(le); + // SyntaxKind.RestType is handled below + case 193: + return va(le); + case 194: + return zt(le); + case 195: + return Za(le); + case 196: + return yc(le); + case 197: + return Fc(le); + case 234: + return Ol(le); + case 198: + return Hl(); + case 199: + return _o(le); + case 200: + return ge(le); + case 201: + return H(le); + case 202: + return tt(le); + case 203: + return Ws(le); + case 204: + return Ft(le); + case 205: + return vr(le); + case 206: + return Kt(le); + // Binding patterns + case 207: + return Hr(le); + case 208: + return Vn(le); + case 209: + return ln(le); + // Misc + case 240: + return Gg(le); + case 241: + return Xt(); + // Statements + case 242: + return $g(le); + case 244: + return Sl(le); + case 243: + return Jd( + /*isEmbeddedStatement*/ + !1 + ); + case 245: + return Wf(le); + case 246: + return Nm(le); + case 247: + return et(le); + case 248: + return Ut(le); + case 249: + return Gt(le); + case 250: + return Sr(le); + case 251: + return zr(le); + case 252: + return ni(le); + case 253: + return wi(le); + case 254: + return As(le); + case 255: + return Zi(le); + case 256: + return ys(le); + case 257: + return zo(le); + case 258: + return na(le); + case 259: + return Ll(le); + case 260: + return df(le); + // Declarations + case 261: + return Uf(le); + case 262: + return yp(le); + case 263: + return jh(le); + case 264: + return pr(le); + case 265: + return dn(le); + case 266: + return Ir(le); + case 267: + return Vr(le); + case 268: + return hi(le); + case 269: + return rs(le); + case 270: + return Zn(le); + case 271: + return og(le); + case 272: + return ns(le); + case 273: + return Wo(le); + case 274: + return A_(le); + case 275: + return Xp(le); + case 281: + return pE(le); + case 276: + return $l(le); + case 277: + return Qp(le); + case 278: + return mf(le); + case 279: + return wv(le); + case 280: + return Vw(le); + case 282: + return dE(le); + case 301: + return ag(le); + case 302: + return Pv(le); + case 283: + return; + // Module references + case 284: + return YS(le); + // JSX (non-expression) + case 12: + return KS(le); + case 287: + case 290: + return qw(le); + case 288: + case 291: + return wk(le); + case 292: + return mE(le); + case 293: + return Av(le); + case 294: + return eT(le); + case 295: + return Nk(le); + case 296: + return Ak(le); + // Clauses + case 297: + return o1(le); + case 298: + return j0(le); + case 299: + return Jh(le); + case 300: + return zh(le); + // Property assignments + case 304: + return c1(le); + case 305: + return Iv(le); + case 306: + return tT(le); + // Enum + case 307: + return Fv(le); + // Top-level nodes + case 308: + return Mv(le); + case 309: + return E.fail("Bundles should be printed using printBundle"); + // JSDoc nodes (only used in codefixes currently) + case 310: + return Lv(le); + case 311: + return Uh(le); + case 313: + return bn("*"); + case 314: + return bn("?"); + case 315: + return so(le); + case 316: + return zi(le); + case 317: + return hs(le); + case 318: + return Zo(le); + case 192: + case 319: + return zf(le); + case 320: + return; + case 321: + return Aa(le); + case 323: + return Yu(le); + case 324: + return lg(le); + case 328: + case 333: + case 338: + return Ov(le); + case 329: + case 330: + return cg(le); + case 331: + case 332: + return; + // SyntaxKind.JSDocClassTag (see JSDocTag, above) + case 334: + case 335: + case 336: + case 337: + return; + case 339: + return I_(le); + case 340: + return vu(le); + // SyntaxKind.JSDocEnumTag (see below) + case 342: + case 349: + return f_(le); + case 341: + case 343: + case 344: + case 345: + case 350: + case 351: + return rT(le); + case 346: + return Ro(le); + case 347: + return yu(le); + case 348: + return gE(le); + case 352: + return Wh(le); + // SyntaxKind.JSDocPropertyTag (see JSDocParameterTag, above) + // Transformation nodes + case 354: + case 355: + return; + } + if (ut(le) && (C = 1, o !== nw)) { + const ur = o(C, le) || le; + ur !== le && (le = ur, Nr && (le = Nr(le))); + } + } + if (C === 1) + switch (le.kind) { + // Literals + case 9: + case 10: + return Pe(le); + case 11: + case 14: + case 15: + return yt( + le, + /*jsxAttributeEscape*/ + !1 + ); + // Identifiers + case 80: + return Q(le); + case 81: + return dt(le); + // Expressions + case 210: + return kr(le); + case 211: + return Li(le); + case 212: + return Yi(le); + case 213: + return ra(le); + case 214: + return Eo(le); + case 215: + return $c(le); + case 216: + return Jc(le); + case 217: + return vo(le); + case 218: + return ic(le); + case 219: + return Bd(le); + case 220: + return au(le); + case 221: + return Ie(le); + case 222: + return Ot(le); + case 223: + return Mr(le); + case 224: + return Gi(le); + case 225: + return Da(le); + case 226: + return ma(le); + case 227: + return Ji(le); + case 228: + return Po(le); + case 229: + return sc(le); + case 230: + return vc(le); + case 231: + return Df(le); + case 232: + return Gl(le); + case 233: + return; + case 235: + return pf(le); + case 236: + return Qu(le); + case 234: + return Ol(le); + case 239: + return hp(le); + case 237: + return ig(le); + case 238: + return E.fail("SyntheticExpression should never be printed."); + case 283: + return; + // JSX + case 285: + return R0(le); + case 286: + return ZS(le); + case 289: + return Dk(le); + // Synthesized list + case 353: + return E.fail("SyntaxList should not be printed"); + // Transformation nodes + case 354: + return; + case 356: + return ze(le); + case 357: + return nT(le); + case 358: + return E.fail("SyntheticReferenceExpression should not be printed"); + } + if (k_(le.kind)) return oT(le, fs); + if (Jj(le.kind)) return oT(le, bn); + E.fail(`Unhandled SyntaxKind: ${E.formatSyntaxKind(le.kind)}.`); + } + function Ct(C) { + yr(C.name), fn(), fs("in"), fn(), yr(C.constraint); + } + function qe(C, le) { + const _t = Tt(1, C, le); + E.assertIsDefined(tr), le = tr, tr = void 0, _t(C, le); + } + function Lt(C) { + let le = !1; + const _t = C.kind === 309 ? C : void 0; + if (_t && D === 0) + return; + const ur = _t ? _t.sourceFiles.length : 1; + for (let ti = 0; ti < ur; ti++) { + const gi = _t ? _t.sourceFiles[ti] : C, Ki = Di(gi) ? gi : A, mi = e.noEmitHelpers || !!Ki && cre(Ki), ba = Di(gi) && !Z, Wc = rn(gi); + if (Wc) + for (const bu of Wc) { + if (bu.scoped) { + if (_t) + continue; + } else { + if (mi) continue; + if (ba) { + if (P.get(bu.name)) + continue; + P.set(bu.name, !0); + } + } + typeof bu.text == "string" ? md(bu.text) : md(bu.text(SE)), le = !0; + } + } + return le; + } + function rn(C) { + const le = sz(C); + return le && X_(le, Dte); + } + function Pe(C) { + yt( + C, + /*jsxAttributeEscape*/ + !1 + ); + } + function yt(C, le) { + const _t = m1( + C, + /*sourceFile*/ + void 0, + e.neverAsciiEscape, + le + ); + (e.sourceMap || e.inlineSourceMap) && (C.kind === 11 || ky(C.kind)) ? qh(_t) : S2(_t); + } + function ue(C, le, _t) { + switch (_t.kind) { + case 1: + M(C, le, _t); + break; + case 0: + ye(C, le, _t); + break; + } + } + function M(C, le, _t) { + Ik(`\${${_t.order}:`), pt( + C, + le, + /*allowSnippets*/ + !1 + ), Ik("}"); + } + function ye(C, le, _t) { + E.assert(le.kind === 243, `A tab stop cannot be attached to a node of kind ${E.formatSyntaxKind(le.kind)}.`), E.assert(C !== 5, "A tab stop cannot be attached to an embedded statement."), Ik(`$${_t.order}`); + } + function Q(C) { + (C.symbol ? Gw : me)(V0( + C, + /*includeTrivia*/ + !1 + ), C.symbol), Pn( + C, + SS(C), + 53776 + /* TypeParameters */ + ); + } + function dt(C) { + me(V0( + C, + /*includeTrivia*/ + !1 + )); + } + function Mt(C) { + ke(C.left), bn("."), yr(C.right); + } + function ke(C) { + C.kind === 80 ? Xe(C) : yr(C); + } + function at(C) { + bn("["), Xe(C.expression, Jr.parenthesizeExpressionOfComputedPropertyName), bn("]"); + } + function wt(C) { + Wd(C, C.modifiers), yr(C.name), C.constraint && (fn(), fs("extends"), fn(), yr(C.constraint)), C.default && (fn(), U_("="), fn(), yr(C.default)); + } + function Zr(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !0 + ), yr(C.dotDotDotToken), l1(C.name, aT), yr(C.questionToken), C.parent && C.parent.kind === 318 && !C.name ? yr(C.type) : Zp(C.type), Rv(C.initializer, C.type ? C.type.end : C.questionToken ? C.questionToken.end : C.name ? C.name.end : C.modifiers ? C.modifiers.end : C.pos, C, Jr.parenthesizeExpressionForDisallowedComma); + } + function Rr(C) { + bn("@"), Xe(C.expression, Jr.parenthesizeLeftSideOfAccess); + } + function Pr(C) { + Wd(C, C.modifiers), l1(C.name, vE), yr(C.questionToken), Zp(C.type), Ku(); + } + function rt(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !0 + ), yr(C.name), yr(C.questionToken), yr(C.exclamationToken), Zp(C.type), Rv(C.initializer, C.type ? C.type.end : C.questionToken ? C.questionToken.end : C.name.end, C), Ku(); + } + function vt(C) { + Wd(C, C.modifiers), yr(C.name), yr(C.questionToken), __(C, $p, zd); + } + function Nt(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !0 + ), yr(C.asteriskToken), yr(C.name), yr(C.questionToken), __(C, $p, sg); + } + function Jt(C) { + fs("static"), gd(C), Be(C.body), Gh(C); + } + function _r(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !1 + ), fs("constructor"), __(C, $p, sg); + } + function nr(C) { + const le = Zu( + C, + C.modifiers, + /*allowDecorators*/ + !0 + ), _t = C.kind === 178 ? 139 : 153; + L(_t, le, fs, C), fn(), yr(C.name), __(C, $p, sg); + } + function kt(C) { + __(C, $p, zd); + } + function cr(C) { + fs("new"), fn(), __(C, $p, zd); + } + function fr(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !1 + ), b2(C, C.parameters), Zp(C.type), Ku(); + } + function vr(C) { + yr(C.type), yr(C.literal); + } + function Xt() { + Ku(); + } + function oi(C) { + C.assertsModifier && (yr(C.assertsModifier), fn()), yr(C.parameterName), C.type && (fn(), fs("is"), fn(), yr(C.type)); + } + function Fs(C) { + yr(C.typeName), vp(C, C.typeArguments); + } + function Rs(C) { + __(C, ds, pc); + } + function ds(C) { + Yg(C, C.typeParameters), Im(C, C.parameters), fn(), bn("=>"); + } + function pc(C) { + fn(), yr(C.type); + } + function Zo(C) { + fs("function"), jv(C, C.parameters), bn(":"), yr(C.type); + } + function so(C) { + bn("?"), yr(C.type); + } + function zi(C) { + bn("!"), yr(C.type); + } + function hs(C) { + yr(C.type), bn("="); + } + function Gc(C) { + Wd(C, C.modifiers), fs("new"), fn(), __(C, ds, pc); + } + function Co(C) { + fs("typeof"), fn(), yr(C.exprName), vp(C, C.typeArguments); + } + function ta(C) { + gd(C), lr(C.members, T2), bn("{"); + const le = Ea(C) & 1 ? 768 : 32897; + Pn( + C, + C.members, + le | 524288 + /* NoSpaceIfEmpty */ + ), bn("}"), Gh(C); + } + function Ec(C) { + yr(C.elementType, Jr.parenthesizeNonArrayTypeOfPostfixType), bn("["), bn("]"); + } + function zf(C) { + bn("..."), yr(C.type); + } + function cs(C) { + L(23, C.pos, bn, C); + const le = Ea(C) & 1 ? 528 : 657; + Pn(C, C.elements, le | 524288, Jr.parenthesizeElementTypeOfTupleType), L(24, C.elements.end, bn, C); + } + function Ws(C) { + yr(C.dotDotDotToken), yr(C.name), yr(C.questionToken), L(59, C.name.end, bn, C), fn(), yr(C.type); + } + function Fa(C) { + yr(C.type, Jr.parenthesizeTypeOfOptionalType), bn("?"); + } + function va(C) { + Pn(C, C.types, 516, Jr.parenthesizeConstituentTypeOfUnionType); + } + function zt(C) { + Pn(C, C.types, 520, Jr.parenthesizeConstituentTypeOfIntersectionType); + } + function Za(C) { + yr(C.checkType, Jr.parenthesizeCheckTypeOfConditionalType), fn(), fs("extends"), fn(), yr(C.extendsType, Jr.parenthesizeExtendsTypeOfConditionalType), fn(), bn("?"), fn(), yr(C.trueType), fn(), bn(":"), fn(), yr(C.falseType); + } + function yc(C) { + fs("infer"), fn(), yr(C.typeParameter); + } + function Fc(C) { + bn("("), yr(C.type), bn(")"); + } + function Hl() { + fs("this"); + } + function _o(C) { + f1(C.operator, fs), fn(); + const le = C.operator === 148 ? Jr.parenthesizeOperandOfReadonlyTypeOperator : Jr.parenthesizeOperandOfTypeOperator; + yr(C.type, le); + } + function ge(C) { + yr(C.objectType, Jr.parenthesizeNonArrayTypeOfPostfixType), bn("["), yr(C.indexType), bn("]"); + } + function H(C) { + const le = Ea(C); + bn("{"), le & 1 ? fn() : (Lu(), ug()), C.readonlyToken && (yr(C.readonlyToken), C.readonlyToken.kind !== 148 && fs("readonly"), fn()), bn("["), Y(3, C.typeParameter), C.nameType && (fn(), fs("as"), fn(), yr(C.nameType)), bn("]"), C.questionToken && (yr(C.questionToken), C.questionToken.kind !== 58 && bn("?")), bn(":"), fn(), yr(C.type), Ku(), le & 1 ? fn() : (Lu(), Ud()), Pn( + C, + C.members, + 2 + /* PreserveLines */ + ), bn("}"); + } + function tt(C) { + Xe(C.literal); + } + function Ft(C) { + yr(C.head), Pn( + C, + C.templateSpans, + 262144 + /* TemplateExpressionSpans */ + ); + } + function Kt(C) { + C.isTypeOf && (fs("typeof"), fn()), fs("import"), bn("("), yr(C.argument), C.attributes && (bn(","), fn(), Y(7, C.attributes)), bn(")"), C.qualifier && (bn("."), yr(C.qualifier)), vp(C, C.typeArguments); + } + function Hr(C) { + bn("{"), Pn( + C, + C.elements, + 525136 + /* ObjectBindingPatternElements */ + ), bn("}"); + } + function Vn(C) { + bn("["), Pn( + C, + C.elements, + 524880 + /* ArrayBindingPatternElements */ + ), bn("]"); + } + function ln(C) { + yr(C.dotDotDotToken), C.propertyName && (yr(C.propertyName), bn(":"), fn()), yr(C.name), Rv(C.initializer, C.name.end, C, Jr.parenthesizeExpressionForDisallowedComma); + } + function kr(C) { + const le = C.elements, _t = C.multiLine ? 65536 : 0; + xn(C, le, 8914 | _t, Jr.parenthesizeExpressionForDisallowedComma); + } + function Li(C) { + gd(C), lr(C.properties, T2); + const le = Ea(C) & 131072; + le && ug(); + const _t = C.multiLine ? 65536 : 0, ur = A && A.languageVersion >= 1 && !ap(A) ? 64 : 0; + Pn(C, C.properties, 526226 | ur | _t), le && Ud(), Gh(C); + } + function Yi(C) { + Xe(C.expression, Jr.parenthesizeLeftSideOfAccess); + const le = C.questionDotToken || Ad(N.createToken( + 25 + /* DotToken */ + ), C.expression.end, C.name.pos), _t = Fm(C, C.expression, le), ur = Fm(C, le, C.name); + bp( + _t, + /*writeSpaceIfNotIndenting*/ + !1 + ), le.kind !== 29 && no(C.expression) && !be.hasTrailingComment() && !be.hasTrailingWhitespace() && bn("."), C.questionDotToken ? yr(le) : L(le.kind, C.expression.end, bn, C), bp( + ur, + /*writeSpaceIfNotIndenting*/ + !1 + ), yr(C.name), F_(_t, ur); + } + function no(C) { + if (C = id(C), E_(C)) { + const le = m1( + C, + /*sourceFile*/ + void 0, + /*neverAsciiEscape*/ + !0, + /*jsxAttributeEscape*/ + !1 + ); + return !(C.numericLiteralFlags & 448) && !le.includes(qs( + 25 + /* DotToken */ + )) && !le.includes("E") && !le.includes("e"); + } else if (To(C)) { + const le = yte(C); + return typeof le == "number" && isFinite(le) && le >= 0 && Math.floor(le) === le; + } + } + function ra(C) { + Xe(C.expression, Jr.parenthesizeLeftSideOfAccess), yr(C.questionDotToken), L(23, C.expression.end, bn, C), Xe(C.argumentExpression), L(24, C.argumentExpression.end, bn, C); + } + function Eo(C) { + const le = sd(C) & 16; + le && (bn("("), qh("0"), bn(","), fn()), Xe(C.expression, Jr.parenthesizeLeftSideOfAccess), le && bn(")"), yr(C.questionDotToken), vp(C, C.typeArguments), xn(C, C.arguments, 2576, Jr.parenthesizeExpressionForDisallowedComma); + } + function $c(C) { + L(105, C.pos, fs, C), fn(), Xe(C.expression, Jr.parenthesizeExpressionOfNew), vp(C, C.typeArguments), xn(C, C.arguments, 18960, Jr.parenthesizeExpressionForDisallowedComma); + } + function Jc(C) { + const le = sd(C) & 16; + le && (bn("("), qh("0"), bn(","), fn()), Xe(C.tag, Jr.parenthesizeLeftSideOfAccess), le && bn(")"), vp(C, C.typeArguments), fn(), Xe(C.template); + } + function vo(C) { + bn("<"), yr(C.type), bn(">"), Xe(C.expression, Jr.parenthesizeOperandOfPrefixUnary); + } + function ic(C) { + const le = L(21, C.pos, bn, C), _t = p1(C.expression, C); + Xe( + C.expression, + /*parenthesizerRule*/ + void 0 + ), Ok(C.expression, C), F_(_t), L(22, C.expression ? C.expression.end : le, bn, C); + } + function Bd(C) { + Kg(C.name), M0(C); + } + function au(C) { + Wd(C, C.modifiers), __(C, Ef, P_); + } + function Ef(C) { + Yg(C, C.typeParameters), Im(C, C.parameters), Zp(C.type), fn(), yr(C.equalsGreaterThanToken); + } + function P_(C) { + Ns(C.body) ? Be(C.body) : (fn(), Xe(C.body, Jr.parenthesizeConciseBodyOfArrowFunction)); + } + function Ie(C) { + L(91, C.pos, fs, C), fn(), Xe(C.expression, Jr.parenthesizeOperandOfPrefixUnary); + } + function Ot(C) { + L(114, C.pos, fs, C), fn(), Xe(C.expression, Jr.parenthesizeOperandOfPrefixUnary); + } + function Mr(C) { + L(116, C.pos, fs, C), fn(), Xe(C.expression, Jr.parenthesizeOperandOfPrefixUnary); + } + function Gi(C) { + L(135, C.pos, fs, C), fn(), Xe(C.expression, Jr.parenthesizeOperandOfPrefixUnary); + } + function Da(C) { + f1(C.operator, U_), wa(C) && fn(), Xe(C.operand, Jr.parenthesizeOperandOfPrefixUnary); + } + function wa(C) { + const le = C.operand; + return le.kind === 225 && (C.operator === 40 && (le.operator === 40 || le.operator === 46) || C.operator === 41 && (le.operator === 41 || le.operator === 47)); + } + function ma(C) { + Xe(C.operand, Jr.parenthesizeOperandOfPostfixUnary), f1(C.operator, U_); + } + function il() { + return WF( + C, + le, + _t, + ur, + ti, + /*foldState*/ + void 0 + ); + function C(Ki, mi) { + if (mi) { + mi.stackIndex++, mi.preserveSourceNewlinesStack[mi.stackIndex] = he, mi.containerPosStack[mi.stackIndex] = ie, mi.containerEndStack[mi.stackIndex] = Ne, mi.declarationListContainerEndStack[mi.stackIndex] = Ee; + const ba = mi.shouldEmitCommentsStack[mi.stackIndex] = Ae(Ki), Wc = mi.shouldEmitSourceMapsStack[mi.stackIndex] = $e(Ki); + c?.(Ki), ba && Vd(Ki), Wc && Oa(Ki), re(Ki); + } else + mi = { + stackIndex: 0, + preserveSourceNewlinesStack: [void 0], + containerPosStack: [-1], + containerEndStack: [-1], + declarationListContainerEndStack: [-1], + shouldEmitCommentsStack: [!1], + shouldEmitSourceMapsStack: [!1] + }; + return mi; + } + function le(Ki, mi, ba) { + return gi(Ki, ba, "left"); + } + function _t(Ki, mi, ba) { + const Wc = Ki.kind !== 28, bu = Fm(ba, ba.left, Ki), p_ = Fm(ba, Ki, ba.right); + bp(bu, Wc), th(Ki.pos), oT(Ki, Ki.kind === 103 ? fs : U_), hd( + Ki.end, + /*prefixSpace*/ + !0 + ), bp( + p_, + /*writeSpaceIfNotIndenting*/ + !0 + ); + } + function ur(Ki, mi, ba) { + return gi(Ki, ba, "right"); + } + function ti(Ki, mi) { + const ba = Fm(Ki, Ki.left, Ki.operatorToken), Wc = Fm(Ki, Ki.operatorToken, Ki.right); + if (F_(ba, Wc), mi.stackIndex > 0) { + const bu = mi.preserveSourceNewlinesStack[mi.stackIndex], p_ = mi.containerPosStack[mi.stackIndex], Xv = mi.containerEndStack[mi.stackIndex], d_ = mi.declarationListContainerEndStack[mi.stackIndex], y1 = mi.shouldEmitCommentsStack[mi.stackIndex], qk = mi.shouldEmitSourceMapsStack[mi.stackIndex]; + it(bu), qk && yn(Ki), y1 && h1(Ki, p_, Xv, d_), _?.(Ki), mi.stackIndex--; + } + } + function gi(Ki, mi, ba) { + const Wc = ba === "left" ? Jr.getParenthesizeLeftSideOfBinaryForOperator(mi.operatorToken.kind) : Jr.getParenthesizeRightSideOfBinaryForOperator(mi.operatorToken.kind); + let bu = Ke(0, 1, Ki); + if (bu === qe && (E.assertIsDefined(tr), Ki = Wc(Us(tr, ut)), bu = Tt(1, 1, Ki), tr = void 0), (bu === x2 || bu === gT || bu === mt) && _n(Ki)) + return Ki; + Nr = Wc, bu(1, Ki); + } + } + function Po(C) { + const le = Fm(C, C.condition, C.questionToken), _t = Fm(C, C.questionToken, C.whenTrue), ur = Fm(C, C.whenTrue, C.colonToken), ti = Fm(C, C.colonToken, C.whenFalse); + Xe(C.condition, Jr.parenthesizeConditionOfConditionalExpression), bp( + le, + /*writeSpaceIfNotIndenting*/ + !0 + ), yr(C.questionToken), bp( + _t, + /*writeSpaceIfNotIndenting*/ + !0 + ), Xe(C.whenTrue, Jr.parenthesizeBranchOfConditionalExpression), F_(le, _t), bp( + ur, + /*writeSpaceIfNotIndenting*/ + !0 + ), yr(C.colonToken), bp( + ti, + /*writeSpaceIfNotIndenting*/ + !0 + ), Xe(C.whenFalse, Jr.parenthesizeBranchOfConditionalExpression), F_(ur, ti); + } + function sc(C) { + yr(C.head), Pn( + C, + C.templateSpans, + 262144 + /* TemplateExpressionSpans */ + ); + } + function vc(C) { + L(127, C.pos, fs, C), yr(C.asteriskToken), z0(C.expression && Tr(C.expression), $i); + } + function Df(C) { + L(26, C.pos, bn, C), Xe(C.expression, Jr.parenthesizeExpressionForDisallowedComma); + } + function Gl(C) { + Kg(C.name), Or(C); + } + function Ol(C) { + Xe(C.expression, Jr.parenthesizeLeftSideOfAccess), vp(C, C.typeArguments); + } + function pf(C) { + Xe( + C.expression, + /*parenthesizerRule*/ + void 0 + ), C.type && (fn(), fs("as"), fn(), yr(C.type)); + } + function Qu(C) { + Xe(C.expression, Jr.parenthesizeLeftSideOfAccess), U_("!"); + } + function hp(C) { + Xe( + C.expression, + /*parenthesizerRule*/ + void 0 + ), C.type && (fn(), fs("satisfies"), fn(), yr(C.type)); + } + function ig(C) { + _1(C.keywordToken, C.pos, bn), bn("."), yr(C.name); + } + function Gg(C) { + Xe(C.expression), yr(C.literal); + } + function $g(C) { + N_( + C, + /*forceSingleLine*/ + !C.multiLine && d1(C) + ); + } + function N_(C, le) { + L( + 19, + C.pos, + bn, + /*contextNode*/ + C + ); + const _t = le || Ea(C) & 1 ? 768 : 129; + Pn(C, C.statements, _t), L( + 20, + C.statements.end, + bn, + /*contextNode*/ + C, + /*indentLeading*/ + !!(_t & 1) + ); + } + function Sl(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !1 + ), yr(C.declarationList), Ku(); + } + function Jd(C) { + C ? bn(";") : Ku(); + } + function Wf(C) { + Xe(C.expression, Jr.parenthesizeExpressionOfExpressionStatement), (!A || !ap(A) || lo(C.expression)) && Ku(); + } + function Nm(C) { + const le = L(101, C.pos, fs, C); + fn(), L(21, le, bn, C), Xe(C.expression), L(22, C.expression.end, bn, C), Vh(C, C.thenStatement), C.elseStatement && (qf(C, C.thenStatement, C.elseStatement), L(93, C.thenStatement.end, fs, C), C.elseStatement.kind === 246 ? (fn(), yr(C.elseStatement)) : Vh(C, C.elseStatement)); + } + function ee(C, le) { + const _t = L(117, le, fs, C); + fn(), L(21, _t, bn, C), Xe(C.expression), L(22, C.expression.end, bn, C); + } + function et(C) { + L(92, C.pos, fs, C), Vh(C, C.statement), Ns(C.statement) && !he ? fn() : qf(C, C.statement, C.expression), ee(C, C.statement.end), Ku(); + } + function Ut(C) { + ee(C, C.pos), Vh(C, C.statement); + } + function Gt(C) { + const le = L(99, C.pos, fs, C); + fn(); + let _t = L( + 21, + le, + bn, + /*contextNode*/ + C + ); + jn(C.initializer), _t = L(27, C.initializer ? C.initializer.end : _t, bn, C), z0(C.condition), _t = L(27, C.condition ? C.condition.end : _t, bn, C), z0(C.incrementor), L(22, C.incrementor ? C.incrementor.end : _t, bn, C), Vh(C, C.statement); + } + function Sr(C) { + const le = L(99, C.pos, fs, C); + fn(), L(21, le, bn, C), jn(C.initializer), fn(), L(103, C.initializer.end, fs, C), fn(), Xe(C.expression), L(22, C.expression.end, bn, C), Vh(C, C.statement); + } + function zr(C) { + const le = L(99, C.pos, fs, C); + fn(), iT(C.awaitModifier), L(21, le, bn, C), jn(C.initializer), fn(), L(165, C.initializer.end, fs, C), fn(), Xe(C.expression), L(22, C.expression.end, bn, C), Vh(C, C.statement); + } + function jn(C) { + C !== void 0 && (C.kind === 262 ? yr(C) : Xe(C)); + } + function ni(C) { + L(88, C.pos, fs, C), Vf(C.label), Ku(); + } + function wi(C) { + L(83, C.pos, fs, C), Vf(C.label), Ku(); + } + function L(C, le, _t, ur, ti) { + const gi = vs(ur), Ki = gi && gi.kind === ur.kind, mi = le; + if (Ki && A && (le = oa(A.text, le)), Ki && ur.pos !== mi) { + const ba = ti && A && !lp(mi, le, A); + ba && ug(), th(mi), ba && Ud(); + } + if (!T && (C === 19 || C === 20) ? le = _1(C, le, _t, ur) : le = f1(C, _t, le), Ki && ur.end !== le) { + const ba = ur.kind === 295; + hd( + le, + /*prefixSpace*/ + !ba, + /*forceNoNewline*/ + ba + ); + } + return le; + } + function Oe(C) { + return C.kind === 2 || !!C.hasTrailingNewLine; + } + function xt(C) { + if (!A) return !1; + const le = Eg(A.text, C.pos); + if (le) { + const _t = vs(C); + if (_t && o_(_t.parent)) + return !0; + } + return ot(le, Oe) || ot(l6(C), Oe) ? !0 : Bte(C) ? C.pos !== C.expression.pos && ot(Sy(A.text, C.expression.pos), Oe) ? !0 : xt(C.expression) : !1; + } + function Tr(C) { + if (!Bt) + switch (C.kind) { + case 356: + if (xt(C)) { + const le = vs(C); + if (le && o_(le)) { + const _t = N.createParenthesizedExpression(C.expression); + return Cn(_t, C), ct(_t, le), _t; + } + return N.createParenthesizedExpression(C); + } + return N.updatePartiallyEmittedExpression( + C, + Tr(C.expression) + ); + case 212: + return N.updatePropertyAccessExpression( + C, + Tr(C.expression), + C.name + ); + case 213: + return N.updateElementAccessExpression( + C, + Tr(C.expression), + C.argumentExpression + ); + case 214: + return N.updateCallExpression( + C, + Tr(C.expression), + C.typeArguments, + C.arguments + ); + case 216: + return N.updateTaggedTemplateExpression( + C, + Tr(C.tag), + C.typeArguments, + C.template + ); + case 226: + return N.updatePostfixUnaryExpression( + C, + Tr(C.operand) + ); + case 227: + return N.updateBinaryExpression( + C, + Tr(C.left), + C.operatorToken, + C.right + ); + case 228: + return N.updateConditionalExpression( + C, + Tr(C.condition), + C.questionToken, + C.whenTrue, + C.colonToken, + C.whenFalse + ); + case 235: + return N.updateAsExpression( + C, + Tr(C.expression), + C.type + ); + case 239: + return N.updateSatisfiesExpression( + C, + Tr(C.expression), + C.type + ); + case 236: + return N.updateNonNullExpression( + C, + Tr(C.expression) + ); + } + return C; + } + function $i(C) { + return Tr(Jr.parenthesizeExpressionForDisallowedComma(C)); + } + function As(C) { + L( + 107, + C.pos, + fs, + /*contextNode*/ + C + ), z0(C.expression && Tr(C.expression), Tr), Ku(); + } + function Zi(C) { + const le = L(118, C.pos, fs, C); + fn(), L(21, le, bn, C), Xe(C.expression), L(22, C.expression.end, bn, C), Vh(C, C.statement); + } + function ys(C) { + const le = L(109, C.pos, fs, C); + fn(), L(21, le, bn, C), Xe(C.expression), L(22, C.expression.end, bn, C), fn(), yr(C.caseBlock); + } + function zo(C) { + yr(C.label), L(59, C.label.end, bn, C), fn(), yr(C.statement); + } + function na(C) { + L(111, C.pos, fs, C), z0(Tr(C.expression), Tr), Ku(); + } + function Ll(C) { + L(113, C.pos, fs, C), fn(), yr(C.tryBlock), C.catchClause && (qf(C, C.tryBlock, C.catchClause), yr(C.catchClause)), C.finallyBlock && (qf(C, C.catchClause || C.tryBlock, C.finallyBlock), L(98, (C.catchClause || C.tryBlock).end, fs, C), fn(), yr(C.finallyBlock)); + } + function df(C) { + _1(89, C.pos, fs), Ku(); + } + function Uf(C) { + var le, _t, ur; + yr(C.name), yr(C.exclamationToken), Zp(C.type), Rv(C.initializer, ((le = C.type) == null ? void 0 : le.end) ?? ((ur = (_t = C.name.emitNode) == null ? void 0 : _t.typeNode) == null ? void 0 : ur.end) ?? C.name.end, C, Jr.parenthesizeExpressionForDisallowedComma); + } + function yp(C) { + if (E3(C)) + fs("await"), fn(), fs("using"); + else { + const le = X7(C) ? "let" : BC(C) ? "const" : D3(C) ? "using" : "var"; + fs(le); + } + fn(), Pn( + C, + C.declarations, + 528 + /* VariableDeclarationList */ + ); + } + function jh(C) { + M0(C); + } + function M0(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !1 + ), fs("function"), yr(C.asteriskToken), fn(), bs(C.name), __(C, $p, sg); + } + function __(C, le, _t) { + const ur = Ea(C) & 131072; + ur && ug(), gd(C), lr(C.parameters, Ml), le(C), _t(C), Gh(C), ur && Ud(); + } + function sg(C) { + const le = C.body; + le ? Be(le) : Ku(); + } + function zd(C) { + Ku(); + } + function $p(C) { + Yg(C, C.typeParameters), jv(C, C.parameters), Zp(C.type); + } + function s1(C) { + if (Ea(C) & 1) + return !0; + if (C.multiLine || !lo(C) && A && !hS(C, A) || U0( + C, + Yc(C.statements), + 2 + /* PreserveLines */ + ) || Fk(C, Do(C.statements), 2, C.statements)) + return !1; + let le; + for (const _t of C.statements) { + if (Jv( + le, + _t, + 2 + /* PreserveLines */ + ) > 0) + return !1; + le = _t; + } + return !0; + } + function Be(C) { + Ml(C), c?.(C), fn(), bn("{"), ug(); + const le = s1(C) ? nt : Rt; + k2(C, C.statements, le), Ud(), _1(20, C.statements.end, bn, C), _?.(C); + } + function nt(C) { + Rt( + C, + /*emitBlockFunctionBodyOnSingleLine*/ + !0 + ); + } + function Rt(C, le) { + const _t = Qg(C.statements), ur = be.getTextPos(); + Lt(C), _t === 0 && ur === be.getTextPos() && le ? (Ud(), Pn( + C, + C.statements, + 768 + /* SingleLineFunctionBodyStatements */ + ), ug()) : Pn( + C, + C.statements, + 1, + /*parenthesizerRule*/ + void 0, + _t + ); + } + function pr(C) { + Or(C); + } + function Or(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !0 + ), L(86, dm(C).pos, fs, C), C.name && (fn(), bs(C.name)); + const le = Ea(C) & 131072; + le && ug(), Yg(C, C.typeParameters), Pn( + C, + C.heritageClauses, + 0 + /* ClassHeritageClauses */ + ), fn(), bn("{"), gd(C), lr(C.members, T2), Pn( + C, + C.members, + 129 + /* ClassMembers */ + ), Gh(C), bn("}"), le && Ud(); + } + function dn(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !1 + ), fs("interface"), fn(), yr(C.name), Yg(C, C.typeParameters), Pn( + C, + C.heritageClauses, + 512 + /* HeritageClauses */ + ), fn(), bn("{"), gd(C), lr(C.members, T2), Pn( + C, + C.members, + 129 + /* InterfaceMembers */ + ), Gh(C), bn("}"); + } + function Ir(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !1 + ), fs("type"), fn(), yr(C.name), Yg(C, C.typeParameters), fn(), bn("="), fn(), yr(C.type), Ku(); + } + function Vr(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !1 + ), fs("enum"), fn(), yr(C.name), fn(), bn("{"), Pn( + C, + C.members, + 145 + /* EnumMembers */ + ), bn("}"); + } + function hi(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !1 + ), ~C.flags & 2048 && (fs(C.flags & 32 ? "namespace" : "module"), fn()), yr(C.name); + let le = C.body; + if (!le) return Ku(); + for (; le && jc(le); ) + bn("."), yr(le.name), le = le.body; + fn(), yr(le); + } + function rs(C) { + gd(C), lr(C.statements, Ml), N_( + C, + /*forceSingleLine*/ + d1(C) + ), Gh(C); + } + function Zn(C) { + L(19, C.pos, bn, C), Pn( + C, + C.clauses, + 129 + /* CaseBlockClauses */ + ), L( + 20, + C.clauses.end, + bn, + C, + /*indentLeading*/ + !0 + ); + } + function ns(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !1 + ), L(102, C.modifiers ? C.modifiers.end : C.pos, fs, C), fn(), C.isTypeOnly && (L(156, C.pos, fs, C), fn()), yr(C.name), fn(), L(64, C.name.end, bn, C), fn(), Pi(C.moduleReference), Ku(); + } + function Pi(C) { + C.kind === 80 ? Xe(C) : yr(C); + } + function Wo(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !1 + ), L(102, C.modifiers ? C.modifiers.end : C.pos, fs, C), fn(), C.importClause && (yr(C.importClause), fn(), L(161, C.importClause.end, fs, C), fn()), Xe(C.moduleSpecifier), C.attributes && Vf(C.attributes), Ku(); + } + function A_(C) { + C.phaseModifier !== void 0 && (L(C.phaseModifier, C.pos, fs, C), fn()), yr(C.name), C.name && C.namedBindings && (L(28, C.name.end, bn, C), fn()), yr(C.namedBindings); + } + function Xp(C) { + const le = L(42, C.pos, bn, C); + fn(), L(130, le, fs, C), fn(), yr(C.name); + } + function $l(C) { + Xg(C); + } + function Qp(C) { + Nv(C); + } + function mf(C) { + const le = L(95, C.pos, fs, C); + fn(), C.isExportEquals ? L(64, le, U_, C) : L(90, le, fs, C), fn(), Xe( + C.expression, + C.isExportEquals ? Jr.getParenthesizeRightSideOfBinaryForOperator( + 64 + /* EqualsToken */ + ) : Jr.parenthesizeExpressionOfExportDefault + ), Ku(); + } + function wv(C) { + Zu( + C, + C.modifiers, + /*allowDecorators*/ + !1 + ); + let le = L(95, C.pos, fs, C); + if (fn(), C.isTypeOnly && (le = L(156, le, fs, C), fn()), C.exportClause ? yr(C.exportClause) : le = L(42, le, bn, C), C.moduleSpecifier) { + fn(); + const _t = C.exportClause ? C.exportClause.end : le; + L(161, _t, fs, C), fn(), Xe(C.moduleSpecifier); + } + C.attributes && Vf(C.attributes), Ku(); + } + function Am(C) { + bn("{"), fn(), fs(C.token === 132 ? "assert" : "with"), bn(":"), fn(); + const le = C.elements; + Pn( + C, + le, + 526226 + /* ImportAttributes */ + ), fn(), bn("}"); + } + function ag(C) { + L(C.token, C.pos, fs, C), fn(); + const le = C.elements; + Pn( + C, + le, + 526226 + /* ImportAttributes */ + ); + } + function Pv(C) { + yr(C.name), bn(":"), fn(); + const le = C.value; + if ((Ea(le) & 1024) === 0) { + const _t = hm(le); + hd(_t.pos); + } + yr(le); + } + function og(C) { + let le = L(95, C.pos, fs, C); + fn(), le = L(130, le, fs, C), fn(), le = L(145, le, fs, C), fn(), yr(C.name), Ku(); + } + function pE(C) { + const le = L(42, C.pos, bn, C); + fn(), L(130, le, fs, C), fn(), yr(C.name); + } + function Vw(C) { + Xg(C); + } + function dE(C) { + Nv(C); + } + function Xg(C) { + bn("{"), Pn( + C, + C.elements, + 525136 + /* NamedImportsOrExportsElements */ + ), bn("}"); + } + function Nv(C) { + C.isTypeOnly && (fs("type"), fn()), C.propertyName && (yr(C.propertyName), fn(), L(130, C.propertyName.end, fs, C), fn()), yr(C.name); + } + function YS(C) { + fs("require"), bn("("), Xe(C.expression), bn(")"); + } + function R0(C) { + yr(C.openingElement), Pn( + C, + C.children, + 262144 + /* JsxElementOrFragmentChildren */ + ), yr(C.closingElement); + } + function ZS(C) { + bn("<"), h2(C.tagName), vp(C, C.typeArguments), fn(), yr(C.attributes), bn("/>"); + } + function Dk(C) { + yr(C.openingFragment), Pn( + C, + C.children, + 262144 + /* JsxElementOrFragmentChildren */ + ), yr(C.closingFragment); + } + function qw(C) { + if (bn("<"), Id(C)) { + const le = p1(C.tagName, C); + h2(C.tagName), vp(C, C.typeArguments), C.attributes.properties && C.attributes.properties.length > 0 && fn(), yr(C.attributes), Ok(C.attributes, C), F_(le); + } + bn(">"); + } + function KS(C) { + be.writeLiteral(C.text); + } + function wk(C) { + bn(""); + } + function Av(C) { + Pn( + C, + C.properties, + 262656 + /* JsxElementAttributes */ + ); + } + function mE(C) { + yr(C.name), ga("=", bn, C.initializer, Et); + } + function eT(C) { + bn("{..."), Xe(C.expression), bn("}"); + } + function Pk(C) { + let le = !1; + return QP(A?.text || "", C + 1, () => le = !0), le; + } + function g2(C) { + let le = !1; + return XP(A?.text || "", C + 1, () => le = !0), le; + } + function a1(C) { + return Pk(C) || g2(C); + } + function Nk(C) { + var le; + if (C.expression || !Bt && !lo(C) && a1(C.pos)) { + const _t = A && !lo(C) && js(A, C.pos).line !== js(A, C.end).line; + _t && be.increaseIndent(); + const ur = L(19, C.pos, bn, C); + yr(C.dotDotDotToken), Xe(C.expression), L(20, ((le = C.expression) == null ? void 0 : le.end) || ur, bn, C), _t && be.decreaseIndent(); + } + } + function Ak(C) { + bs(C.namespace), bn(":"), bs(C.name); + } + function h2(C) { + C.kind === 80 ? Xe(C) : yr(C); + } + function o1(C) { + L(84, C.pos, fs, C), fn(), Xe(C.expression, Jr.parenthesizeExpressionForDisallowedComma), Bh(C, C.statements, C.expression.end); + } + function j0(C) { + const le = L(90, C.pos, fs, C); + Bh(C, C.statements, le); + } + function Bh(C, le, _t) { + const ur = le.length === 1 && // treat synthesized nodes as located on the same line for emit purposes + (!A || lo(C) || lo(le[0]) || M5(C, le[0], A)); + let ti = 163969; + ur ? (_1(59, _t, bn, C), fn(), ti &= -130) : L(59, _t, bn, C), Pn(C, le, ti); + } + function Jh(C) { + fn(), f1(C.token, fs), fn(), Pn( + C, + C.types, + 528 + /* HeritageClauseTypes */ + ); + } + function zh(C) { + const le = L(85, C.pos, fs, C); + fn(), C.variableDeclaration && (L(21, le, bn, C), yr(C.variableDeclaration), L(22, C.variableDeclaration.end, bn, C), fn()), yr(C.block); + } + function c1(C) { + yr(C.name), bn(":"), fn(); + const le = C.initializer; + if ((Ea(le) & 1024) === 0) { + const _t = hm(le); + hd(_t.pos); + } + Xe(le, Jr.parenthesizeExpressionForDisallowedComma); + } + function Iv(C) { + yr(C.name), C.objectAssignmentInitializer && (fn(), bn("="), fn(), Xe(C.objectAssignmentInitializer, Jr.parenthesizeExpressionForDisallowedComma)); + } + function tT(C) { + C.expression && (L(26, C.pos, bn, C), Xe(C.expression, Jr.parenthesizeExpressionForDisallowedComma)); + } + function Fv(C) { + yr(C.name), Rv(C.initializer, C.name.end, C, Jr.parenthesizeExpressionForDisallowedComma); + } + function Aa(C) { + if (me("/**"), C.comment) { + const le = s3(C.comment); + if (le) { + const _t = le.split(/\r\n?|\n/); + for (const ur of _t) + Lu(), fn(), bn("*"), fn(), me(ur); + } + } + C.tags && (C.tags.length === 1 && C.tags[0].kind === 345 && !C.comment ? (fn(), yr(C.tags[0])) : Pn( + C, + C.tags, + 33 + /* JSDocComment */ + )), fn(), me("*/"); + } + function rT(C) { + Yp(C.tagName), Lv(C.typeExpression), pd(C.comment); + } + function gE(C) { + Yp(C.tagName), yr(C.name), pd(C.comment); + } + function Wh(C) { + Yp(C.tagName), fn(), C.importClause && (yr(C.importClause), fn(), L(161, C.importClause.end, fs, C), fn()), Xe(C.moduleSpecifier), C.attributes && Vf(C.attributes), pd(C.comment); + } + function Uh(C) { + fn(), bn("{"), yr(C.name), bn("}"); + } + function cg(C) { + Yp(C.tagName), fn(), bn("{"), yr(C.class), bn("}"), pd(C.comment); + } + function Ro(C) { + Yp(C.tagName), Lv(C.constraint), fn(), Pn( + C, + C.typeParameters, + 528 + /* CommaListElements */ + ), pd(C.comment); + } + function yu(C) { + Yp(C.tagName), C.typeExpression && (C.typeExpression.kind === 310 ? Lv(C.typeExpression) : (fn(), bn("{"), me("Object"), C.typeExpression.isArrayType && (bn("["), bn("]")), bn("}"))), C.fullName && (fn(), yr(C.fullName)), pd(C.comment), C.typeExpression && C.typeExpression.kind === 323 && Yu(C.typeExpression); + } + function I_(C) { + Yp(C.tagName), C.name && (fn(), yr(C.name)), pd(C.comment), lg(C.typeExpression); + } + function vu(C) { + pd(C.comment), lg(C.typeExpression); + } + function Ov(C) { + Yp(C.tagName), pd(C.comment); + } + function Yu(C) { + Pn( + C, + N.createNodeArray(C.jsDocPropertyTags), + 33 + /* JSDocComment */ + ); + } + function lg(C) { + C.typeParameters && Pn( + C, + N.createNodeArray(C.typeParameters), + 33 + /* JSDocComment */ + ), C.parameters && Pn( + C, + N.createNodeArray(C.parameters), + 33 + /* JSDocComment */ + ), C.type && (Lu(), fn(), bn("*"), fn(), yr(C.type)); + } + function f_(C) { + Yp(C.tagName), Lv(C.typeExpression), fn(), C.isBracketed && bn("["), yr(C.name), C.isBracketed && bn("]"), pd(C.comment); + } + function Yp(C) { + bn("@"), yr(C); + } + function pd(C) { + const le = s3(C); + le && (fn(), me(le)); + } + function Lv(C) { + C && (fn(), bn("{"), yr(C.type), bn("}")); + } + function Mv(C) { + Lu(); + const le = C.statements; + if (le.length === 0 || !cm(le[0]) || lo(le[0])) { + k2(C, le, y2); + return; + } + y2(C); + } + function Hw(C) { + B0(!!C.hasNoDefaultLib, C.syntheticFileReferences || [], C.syntheticTypeReferences || [], C.syntheticLibReferences || []); + } + function hE(C) { + C.isDeclarationFile && B0(C.hasNoDefaultLib, C.referencedFiles, C.typeReferenceDirectives, C.libReferenceDirectives); + } + function B0(C, le, _t, ur) { + if (C && (u1('/// '), Lu()), A && A.moduleName && (u1(`/// `), Lu()), A && A.amdDependencies) + for (const gi of A.amdDependencies) + gi.name ? u1(`/// `) : u1(`/// `), Lu(); + function ti(gi, Ki) { + for (const mi of Ki) { + const ba = mi.resolutionMode ? `resolution-mode="${mi.resolutionMode === 99 ? "import" : "require"}" ` : "", Wc = mi.preserve ? 'preserve="true" ' : ""; + u1(`/// `), Lu(); + } + } + ti("path", le), ti("types", _t), ti("lib", ur); + } + function y2(C) { + const le = C.statements; + gd(C), lr(C.statements, Ml), Lt(C); + const _t = oc(le, (ur) => !cm(ur)); + hE(C), Pn( + C, + le, + 1, + /*parenthesizerRule*/ + void 0, + _t === -1 ? le.length : _t + ), Gh(C); + } + function ze(C) { + const le = Ea(C); + !(le & 1024) && C.pos !== C.expression.pos && hd(C.expression.pos), Xe(C.expression), !(le & 2048) && C.end !== C.expression.end && th(C.expression.end); + } + function nT(C) { + xn( + C, + C.elements, + 528, + /*parenthesizerRule*/ + void 0 + ); + } + function Qg(C, le, _t) { + let ur = !!le; + for (let ti = 0; ti < C.length; ti++) { + const gi = C[ti]; + if (cm(gi)) + (_t ? !_t.has(gi.expression.text) : !0) && (ur && (ur = !1, Un(le)), Lu(), yr(gi), _t && _t.add(gi.expression.text)); + else + return ti; + } + return C.length; + } + function dd(C) { + if (Di(C)) + Qg(C.statements, C); + else { + const le = /* @__PURE__ */ new Set(); + for (const _t of C.sourceFiles) + Qg(_t.statements, _t, le); + Un(void 0); + } + } + function J0(C) { + if (Di(C)) { + const le = m7(C.text); + if (le) + return u1(le), Lu(), !0; + } else + for (const le of C.sourceFiles) + if (J0(le)) + return !0; + } + function l1(C, le) { + if (!C) return; + const _t = me; + me = le, yr(C), me = _t; + } + function Zu(C, le, _t) { + if (le?.length) { + if (Ni(le, Zs)) + return Wd(C, le); + if (Ni(le, ul)) + return _t ? v2(C, le) : C.pos; + u?.(le); + let ur, ti, gi = 0, Ki = 0, mi; + for (; gi < le.length; ) { + for (; Ki < le.length; ) { + if (mi = le[Ki], ti = ul(mi) ? "decorators" : "modifiers", ur === void 0) + ur = ti; + else if (ti !== ur) + break; + Ki++; + } + const ba = { pos: -1, end: -1 }; + gi === 0 && (ba.pos = le.pos), Ki === le.length - 1 && (ba.end = le.end), (ur === "modifiers" || _t) && sT( + yr, + C, + le, + ur === "modifiers" ? 2359808 : 2146305, + /*parenthesizerRule*/ + void 0, + gi, + Ki - gi, + /*hasTrailingComma*/ + !1, + ba + ), gi = Ki, ur = ti, Ki++; + } + if (g?.(le), mi && !Nd(mi.end)) + return mi.end; + } + return C.pos; + } + function Wd(C, le) { + Pn( + C, + le, + 2359808 + /* Modifiers */ + ); + const _t = Do(le); + return _t && !Nd(_t.end) ? _t.end : C.pos; + } + function Zp(C) { + C && (bn(":"), fn(), yr(C)); + } + function Rv(C, le, _t, ur) { + C && (fn(), L(64, le, U_, _t), fn(), Xe(C, ur)); + } + function ga(C, le, _t, ur) { + _t && (le(C), ur(_t)); + } + function Vf(C) { + C && (fn(), yr(C)); + } + function z0(C, le) { + C && (fn(), Xe(C, le)); + } + function iT(C) { + C && (yr(C), fn()); + } + function Vh(C, le) { + Ns(le) || Ea(C) & 1 || he && !U0( + C, + le, + 0 + /* None */ + ) ? (fn(), yr(le)) : (Lu(), ug(), hz(le) ? Y(5, le) : yr(le), Ud()); + } + function v2(C, le) { + Pn( + C, + le, + 2146305 + /* Decorators */ + ); + const _t = Do(le); + return _t && !Nd(_t.end) ? _t.end : C.pos; + } + function vp(C, le) { + Pn(C, le, 53776, ui); + } + function Yg(C, le) { + if (Es(C) && C.typeArguments) + return vp(C, C.typeArguments); + Pn(C, le, 53776 | (xo(C) ? 64 : 0)); + } + function jv(C, le) { + Pn( + C, + le, + 2576 + /* Parameters */ + ); + } + function W0(C, le) { + const _t = xg(le); + return _t && _t.pos === C.pos && xo(C) && !C.type && !ot(C.modifiers) && !ot(C.typeParameters) && !ot(_t.modifiers) && !_t.dotDotDotToken && !_t.questionToken && !_t.type && !_t.initializer && Me(_t.name); + } + function Im(C, le) { + W0(C, le) ? Pn( + C, + le, + 528 + /* Parenthesis */ + ) : jv(C, le); + } + function b2(C, le) { + Pn( + C, + le, + 8848 + /* IndexSignatureParameters */ + ); + } + function Bv(C) { + switch (C & 60) { + case 0: + break; + case 16: + bn(","); + break; + case 4: + fn(), bn("|"); + break; + case 32: + fn(), bn("*"), fn(); + break; + case 8: + fn(), bn("&"); + break; + } + } + function Pn(C, le, _t, ur, ti, gi) { + Xl( + yr, + C, + le, + _t | (C && Ea(C) & 2 ? 65536 : 0), + ur, + ti, + gi + ); + } + function xn(C, le, _t, ur, ti, gi) { + Xl(Xe, C, le, _t, ur, ti, gi); + } + function Xl(C, le, _t, ur, ti, gi = 0, Ki = _t ? _t.length - gi : 0) { + if (_t === void 0 && ur & 16384) + return; + const ba = _t === void 0 || gi >= _t.length || Ki === 0; + if (ba && ur & 32768) { + u?.(_t), g?.(_t); + return; + } + ur & 15360 && (bn(qje(ur)), ba && _t && hd( + _t.pos, + /*prefixSpace*/ + !0 + )), u?.(_t), ba ? ur & 1 && !(he && (!le || A && hS(le, A))) ? Lu() : ur & 256 && !(ur & 524288) && fn() : sT(C, le, _t, ur, ti, gi, Ki, _t.hasTrailingComma, _t), g?.(_t), ur & 15360 && (ba && _t && th(_t.end), bn(Hje(ur))); + } + function sT(C, le, _t, ur, ti, gi, Ki, mi, ba) { + const Wc = (ur & 262144) === 0; + let bu = Wc; + const p_ = U0(le, _t[gi], ur); + p_ ? (Lu(p_), bu = !1) : ur & 256 && fn(), ur & 128 && ug(); + const Xv = Qje(C, ti); + let d_, y1 = !1; + for (let G0 = 0; G0 < Ki; G0++) { + const yd = _t[gi + G0]; + if (ur & 32) + Lu(), Bv(ur); + else if (d_) { + ur & 60 && d_.end !== (le ? le.end : -1) && (Ea(d_) & 2048 || th(d_.end)), Bv(ur); + const $0 = Jv(d_, yd, ur); + if ($0 > 0) { + if ((ur & 131) === 0 && (ug(), y1 = !0), bu && ur & 60 && !Nd(yd.pos)) { + const E2 = hm(yd); + hd( + E2.pos, + /*prefixSpace*/ + !!(ur & 512), + /*forceNoNewline*/ + !0 + ); + } + Lu($0), bu = !1; + } else d_ && ur & 512 && fn(); + } + if (bu) { + const $0 = hm(yd); + hd($0.pos); + } else + bu = Wc; + q = yd.pos, Xv(yd, C, ti, G0), y1 && (Ud(), y1 = !1), d_ = yd; + } + const qk = d_ ? Ea(d_) : 0, Kp = Bt || !!(qk & 2048), Ho = mi && ur & 64 && ur & 16; + Ho && (d_ && !Kp ? L(28, d_.end, bn, d_) : bn(",")), d_ && (le ? le.end : -1) !== d_.end && ur & 60 && !Kp && th(Ho && ba?.end ? ba.end : d_.end), ur & 128 && Ud(); + const vT = Fk(le, _t[gi + Ki - 1], ur, ba); + vT ? Lu(vT) : ur & 2097408 && fn(); + } + function qh(C) { + be.writeLiteral(C); + } + function S2(C) { + be.writeStringLiteral(C); + } + function yE(C) { + be.write(C); + } + function Gw(C, le) { + be.writeSymbol(C, le); + } + function bn(C) { + be.writePunctuation(C); + } + function Ku() { + be.writeTrailingSemicolon(";"); + } + function fs(C) { + be.writeKeyword(C); + } + function U_(C) { + be.writeOperator(C); + } + function aT(C) { + be.writeParameter(C); + } + function u1(C) { + be.writeComment(C); + } + function fn() { + be.writeSpace(" "); + } + function vE(C) { + be.writeProperty(C); + } + function Ik(C) { + be.nonEscapingWrite ? be.nonEscapingWrite(C) : be.write(C); + } + function Lu(C = 1) { + for (let le = 0; le < C; le++) + be.writeLine(le > 0); + } + function ug() { + be.increaseIndent(); + } + function Ud() { + be.decreaseIndent(); + } + function _1(C, le, _t, ur) { + return pe ? f1(C, _t, le) : hT(ur, C, _t, le, f1); + } + function oT(C, le) { + m && m(C), le(qs(C.kind)), h && h(C); + } + function f1(C, le, _t) { + const ur = qs(C); + return le(ur), _t < 0 ? _t : _t + ur.length; + } + function qf(C, le, _t) { + if (Ea(C) & 1) + fn(); + else if (he) { + const ur = Fm(C, le, _t); + ur ? Lu(ur) : fn(); + } else + Lu(); + } + function md(C) { + const le = C.split(/\r\n?|\n/), _t = BZ(le); + for (const ur of le) { + const ti = _t ? ur.slice(_t) : ur; + ti.length && (Lu(), me(ti)); + } + } + function bp(C, le) { + C ? (ug(), Lu(C)) : le && fn(); + } + function F_(C, le) { + C && Ud(), le && Ud(); + } + function U0(C, le, _t) { + if (_t & 2 || he) { + if (_t & 65536) + return 1; + if (le === void 0) + return !C || A && hS(C, A) ? 0 : 1; + if (le.pos === q || le.kind === 12) + return 0; + if (A && C && !Nd(C.pos) && !lo(le) && (!le.parent || Vo(le.parent) === Vo(C))) + return he ? zv( + (ur) => dee( + le.pos, + C.pos, + A, + ur + ) + ) : M5(C, le, A) ? 0 : 1; + if (Hh(le, _t)) + return 1; + } + return _t & 1 ? 1 : 0; + } + function Jv(C, le, _t) { + if (_t & 2 || he) { + if (C === void 0 || le === void 0 || le.kind === 12) + return 0; + if (A && !lo(C) && !lo(le)) + return he && Mu(C, le) ? zv( + (ur) => fJ( + C, + le, + A, + ur + ) + ) : !he && Jk(C, le) ? uN(C, le, A) ? 0 : 1 : _t & 65536 ? 1 : 0; + if (Hh(C, _t) || Hh(le, _t)) + return 1; + } else if (k4(le)) + return 1; + return _t & 1 ? 1 : 0; + } + function Fk(C, le, _t, ur) { + if (_t & 2 || he) { + if (_t & 65536) + return 1; + if (le === void 0) + return !C || A && hS(C, A) ? 0 : 1; + if (A && C && !Nd(C.pos) && !lo(le) && (!le.parent || le.parent === C)) { + if (he) { + const ti = ur && !Nd(ur.end) ? ur.end : le.end; + return zv( + (gi) => mee( + ti, + C.end, + A, + gi + ) + ); + } + return _ee(C, le, A) ? 0 : 1; + } + if (Hh(le, _t)) + return 1; + } + return _t & 1 && !(_t & 131072) ? 1 : 0; + } + function zv(C) { + E.assert(!!he); + const le = C( + /*includeComments*/ + !0 + ); + return le === 0 ? C( + /*includeComments*/ + !1 + ) : le; + } + function p1(C, le) { + const _t = he && U0( + le, + C, + 0 + /* None */ + ); + return _t && bp( + _t, + /*writeSpaceIfNotIndenting*/ + !1 + ), !!_t; + } + function Ok(C, le) { + const _t = he && Fk( + le, + C, + 0, + /*childrenTextRange*/ + void 0 + ); + _t && Lu(_t); + } + function Hh(C, le) { + if (lo(C)) { + const _t = k4(C); + return _t === void 0 ? (le & 65536) !== 0 : _t; + } + return (le & 65536) !== 0; + } + function Fm(C, le, _t) { + return Ea(C) & 262144 ? 0 : (C = Wv(C), le = Wv(le), _t = Wv(_t), k4(_t) ? 1 : A && !lo(C) && !lo(le) && !lo(_t) ? he ? zv( + (ur) => fJ( + le, + _t, + A, + ur + ) + ) : uN(le, _t, A) ? 0 : 1 : 0); + } + function d1(C) { + return C.statements.length === 0 && (!A || uN(C, C, A)); + } + function Wv(C) { + for (; C.kind === 218 && lo(C); ) + C = C.expression; + return C; + } + function V0(C, le) { + if (Bo(C) || tS(C)) + return Uv(C); + if (ca(C) && C.textSourceNode) + return V0(C.textSourceNode, le); + const _t = A, ur = !!_t && !!C.parent && !lo(C); + if (wg(C)) { + if (!ur || xr(C) !== Vo(_t)) + return An(C); + } else if (Fd(C)) { + if (!ur || xr(C) !== Vo(_t)) + return T4(C); + } else if (E.assertNode(C, eS), !ur) + return C.text; + return Db(_t, C, le); + } + function m1(C, le = A, _t, ur) { + if (C.kind === 11 && C.textSourceNode) { + const gi = C.textSourceNode; + if (Me(gi) || Ai(gi) || E_(gi) || Fd(gi)) { + const Ki = E_(gi) ? gi.text : V0(gi); + return ur ? `"${GB(Ki)}"` : _t || Ea(C) & 16777216 ? `"${Ym(Ki)}"` : `"${S5(Ki)}"`; + } else + return m1(gi, xr(gi), _t, ur); + } + const ti = (_t ? 1 : 0) | (ur ? 2 : 0) | (e.terminateUnterminatedLiterals ? 4 : 0) | (e.target && e.target >= 8 ? 8 : 0); + return ZZ(C, le, ti); + } + function gd(C) { + W.push(_e), _e = 0, ce.push(fe), !(C && Ea(C) & 1048576) && (K.push(V), V = 0, U.push($), $ = void 0, ae.push(se)); + } + function Gh(C) { + _e = W.pop(), fe = ce.pop(), !(C && Ea(C) & 1048576) && (V = K.pop(), $ = U.pop(), se = ae.pop()); + } + function Zg(C) { + (!se || se === Do(ae)) && (se = /* @__PURE__ */ new Set()), se.add(C); + } + function g1(C) { + (!fe || fe === Do(ce)) && (fe = /* @__PURE__ */ new Set()), fe.add(C); + } + function Ml(C) { + if (C) + switch (C.kind) { + case 242: + lr(C.statements, Ml); + break; + case 257: + case 255: + case 247: + case 248: + Ml(C.statement); + break; + case 246: + Ml(C.thenStatement), Ml(C.elseStatement); + break; + case 249: + case 251: + case 250: + Ml(C.initializer), Ml(C.statement); + break; + case 256: + Ml(C.caseBlock); + break; + case 270: + lr(C.clauses, Ml); + break; + case 297: + case 298: + lr(C.statements, Ml); + break; + case 259: + Ml(C.tryBlock), Ml(C.catchClause), Ml(C.finallyBlock); + break; + case 300: + Ml(C.variableDeclaration), Ml(C.block); + break; + case 244: + Ml(C.declarationList); + break; + case 262: + lr(C.declarations, Ml); + break; + case 261: + case 170: + case 209: + case 264: + Kg(C.name); + break; + case 263: + Kg(C.name), Ea(C) & 1048576 && (lr(C.parameters, Ml), Ml(C.body)); + break; + case 207: + case 208: + lr(C.elements, Ml); + break; + case 273: + Ml(C.importClause); + break; + case 274: + Kg(C.name), Ml(C.namedBindings); + break; + case 275: + Kg(C.name); + break; + case 281: + Kg(C.name); + break; + case 276: + lr(C.elements, Ml); + break; + case 277: + Kg(C.propertyName || C.name); + break; + } + } + function T2(C) { + if (C) + switch (C.kind) { + case 304: + case 305: + case 173: + case 172: + case 175: + case 174: + case 178: + case 179: + Kg(C.name); + break; + } + } + function Kg(C) { + C && (Bo(C) || tS(C) ? Uv(C) : ws(C) && Ml(C)); + } + function Uv(C) { + const le = C.emitNode.autoGenerate; + if ((le.flags & 7) === 4) + return cT(QN(C), Ai(C), le.flags, le.prefix, le.suffix); + { + const _t = le.id; + return R[_t] || (R[_t] = Sp(C)); + } + } + function cT(C, le, _t, ur, ti) { + const gi = Ma(C), Ki = le ? F : O; + return Ki[gi] || (Ki[gi] = O_(C, le, _t ?? 0, E6(ur, Uv), E6(ti))); + } + function eh(C, le) { + return Lk(C) && !bE(C, le) && !B.has(C); + } + function bE(C, le) { + let _t, ur; + if (le ? (_t = fe, ur = ce) : (_t = se, ur = ae), _t?.has(C)) + return !0; + for (let ti = ur.length - 1; ti >= 0; ti--) + if (_t !== ur[ti] && (_t = ur[ti], _t?.has(C))) + return !0; + return !1; + } + function Lk(C, le) { + return A ? W7(A, C, n) : !0; + } + function Mk(C, le) { + for (let _t = le; _t && Ob(_t, le); _t = _t.nextContainer) + if (qm(_t) && _t.locals) { + const ur = _t.locals.get(tc(C)); + if (ur && ur.flags & 3257279) + return !1; + } + return !0; + } + function $w(C) { + switch (C) { + case "": + return V; + case "#": + return _e; + default: + return $?.get(C) ?? 0; + } + } + function Rk(C, le) { + switch (C) { + case "": + V = le; + break; + case "#": + _e = le; + break; + default: + $ ?? ($ = /* @__PURE__ */ new Map()), $.set(C, le); + break; + } + } + function Vv(C, le, _t, ur, ti) { + ur.length > 0 && ur.charCodeAt(0) === 35 && (ur = ur.slice(1)); + const gi = _v(_t, ur, "", ti); + let Ki = $w(gi); + if (C && !(Ki & C)) { + const ba = _v(_t, ur, C === 268435456 ? "_i" : "_n", ti); + if (eh(ba, _t)) + return Ki |= C, _t ? g1(ba) : le && Zg(ba), Rk(gi, Ki), ba; + } + for (; ; ) { + const mi = Ki & 268435455; + if (Ki++, mi !== 8 && mi !== 13) { + const ba = mi < 26 ? "_" + String.fromCharCode(97 + mi) : "_" + (mi - 26), Wc = _v(_t, ur, ba, ti); + if (eh(Wc, _t)) + return _t ? g1(Wc) : le && Zg(Wc), Rk(gi, Ki), Wc; + } + } + } + function $h(C, le = eh, _t, ur, ti, gi, Ki) { + if (C.length > 0 && C.charCodeAt(0) === 35 && (C = C.slice(1)), gi.length > 0 && gi.charCodeAt(0) === 35 && (gi = gi.slice(1)), _t) { + const ba = _v(ti, gi, C, Ki); + if (le(ba, ti)) + return ti ? g1(ba) : ur ? Zg(ba) : B.add(ba), ba; + } + C.charCodeAt(C.length - 1) !== 95 && (C += "_"); + let mi = 1; + for (; ; ) { + const ba = _v(ti, gi, C + mi, Ki); + if (le(ba, ti)) + return ti ? g1(ba) : ur ? Zg(ba) : B.add(ba), ba; + mi++; + } + } + function SE(C) { + return $h( + C, + Lk, + /*optimistic*/ + !0, + /*scoped*/ + !1, + /*privateName*/ + !1, + /*prefix*/ + "", + /*suffix*/ + "" + ); + } + function qv(C) { + const le = V0(C.name); + return Mk(le, Bn(C, qm)) ? le : $h( + le, + eh, + /*optimistic*/ + !1, + /*scoped*/ + !1, + /*privateName*/ + !1, + /*prefix*/ + "", + /*suffix*/ + "" + ); + } + function lT(C) { + const le = hx(C), _t = ca(le) ? eK(le.text) : "module"; + return $h( + _t, + eh, + /*optimistic*/ + !1, + /*scoped*/ + !1, + /*privateName*/ + !1, + /*prefix*/ + "", + /*suffix*/ + "" + ); + } + function zc() { + return $h( + "default", + eh, + /*optimistic*/ + !1, + /*scoped*/ + !1, + /*privateName*/ + !1, + /*prefix*/ + "", + /*suffix*/ + "" + ); + } + function Rl() { + return $h( + "class", + eh, + /*optimistic*/ + !1, + /*scoped*/ + !1, + /*privateName*/ + !1, + /*prefix*/ + "", + /*suffix*/ + "" + ); + } + function jk(C, le, _t, ur) { + return Me(C.name) ? cT(C.name, le) : Vv( + 0, + /*reservedInNestedScopes*/ + !1, + le, + _t, + ur + ); + } + function O_(C, le, _t, ur, ti) { + switch (C.kind) { + case 80: + case 81: + return $h( + V0(C), + eh, + !!(_t & 16), + !!(_t & 8), + le, + ur, + ti + ); + case 268: + case 267: + return E.assert(!ur && !ti && !le), qv(C); + case 273: + case 279: + return E.assert(!ur && !ti && !le), lT(C); + case 263: + case 264: { + E.assert(!ur && !ti && !le); + const gi = C.name; + return gi && !Bo(gi) ? O_( + gi, + /*privateName*/ + !1, + _t, + ur, + ti + ) : zc(); + } + case 278: + return E.assert(!ur && !ti && !le), zc(); + case 232: + return E.assert(!ur && !ti && !le), Rl(); + case 175: + case 178: + case 179: + return jk(C, le, ur, ti); + case 168: + return Vv( + 0, + /*reservedInNestedScopes*/ + !0, + le, + ur, + ti + ); + default: + return Vv( + 0, + /*reservedInNestedScopes*/ + !1, + le, + ur, + ti + ); + } + } + function Sp(C) { + const le = C.emitNode.autoGenerate, _t = E6(le.prefix, Uv), ur = E6(le.suffix); + switch (le.flags & 7) { + case 1: + return Vv(0, !!(le.flags & 8), Ai(C), _t, ur); + case 2: + return E.assertNode(C, Me), Vv( + 268435456, + !!(le.flags & 8), + /*privateName*/ + !1, + _t, + ur + ); + case 3: + return $h( + An(C), + le.flags & 32 ? Lk : eh, + !!(le.flags & 16), + !!(le.flags & 8), + Ai(C), + _t, + ur + ); + } + return E.fail(`Unsupported GeneratedIdentifierKind: ${E.formatEnum( + le.flags & 7, + tj, + /*isFlags*/ + !0 + )}.`); + } + function x2(C, le) { + const _t = Tt(2, C, le), ur = ie, ti = Ne, gi = Ee; + Vd(le), _t(C, le), h1(le, ur, ti, gi); + } + function Vd(C) { + const le = Ea(C), _t = hm(C); + q0(C, le, _t.pos, _t.end), le & 4096 && (Bt = !0); + } + function h1(C, le, _t, ur) { + const ti = Ea(C), gi = hm(C); + ti & 4096 && (Bt = !1), Bk(C, ti, gi.pos, gi.end, le, _t, ur); + const Ki = Tte(C); + Ki && Bk(C, ti, Ki.pos, Ki.end, le, _t, ur); + } + function q0(C, le, _t, ur) { + st(), St = !1; + const ti = _t < 0 || (le & 1024) !== 0 || C.kind === 12, gi = ur < 0 || (le & 2048) !== 0 || C.kind === 12; + (_t > 0 || ur > 0) && _t !== ur && (ti || V_( + _t, + /*isEmittedNode*/ + C.kind !== 354 + /* NotEmittedStatement */ + ), (!ti || _t >= 0 && (le & 1024) !== 0) && (ie = _t), (!gi || ur >= 0 && (le & 2048) !== 0) && (Ne = ur, C.kind === 262 && (Ee = ur))), lr(l6(C), Xw), Wt(); + } + function Bk(C, le, _t, ur, ti, gi, Ki) { + st(); + const mi = ur < 0 || (le & 2048) !== 0 || C.kind === 12; + lr(ON(C), dc), (_t > 0 || ur > 0) && _t !== ur && (ie = ti, Ne = gi, Ee = Ki, !mi && C.kind !== 354 && zk(ur)), Wt(); + } + function Xw(C) { + (C.hasLeadingNewline || C.kind === 2) && be.writeLine(), TE(C), C.hasTrailingNewLine || C.kind === 2 ? be.writeLine() : be.writeSpace(" "); + } + function dc(C) { + be.isAtStartOfLine() || be.writeSpace(" "), TE(C), C.hasTrailingNewLine && be.writeLine(); + } + function TE(C) { + const le = uT(C), _t = C.kind === 3 ? nx(le) : void 0; + KC(le, _t, be, 0, le.length, k); + } + function uT(C) { + return C.kind === 3 ? `/*${C.text}*/` : `//${C.text}`; + } + function k2(C, le, _t) { + st(); + const { pos: ur, end: ti } = le, gi = Ea(C), Ki = ur < 0 || (gi & 1024) !== 0, mi = Bt || ti < 0 || (gi & 2048) !== 0; + Ki || gf(le), Wt(), gi & 4096 && !Bt ? (Bt = !0, _t(C), Bt = !1) : _t(C), st(), mi || (V_( + le.end, + /*isEmittedNode*/ + !0 + ), St && !be.isAtStartOfLine() && be.writeLine()), Wt(); + } + function Jk(C, le) { + return C = Vo(C), C.parent && C.parent === Vo(le).parent; + } + function Mu(C, le) { + if (le.pos < C.end) + return !1; + C = Vo(C), le = Vo(le); + const _t = C.parent; + if (!_t || _t !== le.parent) + return !1; + const ur = Xee(C), ti = ur?.indexOf(C); + return ti !== void 0 && ti > -1 && ur.indexOf(le) === ti + 1; + } + function V_(C, le) { + St = !1, le ? C === 0 && A?.isDeclarationFile ? Uk(C, Hv) : Uk(C, fT) : C === 0 && Uk(C, _T); + } + function _T(C, le, _t, ur, ti) { + mT(C, le) && fT(C, le, _t, ur, ti); + } + function Hv(C, le, _t, ur, ti) { + mT(C, le) || fT(C, le, _t, ur, ti); + } + function q_(C, le) { + return e.onlyPrintJsDocStyle ? Wz(C, le) || U7(C, le) : !0; + } + function fT(C, le, _t, ur, ti) { + !A || !q_(A.text, C) || (St || (YK(Ks(), be, ti, C), St = !0), Tl(C), KC(A.text, Ks(), be, C, le, k), Tl(le), ur ? be.writeLine() : _t === 3 && be.writeSpace(" ")); + } + function th(C) { + Bt || C === -1 || V_( + C, + /*isEmittedNode*/ + !0 + ); + } + function zk(C) { + dT(C, pT); + } + function pT(C, le, _t, ur) { + !A || !q_(A.text, C) || (be.isAtStartOfLine() || be.writeSpace(" "), Tl(C), KC(A.text, Ks(), be, C, le, k), Tl(le), ur && be.writeLine()); + } + function hd(C, le, _t) { + Bt || (st(), dT(C, le ? pT : _t ? Wk : xE), Wt()); + } + function Wk(C, le, _t) { + A && (Tl(C), KC(A.text, Ks(), be, C, le, k), Tl(le), _t === 2 && be.writeLine()); + } + function xE(C, le, _t, ur) { + A && (Tl(C), KC(A.text, Ks(), be, C, le, k), Tl(le), ur ? be.writeLine() : be.writeSpace(" ")); + } + function Uk(C, le) { + A && (ie === -1 || C !== ie) && (Vk(C) ? H0(le) : XP( + A.text, + C, + le, + /*state*/ + C + )); + } + function dT(C, le) { + A && (Ne === -1 || C !== Ne && C !== Ee) && QP(A.text, C, le); + } + function Vk(C) { + return Ve !== void 0 && pa(Ve).nodePos === C; + } + function H0(C) { + if (!A) return; + const le = pa(Ve).detachedCommentEndPos; + Ve.length - 1 ? Ve.pop() : Ve = void 0, XP( + A.text, + le, + C, + /*state*/ + le + ); + } + function gf(C) { + const le = A && ZK(A.text, Ks(), be, Om, C, k, Bt); + le && (Ve ? Ve.push(le) : Ve = [le]); + } + function Om(C, le, _t, ur, ti, gi) { + !A || !q_(A.text, ur) || (Tl(ur), KC(C, le, _t, ur, ti, gi), Tl(ti)); + } + function mT(C, le) { + return !!A && sB(A.text, C, le); + } + function gT(C, le) { + const _t = Tt(3, C, le); + Oa(le), _t(C, le), yn(le); + } + function Oa(C) { + const le = Ea(C), _t = x0(C), ur = _t.source || Fe; + C.kind !== 354 && (le & 32) === 0 && _t.pos >= 0 && Gv(_t.source || Fe, Hf(ur, _t.pos)), le & 128 && (pe = !0); + } + function yn(C) { + const le = Ea(C), _t = x0(C); + le & 128 && (pe = !1), C.kind !== 354 && (le & 64) === 0 && _t.end >= 0 && Gv(_t.source || Fe, _t.end); + } + function Hf(C, le) { + return C.skipTrivia ? C.skipTrivia(le) : oa(C.text, le); + } + function Tl(C) { + if (pe || Nd(C) || yT(Fe)) + return; + const { line: le, character: _t } = js(Fe, C); + Te.addMapping( + be.getLine(), + be.getColumn(), + Ye, + le, + _t, + /*nameIndex*/ + void 0 + ); + } + function Gv(C, le) { + if (C !== Fe) { + const _t = Fe, ur = Ye; + C2(C), Tl(le), $v(_t, ur); + } else + Tl(le); + } + function hT(C, le, _t, ur, ti) { + if (pe || C && c5(C)) + return ti(le, _t, ur); + const gi = C && C.emitNode, Ki = gi && gi.flags || 0, mi = gi && gi.tokenSourceMapRanges && gi.tokenSourceMapRanges[le], ba = mi && mi.source || Fe; + return ur = Hf(ba, mi ? mi.pos : ur), (Ki & 256) === 0 && ur >= 0 && Gv(ba, ur), ur = ti(le, _t, ur), mi && (ur = mi.end), (Ki & 512) === 0 && ur >= 0 && Gv(ba, ur), ur; + } + function C2(C) { + if (!pe) { + if (Fe = C, C === ne) { + Ye = Se; + return; + } + yT(C) || (Ye = Te.addSource(C.fileName), e.inlineSources && Te.setSourceContent(Ye, C.text), ne = C, Se = Ye); + } + } + function $v(C, le) { + Fe = C, Ye = le; + } + function yT(C) { + return Xo( + C.fileName, + ".json" + /* Json */ + ); + } + } + function Vje() { + const e = []; + return e[ + 1024 + /* Braces */ + ] = ["{", "}"], e[ + 2048 + /* Parenthesis */ + ] = ["(", ")"], e[ + 4096 + /* AngleBrackets */ + ] = ["<", ">"], e[ + 8192 + /* SquareBrackets */ + ] = ["[", "]"], e; + } + function qje(e) { + return fve[ + e & 15360 + /* BracketsMask */ + ][0]; + } + function Hje(e) { + return fve[ + e & 15360 + /* BracketsMask */ + ][1]; + } + function Gje(e, t, n, i) { + t(e); + } + function $je(e, t, n, i) { + t(e, n.select(i)); + } + function Xje(e, t, n, i) { + t(e, n); + } + function Qje(e, t) { + return e.length === 1 ? Gje : typeof t == "object" ? $je : Xje; + } + function IO(e, t, n) { + if (!e.getDirectories || !e.readDirectory) + return; + const i = /* @__PURE__ */ new Map(), s = Zl(n); + return { + useCaseSensitiveFileNames: n, + fileExists: T, + readFile: (W, _e) => e.readFile(W, _e), + directoryExists: e.directoryExists && k, + getDirectories: P, + readDirectory: A, + createDirectory: e.createDirectory && D, + writeFile: e.writeFile && S, + addOrDeleteFileOrDirectory: R, + addOrDeleteFile: B, + clearCache: $, + realpath: e.realpath && O + }; + function o(W) { + return oo(W, t, s); + } + function c(W) { + return i.get(gl(W)); + } + function _(W) { + const _e = c(Hn(W)); + return _e && (_e.sortedAndCanonicalizedFiles || (_e.sortedAndCanonicalizedFiles = _e.files.map(s).sort(), _e.sortedAndCanonicalizedDirectories = _e.directories.map(s).sort()), _e); + } + function u(W) { + return Zc(Hs(W)); + } + function g(W, _e) { + var K; + if (!e.realpath || gl(o(e.realpath(W))) === _e) { + const V = { + files: hr(e.readDirectory( + W, + /*extensions*/ + void 0, + /*exclude*/ + void 0, + /*include*/ + ["*.*"] + ), u) || [], + directories: e.getDirectories(W) || [] + }; + return i.set(gl(_e), V), V; + } + if ((K = e.directoryExists) != null && K.call(e, W)) + return i.set(_e, !1), !1; + } + function m(W, _e) { + _e = gl(_e); + const K = c(_e); + if (K) + return K; + try { + return g(W, _e); + } catch { + E.assert(!i.has(gl(_e))); + return; + } + } + function h(W, _e) { + return py(W, _e, go, _u) >= 0; + } + function S(W, _e, K) { + const V = o(W), ae = _(V); + return ae && U( + ae, + u(W), + /*fileExists*/ + !0 + ), e.writeFile(W, _e, K); + } + function T(W) { + const _e = o(W), K = _(_e); + return K && h(K.sortedAndCanonicalizedFiles, s(u(W))) || e.fileExists(W); + } + function k(W) { + const _e = o(W); + return i.has(gl(_e)) || e.directoryExists(W); + } + function D(W) { + const _e = o(W), K = _(_e); + if (K) { + const V = u(W), ae = s(V), se = K.sortedAndCanonicalizedDirectories; + _y(se, ae, _u) && K.directories.push(V); + } + e.createDirectory(W); + } + function P(W) { + const _e = o(W), K = m(W, _e); + return K ? K.directories.slice() : e.getDirectories(W); + } + function A(W, _e, K, V, ae) { + const se = o(W), ce = m(W, se); + let fe; + if (ce !== void 0) + return NJ(W, _e, K, V, n, t, ae, he, O); + return e.readDirectory(W, _e, K, V, ae); + function he(be) { + const je = o(be); + if (je === se) + return ce || q(be, je); + const me = m(be, je); + return me !== void 0 ? me || q(be, je) : OJ; + } + function q(be, je) { + if (fe && je === se) return fe; + const me = { + files: hr(e.readDirectory( + be, + /*extensions*/ + void 0, + /*exclude*/ + void 0, + /*include*/ + ["*.*"] + ), u) || Ge, + directories: e.getDirectories(be) || Ge + }; + return je === se && (fe = me), me; + } + } + function O(W) { + return e.realpath ? e.realpath(W) : W; + } + function F(W) { + pD( + Hn(W), + (_e) => i.delete(gl(_e)) ? !0 : void 0 + ); + } + function R(W, _e) { + if (c(_e) !== void 0) { + $(); + return; + } + const V = _(_e); + if (!V) { + F(_e); + return; + } + if (!e.directoryExists) { + $(); + return; + } + const ae = u(W), se = { + fileExists: e.fileExists(W), + directoryExists: e.directoryExists(W) + }; + return se.directoryExists || h(V.sortedAndCanonicalizedDirectories, s(ae)) ? $() : U(V, ae, se.fileExists), se; + } + function B(W, _e, K) { + if (K === 1) + return; + const V = _(_e); + V ? U( + V, + u(W), + K === 0 + /* Created */ + ) : F(_e); + } + function U(W, _e, K) { + const V = W.sortedAndCanonicalizedFiles, ae = s(_e); + if (K) + _y(V, ae, _u) && W.files.push(_e); + else { + const se = py(V, ae, go, _u); + if (se >= 0) { + V.splice(se, 1); + const ce = W.files.findIndex((fe) => s(fe) === ae); + W.files.splice(ce, 1); + } + } + } + function $() { + i.clear(); + } + } + var Tie = /* @__PURE__ */ ((e) => (e[e.Update = 0] = "Update", e[e.RootNamesAndUpdate = 1] = "RootNamesAndUpdate", e[e.Full = 2] = "Full", e))(Tie || {}); + function FO(e, t, n, i, s) { + var o; + const c = hC(((o = t?.configFile) == null ? void 0 : o.extendedSourceFiles) || Ge, s); + n.forEach((_, u) => { + c.has(u) || (_.projects.delete(e), _.close()); + }), c.forEach((_, u) => { + const g = n.get(u); + g ? g.projects.add(e) : n.set(u, { + projects: /* @__PURE__ */ new Set([e]), + watcher: i(_, u), + close: () => { + const m = n.get(u); + !m || m.projects.size !== 0 || (m.watcher.close(), n.delete(u)); + } + }); + }); + } + function aU(e, t) { + t.forEach((n) => { + n.projects.delete(e) && n.close(); + }); + } + function OO(e, t, n) { + e.delete(t) && e.forEach(({ extendedResult: i }, s) => { + var o; + (o = i.extendedSourceFiles) != null && o.some((c) => n(c) === t) && OO(e, s, n); + }); + } + function oU(e, t, n) { + o4( + t, + e.getMissingFilePaths(), + { + // Watch the missing files + createNewValue: n, + // Files that are no longer missing (e.g. because they are no longer required) + // should no longer be watched. + onDeleteValue: od + } + ); + } + function xA(e, t, n) { + t ? o4( + e, + new Map(Object.entries(t)), + { + // Create new watch and recursive info + createNewValue: i, + // Close existing watch thats not needed any more + onDeleteValue: gp, + // Close existing watch that doesnt match in the flags + onExistingValue: s + } + ) : B_(e, gp); + function i(o, c) { + return { + watcher: n(o, c), + flags: c + }; + } + function s(o, c, _) { + o.flags !== c && (o.watcher.close(), e.set(_, i(_, c))); + } + } + function kA({ + watchedDirPath: e, + fileOrDirectory: t, + fileOrDirectoryPath: n, + configFileName: i, + options: s, + program: o, + extraFileExtensions: c, + currentDirectory: _, + useCaseSensitiveFileNames: u, + writeLog: g, + toPath: m, + getScriptKind: h + }) { + const S = GO(n); + if (!S) + return g(`Project: ${i} Detected ignored path: ${t}`), !0; + if (n = S, n === e) return !1; + if (xC(n) && !(FJ(t, s, c) || A())) + return g(`Project: ${i} Detected file add/remove of non supported extension: ${t}`), !0; + if (qre(t, s.configFile.configFileSpecs, Qi(Hn(i), _), u, _)) + return g(`Project: ${i} Detected excluded file: ${t}`), !0; + if (!o || s.outFile || s.outDir) return !1; + if (Il(n)) { + if (s.declarationDir) return !1; + } else if (!xc(n, s6)) + return !1; + const T = Gu(n), k = as(o) ? void 0 : RU(o) ? o.getProgramOrUndefined() : o, D = !k && !as(o) ? o : void 0; + if (P( + T + ".ts" + /* Ts */ + ) || P( + T + ".tsx" + /* Tsx */ + )) + return g(`Project: ${i} Detected output file: ${t}`), !0; + return !1; + function P(O) { + return k ? !!k.getSourceFileByPath(O) : D ? D.state.fileInfos.has(O) : !!Nn(o, (F) => m(F) === O); + } + function A() { + if (!h) return !1; + switch (h(t)) { + case 3: + case 4: + case 7: + case 5: + return !0; + case 1: + case 2: + return Jy(s); + case 6: + return zb(s); + case 0: + return !1; + } + } + } + function xie(e, t) { + return e ? e.isEmittedFile(t) : !1; + } + var kie = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.TriggerOnly = 1] = "TriggerOnly", e[e.Verbose = 2] = "Verbose", e))(kie || {}); + function cU(e, t, n, i) { + AY(t === 2 ? n : Ha); + const s = { + watchFile: (D, P, A, O) => e.watchFile(D, P, A, O), + watchDirectory: (D, P, A, O) => e.watchDirectory(D, P, (A & 1) !== 0, O) + }, o = t !== 0 ? { + watchFile: T("watchFile"), + watchDirectory: T("watchDirectory") + } : void 0, c = t === 2 ? { + watchFile: h, + watchDirectory: S + } : o || s, _ = t === 2 ? m : _w; + return { + watchFile: u("watchFile"), + watchDirectory: u("watchDirectory") + }; + function u(D) { + return (P, A, O, F, R, B) => { + var U; + return sO(P, D === "watchFile" ? F?.excludeFiles : F?.excludeDirectories, g(), ((U = e.getCurrentDirectory) == null ? void 0 : U.call(e)) || "") ? _(P, O, F, R, B) : c[D].call( + /*thisArgs*/ + void 0, + P, + A, + O, + F, + R, + B + ); + }; + } + function g() { + return typeof e.useCaseSensitiveFileNames == "boolean" ? e.useCaseSensitiveFileNames : e.useCaseSensitiveFileNames(); + } + function m(D, P, A, O, F) { + return n(`ExcludeWatcher:: Added:: ${k(D, P, A, O, F, i)}`), { + close: () => n(`ExcludeWatcher:: Close:: ${k(D, P, A, O, F, i)}`) + }; + } + function h(D, P, A, O, F, R) { + n(`FileWatcher:: Added:: ${k(D, A, O, F, R, i)}`); + const B = o.watchFile(D, P, A, O, F, R); + return { + close: () => { + n(`FileWatcher:: Close:: ${k(D, A, O, F, R, i)}`), B.close(); + } + }; + } + function S(D, P, A, O, F, R) { + const B = `DirectoryWatcher:: Added:: ${k(D, A, O, F, R, i)}`; + n(B); + const U = ao(), $ = o.watchDirectory(D, P, A, O, F, R), W = ao() - U; + return n(`Elapsed:: ${W}ms ${B}`), { + close: () => { + const _e = `DirectoryWatcher:: Close:: ${k(D, A, O, F, R, i)}`; + n(_e); + const K = ao(); + $.close(); + const V = ao() - K; + n(`Elapsed:: ${V}ms ${_e}`); + } + }; + } + function T(D) { + return (P, A, O, F, R, B) => s[D].call( + /*thisArgs*/ + void 0, + P, + (...U) => { + const $ = `${D === "watchFile" ? "FileWatcher" : "DirectoryWatcher"}:: Triggered with ${U[0]} ${U[1] !== void 0 ? U[1] : ""}:: ${k(P, O, F, R, B, i)}`; + n($); + const W = ao(); + A.call( + /*thisArg*/ + void 0, + ...U + ); + const _e = ao() - W; + n(`Elapsed:: ${_e}ms ${$}`); + }, + O, + F, + R, + B + ); + } + function k(D, P, A, O, F, R) { + return `WatchInfo: ${D} ${P} ${JSON.stringify(A)} ${R ? R(O, F) : F === void 0 ? O : `${O} ${F}`}`; + } + } + function CA(e) { + const t = e?.fallbackPolling; + return { + watchFile: t !== void 0 ? t : 1 + /* PriorityPollingInterval */ + }; + } + function gp(e) { + e.watcher.close(); + } + function lU(e, t, n = "tsconfig.json") { + return pD(e, (i) => { + const s = On(i, n); + return t(s) ? s : void 0; + }); + } + function uU(e, t) { + const n = Hn(t), i = Z_(e) ? e : On(n, e); + return Hs(i); + } + function Cie(e, t, n) { + let i; + return lr(e, (o) => { + const c = l7(o, t); + if (c.pop(), !i) { + i = c; + return; + } + const _ = Math.min(i.length, c.length); + for (let u = 0; u < _; u++) + if (n(i[u]) !== n(c[u])) { + if (u === 0) + return !0; + i.length = u; + break; + } + c.length < i.length && (i.length = c.length); + }) ? "" : i ? B1(i) : t; + } + function Eie(e, t) { + return LO(e, t); + } + function _U(e, t) { + return (n, i, s) => { + let o; + try { + Ko("beforeIORead"), o = e(n), Ko("afterIORead"), rp("I/O Read", "beforeIORead", "afterIORead"); + } catch (c) { + s && s(c.message), o = ""; + } + return o !== void 0 ? ek(n, o, i, t) : void 0; + }; + } + function fU(e, t, n) { + return (i, s, o, c) => { + try { + Ko("beforeIOWrite"), KB( + i, + s, + o, + e, + t, + n + ), Ko("afterIOWrite"), rp("I/O Write", "beforeIOWrite", "afterIOWrite"); + } catch (_) { + c && c(_.message); + } + }; + } + function LO(e, t, n = ml) { + const i = /* @__PURE__ */ new Map(), s = Zl(n.useCaseSensitiveFileNames); + function o(m) { + return i.has(m) ? !0 : (g.directoryExists || n.directoryExists)(m) ? (i.set(m, !0), !0) : !1; + } + function c() { + return Hn(Hs(n.getExecutingFilePath())); + } + const _ = v0(e), u = n.realpath && ((m) => n.realpath(m)), g = { + getSourceFile: _U((m) => g.readFile(m), t), + getDefaultLibLocation: c, + getDefaultLibFileName: (m) => On(c(), ZP(m)), + writeFile: fU( + (m, h, S) => n.writeFile(m, h, S), + (m) => (g.createDirectory || n.createDirectory)(m), + (m) => o(m) + ), + getCurrentDirectory: Uu(() => n.getCurrentDirectory()), + useCaseSensitiveFileNames: () => n.useCaseSensitiveFileNames, + getCanonicalFileName: s, + getNewLine: () => _, + fileExists: (m) => n.fileExists(m), + readFile: (m) => n.readFile(m), + trace: (m) => n.write(m + _), + directoryExists: (m) => n.directoryExists(m), + getEnvironmentVariable: (m) => n.getEnvironmentVariable ? n.getEnvironmentVariable(m) : "", + getDirectories: (m) => n.getDirectories(m), + realpath: u, + readDirectory: (m, h, S, T, k) => n.readDirectory(m, h, S, T, k), + createDirectory: (m) => n.createDirectory(m), + createHash: Os(n, n.createHash) + }; + return g; + } + function ow(e, t, n) { + const i = e.readFile, s = e.fileExists, o = e.directoryExists, c = e.createDirectory, _ = e.writeFile, u = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map(), S = (D) => { + const P = t(D), A = u.get(P); + return A !== void 0 ? A !== !1 ? A : void 0 : T(P, D); + }, T = (D, P) => { + const A = i.call(e, P); + return u.set(D, A !== void 0 ? A : !1), A; + }; + e.readFile = (D) => { + const P = t(D), A = u.get(P); + return A !== void 0 ? A !== !1 ? A : void 0 : !Xo( + D, + ".json" + /* Json */ + ) && !gie(D) ? i.call(e, D) : T(P, D); + }; + const k = n ? (D, P, A, O) => { + const F = t(D), R = typeof P == "object" ? P.impliedNodeFormat : void 0, B = h.get(R), U = B?.get(F); + if (U) return U; + const $ = n(D, P, A, O); + return $ && (Il(D) || Xo( + D, + ".json" + /* Json */ + )) && h.set(R, (B || /* @__PURE__ */ new Map()).set(F, $)), $; + } : void 0; + return e.fileExists = (D) => { + const P = t(D), A = g.get(P); + if (A !== void 0) return A; + const O = s.call(e, D); + return g.set(P, !!O), O; + }, _ && (e.writeFile = (D, P, ...A) => { + const O = t(D); + g.delete(O); + const F = u.get(O); + F !== void 0 && F !== P ? (u.delete(O), h.forEach((R) => R.delete(O))) : k && h.forEach((R) => { + const B = R.get(O); + B && B.text !== P && R.delete(O); + }), _.call(e, D, P, ...A); + }), o && (e.directoryExists = (D) => { + const P = t(D), A = m.get(P); + if (A !== void 0) return A; + const O = o.call(e, D); + return m.set(P, !!O), O; + }, c && (e.createDirectory = (D) => { + const P = t(D); + m.delete(P), c.call(e, D); + })), { + originalReadFile: i, + originalFileExists: s, + originalDirectoryExists: o, + originalCreateDirectory: c, + originalWriteFile: _, + getSourceFileWithCache: k, + readFileWithCache: S + }; + } + function bve(e, t, n) { + let i; + return i = In(i, e.getConfigFileParsingDiagnostics()), i = In(i, e.getOptionsDiagnostics(n)), i = In(i, e.getSyntacticDiagnostics(t, n)), i = In(i, e.getGlobalDiagnostics(n)), i = In(i, e.getSemanticDiagnostics(t, n)), J_(e.getCompilerOptions()) && (i = In(i, e.getDeclarationDiagnostics(t, n))), DC(i || Ge); + } + function Sve(e, t) { + let n = ""; + for (const i of e) + n += pU(i, t); + return n; + } + function pU(e, t) { + const n = `${$2(e)} TS${e.code}: ${km(e.messageText, t.getNewLine())}${t.getNewLine()}`; + if (e.file) { + const { line: i, character: s } = js(e.file, e.start), o = e.file.fileName; + return `${fD(o, t.getCurrentDirectory(), (_) => t.getCanonicalFileName(_))}(${i + 1},${s + 1}): ` + n; + } + return n; + } + var Die = /* @__PURE__ */ ((e) => (e.Grey = "\x1B[90m", e.Red = "\x1B[91m", e.Yellow = "\x1B[93m", e.Blue = "\x1B[94m", e.Cyan = "\x1B[96m", e))(Die || {}), wie = "\x1B[7m", Pie = " ", Tve = "\x1B[0m", xve = "...", Yje = " ", kve = " "; + function Cve(e) { + switch (e) { + case 1: + return "\x1B[91m"; + case 0: + return "\x1B[93m"; + case 2: + return E.fail("Should never get an Info diagnostic on the command line."); + case 3: + return "\x1B[94m"; + } + } + function s2(e, t) { + return t + e + Tve; + } + function Eve(e, t, n, i, s, o) { + const { line: c, character: _ } = js(e, t), { line: u, character: g } = js(e, t + n), m = js(e, e.text.length).line, h = u - c >= 4; + let S = (u + 1 + "").length; + h && (S = Math.max(xve.length, S)); + let T = ""; + for (let k = c; k <= u; k++) { + T += o.getNewLine(), h && c + 1 < k && k < u - 1 && (T += i + s2(xve.padStart(S), wie) + Pie + o.getNewLine(), k = u - 1); + const D = GP(e, k, 0), P = k < m ? GP(e, k + 1, 0) : e.text.length; + let A = e.text.slice(D, P); + if (A = A.trimEnd(), A = A.replace(/\t/g, " "), T += i + s2((k + 1 + "").padStart(S), wie) + Pie, T += A + o.getNewLine(), T += i + s2("".padStart(S), wie) + Pie, T += s, k === c) { + const O = k === u ? g : void 0; + T += A.slice(0, _).replace(/\S/g, " "), T += A.slice(_, O).replace(/./g, "~"); + } else k === u ? T += A.slice(0, g).replace(/./g, "~") : T += A.replace(/./g, "~"); + T += Tve; + } + return T; + } + function dU(e, t, n, i = s2) { + const { line: s, character: o } = js(e, t), c = n ? fD(e.fileName, n.getCurrentDirectory(), (u) => n.getCanonicalFileName(u)) : e.fileName; + let _ = ""; + return _ += i( + c, + "\x1B[96m" + /* Cyan */ + ), _ += ":", _ += i( + `${s + 1}`, + "\x1B[93m" + /* Yellow */ + ), _ += ":", _ += i( + `${o + 1}`, + "\x1B[93m" + /* Yellow */ + ), _; + } + function Nie(e, t) { + let n = ""; + for (const i of e) { + if (i.file) { + const { file: s, start: o } = i; + n += dU(s, o, t), n += " - "; + } + if (n += s2($2(i), Cve(i.category)), n += s2( + ` TS${i.code}: `, + "\x1B[90m" + /* Grey */ + ), n += km(i.messageText, t.getNewLine()), i.file && i.code !== p.File_appears_to_be_binary.code && (n += t.getNewLine(), n += Eve(i.file, i.start, i.length, "", Cve(i.category), t)), i.relatedInformation) { + n += t.getNewLine(); + for (const { file: s, start: o, length: c, messageText: _ } of i.relatedInformation) + s && (n += t.getNewLine(), n += Yje + dU(s, o, t), n += Eve(s, o, c, kve, "\x1B[96m", t)), n += t.getNewLine(), n += kve + km(_, t.getNewLine()); + } + n += t.getNewLine(); + } + return n; + } + function km(e, t, n = 0) { + if (gs(e)) + return e; + if (e === void 0) + return ""; + let i = ""; + if (n) { + i += t; + for (let s = 0; s < n; s++) + i += " "; + } + if (i += e.messageText, n++, e.next) + for (const s of e.next) + i += km(s, t, n); + return i; + } + function Aie(e, t) { + return (gs(e) ? t : e.resolutionMode) || t; + } + function Dve(e, t, n) { + return MO(e, PA(e, t), n); + } + function mU(e) { + var t; + return Bc(e) ? e.isTypeOnly : !!((t = e.importClause) != null && t.isTypeOnly); + } + function gU(e, t, n) { + return MO(e, t, n); + } + function MO(e, t, n) { + if ((qo(t.parent) || Bc(t.parent) || xm(t.parent)) && mU(t.parent)) { + const s = R6(t.parent.attributes); + if (s) + return s; + } + if (t.parent.parent && ym(t.parent.parent)) { + const i = R6(t.parent.parent.attributes); + if (i) + return i; + } + if (n && xJ(n)) + return wve(e, t, n); + } + function wve(e, t, n) { + var i; + if (!n) + return; + const s = (i = ad(t.parent)) == null ? void 0 : i.parent; + if (s && _l(s) || x_( + t.parent, + /*requireStringLiteralLikeArgument*/ + !1 + )) + return 1; + if (T_(ad(t.parent))) + return Ive(e, n) ? 1 : 99; + const o = uw(e, n); + return o === 1 ? 1 : hN(o) || o === 200 ? 99 : void 0; + } + function R6(e, t) { + if (!e) return; + if (wr(e.elements) !== 1) { + t?.( + e, + e.token === 118 ? p.Type_import_attributes_should_have_exactly_one_key_resolution_mode_with_value_import_or_require : p.Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require + ); + return; + } + const n = e.elements[0]; + if (ja(n.name)) { + if (n.name.text !== "resolution-mode") { + t?.( + n.name, + e.token === 118 ? p.resolution_mode_is_the_only_valid_key_for_type_import_attributes : p.resolution_mode_is_the_only_valid_key_for_type_import_assertions + ); + return; + } + if (ja(n.value)) { + if (n.value.text !== "import" && n.value.text !== "require") { + t?.(n.value, p.resolution_mode_should_be_either_require_or_import); + return; + } + return n.value.text === "import" ? 99 : 1; + } + } + } + var Pve = { + resolvedModule: void 0, + resolvedTypeReferenceDirective: void 0 + }; + function Iie(e) { + return e.text; + } + var RO = { + getName: Iie, + getMode: (e, t, n) => gU(t, e, n) + }; + function hU(e, t, n, i, s) { + return { + nameAndMode: RO, + resolve: (o, c) => MS( + o, + e, + n, + i, + s, + t, + c + ) + }; + } + function Fie(e) { + return gs(e) ? e : e.fileName; + } + var Nve = { + getName: Fie, + getMode: (e, t, n) => Aie(e, t && zO(t, n)) + }; + function jO(e, t, n, i, s) { + return { + nameAndMode: Nve, + resolve: (o, c) => ene( + o, + e, + n, + i, + t, + s, + c + ) + }; + } + function EA(e, t, n, i, s, o, c, _) { + if (e.length === 0) return Ge; + const u = [], g = /* @__PURE__ */ new Map(), m = _(t, n, i, o, c); + for (const h of e) { + const S = m.nameAndMode.getName(h), T = m.nameAndMode.getMode(h, s, n?.commandLine.options || i), k = H4(S, T); + let D = g.get(k); + D || g.set(k, D = m.resolve(S, T)), u.push(D); + } + return u; + } + var cw = "__inferred type names__.ts"; + function BO(e, t, n) { + const i = e.configFilePath ? Hn(e.configFilePath) : t; + return On(i, `__lib_node_modules_lookup_${n}__.ts`); + } + function yU(e) { + const t = e.split("."); + let n = t[1], i = 2; + for (; t[i] && t[i] !== "d"; ) + n += (i === 2 ? "/" : "-") + t[i], i++; + return "@typescript/lib-" + n; + } + function yv(e) { + switch (e?.kind) { + case 3: + case 4: + case 5: + case 7: + return !0; + default: + return !1; + } + } + function j6(e) { + return e.pos !== void 0; + } + function lw(e, t) { + var n, i, s, o; + const c = E.checkDefined(e.getSourceFileByPath(t.file)), { kind: _, index: u } = t; + let g, m, h; + switch (_) { + case 3: + const S = PA(c, u); + if (h = (i = (n = e.getResolvedModuleFromModuleSpecifier(S, c)) == null ? void 0 : n.resolvedModule) == null ? void 0 : i.packageId, S.pos === -1) return { file: c, packageId: h, text: S.text }; + g = oa(c.text, S.pos), m = S.end; + break; + case 4: + ({ pos: g, end: m } = c.referencedFiles[u]); + break; + case 5: + ({ pos: g, end: m } = c.typeReferenceDirectives[u]), h = (o = (s = e.getResolvedTypeReferenceDirectiveFromTypeReferenceDirective(c.typeReferenceDirectives[u], c)) == null ? void 0 : s.resolvedTypeReferenceDirective) == null ? void 0 : o.packageId; + break; + case 7: + ({ pos: g, end: m } = c.libReferenceDirectives[u]); + break; + default: + return E.assertNever(_); + } + return { file: c, pos: g, end: m, packageId: h }; + } + function vU(e, t, n, i, s, o, c, _, u, g) { + if (!e || _?.() || !Tf(e.getRootFileNames(), t)) return !1; + let m; + if (!Tf(e.getProjectReferences(), g, D) || e.getSourceFiles().some(T)) return !1; + const h = e.getMissingFilePaths(); + if (h && hl(h, s)) return !1; + const S = e.getCompilerOptions(); + if (!gJ(S, n) || e.resolvedLibReferences && hl(e.resolvedLibReferences, (A, O) => c(O))) return !1; + if (S.configFile && n.configFile) return S.configFile.text === n.configFile.text; + return !0; + function T(A) { + return !k(A) || o(A.path); + } + function k(A) { + return A.version === i(A.resolvedPath, A.fileName); + } + function D(A, O, F) { + return tB(A, O) && P(e.getResolvedProjectReferences()[F], A); + } + function P(A, O) { + if (A) { + if (ms(m, A)) return !0; + const R = ck(O), B = u(R); + return !B || A.commandLine.options.configFile !== B.options.configFile || !Tf(A.commandLine.fileNames, B.fileNames) ? !1 : ((m || (m = [])).push(A), !lr( + A.references, + (U, $) => !P( + U, + A.commandLine.projectReferences[$] + ) + )); + } + const F = ck(O); + return !u(F); + } + } + function a2(e) { + return e.options.configFile ? [...e.options.configFile.parseDiagnostics, ...e.errors] : e.errors; + } + function DA(e, t, n, i) { + const s = JO(e, t, n, i); + return typeof s == "object" ? s.impliedNodeFormat : s; + } + function JO(e, t, n, i) { + const s = Pu(i), o = 3 <= s && s <= 99 || Yy(e); + return xc(e, [ + ".d.mts", + ".mts", + ".mjs" + /* Mjs */ + ]) ? 99 : xc(e, [ + ".d.cts", + ".cts", + ".cjs" + /* Cjs */ + ]) ? 1 : o && xc(e, [ + ".d.ts", + ".ts", + ".tsx", + ".js", + ".jsx" + /* Jsx */ + ]) ? c() : void 0; + function c() { + const _ = G4(t, n, i), u = []; + _.failedLookupLocations = u, _.affectingLocations = u; + const g = $4(Hn(e), _); + return { impliedNodeFormat: g?.contents.packageJsonContent.type === "module" ? 99 : 1, packageJsonLocations: u, packageJsonScope: g }; + } + } + var Ave = /* @__PURE__ */ new Set([ + // binder errors + p.Cannot_redeclare_block_scoped_variable_0.code, + p.A_module_cannot_have_multiple_default_exports.code, + p.Another_export_default_is_here.code, + p.The_first_export_default_is_here.code, + p.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module.code, + p.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode.code, + p.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here.code, + p.constructor_is_a_reserved_word.code, + p.delete_cannot_be_called_on_an_identifier_in_strict_mode.code, + p.Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of_0_For_more_information_see_https_Colon_Slash_Slashdeveloper_mozilla_org_Slashen_US_Slashdocs_SlashWeb_SlashJavaScript_SlashReference_SlashStrict_mode.code, + p.Invalid_use_of_0_Modules_are_automatically_in_strict_mode.code, + p.Invalid_use_of_0_in_strict_mode.code, + p.A_label_is_not_allowed_here.code, + p.with_statements_are_not_allowed_in_strict_mode.code, + // grammar errors + p.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement.code, + p.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement.code, + p.A_class_declaration_without_the_default_modifier_must_have_a_name.code, + p.A_class_member_cannot_have_the_0_keyword.code, + p.A_comma_expression_is_not_allowed_in_a_computed_property_name.code, + p.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement.code, + p.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement.code, + p.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement.code, + p.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement.code, + p.A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration.code, + p.A_definite_assignment_assertion_is_not_permitted_in_this_context.code, + p.A_destructuring_declaration_must_have_an_initializer.code, + p.A_get_accessor_cannot_have_parameters.code, + p.A_rest_element_cannot_contain_a_binding_pattern.code, + p.A_rest_element_cannot_have_a_property_name.code, + p.A_rest_element_cannot_have_an_initializer.code, + p.A_rest_element_must_be_last_in_a_destructuring_pattern.code, + p.A_rest_parameter_cannot_have_an_initializer.code, + p.A_rest_parameter_must_be_last_in_a_parameter_list.code, + p.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma.code, + p.A_return_statement_cannot_be_used_inside_a_class_static_block.code, + p.A_set_accessor_cannot_have_rest_parameter.code, + p.A_set_accessor_must_have_exactly_one_parameter.code, + p.An_export_declaration_can_only_be_used_at_the_top_level_of_a_module.code, + p.An_export_declaration_cannot_have_modifiers.code, + p.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module.code, + p.An_import_declaration_cannot_have_modifiers.code, + p.An_object_member_cannot_be_declared_optional.code, + p.Argument_of_dynamic_import_cannot_be_spread_element.code, + p.Cannot_assign_to_private_method_0_Private_methods_are_not_writable.code, + p.Cannot_redeclare_identifier_0_in_catch_clause.code, + p.Catch_clause_variable_cannot_have_an_initializer.code, + p.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator.code, + p.Classes_can_only_extend_a_single_class.code, + p.Classes_may_not_have_a_field_named_constructor.code, + p.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern.code, + p.Duplicate_label_0.code, + p.Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_set_of_attributes_as_arguments.code, + p.for_await_loops_cannot_be_used_inside_a_class_static_block.code, + p.JSX_attributes_must_only_be_assigned_a_non_empty_expression.code, + p.JSX_elements_cannot_have_multiple_attributes_with_the_same_name.code, + p.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array.code, + p.JSX_property_access_expressions_cannot_include_JSX_namespace_names.code, + p.Jump_target_cannot_cross_function_boundary.code, + p.Line_terminator_not_permitted_before_arrow.code, + p.Modifiers_cannot_appear_here.code, + p.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement.code, + p.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement.code, + p.Private_identifiers_are_not_allowed_outside_class_bodies.code, + p.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression.code, + p.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier.code, + p.Tagged_template_expressions_are_not_permitted_in_an_optional_chain.code, + p.The_left_hand_side_of_a_for_of_statement_may_not_be_async.code, + p.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer.code, + p.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer.code, + p.Trailing_comma_not_allowed.code, + p.Variable_declaration_list_cannot_be_empty.code, + p._0_and_1_operations_cannot_be_mixed_without_parentheses.code, + p._0_expected.code, + p._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2.code, + p._0_list_cannot_be_empty.code, + p._0_modifier_already_seen.code, + p._0_modifier_cannot_appear_on_a_constructor_declaration.code, + p._0_modifier_cannot_appear_on_a_module_or_namespace_element.code, + p._0_modifier_cannot_appear_on_a_parameter.code, + p._0_modifier_cannot_appear_on_class_elements_of_this_kind.code, + p._0_modifier_cannot_be_used_here.code, + p._0_modifier_must_precede_1_modifier.code, + p._0_declarations_can_only_be_declared_inside_a_block.code, + p._0_declarations_must_be_initialized.code, + p.extends_clause_already_seen.code, + p.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations.code, + p.Class_constructor_may_not_be_a_generator.code, + p.Class_constructor_may_not_be_an_accessor.code, + p.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code, + p.await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code, + p.Private_field_0_must_be_declared_in_an_enclosing_class.code, + // Type errors + p.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value.code + ]); + function Zje(e, t) { + return e ? ux(e.getCompilerOptions(), t, Qz) : !1; + } + function Kje(e, t, n, i, s, o) { + return { + rootNames: e, + options: t, + host: n, + oldProgram: i, + configFileParsingDiagnostics: s, + typeScriptVersion: o + }; + } + function wA(e, t, n, i, s) { + var o, c, _, u, g, m, h, S, T, k, D, P, A, O, F, R; + let B = as(e) ? Kje(e, t, n, i, s) : e; + const { rootNames: U, options: $, configFileParsingDiagnostics: W, projectReferences: _e, typeScriptVersion: K, host: V } = B; + let { oldProgram: ae } = B; + B = void 0, e = void 0; + for (const Be of Fre) + if (eo($, Be.name) && typeof $[Be.name] == "string") + throw new Error(`${Be.name} is a string value; tsconfig JSON must be parsed with parseJsonSourceFileConfigFileContent or getParsedCommandLineOfConfigFile before passing to createProgram`); + const se = Uu(() => xt("ignoreDeprecations", p.Invalid_value_for_ignoreDeprecations)); + let ce, fe, he, q, be, je, me, Z, pe; + const Te = Oie(Zi); + let Fe, Ye, ne, Se, ie, Ne, Ee, Ce, Ve; + const St = typeof $.maxNodeModuleJsDepth == "number" ? $.maxNodeModuleJsDepth : 0; + let Bt = 0; + const tr = /* @__PURE__ */ new Map(), Nr = /* @__PURE__ */ new Map(); + (o = on) == null || o.push( + on.Phase.Program, + "createProgram", + { configFilePath: $.configFilePath, rootDir: $.rootDir }, + /*separateBeginAndEnd*/ + !0 + ), Ko("beforeProgram"); + const st = V || Eie($), Wt = UO(st); + let Jr = $.noLib; + const ui = Uu(() => st.getDefaultLibFileName($)), Ji = st.getDefaultLibLocation ? st.getDefaultLibLocation() : Hn(ui()); + let Dt = !1; + const Mn = st.getCurrentDirectory(), ai = _4($), fi = bN($, ai), pn = /* @__PURE__ */ new Map(); + let _i, Je, ft, er; + const qr = st.hasInvalidatedResolutions || mh; + st.resolveModuleNameLiterals ? (er = st.resolveModuleNameLiterals.bind(st), ft = (c = st.getModuleResolutionCache) == null ? void 0 : c.call(st)) : st.resolveModuleNames ? (er = (Be, nt, Rt, pr, Or, dn) => st.resolveModuleNames( + Be.map(Iie), + nt, + dn?.map(Iie), + Rt, + pr, + Or + ).map( + (Ir) => Ir ? Ir.extension !== void 0 ? { resolvedModule: Ir } : ( + // An older host may have omitted extension, in which case we should infer it from the file extension of resolvedFileName. + { resolvedModule: { ...Ir, extension: p4(Ir.resolvedFileName) } } + ) : Pve + ), ft = (_ = st.getModuleResolutionCache) == null ? void 0 : _.call(st)) : (ft = A6(Mn, Sl, $), er = (Be, nt, Rt, pr, Or) => EA( + Be, + nt, + Rt, + pr, + Or, + st, + ft, + hU + )); + let Jn; + if (st.resolveTypeReferenceDirectiveReferences) + Jn = st.resolveTypeReferenceDirectiveReferences.bind(st); + else if (st.resolveTypeReferenceDirectives) + Jn = (Be, nt, Rt, pr, Or) => st.resolveTypeReferenceDirectives( + Be.map(Fie), + nt, + Rt, + pr, + Or?.impliedNodeFormat + ).map((dn) => ({ resolvedTypeReferenceDirective: dn })); + else { + const Be = _O( + Mn, + Sl, + /*options*/ + void 0, + ft?.getPackageJsonInfoCache(), + ft?.optionsToRedirectsKey + ); + Jn = (nt, Rt, pr, Or, dn) => EA( + nt, + Rt, + pr, + Or, + dn, + st, + Be, + jO + ); + } + const Un = st.hasInvalidatedLibResolutions || mh; + let ki; + if (st.resolveLibrary) + ki = st.resolveLibrary.bind(st); + else { + const Be = A6(Mn, Sl, $, ft?.getPackageJsonInfoCache()); + ki = (nt, Rt, pr) => fO(nt, Rt, pr, st, Be); + } + const Ds = /* @__PURE__ */ new Map(); + let Ks = /* @__PURE__ */ new Map(), yr = Fp(), bs; + const Xe = /* @__PURE__ */ new Map(); + let Et = /* @__PURE__ */ new Map(); + const re = st.useCaseSensitiveFileNames() ? /* @__PURE__ */ new Map() : void 0; + let it, Y, Ae, $e; + const Ke = !!((u = st.useSourceOfProjectReferenceRedirect) != null && u.call(st)) && !$.disableSourceOfProjectReferenceRedirect, { onProgramCreateComplete: Tt, fileExists: Le, directoryExists: mt } = eBe({ + compilerHost: st, + getSymlinkCache: Uf, + useSourceOfProjectReferenceRedirect: Ke, + toPath: Nt, + getResolvedProjectReferences: Rs, + getRedirectFromOutput: vc, + forEachResolvedProjectReference: sc + }), pt = st.readFile.bind(st); + (g = on) == null || g.push(on.Phase.Program, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!ae }); + const Ct = Zje(ae, $); + (m = on) == null || m.pop(); + let qe; + if ((h = on) == null || h.push(on.Phase.Program, "tryReuseStructureFromOldProgram", {}), qe = vr(), (S = on) == null || S.pop(), qe !== 2) { + if (ce = [], fe = [], _e && (it || (it = _e.map(Nm)), U.length && it?.forEach((Be, nt) => { + if (!Be) return; + const Rt = Be.commandLine.options.outFile; + if (Ke) { + if (Rt || Hu(Be.commandLine.options) === 0) + for (const pr of Be.commandLine.fileNames) + P_(pr, { kind: 1, index: nt }); + } else if (Rt) + P_(S0(Rt, ".d.ts"), { kind: 2, index: nt }); + else if (Hu(Be.commandLine.options) === 0) { + const pr = Uu(() => JS(Be.commandLine, !st.useCaseSensitiveFileNames())); + for (const Or of Be.commandLine.fileNames) + !Il(Or) && !Xo( + Or, + ".json" + /* Json */ + ) && P_(sw(Or, Be.commandLine, !st.useCaseSensitiveFileNames(), pr), { kind: 2, index: nt }); + } + })), (T = on) == null || T.push(on.Phase.Program, "processRootFiles", { count: U.length }), lr(U, (Be, nt) => ra( + Be, + /*isDefaultLib*/ + !1, + /*ignoreNoDefaultLib*/ + !1, + { kind: 0, index: nt } + )), (k = on) == null || k.pop(), Fe ?? (Fe = U.length ? lO($, st) : Ge), Ye = N6(), Fe.length) { + (D = on) == null || D.push(on.Phase.Program, "processTypeReferences", { count: Fe.length }); + const Be = $.configFilePath ? Hn($.configFilePath) : Mn, nt = On(Be, cw), Rt = kt(Fe, nt); + for (let pr = 0; pr < Fe.length; pr++) + Ye.set( + Fe[pr], + /*mode*/ + void 0, + Rt[pr] + ), hp( + Fe[pr], + /*mode*/ + void 0, + Rt[pr], + { + kind: 8, + typeReference: Fe[pr], + packageId: (A = (P = Rt[pr]) == null ? void 0 : P.resolvedTypeReferenceDirective) == null ? void 0 : A.packageId + } + ); + (O = on) == null || O.pop(); + } + if (U.length && !Jr) { + const Be = ui(); + !$.lib && Be ? ra( + Be, + /*isDefaultLib*/ + !0, + /*ignoreNoDefaultLib*/ + !1, + { + kind: 6 + /* LibFile */ + } + ) : lr($.lib, (nt, Rt) => { + ra( + Gg(nt), + /*isDefaultLib*/ + !0, + /*ignoreNoDefaultLib*/ + !1, + { kind: 6, index: Rt } + ); + }); + } + he = X_(ce, rt).concat(fe), ce = void 0, fe = void 0, me = void 0; + } + if (ae && st.onReleaseOldSourceFile) { + const Be = ae.getSourceFiles(); + for (const nt of Be) { + const Rt = ta(nt.resolvedPath); + (Ct || !Rt || Rt.impliedNodeFormat !== nt.impliedNodeFormat || // old file wasn't redirect but new file is + nt.resolvedPath === nt.path && Rt.resolvedPath !== nt.path) && st.onReleaseOldSourceFile(nt, ae.getCompilerOptions(), !!ta(nt.path), Rt); + } + st.getParsedCommandLine || ae.forEachResolvedProjectReference((nt) => { + Gl(nt.sourceFile.path) || st.onReleaseOldSourceFile( + nt.sourceFile, + ae.getCompilerOptions(), + /*hasSourceFileByPath*/ + !1, + /*newSourceFileByResolvedPath*/ + void 0 + ); + }); + } + ae && st.onReleaseParsedCommandLine && x4( + ae.getProjectReferences(), + ae.getResolvedProjectReferences(), + (Be, nt, Rt) => { + const pr = nt?.commandLine.projectReferences[Rt] || ae.getProjectReferences()[Rt], Or = ck(pr); + Y?.has(Nt(Or)) || st.onReleaseParsedCommandLine(Or, Be, ae.getCompilerOptions()); + } + ), ae = void 0, Se = void 0, Ne = void 0, Ce = void 0; + const Lt = { + getRootFileNames: () => U, + getSourceFile: Co, + getSourceFileByPath: ta, + getSourceFiles: () => he, + getMissingFilePaths: () => Et, + getModuleResolutionCache: () => ft, + getFilesByNameMap: () => Xe, + getCompilerOptions: () => $, + getSyntacticDiagnostics: zf, + getOptionsDiagnostics: kr, + getGlobalDiagnostics: Yi, + getSemanticDiagnostics: cs, + getCachedSemanticDiagnostics: Ws, + getSuggestionDiagnostics: tt, + getDeclarationDiagnostics: zt, + getBindAndCheckDiagnostics: Fa, + getProgramDiagnostics: va, + getTypeChecker: so, + getClassifiableNames: _r, + getCommonSourceDirectory: Jt, + emit: zi, + getCurrentDirectory: () => Mn, + getNodeCount: () => so().getNodeCount(), + getIdentifierCount: () => so().getIdentifierCount(), + getSymbolCount: () => so().getSymbolCount(), + getTypeCount: () => so().getTypeCount(), + getInstantiationCount: () => so().getInstantiationCount(), + getRelationCacheSizes: () => so().getRelationCacheSizes(), + getFileProcessingDiagnostics: () => Te.getFileProcessingDiagnostics(), + getAutomaticTypeDirectiveNames: () => Fe, + getAutomaticTypeDirectiveResolutions: () => Ye, + isSourceFileFromExternalLibrary: pc, + isSourceFileDefaultLibrary: Zo, + getModeForUsageLocation: yp, + getEmitSyntaxForUsageLocation: jh, + getModeForResolutionAtIndex: M0, + getSourceFileFromReference: Bd, + getLibFileFromReference: ic, + sourceFileToPackageName: Ks, + redirectTargetsMap: yr, + usesUriStyleNodeCoreModules: bs, + resolvedModules: ie, + resolvedTypeReferenceDirectiveNames: Ee, + resolvedLibReferences: ne, + getProgramDiagnosticsContainer: () => Te, + getResolvedModule: rn, + getResolvedModuleFromModuleSpecifier: Pe, + getResolvedTypeReferenceDirective: yt, + getResolvedTypeReferenceDirectiveFromTypeReferenceDirective: ue, + forEachResolvedModule: M, + forEachResolvedTypeReferenceDirective: ye, + getCurrentPackagesMap: () => Ve, + typesPackageExists: Mt, + packageBundlesTypes: ke, + isEmittedFile: Ll, + getConfigFileParsingDiagnostics: no, + getProjectReferences: ds, + getResolvedProjectReferences: Rs, + getRedirectFromSourceFile: Po, + getResolvedProjectReferenceByPath: Gl, + forEachResolvedProjectReference: sc, + isSourceOfProjectReferenceRedirect: Df, + getRedirectFromOutput: vc, + getCompilerOptionsForFile: Qu, + getDefaultResolutionModeForFile: __, + getEmitModuleFormatOfFile: zd, + getImpliedNodeFormatForEmit: sg, + shouldTransformImportCall: $p, + emitBuildInfo: Fs, + fileExists: Le, + readFile: pt, + directoryExists: mt, + getSymlinkCache: Uf, + realpath: (F = st.realpath) == null ? void 0 : F.bind(st), + useCaseSensitiveFileNames: () => st.useCaseSensitiveFileNames(), + getCanonicalFileName: Sl, + getFileIncludeReasons: () => Te.getFileReasons(), + structureIsReused: qe, + writeFile: oi, + getGlobalTypingsCacheLocation: Os(st, st.getGlobalTypingsCacheLocation) + }; + return Tt(), Dt || ee(), Ko("afterProgram"), rp("Program", "beforeProgram", "afterProgram"), (R = on) == null || R.pop(), Lt; + function rn(Be, nt, Rt) { + var pr; + return (pr = ie?.get(Be.path)) == null ? void 0 : pr.get(nt, Rt); + } + function Pe(Be, nt) { + return nt ?? (nt = xr(Be)), E.assertIsDefined(nt, "`moduleSpecifier` must have a `SourceFile` ancestor. Use `program.getResolvedModule` instead to provide the containing file and resolution mode."), rn(nt, Be.text, yp(nt, Be)); + } + function yt(Be, nt, Rt) { + var pr; + return (pr = Ee?.get(Be.path)) == null ? void 0 : pr.get(nt, Rt); + } + function ue(Be, nt) { + return yt( + nt, + Be.fileName, + s1(Be, nt) + ); + } + function M(Be, nt) { + Q(ie, Be, nt); + } + function ye(Be, nt) { + Q(Ee, Be, nt); + } + function Q(Be, nt, Rt) { + var pr; + Rt ? (pr = Be?.get(Rt.path)) == null || pr.forEach((Or, dn, Ir) => nt(Or, dn, Ir, Rt.path)) : Be?.forEach((Or, dn) => Or.forEach((Ir, Vr, hi) => nt(Ir, Vr, hi, dn))); + } + function dt() { + return Ve || (Ve = /* @__PURE__ */ new Map(), M(({ resolvedModule: Be }) => { + Be?.packageId && Ve.set(Be.packageId.name, Be.extension === ".d.ts" || !!Ve.get(Be.packageId.name)); + }), Ve); + } + function Mt(Be) { + return dt().has(mO(Be)); + } + function ke(Be) { + return !!dt().get(Be); + } + function at(Be) { + var nt; + (nt = Be.resolutionDiagnostics) != null && nt.length && Te.addFileProcessingDiagnostic({ + kind: 2, + diagnostics: Be.resolutionDiagnostics + }); + } + function wt(Be, nt, Rt, pr) { + if (st.resolveModuleNameLiterals || !st.resolveModuleNames) return at(Rt); + if (!ft || Dl(nt)) return; + const Or = Qi(Be.originalFileName, Mn), dn = Hn(Or), Ir = Pr(Be), Vr = ft.getFromNonRelativeNameCache(nt, pr, dn, Ir); + Vr && at(Vr); + } + function Zr(Be, nt, Rt) { + var pr, Or; + const dn = Qi(nt.originalFileName, Mn), Ir = Pr(nt); + (pr = on) == null || pr.push(on.Phase.Program, "resolveModuleNamesWorker", { containingFileName: dn }), Ko("beforeResolveModule"); + const Vr = er( + Be, + dn, + Ir, + $, + nt, + Rt + ); + return Ko("afterResolveModule"), rp("ResolveModule", "beforeResolveModule", "afterResolveModule"), (Or = on) == null || Or.pop(), Vr; + } + function Rr(Be, nt, Rt) { + var pr, Or; + const dn = gs(nt) ? void 0 : nt, Ir = gs(nt) ? nt : Qi(nt.originalFileName, Mn), Vr = dn && Pr(dn); + (pr = on) == null || pr.push(on.Phase.Program, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName: Ir }), Ko("beforeResolveTypeReference"); + const hi = Jn( + Be, + Ir, + Vr, + $, + dn, + Rt + ); + return Ko("afterResolveTypeReference"), rp("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference"), (Or = on) == null || Or.pop(), hi; + } + function Pr(Be) { + var nt, Rt; + const pr = Po(Be.originalFileName); + if (pr || !Il(Be.originalFileName)) return pr?.resolvedRef; + const Or = (nt = vc(Be.path)) == null ? void 0 : nt.resolvedRef; + if (Or) return Or; + if (!st.realpath || !$.preserveSymlinks || !Be.originalFileName.includes(qg)) return; + const dn = Nt(st.realpath(Be.originalFileName)); + return dn === Be.path || (Rt = vc(dn)) == null ? void 0 : Rt.resolvedRef; + } + function rt(Be, nt) { + return ho(vt(Be), vt(nt)); + } + function vt(Be) { + if (np( + Ji, + Be.fileName, + /*ignoreCase*/ + !1 + )) { + const nt = Zc(Be.fileName); + if (nt === "lib.d.ts" || nt === "lib.es6.d.ts") return 0; + const Rt = bC(nD(nt, "lib."), ".d.ts"), pr = HF.indexOf(Rt); + if (pr !== -1) return pr + 1; + } + return HF.length + 2; + } + function Nt(Be) { + return oo(Be, Mn, Sl); + } + function Jt() { + let Be = Te.getCommonSourceDirectory(); + if (Be !== void 0) + return Be; + const nt = kn(he, (Rt) => Mb(Rt, Lt)); + return Be = aw( + $, + () => Fi(nt, (Rt) => Rt.isDeclarationFile ? void 0 : Rt.fileName), + Mn, + Sl, + (Rt) => Wf(nt, Rt) + ), Te.setCommonSourceDirectory(Be), Be; + } + function _r() { + var Be; + if (!je) { + so(), je = /* @__PURE__ */ new Set(); + for (const nt of he) + (Be = nt.classifiableNames) == null || Be.forEach((Rt) => je.add(Rt)); + } + return je; + } + function nr(Be, nt) { + return cr({ + entries: Be, + containingFile: nt, + containingSourceFile: nt, + redirectedReference: Pr(nt), + nameAndModeGetter: RO, + resolutionWorker: Zr, + getResolutionFromOldProgram: (Rt, pr) => ae?.getResolvedModule(nt, Rt, pr), + getResolved: _x, + canReuseResolutionsInFile: () => nt === ae?.getSourceFile(nt.fileName) && !qr(nt.path), + resolveToOwnAmbientModule: !0 + }); + } + function kt(Be, nt) { + const Rt = gs(nt) ? void 0 : nt; + return cr({ + entries: Be, + containingFile: nt, + containingSourceFile: Rt, + redirectedReference: Rt && Pr(Rt), + nameAndModeGetter: Nve, + resolutionWorker: Rr, + getResolutionFromOldProgram: (pr, Or) => { + var dn; + return Rt ? ae?.getResolvedTypeReferenceDirective(Rt, pr, Or) : (dn = ae?.getAutomaticTypeDirectiveResolutions()) == null ? void 0 : dn.get(pr, Or); + }, + getResolved: B7, + canReuseResolutionsInFile: () => Rt ? Rt === ae?.getSourceFile(Rt.fileName) && !qr(Rt.path) : !qr(Nt(nt)) + }); + } + function cr({ + entries: Be, + containingFile: nt, + containingSourceFile: Rt, + redirectedReference: pr, + nameAndModeGetter: Or, + resolutionWorker: dn, + getResolutionFromOldProgram: Ir, + getResolved: Vr, + canReuseResolutionsInFile: hi, + resolveToOwnAmbientModule: rs + }) { + if (!Be.length) return Ge; + if (qe === 0 && (!rs || !Rt.ambientModuleNames.length)) + return dn( + Be, + nt, + /*reusedNames*/ + void 0 + ); + let Zn, ns, Pi, Wo; + const A_ = hi(); + for (let $l = 0; $l < Be.length; $l++) { + const Qp = Be[$l]; + if (A_) { + const mf = Or.getName(Qp), wv = Or.getMode(Qp, Rt, pr?.commandLine.options ?? $), Am = Ir(mf, wv), ag = Am && Vr(Am); + if (ag) { + Xy($, st) && ts( + st, + dn === Zr ? ag.packageId ? p.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : p.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : ag.packageId ? p.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : p.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2, + mf, + Rt ? Qi(Rt.originalFileName, Mn) : nt, + ag.resolvedFileName, + ag.packageId && U1(ag.packageId) + ), (Pi ?? (Pi = new Array(Be.length)))[$l] = Am, (Wo ?? (Wo = [])).push(Qp); + continue; + } + } + if (rs) { + const mf = Or.getName(Qp); + if (ms(Rt.ambientModuleNames, mf)) { + Xy($, st) && ts( + st, + p.Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1, + mf, + Qi(Rt.originalFileName, Mn) + ), (Pi ?? (Pi = new Array(Be.length)))[$l] = Pve; + continue; + } + } + (Zn ?? (Zn = [])).push(Qp), (ns ?? (ns = [])).push($l); + } + if (!Zn) return Pi; + const Xp = dn(Zn, nt, Wo); + return Pi ? (Xp.forEach(($l, Qp) => Pi[ns[Qp]] = $l), Pi) : Xp; + } + function fr() { + return !x4( + ae.getProjectReferences(), + ae.getResolvedProjectReferences(), + (Be, nt, Rt) => { + const pr = (nt ? nt.commandLine.projectReferences : _e)[Rt], Or = Nm(pr); + return Be ? !Or || Or.sourceFile !== Be.sourceFile || !Tf(Be.commandLine.fileNames, Or.commandLine.fileNames) : Or !== void 0; + }, + (Be, nt) => { + const Rt = nt ? Gl(nt.sourceFile.path).commandLine.projectReferences : _e; + return !Tf(Be, Rt, tB); + } + ); + } + function vr() { + var Be; + if (!ae) + return 0; + const nt = ae.getCompilerOptions(); + if (R7(nt, $)) + return 0; + const Rt = ae.getRootFileNames(); + if (!Tf(Rt, U) || !fr()) + return 0; + _e && (it = _e.map(Nm)); + const pr = [], Or = []; + if (qe = 2, hl(ae.getMissingFilePaths(), (Zn) => st.fileExists(Zn))) + return 0; + const dn = ae.getSourceFiles(); + let Ir; + ((Zn) => { + Zn[Zn.Exists = 0] = "Exists", Zn[Zn.Modified = 1] = "Modified"; + })(Ir || (Ir = {})); + const Vr = /* @__PURE__ */ new Map(); + for (const Zn of dn) { + const ns = Gi(Zn.fileName, ft, st, $); + let Pi = st.getSourceFileByPath ? st.getSourceFileByPath( + Zn.fileName, + Zn.resolvedPath, + ns, + /*onError*/ + void 0, + Ct + ) : st.getSourceFile( + Zn.fileName, + ns, + /*onError*/ + void 0, + Ct + ); + if (!Pi) + return 0; + Pi.packageJsonLocations = (Be = ns.packageJsonLocations) != null && Be.length ? ns.packageJsonLocations : void 0, Pi.packageJsonScope = ns.packageJsonScope, E.assert(!Pi.redirectInfo, "Host should not return a redirect source file from `getSourceFile`"); + let Wo; + if (Zn.redirectInfo) { + if (Pi !== Zn.redirectInfo.unredirected) + return 0; + Wo = !1, Pi = Zn; + } else if (ae.redirectTargetsMap.has(Zn.path)) { + if (Pi !== Zn) + return 0; + Wo = !1; + } else + Wo = Pi !== Zn; + Pi.path = Zn.path, Pi.originalFileName = Zn.originalFileName, Pi.resolvedPath = Zn.resolvedPath, Pi.fileName = Zn.fileName; + const A_ = ae.sourceFileToPackageName.get(Zn.path); + if (A_ !== void 0) { + const Xp = Vr.get(A_), $l = Wo ? 1 : 0; + if (Xp !== void 0 && $l === 1 || Xp === 1) + return 0; + Vr.set(A_, $l); + } + Wo ? (Zn.impliedNodeFormat !== Pi.impliedNodeFormat ? qe = 1 : Tf(Zn.libReferenceDirectives, Pi.libReferenceDirectives, Eo) ? Zn.hasNoDefaultLib !== Pi.hasNoDefaultLib ? qe = 1 : Tf(Zn.referencedFiles, Pi.referencedFiles, Eo) ? (vo(Pi), Tf(Zn.imports, Pi.imports, $c) && Tf(Zn.moduleAugmentations, Pi.moduleAugmentations, $c) ? (Zn.flags & 12582912) !== (Pi.flags & 12582912) ? qe = 1 : Tf(Zn.typeReferenceDirectives, Pi.typeReferenceDirectives, Eo) || (qe = 1) : qe = 1) : qe = 1 : qe = 1, Or.push(Pi)) : qr(Zn.path) && (qe = 1, Or.push(Pi)), pr.push(Pi); + } + if (qe !== 2) + return qe; + for (const Zn of Or) { + const ns = Fve(Zn), Pi = nr(ns, Zn); + (Ne ?? (Ne = /* @__PURE__ */ new Map())).set(Zn.path, Pi); + const Wo = Qu(Zn); + nB( + ns, + Pi, + (mf) => ae.getResolvedModule(Zn, mf.text, MO(Zn, mf, Wo)), + qZ + ) && (qe = 1); + const Xp = Zn.typeReferenceDirectives, $l = kt(Xp, Zn); + (Ce ?? (Ce = /* @__PURE__ */ new Map())).set(Zn.path, $l), nB( + Xp, + $l, + (mf) => ae.getResolvedTypeReferenceDirective( + Zn, + Fie(mf), + s1(mf, Zn) + ), + HZ + ) && (qe = 1); + } + if (qe !== 2) + return qe; + if (UZ(nt, $) || ae.resolvedLibReferences && hl(ae.resolvedLibReferences, (Zn, ns) => $g(ns).actual !== Zn.actual)) + return 1; + if (st.hasChangedAutomaticTypeDirectiveNames) { + if (st.hasChangedAutomaticTypeDirectiveNames()) return 1; + } else if (Fe = lO($, st), !Tf(ae.getAutomaticTypeDirectiveNames(), Fe)) return 1; + Et = ae.getMissingFilePaths(), E.assert(pr.length === ae.getSourceFiles().length); + for (const Zn of pr) + Xe.set(Zn.path, Zn); + ae.getFilesByNameMap().forEach((Zn, ns) => { + if (!Zn) { + Xe.set(ns, Zn); + return; + } + if (Zn.path === ns) { + ae.isSourceFileFromExternalLibrary(Zn) && Nr.set(Zn.path, !0); + return; + } + Xe.set(ns, Xe.get(Zn.path)); + }); + const rs = nt.configFile && nt.configFile === $.configFile || !nt.configFile && !$.configFile && !ux(nt, $, _d); + return Te.reuseStateFromOldProgram(ae.getProgramDiagnosticsContainer(), rs), Dt = rs, he = pr, Fe = ae.getAutomaticTypeDirectiveNames(), Ye = ae.getAutomaticTypeDirectiveResolutions(), Ks = ae.sourceFileToPackageName, yr = ae.redirectTargetsMap, bs = ae.usesUriStyleNodeCoreModules, ie = ae.resolvedModules, Ee = ae.resolvedTypeReferenceDirectiveNames, ne = ae.resolvedLibReferences, Ve = ae.getCurrentPackagesMap(), 2; + } + function Xt(Be) { + return { + getCanonicalFileName: Sl, + getCommonSourceDirectory: Lt.getCommonSourceDirectory, + getCompilerOptions: Lt.getCompilerOptions, + getCurrentDirectory: () => Mn, + getSourceFile: Lt.getSourceFile, + getSourceFileByPath: Lt.getSourceFileByPath, + getSourceFiles: Lt.getSourceFiles, + isSourceFileFromExternalLibrary: pc, + getRedirectFromSourceFile: Po, + isSourceOfProjectReferenceRedirect: Df, + getSymlinkCache: Uf, + writeFile: Be || oi, + isEmitBlocked: hs, + shouldTransformImportCall: $p, + getEmitModuleFormatOfFile: zd, + getDefaultResolutionModeForFile: __, + getModeForResolutionAtIndex: M0, + readFile: (nt) => st.readFile(nt), + fileExists: (nt) => { + const Rt = Nt(nt); + return ta(Rt) ? !0 : Et.has(Rt) ? !1 : st.fileExists(nt); + }, + realpath: Os(st, st.realpath), + useCaseSensitiveFileNames: () => st.useCaseSensitiveFileNames(), + getBuildInfo: () => { + var nt; + return (nt = Lt.getBuildInfo) == null ? void 0 : nt.call(Lt); + }, + getSourceFileFromReference: (nt, Rt) => Lt.getSourceFileFromReference(nt, Rt), + redirectTargetsMap: yr, + getFileIncludeReasons: Lt.getFileIncludeReasons, + createHash: Os(st, st.createHash), + getModuleResolutionCache: () => Lt.getModuleResolutionCache(), + trace: Os(st, st.trace), + getGlobalTypingsCacheLocation: Lt.getGlobalTypingsCacheLocation + }; + } + function oi(Be, nt, Rt, pr, Or, dn) { + st.writeFile(Be, nt, Rt, pr, Or, dn); + } + function Fs(Be) { + var nt, Rt; + (nt = on) == null || nt.push( + on.Phase.Emit, + "emitBuildInfo", + {}, + /*separateBeginAndEnd*/ + !0 + ), Ko("beforeEmit"); + const pr = nU( + vie, + Xt(Be), + /*targetSourceFile*/ + void 0, + /*transformers*/ + die, + /*emitOnly*/ + !1, + /*onlyBuildInfo*/ + !0 + ); + return Ko("afterEmit"), rp("Emit", "beforeEmit", "afterEmit"), (Rt = on) == null || Rt.pop(), pr; + } + function Rs() { + return it; + } + function ds() { + return _e; + } + function pc(Be) { + return !!Nr.get(Be.path); + } + function Zo(Be) { + if (!Be.isDeclarationFile) + return !1; + if (Be.hasNoDefaultLib) + return !0; + if ($.noLib) + return !1; + const nt = st.useCaseSensitiveFileNames() ? bb : hy; + return $.lib ? ot($.lib, (Rt) => { + const pr = ne.get(Rt); + return !!pr && nt(Be.fileName, pr.actual); + }) : nt(Be.fileName, ui()); + } + function so() { + return be || (be = Ene(Lt)); + } + function zi(Be, nt, Rt, pr, Or, dn, Ir) { + var Vr, hi; + (Vr = on) == null || Vr.push( + on.Phase.Emit, + "emit", + { path: Be?.path }, + /*separateBeginAndEnd*/ + !0 + ); + const rs = yc( + () => Gc( + Lt, + Be, + nt, + Rt, + pr, + Or, + dn, + Ir + ) + ); + return (hi = on) == null || hi.pop(), rs; + } + function hs(Be) { + return pn.has(Nt(Be)); + } + function Gc(Be, nt, Rt, pr, Or, dn, Ir, Vr) { + if (!Ir) { + const ns = SU(Be, nt, Rt, pr); + if (ns) return ns; + } + const hi = so(), rs = hi.getEmitResolver( + $.outFile ? void 0 : nt, + pr, + rU(Or, Ir) + ); + Ko("beforeEmit"); + const Zn = hi.runWithCancellationToken( + pr, + () => nU( + rs, + Xt(Rt), + nt, + mie($, dn, Or), + Or, + /*onlyBuildInfo*/ + !1, + Ir, + Vr + ) + ); + return Ko("afterEmit"), rp("Emit", "beforeEmit", "afterEmit"), Zn; + } + function Co(Be) { + return ta(Nt(Be)); + } + function ta(Be) { + return Xe.get(Be) || void 0; + } + function Ec(Be, nt, Rt) { + return DC(Be ? nt(Be, Rt) : ka(Lt.getSourceFiles(), (pr) => (Rt && Rt.throwIfCancellationRequested(), nt(pr, Rt)))); + } + function zf(Be, nt) { + return Ec(Be, Za, nt); + } + function cs(Be, nt, Rt) { + return Ec( + Be, + (pr, Or) => Fc(pr, Or, Rt), + nt + ); + } + function Ws(Be) { + return Z?.get(Be.path); + } + function Fa(Be, nt) { + return Hl( + Be, + nt, + /*nodesToCheck*/ + void 0 + ); + } + function va(Be) { + var nt; + if (a6(Be, $, Lt)) + return Ge; + const Rt = Te.getCombinedDiagnostics(Lt).getDiagnostics(Be.fileName); + return (nt = Be.commentDirectives) != null && nt.length ? H(Be, Be.commentDirectives, Rt).diagnostics : Rt; + } + function zt(Be, nt) { + return Ec(Be, ln, nt); + } + function Za(Be) { + return n_(Be) ? (Be.additionalSyntacticDiagnostics || (Be.additionalSyntacticDiagnostics = Kt(Be)), Bi(Be.additionalSyntacticDiagnostics, Be.parseDiagnostics)) : Be.parseDiagnostics; + } + function yc(Be) { + try { + return Be(); + } catch (nt) { + throw nt instanceof lD && (be = void 0), nt; + } + } + function Fc(Be, nt, Rt) { + return Bi( + WO(Hl(Be, nt, Rt), $), + va(Be) + ); + } + function Hl(Be, nt, Rt) { + if (Rt) + return _o(Be, nt, Rt); + let pr = Z?.get(Be.path); + return pr || (Z ?? (Z = /* @__PURE__ */ new Map())).set( + Be.path, + pr = _o(Be, nt) + ), pr; + } + function _o(Be, nt, Rt) { + return yc(() => { + if (a6(Be, $, Lt)) + return Ge; + const pr = so(); + E.assert(!!Be.bindDiagnostics); + const Or = Be.scriptKind === 1 || Be.scriptKind === 2, dn = AD(Be, $.checkJs), Ir = Or && d4(Be, $); + let Vr = Be.bindDiagnostics, hi = pr.getDiagnostics(Be, nt, Rt); + return dn && (Vr = kn(Vr, (rs) => Ave.has(rs.code)), hi = kn(hi, (rs) => Ave.has(rs.code))), ge( + Be, + !dn, + !!Rt, + Vr, + hi, + Ir ? Be.jsDocDiagnostics : void 0 + ); + }); + } + function ge(Be, nt, Rt, ...pr) { + var Or; + const dn = Ip(pr); + if (!nt || !((Or = Be.commentDirectives) != null && Or.length)) + return dn; + const { diagnostics: Ir, directives: Vr } = H(Be, Be.commentDirectives, dn); + if (Rt) + return Ir; + for (const hi of Vr.getUnusedExpectations()) + Ir.push(lK(Be, hi.range, p.Unused_ts_expect_error_directive)); + return Ir; + } + function H(Be, nt, Rt) { + const pr = XZ(Be, nt); + return { diagnostics: Rt.filter((dn) => Ft(dn, pr) === -1), directives: pr }; + } + function tt(Be, nt) { + return yc(() => so().getSuggestionDiagnostics(Be, nt)); + } + function Ft(Be, nt) { + const { file: Rt, start: pr } = Be; + if (!Rt) + return -1; + const Or = kg(Rt); + let dn = CC(Or, pr).line - 1; + for (; dn >= 0; ) { + if (nt.markUsed(dn)) + return dn; + const Ir = Rt.text.slice(Or[dn], Or[dn + 1]).trim(); + if (Ir !== "" && !/^\s*\/\/.*$/.test(Ir)) + return -1; + dn--; + } + return -1; + } + function Kt(Be) { + return yc(() => { + const nt = []; + return Rt(Be, Be), Kx(Be, Rt, pr), nt; + function Rt(Vr, hi) { + switch (hi.kind) { + case 170: + case 173: + case 175: + if (hi.questionToken === Vr) + return nt.push(Ir(Vr, p.The_0_modifier_can_only_be_used_in_TypeScript_files, "?")), "skip"; + // falls through + case 174: + case 177: + case 178: + case 179: + case 219: + case 263: + case 220: + case 261: + if (hi.type === Vr) + return nt.push(Ir(Vr, p.Type_annotations_can_only_be_used_in_TypeScript_files)), "skip"; + } + switch (Vr.kind) { + case 274: + if (Vr.isTypeOnly) + return nt.push(Ir(hi, p._0_declarations_can_only_be_used_in_TypeScript_files, "import type")), "skip"; + break; + case 279: + if (Vr.isTypeOnly) + return nt.push(Ir(Vr, p._0_declarations_can_only_be_used_in_TypeScript_files, "export type")), "skip"; + break; + case 277: + case 282: + if (Vr.isTypeOnly) + return nt.push(Ir(Vr, p._0_declarations_can_only_be_used_in_TypeScript_files, Xu(Vr) ? "import...type" : "export...type")), "skip"; + break; + case 272: + return nt.push(Ir(Vr, p.import_can_only_be_used_in_TypeScript_files)), "skip"; + case 278: + if (Vr.isExportEquals) + return nt.push(Ir(Vr, p.export_can_only_be_used_in_TypeScript_files)), "skip"; + break; + case 299: + if (Vr.token === 119) + return nt.push(Ir(Vr, p.implements_clauses_can_only_be_used_in_TypeScript_files)), "skip"; + break; + case 265: + const Zn = qs( + 120 + /* InterfaceKeyword */ + ); + return E.assertIsDefined(Zn), nt.push(Ir(Vr, p._0_declarations_can_only_be_used_in_TypeScript_files, Zn)), "skip"; + case 268: + const ns = Vr.flags & 32 ? qs( + 145 + /* NamespaceKeyword */ + ) : qs( + 144 + /* ModuleKeyword */ + ); + return E.assertIsDefined(ns), nt.push(Ir(Vr, p._0_declarations_can_only_be_used_in_TypeScript_files, ns)), "skip"; + case 266: + return nt.push(Ir(Vr, p.Type_aliases_can_only_be_used_in_TypeScript_files)), "skip"; + case 177: + case 175: + case 263: + return Vr.body ? void 0 : (nt.push(Ir(Vr, p.Signature_declarations_can_only_be_used_in_TypeScript_files)), "skip"); + case 267: + const Pi = E.checkDefined(qs( + 94 + /* EnumKeyword */ + )); + return nt.push(Ir(Vr, p._0_declarations_can_only_be_used_in_TypeScript_files, Pi)), "skip"; + case 236: + return nt.push(Ir(Vr, p.Non_null_assertions_can_only_be_used_in_TypeScript_files)), "skip"; + case 235: + return nt.push(Ir(Vr.type, p.Type_assertion_expressions_can_only_be_used_in_TypeScript_files)), "skip"; + case 239: + return nt.push(Ir(Vr.type, p.Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files)), "skip"; + case 217: + E.fail(); + } + } + function pr(Vr, hi) { + if (jz(hi)) { + const rs = Nn(hi.modifiers, ul); + rs && nt.push(Ir(rs, p.Decorators_are_not_valid_here)); + } else if (e2(hi) && hi.modifiers) { + const rs = oc(hi.modifiers, ul); + if (rs >= 0) { + if (Ii(hi) && !$.experimentalDecorators) + nt.push(Ir(hi.modifiers[rs], p.Decorators_are_not_valid_here)); + else if (tl(hi)) { + const Zn = oc(hi.modifiers, zx); + if (Zn >= 0) { + const ns = oc(hi.modifiers, kF); + if (rs > Zn && ns >= 0 && rs < ns) + nt.push(Ir(hi.modifiers[rs], p.Decorators_are_not_valid_here)); + else if (Zn >= 0 && rs < Zn) { + const Pi = oc(hi.modifiers, ul, Zn); + Pi >= 0 && nt.push(zs( + Ir(hi.modifiers[Pi], p.Decorators_may_not_appear_after_export_or_export_default_if_they_also_appear_before_export), + Ir(hi.modifiers[rs], p.Decorator_used_before_export_here) + )); + } + } + } + } + } + switch (hi.kind) { + case 264: + case 232: + case 175: + case 177: + case 178: + case 179: + case 219: + case 263: + case 220: + if (Vr === hi.typeParameters) + return nt.push(dn(Vr, p.Type_parameter_declarations_can_only_be_used_in_TypeScript_files)), "skip"; + // falls through + case 244: + if (Vr === hi.modifiers) + return Or( + hi.modifiers, + hi.kind === 244 + /* VariableStatement */ + ), "skip"; + break; + case 173: + if (Vr === hi.modifiers) { + for (const rs of Vr) + Zs(rs) && rs.kind !== 126 && rs.kind !== 129 && nt.push(Ir(rs, p.The_0_modifier_can_only_be_used_in_TypeScript_files, qs(rs.kind))); + return "skip"; + } + break; + case 170: + if (Vr === hi.modifiers && ot(Vr, Zs)) + return nt.push(dn(Vr, p.Parameter_modifiers_can_only_be_used_in_TypeScript_files)), "skip"; + break; + case 214: + case 215: + case 234: + case 286: + case 287: + case 216: + if (Vr === hi.typeArguments) + return nt.push(dn(Vr, p.Type_arguments_can_only_be_used_in_TypeScript_files)), "skip"; + break; + } + } + function Or(Vr, hi) { + for (const rs of Vr) + switch (rs.kind) { + case 87: + if (hi) + continue; + // to report error, + // falls through + case 125: + case 123: + case 124: + case 148: + case 138: + case 128: + case 164: + case 103: + case 147: + nt.push(Ir(rs, p.The_0_modifier_can_only_be_used_in_TypeScript_files, qs(rs.kind))); + break; + // These are all legal modifiers. + case 126: + case 95: + case 90: + case 129: + } + } + function dn(Vr, hi, ...rs) { + const Zn = Vr.pos; + return ll(Be, Zn, Vr.end - Zn, hi, ...rs); + } + function Ir(Vr, hi, ...rs) { + return sp(Be, Vr, hi, ...rs); + } + }); + } + function Hr(Be, nt) { + let Rt = pe?.get(Be.path); + return Rt || (pe ?? (pe = /* @__PURE__ */ new Map())).set( + Be.path, + Rt = Vn(Be, nt) + ), Rt; + } + function Vn(Be, nt) { + return yc(() => { + const Rt = so().getEmitResolver(Be, nt); + return pie(Xt(Ha), Rt, Be) || Ge; + }); + } + function ln(Be, nt) { + return Be.isDeclarationFile ? Ge : Hr(Be, nt); + } + function kr() { + return DC(Bi( + Te.getCombinedDiagnostics(Lt).getGlobalDiagnostics(), + Li() + )); + } + function Li() { + if (!$.configFile) return Ge; + let Be = Te.getCombinedDiagnostics(Lt).getDiagnostics($.configFile.fileName); + return sc((nt) => { + Be = Bi(Be, Te.getCombinedDiagnostics(Lt).getDiagnostics(nt.sourceFile.fileName)); + }), Be; + } + function Yi() { + return U.length ? DC(so().getGlobalDiagnostics().slice()) : Ge; + } + function no() { + return W || Ge; + } + function ra(Be, nt, Rt, pr) { + Ef( + Hs(Be), + nt, + Rt, + /*packageId*/ + void 0, + pr + ); + } + function Eo(Be, nt) { + return Be.fileName === nt.fileName; + } + function $c(Be, nt) { + return Be.kind === 80 ? nt.kind === 80 && Be.escapedText === nt.escapedText : nt.kind === 11 && Be.text === nt.text; + } + function Jc(Be, nt) { + const Rt = N.createStringLiteral(Be), pr = N.createImportDeclaration( + /*modifiers*/ + void 0, + /*importClause*/ + void 0, + Rt + ); + return bS( + pr, + 2 + /* NeverApplyImportHelper */ + ), za(Rt, pr), za(pr, nt), Rt.flags &= -17, pr.flags &= -17, Rt; + } + function vo(Be) { + if (Be.imports) + return; + const nt = n_(Be), Rt = fl(Be); + let pr, Or, dn; + if (nt || !Be.isDeclarationFile && (zp($) || fl(Be))) { + $.importHelpers && (pr = [Jc(Py, Be)]); + const Vr = $5(yN($, Be), $); + Vr && (pr || (pr = [])).push(Jc(Vr, Be)); + } + for (const Vr of Be.statements) + Ir( + Vr, + /*inAmbientModule*/ + !1 + ); + (Be.flags & 4194304 || nt) && dF( + Be, + /*includeTypeSpaceImports*/ + !0, + /*requireStringLiteralLikeArgument*/ + !0, + (Vr, hi) => { + ev( + Vr, + /*incremental*/ + !1 + ), pr = Er(pr, hi); + } + ), Be.imports = pr || Ge, Be.moduleAugmentations = Or || Ge, Be.ambientModuleNames = dn || Ge; + return; + function Ir(Vr, hi) { + if (T3(Vr)) { + const rs = hx(Vr); + rs && ca(rs) && rs.text && (!hi || !Dl(rs.text)) && (ev( + Vr, + /*incremental*/ + !1 + ), pr = Er(pr, rs), !bs && Bt === 0 && !Be.isDeclarationFile && (Ui(rs.text, "node:") && !pF.has(rs.text) ? bs = !0 : bs === void 0 && ste.has(rs.text) && (bs = !1))); + } else if (jc(Vr) && Vu(Vr) && (hi || Gn( + Vr, + 128 + /* Ambient */ + ) || Be.isDeclarationFile)) { + Vr.name.parent = Vr; + const rs = op(Vr.name); + if (Rt || hi && !Dl(rs)) + (Or || (Or = [])).push(Vr.name); + else if (!hi) { + Be.isDeclarationFile && (dn || (dn = [])).push(rs); + const Zn = Vr.body; + if (Zn) + for (const ns of Zn.statements) + Ir( + ns, + /*inAmbientModule*/ + !0 + ); + } + } + } + } + function ic(Be) { + var nt; + const Rt = QJ(Be), pr = Rt && ((nt = ne?.get(Rt)) == null ? void 0 : nt.actual); + return pr !== void 0 ? Co(pr) : void 0; + } + function Bd(Be, nt) { + return au(uU(nt.fileName, Be.fileName), Co); + } + function au(Be, nt, Rt, pr) { + if (xC(Be)) { + const Or = st.getCanonicalFileName(Be); + if (!$.allowNonTsExtensions && !lr(Ip(fi), (Ir) => Xo(Or, Ir))) { + Rt && (Bg(Or) ? Rt(p.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option, Be) : Rt(p.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1, Be, "'" + Ip(ai).join("', '") + "'")); + return; + } + const dn = nt(Be); + if (Rt) + if (dn) + yv(pr) && Or === st.getCanonicalFileName(ta(pr.file).fileName) && Rt(p.A_file_cannot_have_a_reference_to_itself); + else { + const Ir = Po(Be); + Ir?.outputDts ? Rt(p.Output_file_0_has_not_been_built_from_source_file_1, Ir.outputDts, Be) : Rt(p.File_0_not_found, Be); + } + return dn; + } else { + const Or = $.allowNonTsExtensions && nt(Be); + if (Or) return Or; + if (Rt && $.allowNonTsExtensions) { + Rt(p.File_0_not_found, Be); + return; + } + const dn = lr(ai[0], (Ir) => nt(Be + Ir)); + return Rt && !dn && Rt(p.Could_not_resolve_the_path_0_with_the_extensions_Colon_1, Be, "'" + Ip(ai).join("', '") + "'"), dn; + } + } + function Ef(Be, nt, Rt, pr, Or) { + au( + Be, + (dn) => Mr(dn, nt, Rt, Or, pr), + // TODO: GH#18217 + (dn, ...Ir) => zr( + /*file*/ + void 0, + Or, + dn, + Ir + ), + Or + ); + } + function P_(Be, nt) { + return Ef( + Be, + /*isDefaultLib*/ + !1, + /*ignoreNoDefaultLib*/ + !1, + /*packageId*/ + void 0, + nt + ); + } + function Ie(Be, nt, Rt) { + !yv(Rt) && ot(Te.getFileReasons().get(nt.path), yv) ? zr(nt, Rt, p.Already_included_file_name_0_differs_from_file_name_1_only_in_casing, [nt.fileName, Be]) : zr(nt, Rt, p.File_name_0_differs_from_already_included_file_name_1_only_in_casing, [Be, nt.fileName]); + } + function Ot(Be, nt, Rt, pr, Or, dn, Ir) { + var Vr; + const hi = fv.createRedirectedSourceFile({ redirectTarget: Be, unredirected: nt }); + return hi.fileName = Rt, hi.path = pr, hi.resolvedPath = Or, hi.originalFileName = dn, hi.packageJsonLocations = (Vr = Ir.packageJsonLocations) != null && Vr.length ? Ir.packageJsonLocations : void 0, hi.packageJsonScope = Ir.packageJsonScope, Nr.set(pr, Bt > 0), hi; + } + function Mr(Be, nt, Rt, pr, Or) { + var dn, Ir; + (dn = on) == null || dn.push(on.Phase.Program, "findSourceFile", { + fileName: Be, + isDefaultLib: nt || void 0, + fileIncludeKind: rj[pr.kind] + }); + const Vr = Da(Be, nt, Rt, pr, Or); + return (Ir = on) == null || Ir.pop(), Vr; + } + function Gi(Be, nt, Rt, pr) { + const Or = JO(Qi(Be, Mn), nt?.getPackageJsonInfoCache(), Rt, pr), dn = da(pr), Ir = pN(pr); + return typeof Or == "object" ? { ...Or, languageVersion: dn, setExternalModuleIndicator: Ir, jsDocParsingMode: Rt.jsDocParsingMode } : { languageVersion: dn, impliedNodeFormat: Or, setExternalModuleIndicator: Ir, jsDocParsingMode: Rt.jsDocParsingMode }; + } + function Da(Be, nt, Rt, pr, Or) { + var dn, Ir; + const Vr = Nt(Be); + if (Ke) { + let Pi = vc(Vr); + if (!Pi && st.realpath && $.preserveSymlinks && Il(Be) && Be.includes(qg)) { + const Wo = Nt(st.realpath(Be)); + Wo !== Vr && (Pi = vc(Wo)); + } + if (Pi?.source) { + const Wo = Mr(Pi.source, nt, Rt, pr, Or); + return Wo && ma( + Wo, + Vr, + Be, + /*redirectedPath*/ + void 0 + ), Wo; + } + } + const hi = Be; + if (Xe.has(Vr)) { + const Pi = Xe.get(Vr), Wo = wa( + Pi || void 0, + pr, + /*checkExisting*/ + !0 + ); + if (Pi && Wo && $.forceConsistentCasingInFileNames !== !1) { + const A_ = Pi.fileName; + Nt(A_) !== Nt(Be) && (Be = ((dn = Po(Be)) == null ? void 0 : dn.outputDts) || Be); + const $l = bj(A_, Mn), Qp = bj(Be, Mn); + $l !== Qp && Ie(Be, Pi, pr); + } + return Pi && Nr.get(Pi.path) && Bt === 0 ? (Nr.set(Pi.path, !1), $.noResolve || (Ol(Pi, nt), pf(Pi)), $.noLib || N_(Pi), tr.set(Pi.path, !1), Jd(Pi)) : Pi && tr.get(Pi.path) && Bt < St && (tr.set(Pi.path, !1), Jd(Pi)), Pi || void 0; + } + let rs; + if (!Ke) { + const Pi = Po(Be); + if (Pi?.outputDts) { + if (Pi.resolvedRef.commandLine.options.outFile) + return; + Be = Pi.outputDts, rs = Nt(Pi.outputDts); + } + } + const Zn = Gi(Be, ft, st, $), ns = st.getSourceFile( + Be, + Zn, + (Pi) => zr( + /*file*/ + void 0, + pr, + p.Cannot_read_file_0_Colon_1, + [Be, Pi] + ), + Ct + ); + if (Or) { + const Pi = U1(Or), Wo = Ds.get(Pi); + if (Wo) { + const A_ = Ot(Wo, ns, Be, Vr, Nt(Be), hi, Zn); + return yr.add(Wo.path, Be), ma(A_, Vr, Be, rs), wa( + A_, + pr, + /*checkExisting*/ + !1 + ), Ks.set(Vr, z7(Or)), fe.push(A_), A_; + } else ns && (Ds.set(Pi, ns), Ks.set(Vr, z7(Or))); + } + if (ma(ns, Vr, Be, rs), ns) { + if (Nr.set(Vr, Bt > 0), ns.fileName = Be, ns.path = Vr, ns.resolvedPath = Nt(Be), ns.originalFileName = hi, ns.packageJsonLocations = (Ir = Zn.packageJsonLocations) != null && Ir.length ? Zn.packageJsonLocations : void 0, ns.packageJsonScope = Zn.packageJsonScope, wa( + ns, + pr, + /*checkExisting*/ + !1 + ), st.useCaseSensitiveFileNames()) { + const Pi = my(Vr), Wo = re.get(Pi); + Wo ? Ie(Be, Wo, pr) : re.set(Pi, ns); + } + Jr = Jr || ns.hasNoDefaultLib && !Rt, $.noResolve || (Ol(ns, nt), pf(ns)), $.noLib || N_(ns), Jd(ns), nt ? ce.push(ns) : fe.push(ns), (me ?? (me = /* @__PURE__ */ new Set())).add(ns.path); + } + return ns; + } + function wa(Be, nt, Rt) { + return Be && (!Rt || !yv(nt) || !me?.has(nt.file)) ? (Te.getFileReasons().add(Be.path, nt), !0) : !1; + } + function ma(Be, nt, Rt, pr) { + pr ? (il(Rt, pr, Be), il(Rt, nt, Be || !1)) : il(Rt, nt, Be); + } + function il(Be, nt, Rt) { + Xe.set(nt, Rt), Rt !== void 0 ? Et.delete(nt) : Et.set(nt, Be); + } + function Po(Be) { + return Ae?.get(Nt(Be)); + } + function sc(Be) { + return YJ(it, Be); + } + function vc(Be) { + return $e?.get(Be); + } + function Df(Be) { + return Ke && !!Po(Be); + } + function Gl(Be) { + if (Y) + return Y.get(Be) || void 0; + } + function Ol(Be, nt) { + lr(Be.referencedFiles, (Rt, pr) => { + Ef( + uU(Rt.fileName, Be.fileName), + nt, + /*ignoreNoDefaultLib*/ + !1, + /*packageId*/ + void 0, + { kind: 4, file: Be.path, index: pr } + ); + }); + } + function pf(Be) { + const nt = Be.typeReferenceDirectives; + if (!nt.length) return; + const Rt = Ce?.get(Be.path) || kt(nt, Be), pr = N6(); + (Ee ?? (Ee = /* @__PURE__ */ new Map())).set(Be.path, pr); + for (let Or = 0; Or < nt.length; Or++) { + const dn = Be.typeReferenceDirectives[Or], Ir = Rt[Or], Vr = dn.fileName, hi = s1(dn, Be); + pr.set(Vr, hi, Ir), hp(Vr, hi, Ir, { kind: 5, file: Be.path, index: Or }); + } + } + function Qu(Be) { + var nt; + return ((nt = Pr(Be)) == null ? void 0 : nt.commandLine.options) || $; + } + function hp(Be, nt, Rt, pr) { + var Or, dn; + (Or = on) == null || Or.push(on.Phase.Program, "processTypeReferenceDirective", { directive: Be, hasResolved: !!Rt.resolvedTypeReferenceDirective, refKind: pr.kind, refPath: yv(pr) ? pr.file : void 0 }), ig(Be, nt, Rt, pr), (dn = on) == null || dn.pop(); + } + function ig(Be, nt, Rt, pr) { + at(Rt); + const { resolvedTypeReferenceDirective: Or } = Rt; + Or ? (Or.isExternalLibraryImport && Bt++, Ef( + Or.resolvedFileName, + /*isDefaultLib*/ + !1, + /*ignoreNoDefaultLib*/ + !1, + Or.packageId, + pr + ), Or.isExternalLibraryImport && Bt--) : zr( + /*file*/ + void 0, + pr, + p.Cannot_find_type_definition_file_for_0, + [Be] + ); + } + function Gg(Be) { + const nt = ne?.get(Be); + if (nt) return nt.actual; + const Rt = $g(Be); + return (ne ?? (ne = /* @__PURE__ */ new Map())).set(Be, Rt), Rt.actual; + } + function $g(Be) { + var nt, Rt, pr, Or, dn; + const Ir = Se?.get(Be); + if (Ir) return Ir; + if ($.libReplacement === !1) { + const ns = { + resolution: { + resolvedModule: void 0 + }, + actual: On(Ji, Be) + }; + return (Se ?? (Se = /* @__PURE__ */ new Map())).set(Be, ns), ns; + } + if (qe !== 0 && ae && !Un(Be)) { + const ns = (nt = ae.resolvedLibReferences) == null ? void 0 : nt.get(Be); + if (ns) { + if (ns.resolution && Xy($, st)) { + const Pi = yU(Be), Wo = BO($, Mn, Be); + ts( + st, + ns.resolution.resolvedModule ? ns.resolution.resolvedModule.packageId ? p.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : p.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : p.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved, + Pi, + Qi(Wo, Mn), + (Rt = ns.resolution.resolvedModule) == null ? void 0 : Rt.resolvedFileName, + ((pr = ns.resolution.resolvedModule) == null ? void 0 : pr.packageId) && U1(ns.resolution.resolvedModule.packageId) + ); + } + return (Se ?? (Se = /* @__PURE__ */ new Map())).set(Be, ns), ns; + } + } + const Vr = yU(Be), hi = BO($, Mn, Be); + (Or = on) == null || Or.push(on.Phase.Program, "resolveLibrary", { resolveFrom: hi }), Ko("beforeResolveLibrary"); + const rs = ki(Vr, hi, $, Be); + Ko("afterResolveLibrary"), rp("ResolveLibrary", "beforeResolveLibrary", "afterResolveLibrary"), (dn = on) == null || dn.pop(); + const Zn = { + resolution: rs, + actual: rs.resolvedModule ? rs.resolvedModule.resolvedFileName : On(Ji, Be) + }; + return (Se ?? (Se = /* @__PURE__ */ new Map())).set(Be, Zn), Zn; + } + function N_(Be) { + lr(Be.libReferenceDirectives, (nt, Rt) => { + const pr = QJ(nt); + pr ? ra( + Gg(pr), + /*isDefaultLib*/ + !0, + /*ignoreNoDefaultLib*/ + !0, + { kind: 7, file: Be.path, index: Rt } + ) : Te.addFileProcessingDiagnostic({ + kind: 0, + reason: { kind: 7, file: Be.path, index: Rt } + }); + }); + } + function Sl(Be) { + return st.getCanonicalFileName(Be); + } + function Jd(Be) { + if (vo(Be), Be.imports.length || Be.moduleAugmentations.length) { + const nt = Fve(Be), Rt = Ne?.get(Be.path) || nr(nt, Be); + E.assert(Rt.length === nt.length); + const pr = Qu(Be), Or = N6(); + (ie ?? (ie = /* @__PURE__ */ new Map())).set(Be.path, Or); + for (let dn = 0; dn < nt.length; dn++) { + const Ir = Rt[dn].resolvedModule, Vr = nt[dn].text, hi = MO(Be, nt[dn], pr); + if (Or.set(Vr, hi, Rt[dn]), wt(Be, Vr, Rt[dn], hi), !Ir) + continue; + const rs = Ir.isExternalLibraryImport, Zn = !f4(Ir.extension) && !Po(Ir.resolvedFileName), ns = rs && Zn && (!Ir.originalPath || Yy(Ir.resolvedFileName)), Pi = Ir.resolvedFileName; + rs && Bt++; + const Wo = ns && Bt > St, A_ = Pi && !TU(pr, Ir, Be) && !pr.noResolve && dn < Be.imports.length && !Wo && !(Zn && !Jy(pr)) && (an(Be.imports[dn]) || !(Be.imports[dn].flags & 16777216)); + Wo ? tr.set(Be.path, !0) : A_ && Mr( + Pi, + /*isDefaultLib*/ + !1, + /*ignoreNoDefaultLib*/ + !1, + { kind: 3, file: Be.path, index: dn }, + Ir.packageId + ), rs && Bt--; + } + } + } + function Wf(Be, nt) { + let Rt = !0; + const pr = st.getCanonicalFileName(Qi(nt, Mn)); + for (const Or of Be) + Or.isDeclarationFile || st.getCanonicalFileName(Qi(Or.fileName, Mn)).indexOf(pr) !== 0 && (Te.addLazyConfigDiagnostic( + Or, + p.File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files, + Or.fileName, + nt + ), Rt = !1); + return Rt; + } + function Nm(Be) { + Y || (Y = /* @__PURE__ */ new Map()); + const nt = ck(Be), Rt = Nt(nt), pr = Y.get(Rt); + if (pr !== void 0) + return pr || void 0; + let Or, dn; + if (st.getParsedCommandLine) { + if (Or = st.getParsedCommandLine(nt), !Or) { + ma( + /*file*/ + void 0, + Rt, + nt, + /*redirectedPath*/ + void 0 + ), Y.set(Rt, !1); + return; + } + dn = E.checkDefined(Or.options.configFile), E.assert(!dn.path || dn.path === Rt), ma( + dn, + Rt, + nt, + /*redirectedPath*/ + void 0 + ); + } else { + const Vr = Qi(Hn(nt), Mn); + if (dn = st.getSourceFile( + nt, + 100 + /* JSON */ + ), ma( + dn, + Rt, + nt, + /*redirectedPath*/ + void 0 + ), dn === void 0) { + Y.set(Rt, !1); + return; + } + Or = sA( + dn, + Wt, + Vr, + /*existingOptions*/ + void 0, + nt + ); + } + dn.fileName = nt, dn.path = Rt, dn.resolvedPath = Rt, dn.originalFileName = nt; + const Ir = { commandLine: Or, sourceFile: dn }; + if (Y.set(Rt, Ir), $.configFile !== dn) { + Ae ?? (Ae = /* @__PURE__ */ new Map()), $e ?? ($e = /* @__PURE__ */ new Map()); + let Vr; + Or.options.outFile && (Vr = S0( + Or.options.outFile, + ".d.ts" + /* Dts */ + ), $e?.set(Nt(Vr), { resolvedRef: Ir })); + const hi = Uu(() => JS(Ir.commandLine, !st.useCaseSensitiveFileNames())); + Or.fileNames.forEach((rs) => { + const Zn = Nt(rs); + let ns; + !Il(rs) && !Xo( + rs, + ".json" + /* Json */ + ) && (Or.options.outFile ? ns = Vr : (ns = sw(rs, Ir.commandLine, !st.useCaseSensitiveFileNames(), hi), $e.set(Nt(ns), { resolvedRef: Ir, source: rs }))), Ae.set(Zn, { resolvedRef: Ir, outputDts: ns }); + }); + } + return Or.projectReferences && (Ir.references = Or.projectReferences.map(Nm)), Ir; + } + function ee() { + $.strictPropertyInitialization && !du($, "strictNullChecks") && Oe(p.Option_0_cannot_be_specified_without_specifying_option_1, "strictPropertyInitialization", "strictNullChecks"), $.exactOptionalPropertyTypes && !du($, "strictNullChecks") && Oe(p.Option_0_cannot_be_specified_without_specifying_option_1, "exactOptionalPropertyTypes", "strictNullChecks"), ($.isolatedModules || $.verbatimModuleSyntax) && $.outFile && Oe(p.Option_0_cannot_be_specified_with_option_1, "outFile", $.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules"), $.isolatedDeclarations && (Jy($) && Oe(p.Option_0_cannot_be_specified_with_option_1, "allowJs", "isolatedDeclarations"), J_($) || Oe(p.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "isolatedDeclarations", "declaration", "composite")), $.inlineSourceMap && ($.sourceMap && Oe(p.Option_0_cannot_be_specified_with_option_1, "sourceMap", "inlineSourceMap"), $.mapRoot && Oe(p.Option_0_cannot_be_specified_with_option_1, "mapRoot", "inlineSourceMap")), $.composite && ($.declaration === !1 && Oe(p.Composite_projects_may_not_disable_declaration_emit, "declaration"), $.incremental === !1 && Oe(p.Composite_projects_may_not_disable_incremental_compilation, "declaration")); + const Be = $.outFile; + if (!$.tsBuildInfoFile && $.incremental && !Be && !$.configFilePath && Te.addConfigDiagnostic(Yo(p.Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified)), Gt(), jn(), $.composite) { + const Ir = new Set(U.map(Nt)); + for (const Vr of he) + Mb(Vr, Lt) && !Ir.has(Vr.path) && Te.addLazyConfigDiagnostic( + Vr, + p.File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_include_pattern, + Vr.fileName, + $.configFilePath || "" + ); + } + if ($.paths) { + for (const Ir in $.paths) + if (eo($.paths, Ir)) + if (CJ(Ir) || wi( + /*onKey*/ + !0, + Ir, + p.Pattern_0_can_have_at_most_one_Asterisk_character, + Ir + ), as($.paths[Ir])) { + const Vr = $.paths[Ir].length; + Vr === 0 && wi( + /*onKey*/ + !1, + Ir, + p.Substitutions_for_pattern_0_shouldn_t_be_an_empty_array, + Ir + ); + for (let hi = 0; hi < Vr; hi++) { + const rs = $.paths[Ir][hi], Zn = typeof rs; + Zn === "string" ? (CJ(rs) || ni(Ir, hi, p.Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character, rs, Ir), !$.baseUrl && !xf(rs) && !_D(rs) && ni(Ir, hi, p.Non_relative_paths_are_not_allowed_when_baseUrl_is_not_set_Did_you_forget_a_leading_Slash)) : ni(Ir, hi, p.Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2, rs, Ir, Zn); + } + } else + wi( + /*onKey*/ + !1, + Ir, + p.Substitutions_for_pattern_0_should_be_an_array, + Ir + ); + } + !$.sourceMap && !$.inlineSourceMap && ($.inlineSources && Oe(p.Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided, "inlineSources"), $.sourceRoot && Oe(p.Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided, "sourceRoot")), $.mapRoot && !($.sourceMap || $.declarationMap) && Oe(p.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "mapRoot", "sourceMap", "declarationMap"), $.declarationDir && (J_($) || Oe(p.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "declarationDir", "declaration", "composite"), Be && Oe(p.Option_0_cannot_be_specified_with_option_1, "declarationDir", "outFile")), $.declarationMap && !J_($) && Oe(p.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "declarationMap", "declaration", "composite"), $.lib && $.noLib && Oe(p.Option_0_cannot_be_specified_with_option_1, "lib", "noLib"); + const nt = da($), Rt = Nn(he, (Ir) => fl(Ir) && !Ir.isDeclarationFile); + if ($.isolatedModules || $.verbatimModuleSyntax) + $.module === 0 && nt < 2 && $.isolatedModules && Oe(p.Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher, "isolatedModules", "target"), $.preserveConstEnums === !1 && Oe(p.Option_preserveConstEnums_cannot_be_disabled_when_0_is_enabled, $.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules", "preserveConstEnums"); + else if (Rt && nt < 2 && $.module === 0) { + const Ir = aS(Rt, typeof Rt.externalModuleIndicator == "boolean" ? Rt : Rt.externalModuleIndicator); + Te.addConfigDiagnostic(ll(Rt, Ir.start, Ir.length, p.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none)); + } + if (Be && !$.emitDeclarationOnly) { + if ($.module && !($.module === 2 || $.module === 4)) + Oe(p.Only_amd_and_system_modules_are_supported_alongside_0, "outFile", "module"); + else if ($.module === void 0 && Rt) { + const Ir = aS(Rt, typeof Rt.externalModuleIndicator == "boolean" ? Rt : Rt.externalModuleIndicator); + Te.addConfigDiagnostic(ll(Rt, Ir.start, Ir.length, p.Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system, "outFile")); + } + } + if (zb($) && (Pu($) === 1 ? Oe(p.Option_resolveJsonModule_cannot_be_specified_when_moduleResolution_is_set_to_classic, "resolveJsonModule") : V5($) || Oe(p.Option_resolveJsonModule_cannot_be_specified_when_module_is_set_to_none_system_or_umd, "resolveJsonModule", "module")), $.outDir || // there is --outDir specified + $.rootDir || // there is --rootDir specified + $.sourceRoot || // there is --sourceRoot specified + $.mapRoot || // there is --mapRoot specified + J_($) && $.declarationDir) { + const Ir = Jt(); + $.outDir && Ir === "" && he.some((Vr) => kd(Vr.fileName) > 1) && Oe(p.Cannot_find_the_common_subdirectory_path_for_the_input_files, "outDir"); + } + $.checkJs && !Jy($) && Oe(p.Option_0_cannot_be_specified_without_specifying_option_1, "checkJs", "allowJs"), $.emitDeclarationOnly && (J_($) || Oe(p.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "emitDeclarationOnly", "declaration", "composite")), $.emitDecoratorMetadata && !$.experimentalDecorators && Oe(p.Option_0_cannot_be_specified_without_specifying_option_1, "emitDecoratorMetadata", "experimentalDecorators"), $.jsxFactory ? ($.reactNamespace && Oe(p.Option_0_cannot_be_specified_with_option_1, "reactNamespace", "jsxFactory"), ($.jsx === 4 || $.jsx === 5) && Oe(p.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxFactory", eA.get("" + $.jsx)), tk($.jsxFactory, nt) || xt("jsxFactory", p.Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name, $.jsxFactory)) : $.reactNamespace && !R_($.reactNamespace, nt) && xt("reactNamespace", p.Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier, $.reactNamespace), $.jsxFragmentFactory && ($.jsxFactory || Oe(p.Option_0_cannot_be_specified_without_specifying_option_1, "jsxFragmentFactory", "jsxFactory"), ($.jsx === 4 || $.jsx === 5) && Oe(p.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxFragmentFactory", eA.get("" + $.jsx)), tk($.jsxFragmentFactory, nt) || xt("jsxFragmentFactory", p.Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name, $.jsxFragmentFactory)), $.reactNamespace && ($.jsx === 4 || $.jsx === 5) && Oe(p.Option_0_cannot_be_specified_when_option_jsx_is_1, "reactNamespace", eA.get("" + $.jsx)), $.jsxImportSource && $.jsx === 2 && Oe(p.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxImportSource", eA.get("" + $.jsx)); + const pr = Hu($); + $.verbatimModuleSyntax && (pr === 2 || pr === 3 || pr === 4) && Oe(p.Option_verbatimModuleSyntax_cannot_be_used_when_module_is_set_to_UMD_AMD_or_System, "verbatimModuleSyntax"), $.allowImportingTsExtensions && !($.noEmit || $.emitDeclarationOnly || $.rewriteRelativeImportExtensions) && xt("allowImportingTsExtensions", p.Option_allowImportingTsExtensions_can_only_be_used_when_either_noEmit_or_emitDeclarationOnly_is_set); + const Or = Pu($); + if ($.resolvePackageJsonExports && !i6(Or) && Oe(p.Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler, "resolvePackageJsonExports"), $.resolvePackageJsonImports && !i6(Or) && Oe(p.Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler, "resolvePackageJsonImports"), $.customConditions && !i6(Or) && Oe(p.Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler, "customConditions"), Or === 100 && !hN(pr) && pr !== 200 && xt("moduleResolution", p.Option_0_can_only_be_used_when_module_is_set_to_preserve_or_to_es2015_or_later, "bundler"), TC[pr] && 100 <= pr && pr <= 199 && !(3 <= Or && Or <= 99)) { + const Ir = TC[pr], Vr = SC[Ir] ? Ir : "Node16"; + xt("moduleResolution", p.Option_moduleResolution_must_be_set_to_0_or_left_unspecified_when_option_module_is_set_to_1, Vr, Ir); + } else if (SC[Or] && 3 <= Or && Or <= 99 && !(100 <= pr && pr <= 199)) { + const Ir = SC[Or]; + xt("module", p.Option_module_must_be_set_to_0_when_option_moduleResolution_is_set_to_1, Ir, Ir); + } + if (!$.noEmit && !$.suppressOutputPathCheck) { + const Ir = Xt(), Vr = /* @__PURE__ */ new Set(); + ZW(Ir, (hi) => { + $.emitDeclarationOnly || dn(hi.jsFilePath, Vr), dn(hi.declarationFilePath, Vr); + }); + } + function dn(Ir, Vr) { + if (Ir) { + const hi = Nt(Ir); + if (Xe.has(hi)) { + let Zn; + $.configFilePath || (Zn = Ts( + /*details*/ + void 0, + p.Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript_files_Learn_more_at_https_Colon_Slash_Slashaka_ms_Slashtsconfig + )), Zn = Ts(Zn, p.Cannot_write_file_0_because_it_would_overwrite_input_file, Ir), na(Ir, z5(Zn)); + } + const rs = st.useCaseSensitiveFileNames() ? hi : my(hi); + Vr.has(rs) ? na(Ir, Yo(p.Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files, Ir)) : Vr.add(rs); + } + } + } + function et() { + const Be = $.ignoreDeprecations; + if (Be) { + if (Be === "5.0") + return new xd(Be); + se(); + } + return xd.zero; + } + function Ut(Be, nt, Rt, pr) { + const Or = new xd(Be), dn = new xd(nt), Ir = new xd(K || q2), Vr = et(), hi = dn.compareTo(Ir) !== 1, rs = !hi && Vr.compareTo(Or) === -1; + (hi || rs) && pr((Zn, ns, Pi) => { + hi ? ns === void 0 ? Rt(Zn, ns, Pi, p.Option_0_has_been_removed_Please_remove_it_from_your_configuration, Zn) : Rt(Zn, ns, Pi, p.Option_0_1_has_been_removed_Please_remove_it_from_your_configuration, Zn, ns) : ns === void 0 ? Rt(Zn, ns, Pi, p.Option_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_compilerOption_ignoreDeprecations_Colon_2_to_silence_this_error, Zn, nt, Be) : Rt(Zn, ns, Pi, p.Option_0_1_is_deprecated_and_will_stop_functioning_in_TypeScript_2_Specify_compilerOption_ignoreDeprecations_Colon_3_to_silence_this_error, Zn, ns, nt, Be); + }); + } + function Gt() { + function Be(nt, Rt, pr, Or, ...dn) { + if (pr) { + const Ir = Ts( + /*details*/ + void 0, + p.Use_0_instead, + pr + ), Vr = Ts(Ir, Or, ...dn); + $i( + /*onKey*/ + !Rt, + nt, + /*option2*/ + void 0, + Vr + ); + } else + $i( + /*onKey*/ + !Rt, + nt, + /*option2*/ + void 0, + Or, + ...dn + ); + } + Ut("5.0", "5.5", Be, (nt) => { + $.target === 0 && nt("target", "ES3"), $.noImplicitUseStrict && nt("noImplicitUseStrict"), $.keyofStringsOnly && nt("keyofStringsOnly"), $.suppressExcessPropertyErrors && nt("suppressExcessPropertyErrors"), $.suppressImplicitAnyIndexErrors && nt("suppressImplicitAnyIndexErrors"), $.noStrictGenericChecks && nt("noStrictGenericChecks"), $.charset && nt("charset"), $.out && nt( + "out", + /*value*/ + void 0, + "outFile" + ), $.importsNotUsedAsValues && nt( + "importsNotUsedAsValues", + /*value*/ + void 0, + "verbatimModuleSyntax" + ), $.preserveValueImports && nt( + "preserveValueImports", + /*value*/ + void 0, + "verbatimModuleSyntax" + ); + }); + } + function Sr(Be, nt, Rt) { + function pr(Or, dn, Ir, Vr, ...hi) { + Tr(nt, Rt, Vr, ...hi); + } + Ut("5.0", "5.5", pr, (Or) => { + Be.prepend && Or("prepend"); + }); + } + function zr(Be, nt, Rt, pr) { + Te.addFileProcessingDiagnostic({ + kind: 1, + file: Be && Be.path, + fileProcessingReason: nt, + diagnostic: Rt, + args: pr + }); + } + function jn() { + const Be = $.suppressOutputPathCheck ? void 0 : hv($); + x4( + _e, + it, + (nt, Rt, pr) => { + const Or = (Rt ? Rt.commandLine.projectReferences : _e)[pr], dn = Rt && Rt.sourceFile; + if (Sr(Or, dn, pr), !nt) { + Tr(dn, pr, p.File_0_not_found, Or.path); + return; + } + const Ir = nt.commandLine.options; + (!Ir.composite || Ir.noEmit) && (Rt ? Rt.commandLine.fileNames : U).length && (Ir.composite || Tr(dn, pr, p.Referenced_project_0_must_have_setting_composite_Colon_true, Or.path), Ir.noEmit && Tr(dn, pr, p.Referenced_project_0_may_not_disable_emit, Or.path)), !Rt && Be && Be === hv(Ir) && (Tr(dn, pr, p.Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1, Be, Or.path), pn.set(Nt(Be), !0)); + } + ); + } + function ni(Be, nt, Rt, ...pr) { + let Or = !0; + L((dn) => { + _a(dn.initializer) && zC(dn.initializer, Be, (Ir) => { + const Vr = Ir.initializer; + nu(Vr) && Vr.elements.length > nt && (Te.addConfigDiagnostic(sp($.configFile, Vr.elements[nt], Rt, ...pr)), Or = !1); + }); + }), Or && As(Rt, ...pr); + } + function wi(Be, nt, Rt, ...pr) { + let Or = !0; + L((dn) => { + _a(dn.initializer) && zo( + dn.initializer, + Be, + nt, + /*key2*/ + void 0, + Rt, + ...pr + ) && (Or = !1); + }), Or && As(Rt, ...pr); + } + function L(Be) { + return KJ(Zi(), "paths", Be); + } + function Oe(Be, nt, Rt, pr) { + $i( + /*onKey*/ + !0, + nt, + Rt, + Be, + nt, + Rt, + pr + ); + } + function xt(Be, nt, ...Rt) { + $i( + /*onKey*/ + !1, + Be, + /*option2*/ + void 0, + nt, + ...Rt + ); + } + function Tr(Be, nt, Rt, ...pr) { + const Or = P3(Be || $.configFile, "references", (dn) => nu(dn.initializer) ? dn.initializer : void 0); + Or && Or.elements.length > nt ? Te.addConfigDiagnostic(sp(Be || $.configFile, Or.elements[nt], Rt, ...pr)) : Te.addConfigDiagnostic(Yo(Rt, ...pr)); + } + function $i(Be, nt, Rt, pr, ...Or) { + const dn = Zi(); + (!dn || !zo(dn, Be, nt, Rt, pr, ...Or)) && As(pr, ...Or); + } + function As(Be, ...nt) { + const Rt = ys(); + Rt ? "messageText" in Be ? Te.addConfigDiagnostic(Fg($.configFile, Rt.name, Be)) : Te.addConfigDiagnostic(sp($.configFile, Rt.name, Be, ...nt)) : "messageText" in Be ? Te.addConfigDiagnostic(z5(Be)) : Te.addConfigDiagnostic(Yo(Be, ...nt)); + } + function Zi() { + if (_i === void 0) { + const Be = ys(); + _i = Be && Bn(Be.initializer, _a) || !1; + } + return _i || void 0; + } + function ys() { + return Je === void 0 && (Je = zC( + MD($.configFile), + "compilerOptions", + go + ) || !1), Je || void 0; + } + function zo(Be, nt, Rt, pr, Or, ...dn) { + let Ir = !1; + return zC(Be, Rt, (Vr) => { + "messageText" in Or ? Te.addConfigDiagnostic(Fg($.configFile, nt ? Vr.name : Vr.initializer, Or)) : Te.addConfigDiagnostic(sp($.configFile, nt ? Vr.name : Vr.initializer, Or, ...dn)), Ir = !0; + }, pr), Ir; + } + function na(Be, nt) { + pn.set(Nt(Be), !0), Te.addConfigDiagnostic(nt); + } + function Ll(Be) { + if ($.noEmit) + return !1; + const nt = Nt(Be); + if (ta(nt)) + return !1; + const Rt = $.outFile; + if (Rt) + return df(nt, Rt) || df( + nt, + Gu(Rt) + ".d.ts" + /* Dts */ + ); + if ($.declarationDir && np($.declarationDir, nt, Mn, !st.useCaseSensitiveFileNames())) + return !0; + if ($.outDir) + return np($.outDir, nt, Mn, !st.useCaseSensitiveFileNames()); + if (xc(nt, s6) || Il(nt)) { + const pr = Gu(nt); + return !!ta( + pr + ".ts" + /* Ts */ + ) || !!ta( + pr + ".tsx" + /* Tsx */ + ); + } + return !1; + } + function df(Be, nt) { + return gh(Be, nt, Mn, !st.useCaseSensitiveFileNames()) === 0; + } + function Uf() { + return st.getSymlinkCache ? st.getSymlinkCache() : (q || (q = EJ(Mn, Sl)), he && !q.hasProcessedResolutions() && q.setSymlinksFromResolutions(M, ye, Ye), q); + } + function yp(Be, nt) { + return MO(Be, nt, Qu(Be)); + } + function jh(Be, nt) { + return wve(Be, nt, Qu(Be)); + } + function M0(Be, nt) { + return yp(Be, PA(Be, nt)); + } + function __(Be) { + return zO(Be, Qu(Be)); + } + function sg(Be) { + return zS(Be, Qu(Be)); + } + function zd(Be) { + return uw(Be, Qu(Be)); + } + function $p(Be) { + return Ive(Be, Qu(Be)); + } + function s1(Be, nt) { + return Be.resolutionMode || __(nt); + } + } + function Ive(e, t) { + const n = Hu(t); + return 100 <= n && n <= 199 || n === 200 ? !1 : uw(e, t) < 5; + } + function uw(e, t) { + return zS(e, t) ?? Hu(t); + } + function zS(e, t) { + var n, i; + const s = Hu(t); + if (100 <= s && s <= 199) + return e.impliedNodeFormat; + if (e.impliedNodeFormat === 1 && (((n = e.packageJsonScope) == null ? void 0 : n.contents.packageJsonContent.type) === "commonjs" || xc(e.fileName, [ + ".cjs", + ".cts" + /* Cts */ + ]))) + return 1; + if (e.impliedNodeFormat === 99 && (((i = e.packageJsonScope) == null ? void 0 : i.contents.packageJsonContent.type) === "module" || xc(e.fileName, [ + ".mjs", + ".mts" + /* Mts */ + ]))) + return 99; + } + function zO(e, t) { + return xJ(t) ? zS(e, t) : void 0; + } + function eBe(e) { + let t; + const n = e.compilerHost.fileExists, i = e.compilerHost.directoryExists, s = e.compilerHost.getDirectories, o = e.compilerHost.realpath; + if (!e.useSourceOfProjectReferenceRedirect) return { onProgramCreateComplete: Ha, fileExists: u }; + e.compilerHost.fileExists = u; + let c; + return i && (c = e.compilerHost.directoryExists = (T) => i.call(e.compilerHost, T) ? (h(T), !0) : e.getResolvedProjectReferences() ? (t || (t = /* @__PURE__ */ new Set(), e.forEachResolvedProjectReference((k) => { + const D = k.commandLine.options.outFile; + if (D) + t.add(Hn(e.toPath(D))); + else { + const P = k.commandLine.options.declarationDir || k.commandLine.options.outDir; + P && t.add(e.toPath(P)); + } + })), S( + T, + /*isFile*/ + !1 + )) : !1), s && (e.compilerHost.getDirectories = (T) => !e.getResolvedProjectReferences() || i && i.call(e.compilerHost, T) ? s.call(e.compilerHost, T) : []), o && (e.compilerHost.realpath = (T) => { + var k; + return ((k = e.getSymlinkCache().getSymlinkedFiles()) == null ? void 0 : k.get(e.toPath(T))) || o.call(e.compilerHost, T); + }), { onProgramCreateComplete: _, fileExists: u, directoryExists: c }; + function _() { + e.compilerHost.fileExists = n, e.compilerHost.directoryExists = i, e.compilerHost.getDirectories = s; + } + function u(T) { + return n.call(e.compilerHost, T) ? !0 : !e.getResolvedProjectReferences() || !Il(T) ? !1 : S( + T, + /*isFile*/ + !0 + ); + } + function g(T) { + const k = e.getRedirectFromOutput(e.toPath(T)); + return k !== void 0 ? gs(k.source) ? n.call(e.compilerHost, k.source) : !0 : void 0; + } + function m(T) { + const k = e.toPath(T), D = `${k}${So}`; + return Ag( + t, + (P) => k === P || // Any parent directory of declaration dir + Ui(P, D) || // Any directory inside declaration dir + Ui(k, `${P}/`) + ); + } + function h(T) { + var k; + if (!e.getResolvedProjectReferences() || y4(T) || !o || !T.includes(qg)) return; + const D = e.getSymlinkCache(), P = gl(e.toPath(T)); + if ((k = D.getSymlinkedDirectories()) != null && k.has(P)) return; + const A = Hs(o.call(e.compilerHost, T)); + let O; + if (A === T || (O = gl(e.toPath(A))) === P) { + D.setSymlinkedDirectory(P, !1); + return; + } + D.setSymlinkedDirectory(T, { + real: gl(A), + realPath: O + }); + } + function S(T, k) { + var D; + const P = k ? g : m, A = P(T); + if (A !== void 0) return A; + const O = e.getSymlinkCache(), F = O.getSymlinkedDirectories(); + if (!F) return !1; + const R = e.toPath(T); + return R.includes(qg) ? k && ((D = O.getSymlinkedFiles()) != null && D.has(R)) ? !0 : MP( + F.entries(), + ([B, U]) => { + if (!U || !Ui(R, B)) return; + const $ = P(R.replace(B, U.realPath)); + if (k && $) { + const W = Qi(T, e.compilerHost.getCurrentDirectory()); + O.setSymlinkedFile( + R, + `${U.real}${W.replace(new RegExp(B, "i"), "")}` + ); + } + return $; + } + ) || !1 : !1; + } + } + var bU = { diagnostics: Ge, sourceMaps: void 0, emittedFiles: void 0, emitSkipped: !0 }; + function SU(e, t, n, i) { + const s = e.getCompilerOptions(); + if (s.noEmit) + return t ? bU : e.emitBuildInfo(n, i); + if (!s.noEmitOnError) return; + let o = [ + ...e.getOptionsDiagnostics(i), + ...e.getSyntacticDiagnostics(t, i), + ...e.getGlobalDiagnostics(i), + ...e.getSemanticDiagnostics(t, i) + ]; + if (o.length === 0 && J_(e.getCompilerOptions()) && (o = e.getDeclarationDiagnostics( + /*sourceFile*/ + void 0, + i + )), !o.length) return; + let c; + if (!t) { + const _ = e.emitBuildInfo(n, i); + _.diagnostics && (o = [...o, ..._.diagnostics]), c = _.emittedFiles; + } + return { diagnostics: o, sourceMaps: void 0, emittedFiles: c, emitSkipped: !0 }; + } + function WO(e, t) { + return kn(e, (n) => !n.skippedOn || !t[n.skippedOn]); + } + function UO(e, t = e) { + return { + fileExists: (n) => t.fileExists(n), + readDirectory(n, i, s, o, c) { + return E.assertIsDefined(t.readDirectory, "'CompilerHost.readDirectory' must be implemented to correctly process 'projectReferences'"), t.readDirectory(n, i, s, o, c); + }, + readFile: (n) => t.readFile(n), + directoryExists: Os(t, t.directoryExists), + getDirectories: Os(t, t.getDirectories), + realpath: Os(t, t.realpath), + useCaseSensitiveFileNames: e.useCaseSensitiveFileNames(), + getCurrentDirectory: () => e.getCurrentDirectory(), + onUnRecoverableConfigFileDiagnostic: e.onUnRecoverableConfigFileDiagnostic || vb, + trace: e.trace ? (n) => e.trace(n) : void 0 + }; + } + function ck(e) { + return YU(e.path); + } + function TU(e, { extension: t }, { isDeclarationFile: n }) { + switch (t) { + case ".ts": + case ".d.ts": + case ".mts": + case ".d.mts": + case ".cts": + case ".d.cts": + return; + case ".tsx": + return i(); + case ".jsx": + return i() || s(); + case ".js": + case ".mjs": + case ".cjs": + return s(); + case ".json": + return o(); + default: + return c(); + } + function i() { + return e.jsx ? void 0 : p.Module_0_was_resolved_to_1_but_jsx_is_not_set; + } + function s() { + return Jy(e) || !du(e, "noImplicitAny") ? void 0 : p.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type; + } + function o() { + return zb(e) ? void 0 : p.Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used; + } + function c() { + return n || e.allowArbitraryExtensions ? void 0 : p.Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set; + } + } + function Fve({ imports: e, moduleAugmentations: t }) { + const n = e.map((i) => i); + for (const i of t) + i.kind === 11 && n.push(i); + return n; + } + function PA({ imports: e, moduleAugmentations: t }, n) { + if (n < e.length) return e[n]; + let i = e.length; + for (const s of t) + if (s.kind === 11) { + if (n === i) return s; + i++; + } + E.fail("should never ask for module name at index higher than possible module name"); + } + function Oie(e) { + let t, n = Fp(), i, s, o, c, _, u; + return { + addConfigDiagnostic(T) { + E.assert(t === void 0, "Cannot modify program diagnostic state after requesting combined diagnostics"), (o ?? (o = ZD())).add(T); + }, + addLazyConfigDiagnostic(T, k, ...D) { + E.assert(t === void 0, "Cannot modify program diagnostic state after requesting combined diagnostics"), (c ?? (c = [])).push({ file: T, diagnostic: k, args: D }); + }, + addFileProcessingDiagnostic(T) { + E.assert(t === void 0, "Cannot modify program diagnostic state after requesting combined diagnostics"), (i ?? (i = [])).push(T); + }, + setCommonSourceDirectory(T) { + s = T; + }, + reuseStateFromOldProgram(T, k) { + n = T.getFileReasons(), i = T.getFileProcessingDiagnostics(), k && (s = T.getCommonSourceDirectory(), o = T.getConfigDiagnostics(), c = T.getLazyConfigDiagnostics()); + }, + getFileProcessingDiagnostics() { + return i; + }, + getFileReasons() { + return n; + }, + getCommonSourceDirectory() { + return s; + }, + getConfigDiagnostics() { + return o; + }, + getLazyConfigDiagnostics() { + return c; + }, + getCombinedDiagnostics(T) { + return t || (t = ZD(), o?.getDiagnostics().forEach((k) => t.add(k)), i?.forEach((k) => { + switch (k.kind) { + case 1: + return t.add( + m( + T, + k.file && T.getSourceFileByPath(k.file), + k.fileProcessingReason, + k.diagnostic, + k.args || Ge + ) + ); + case 0: + return t.add(g(T, k)); + case 2: + return k.diagnostics.forEach((D) => t.add(D)); + default: + E.assertNever(k); + } + }), c?.forEach( + ({ file: k, diagnostic: D, args: P }) => t.add( + m( + T, + k, + /*fileProcessingReason*/ + void 0, + D, + P + ) + ) + ), _ = void 0, u = void 0, t); + } + }; + function g(T, { reason: k }) { + const { file: D, pos: P, end: A } = lw(T, k), O = D.libReferenceDirectives[k.index], F = XJ(O), R = bC(nD(F, "lib."), ".d.ts"), B = Sb(R, HF, go); + return ll( + D, + E.checkDefined(P), + E.checkDefined(A) - P, + B ? p.Cannot_find_lib_definition_for_0_Did_you_mean_1 : p.Cannot_find_lib_definition_for_0, + F, + B + ); + } + function m(T, k, D, P, A) { + let O, F, R, B, U, $; + const W = k && n.get(k.path); + let _e = yv(D) ? D : void 0, K = k && _?.get(k.path); + K ? (K.fileIncludeReasonDetails ? (O = new Set(W), W?.forEach(ce)) : W?.forEach(se), U = K.redirectInfo) : (W?.forEach(se), U = k && BU(k, T.getCompilerOptionsForFile(k))), D && se(D); + const V = O?.size !== W?.length; + _e && O?.size === 1 && (O = void 0), O && K && (K.details && !V ? $ = Ts(K.details, P, ...A ?? Ge) : K.fileIncludeReasonDetails && (V ? fe() ? F = Er(K.fileIncludeReasonDetails.next.slice(0, W.length), F[0]) : F = [...K.fileIncludeReasonDetails.next, F[0]] : fe() ? F = K.fileIncludeReasonDetails.next.slice(0, W.length) : B = K.fileIncludeReasonDetails)), $ || (B || (B = O && Ts(F, p.The_file_is_in_the_program_because_Colon)), $ = Ts( + U ? B ? [B, ...U] : U : B, + P, + ...A || Ge + )), k && (K ? (!K.fileIncludeReasonDetails || !V && B) && (K.fileIncludeReasonDetails = B) : (_ ?? (_ = /* @__PURE__ */ new Map())).set(k.path, K = { fileIncludeReasonDetails: B, redirectInfo: U }), !K.details && !V && (K.details = $.next)); + const ae = _e && lw(T, _e); + return ae && j6(ae) ? $7(ae.file, ae.pos, ae.end - ae.pos, $, R) : z5($, R); + function se(he) { + O?.has(he) || ((O ?? (O = /* @__PURE__ */ new Set())).add(he), (F ?? (F = [])).push(WU(T, he)), ce(he)); + } + function ce(he) { + !_e && yv(he) ? _e = he : _e !== he && (R = Er(R, h(T, he))); + } + function fe() { + var he; + return ((he = K.fileIncludeReasonDetails.next) == null ? void 0 : he.length) !== W?.length; + } + } + function h(T, k) { + let D = u?.get(k); + return D === void 0 && (u ?? (u = /* @__PURE__ */ new Map())).set(k, D = S(T, k) ?? !1), D || void 0; + } + function S(T, k) { + if (yv(k)) { + const R = lw(T, k); + let B; + switch (k.kind) { + case 3: + B = p.File_is_included_via_import_here; + break; + case 4: + B = p.File_is_included_via_reference_here; + break; + case 5: + B = p.File_is_included_via_type_library_reference_here; + break; + case 7: + B = p.File_is_included_via_library_reference_here; + break; + default: + E.assertNever(k); + } + return j6(R) ? ll( + R.file, + R.pos, + R.end - R.pos, + B + ) : void 0; + } + const D = T.getCurrentDirectory(), P = T.getRootFileNames(), A = T.getCompilerOptions(); + if (!A.configFile) return; + let O, F; + switch (k.kind) { + case 0: + if (!A.configFile.configFileSpecs) return; + const R = Qi(P[k.index], D), B = JU(T, R); + if (B) { + O = e5(A.configFile, "files", B), F = p.File_is_matched_by_files_list_specified_here; + break; + } + const U = zU(T, R); + if (!U || !gs(U)) return; + O = e5(A.configFile, "include", U), F = p.File_is_matched_by_include_pattern_specified_here; + break; + case 1: + case 2: + const $ = T.getResolvedProjectReferences(), W = T.getProjectReferences(), _e = E.checkDefined($?.[k.index]), K = x4( + W, + $, + (fe, he, q) => fe === _e ? { sourceFile: he?.sourceFile || A.configFile, index: q } : void 0 + ); + if (!K) return; + const { sourceFile: V, index: ae } = K, se = P3(V, "references", (fe) => nu(fe.initializer) ? fe.initializer : void 0); + return se && se.elements.length > ae ? sp( + V, + se.elements[ae], + k.kind === 2 ? p.File_is_output_from_referenced_project_specified_here : p.File_is_source_from_referenced_project_specified_here + ) : void 0; + case 8: + if (!A.types) return; + O = ZJ(e(), "types", k.typeReference), F = p.File_is_entry_point_of_type_library_specified_here; + break; + case 6: + if (k.index !== void 0) { + O = ZJ(e(), "lib", A.lib[k.index]), F = p.File_is_library_specified_here; + break; + } + const ce = q5(da(A)); + O = ce ? ote(e(), "target", ce) : void 0, F = p.File_is_default_library_for_target_specified_here; + break; + default: + E.assertNever(k); + } + return O && sp( + A.configFile, + O, + F + ); + } + } + function Lie(e, t, n, i, s, o) { + const c = [], { emitSkipped: _, diagnostics: u } = e.emit(t, g, i, n, s, o); + return { outputFiles: c, emitSkipped: _, diagnostics: u }; + function g(m, h, S) { + c.push({ name: m, writeByteOrderMark: S, text: h }); + } + } + var Mie = /* @__PURE__ */ ((e) => (e[e.ComputedDts = 0] = "ComputedDts", e[e.StoredSignatureAtEmit = 1] = "StoredSignatureAtEmit", e[e.UsedVersion = 2] = "UsedVersion", e))(Mie || {}), Md; + ((e) => { + function t() { + function K(V, ae, se) { + const ce = { + getKeys: (fe) => ae.get(fe), + getValues: (fe) => V.get(fe), + keys: () => V.keys(), + size: () => V.size, + deleteKey: (fe) => { + (se || (se = /* @__PURE__ */ new Set())).add(fe); + const he = V.get(fe); + return he ? (he.forEach((q) => i(ae, q, fe)), V.delete(fe), !0) : !1; + }, + set: (fe, he) => { + se?.delete(fe); + const q = V.get(fe); + return V.set(fe, he), q?.forEach((be) => { + he.has(be) || i(ae, be, fe); + }), he.forEach((be) => { + q?.has(be) || n(ae, be, fe); + }), ce; + } + }; + return ce; + } + return K( + /* @__PURE__ */ new Map(), + /* @__PURE__ */ new Map(), + /*deleted*/ + void 0 + ); + } + e.createManyToManyPathMap = t; + function n(K, V, ae) { + let se = K.get(V); + se || (se = /* @__PURE__ */ new Set(), K.set(V, se)), se.add(ae); + } + function i(K, V, ae) { + const se = K.get(V); + return se?.delete(ae) ? (se.size || K.delete(V), !0) : !1; + } + function s(K) { + return Fi(K.declarations, (V) => { + var ae; + return (ae = xr(V)) == null ? void 0 : ae.resolvedPath; + }); + } + function o(K, V) { + const ae = K.getSymbolAtLocation(V); + return ae && s(ae); + } + function c(K, V, ae, se) { + var ce; + return oo(((ce = K.getRedirectFromSourceFile(V)) == null ? void 0 : ce.outputDts) || V, ae, se); + } + function _(K, V, ae) { + let se; + if (V.imports && V.imports.length > 0) { + const q = K.getTypeChecker(); + for (const be of V.imports) { + const je = o(q, be); + je?.forEach(he); + } + } + const ce = Hn(V.resolvedPath); + if (V.referencedFiles && V.referencedFiles.length > 0) + for (const q of V.referencedFiles) { + const be = c(K, q.fileName, ce, ae); + he(be); + } + if (K.forEachResolvedTypeReferenceDirective(({ resolvedTypeReferenceDirective: q }) => { + if (!q) + return; + const be = q.resolvedFileName, je = c(K, be, ce, ae); + he(je); + }, V), V.moduleAugmentations.length) { + const q = K.getTypeChecker(); + for (const be of V.moduleAugmentations) { + if (!ca(be)) continue; + const je = q.getSymbolAtLocation(be); + je && fe(je); + } + } + for (const q of K.getTypeChecker().getAmbientModules()) + q.declarations && q.declarations.length > 1 && fe(q); + return se; + function fe(q) { + if (q.declarations) + for (const be of q.declarations) { + const je = xr(be); + je && je !== V && he(je.resolvedPath); + } + } + function he(q) { + (se || (se = /* @__PURE__ */ new Set())).add(q); + } + } + function u(K, V) { + return V && !V.referencedMap == !K; + } + e.canReuseOldState = u; + function g(K) { + return K.module !== 0 && !K.outFile ? t() : void 0; + } + e.createReferencedMap = g; + function m(K, V, ae) { + var se, ce; + const fe = /* @__PURE__ */ new Map(), he = K.getCompilerOptions(), q = g(he), be = u(q, V); + K.getTypeChecker(); + for (const je of K.getSourceFiles()) { + const me = E.checkDefined(je.version, "Program intended to be used with Builder should have source files with versions set"), Z = be ? (se = V.oldSignatures) == null ? void 0 : se.get(je.resolvedPath) : void 0, pe = Z === void 0 ? be ? (ce = V.fileInfos.get(je.resolvedPath)) == null ? void 0 : ce.signature : void 0 : Z || void 0; + if (q) { + const Te = _(K, je, K.getCanonicalFileName); + Te && q.set(je.resolvedPath, Te); + } + fe.set(je.resolvedPath, { + version: me, + signature: pe, + // No need to calculate affectsGlobalScope with --out since its not used at all + affectsGlobalScope: he.outFile ? void 0 : U(je) || void 0, + impliedFormat: je.impliedNodeFormat + }); + } + return { + fileInfos: fe, + referencedMap: q, + useFileVersionAsSignature: !ae && !be + }; + } + e.create = m; + function h(K) { + K.allFilesExcludingDefaultLibraryFile = void 0, K.allFileNames = void 0; + } + e.releaseCache = h; + function S(K, V, ae, se, ce) { + var fe; + const he = T( + K, + V, + ae, + se, + ce + ); + return (fe = K.oldSignatures) == null || fe.clear(), he; + } + e.getFilesAffectedBy = S; + function T(K, V, ae, se, ce) { + const fe = V.getSourceFileByPath(ae); + return fe ? P(K, V, fe, se, ce) ? (K.referencedMap ? _e : W)(K, V, fe, se, ce) : [fe] : Ge; + } + e.getFilesAffectedByWithOldState = T; + function k(K, V, ae) { + K.fileInfos.get(ae).signature = V, (K.hasCalledUpdateShapeSignature || (K.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(ae); + } + e.updateSignatureOfFile = k; + function D(K, V, ae, se, ce) { + K.emit( + V, + (fe, he, q, be, je, me) => { + E.assert(Il(fe), `File extension for signature expected to be dts: Got:: ${fe}`), ce( + CU( + K, + V, + he, + se, + me + ), + je + ); + }, + ae, + 2, + /*customTransformers*/ + void 0, + /*forceDtsEmit*/ + !0 + ); + } + e.computeDtsSignature = D; + function P(K, V, ae, se, ce, fe = K.useFileVersionAsSignature) { + var he; + if ((he = K.hasCalledUpdateShapeSignature) != null && he.has(ae.resolvedPath)) return !1; + const q = K.fileInfos.get(ae.resolvedPath), be = q.signature; + let je; + return !ae.isDeclarationFile && !fe && D(V, ae, se, ce, (me) => { + je = me, ce.storeSignatureInfo && (K.signatureInfo ?? (K.signatureInfo = /* @__PURE__ */ new Map())).set( + ae.resolvedPath, + 0 + /* ComputedDts */ + ); + }), je === void 0 && (je = ae.version, ce.storeSignatureInfo && (K.signatureInfo ?? (K.signatureInfo = /* @__PURE__ */ new Map())).set( + ae.resolvedPath, + 2 + /* UsedVersion */ + )), (K.oldSignatures || (K.oldSignatures = /* @__PURE__ */ new Map())).set(ae.resolvedPath, be || !1), (K.hasCalledUpdateShapeSignature || (K.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(ae.resolvedPath), q.signature = je, je !== be; + } + e.updateShapeSignature = P; + function A(K, V, ae) { + if (V.getCompilerOptions().outFile || !K.referencedMap || U(ae)) + return O(K, V); + const ce = /* @__PURE__ */ new Set(), fe = [ae.resolvedPath]; + for (; fe.length; ) { + const he = fe.pop(); + if (!ce.has(he)) { + ce.add(he); + const q = K.referencedMap.getValues(he); + if (q) + for (const be of q.keys()) + fe.push(be); + } + } + return is(uy(ce.keys(), (he) => { + var q; + return ((q = V.getSourceFileByPath(he)) == null ? void 0 : q.fileName) ?? he; + })); + } + e.getAllDependencies = A; + function O(K, V) { + if (!K.allFileNames) { + const ae = V.getSourceFiles(); + K.allFileNames = ae === Ge ? Ge : ae.map((se) => se.fileName); + } + return K.allFileNames; + } + function F(K, V) { + const ae = K.referencedMap.getKeys(V); + return ae ? is(ae.keys()) : []; + } + e.getReferencedByPaths = F; + function R(K) { + for (const V of K.statements) + if (!q7(V)) + return !1; + return !0; + } + function B(K) { + return ot(K.moduleAugmentations, (V) => $m(V.parent)); + } + function U(K) { + return B(K) || !tf(K) && !ap(K) && !R(K); + } + function $(K, V, ae) { + if (K.allFilesExcludingDefaultLibraryFile) + return K.allFilesExcludingDefaultLibraryFile; + let se; + ae && ce(ae); + for (const fe of V.getSourceFiles()) + fe !== ae && ce(fe); + return K.allFilesExcludingDefaultLibraryFile = se || Ge, K.allFilesExcludingDefaultLibraryFile; + function ce(fe) { + V.isSourceFileDefaultLibrary(fe) || (se || (se = [])).push(fe); + } + } + e.getAllFilesExcludingDefaultLibraryFile = $; + function W(K, V, ae) { + const se = V.getCompilerOptions(); + return se && se.outFile ? [ae] : $(K, V, ae); + } + function _e(K, V, ae, se, ce) { + if (U(ae)) + return $(K, V, ae); + const fe = V.getCompilerOptions(); + if (fe && (zp(fe) || fe.outFile)) + return [ae]; + const he = /* @__PURE__ */ new Map(); + he.set(ae.resolvedPath, ae); + const q = F(K, ae.resolvedPath); + for (; q.length > 0; ) { + const be = q.pop(); + if (!he.has(be)) { + const je = V.getSourceFileByPath(be); + he.set(be, je), je && P(K, V, je, se, ce) && q.push(...F(K, je.resolvedPath)); + } + } + return is(uy(he.values(), (be) => be)); + } + })(Md || (Md = {})); + var Rie = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Js = 1] = "Js", e[e.JsMap = 2] = "JsMap", e[e.JsInlineMap = 4] = "JsInlineMap", e[e.DtsErrors = 8] = "DtsErrors", e[e.DtsEmit = 16] = "DtsEmit", e[e.DtsMap = 32] = "DtsMap", e[e.Dts = 24] = "Dts", e[e.AllJs = 7] = "AllJs", e[e.AllDtsEmit = 48] = "AllDtsEmit", e[e.AllDts = 56] = "AllDts", e[e.All = 63] = "All", e))(Rie || {}); + function B6(e) { + return e.program !== void 0; + } + function tBe(e) { + return E.assert(B6(e)), e; + } + function e1(e) { + let t = 1; + return e.sourceMap && (t = t | 2), e.inlineSourceMap && (t = t | 4), J_(e) && (t = t | 24), e.declarationMap && (t = t | 32), e.emitDeclarationOnly && (t = t & 56), t; + } + function VO(e, t) { + const n = t && (dy(t) ? t : e1(t)), i = dy(e) ? e : e1(e); + if (n === i) return 0; + if (!n || !i) return i; + const s = n ^ i; + let o = 0; + return s & 7 && (o = i & 7), s & 8 && (o = o | i & 8), s & 48 && (o = o | i & 48), o; + } + function rBe(e, t) { + return e === t || e !== void 0 && t !== void 0 && e.size === t.size && !Ag(e, (n) => !t.has(n)); + } + function nBe(e, t) { + var n, i; + const s = Md.create( + e, + t, + /*disableUseFileVersionAsSignature*/ + !1 + ); + s.program = e; + const o = e.getCompilerOptions(); + s.compilerOptions = o; + const c = o.outFile; + s.semanticDiagnosticsPerFile = /* @__PURE__ */ new Map(), c && o.composite && t?.outSignature && c === t.compilerOptions.outFile && (s.outSignature = t.outSignature && Ove(o, t.compilerOptions, t.outSignature)), s.changedFilesSet = /* @__PURE__ */ new Set(), s.latestChangedDtsFile = o.composite ? t?.latestChangedDtsFile : void 0, s.checkPending = s.compilerOptions.noCheck ? !0 : void 0; + const _ = Md.canReuseOldState(s.referencedMap, t), u = _ ? t.compilerOptions : void 0; + let g = _ && !Nee(o, u); + const m = o.composite && t?.emitSignatures && !c && !Iee(o, t.compilerOptions); + let h = !0; + _ ? ((n = t.changedFilesSet) == null || n.forEach((A) => s.changedFilesSet.add(A)), !c && ((i = t.affectedFilesPendingEmit) != null && i.size) && (s.affectedFilesPendingEmit = new Map(t.affectedFilesPendingEmit), s.seenAffectedFiles = /* @__PURE__ */ new Set()), s.programEmitPending = t.programEmitPending, c && s.changedFilesSet.size && (g = !1, h = !1), s.hasErrorsFromOldState = t.hasErrors) : s.buildInfoEmitPending = Wb(o); + const S = s.referencedMap, T = _ ? t.referencedMap : void 0, k = g && !o.skipLibCheck == !u.skipLibCheck, D = k && !o.skipDefaultLibCheck == !u.skipDefaultLibCheck; + if (s.fileInfos.forEach((A, O) => { + var F; + let R, B; + if (!_ || // File wasn't present in old state + !(R = t.fileInfos.get(O)) || // versions dont match + R.version !== A.version || // Implied formats dont match + R.impliedFormat !== A.impliedFormat || // Referenced files changed + !rBe(B = S && S.getValues(O), T && T.getValues(O)) || // Referenced file was deleted in the new program + B && Ag(B, (U) => !s.fileInfos.has(U) && t.fileInfos.has(U))) + P(O); + else { + const U = e.getSourceFileByPath(O), $ = h ? (F = t.emitDiagnosticsPerFile) == null ? void 0 : F.get(O) : void 0; + if ($ && (s.emitDiagnosticsPerFile ?? (s.emitDiagnosticsPerFile = /* @__PURE__ */ new Map())).set( + O, + t.hasReusableDiagnostic ? Mve($, O, e) : Lve($, e) + ), g) { + if (U.isDeclarationFile && !k || U.hasNoDefaultLib && !D) return; + const W = t.semanticDiagnosticsPerFile.get(O); + W && (s.semanticDiagnosticsPerFile.set( + O, + t.hasReusableDiagnostic ? Mve(W, O, e) : Lve(W, e) + ), (s.semanticDiagnosticsFromOldState ?? (s.semanticDiagnosticsFromOldState = /* @__PURE__ */ new Set())).add(O)); + } + } + if (m) { + const U = t.emitSignatures.get(O); + U && (s.emitSignatures ?? (s.emitSignatures = /* @__PURE__ */ new Map())).set(O, Ove(o, t.compilerOptions, U)); + } + }), _ && hl(t.fileInfos, (A, O) => s.fileInfos.has(O) ? !1 : A.affectsGlobalScope ? !0 : (s.buildInfoEmitPending = !0, !!c))) + Md.getAllFilesExcludingDefaultLibraryFile( + s, + e, + /*firstSourceFile*/ + void 0 + ).forEach((A) => P(A.resolvedPath)); + else if (u) { + const A = Aee(o, u) ? e1(o) : VO(o, u); + A !== 0 && (c ? s.changedFilesSet.size || (s.programEmitPending = s.programEmitPending ? s.programEmitPending | A : A) : (e.getSourceFiles().forEach((O) => { + s.changedFilesSet.has(O.resolvedPath) || DU( + s, + O.resolvedPath, + A + ); + }), E.assert(!s.seenAffectedFiles || !s.seenAffectedFiles.size), s.seenAffectedFiles = s.seenAffectedFiles || /* @__PURE__ */ new Set()), s.buildInfoEmitPending = !0); + } + return _ && s.semanticDiagnosticsPerFile.size !== s.fileInfos.size && t.checkPending !== s.checkPending && (s.buildInfoEmitPending = !0), s; + function P(A) { + s.changedFilesSet.add(A), c && (g = !1, h = !1, s.semanticDiagnosticsFromOldState = void 0, s.semanticDiagnosticsPerFile.clear(), s.emitDiagnosticsPerFile = void 0), s.buildInfoEmitPending = !0, s.programEmitPending = void 0; + } + } + function Ove(e, t, n) { + return !!e.declarationMap == !!t.declarationMap ? ( + // Use same format of signature + n + ) : ( + // Convert to different format + gs(n) ? [n] : n[0] + ); + } + function Lve(e, t) { + return e.length ? Qc(e, (n) => { + if (gs(n.messageText)) return n; + const i = jie(n.messageText, n.file, t, (s) => { + var o; + return (o = s.repopulateInfo) == null ? void 0 : o.call(s); + }); + return i === n.messageText ? n : { ...n, messageText: i }; + }) : e; + } + function jie(e, t, n, i) { + const s = i(e); + if (s === !0) + return { + ...rB(t), + next: Bie(e.next, t, n, i) + }; + if (s) + return { + ...J7(t, n, s.moduleReference, s.mode, s.packageName || s.moduleReference), + next: Bie(e.next, t, n, i) + }; + const o = Bie(e.next, t, n, i); + return o === e.next ? e : { ...e, next: o }; + } + function Bie(e, t, n, i) { + return Qc(e, (s) => jie(s, t, n, i)); + } + function Mve(e, t, n) { + if (!e.length) return Ge; + let i; + return e.map((o) => { + const c = Rve(o, t, n, s); + c.reportsUnnecessary = o.reportsUnnecessary, c.reportsDeprecated = o.reportDeprecated, c.source = o.source, c.skippedOn = o.skippedOn; + const { relatedInformation: _ } = o; + return c.relatedInformation = _ ? _.length ? _.map((u) => Rve(u, t, n, s)) : [] : void 0, c; + }); + function s(o) { + return i ?? (i = Hn(Qi(hv(n.getCompilerOptions()), n.getCurrentDirectory()))), oo(o, i, n.getCanonicalFileName); + } + } + function Rve(e, t, n, i) { + const { file: s } = e, o = s !== !1 ? n.getSourceFileByPath(s ? i(s) : t) : void 0; + return { + ...e, + file: o, + messageText: gs(e.messageText) ? e.messageText : jie(e.messageText, o, n, (c) => c.info) + }; + } + function iBe(e) { + Md.releaseCache(e), e.program = void 0; + } + function Jie(e, t) { + E.assert(!t || !e.affectedFiles || e.affectedFiles[e.affectedFilesIndex - 1] !== t || !e.semanticDiagnosticsPerFile.has(t.resolvedPath)); + } + function jve(e, t, n) { + for (var i; ; ) { + const { affectedFiles: s } = e; + if (s) { + const _ = e.seenAffectedFiles; + let u = e.affectedFilesIndex; + for (; u < s.length; ) { + const g = s[u]; + if (!_.has(g.resolvedPath)) + return e.affectedFilesIndex = u, DU( + e, + g.resolvedPath, + e1(e.compilerOptions) + ), oBe( + e, + g, + t, + n + ), g; + u++; + } + e.changedFilesSet.delete(e.currentChangedFilePath), e.currentChangedFilePath = void 0, (i = e.oldSignatures) == null || i.clear(), e.affectedFiles = void 0; + } + const o = e.changedFilesSet.keys().next(); + if (o.done) + return; + if (e.program.getCompilerOptions().outFile) return e.program; + e.affectedFiles = Md.getFilesAffectedByWithOldState( + e, + e.program, + o.value, + t, + n + ), e.currentChangedFilePath = o.value, e.affectedFilesIndex = 0, e.seenAffectedFiles || (e.seenAffectedFiles = /* @__PURE__ */ new Set()); + } + } + function Bve(e, t, n) { + var i, s; + if (!(!((i = e.affectedFilesPendingEmit) != null && i.size) && !e.programEmitPending) && (!t && !n && (e.affectedFilesPendingEmit = void 0, e.programEmitPending = void 0), (s = e.affectedFilesPendingEmit) == null || s.forEach((o, c) => { + const _ = n ? o & 55 : o & 7; + _ ? e.affectedFilesPendingEmit.set(c, _) : e.affectedFilesPendingEmit.delete(c); + }), e.programEmitPending)) { + const o = n ? e.programEmitPending & 55 : e.programEmitPending & 7; + o ? e.programEmitPending = o : e.programEmitPending = void 0; + } + } + function qO(e, t, n, i) { + let s = VO(e, t); + return n && (s = s & 56), i && (s = s & 8), s; + } + function xU(e) { + return e ? 8 : 56; + } + function sBe(e, t, n) { + var i; + if ((i = e.affectedFilesPendingEmit) != null && i.size) + return hl(e.affectedFilesPendingEmit, (s, o) => { + var c; + const _ = e.program.getSourceFileByPath(o); + if (!_ || !Mb(_, e.program)) { + e.affectedFilesPendingEmit.delete(o); + return; + } + const u = (c = e.seenEmittedFiles) == null ? void 0 : c.get(_.resolvedPath), g = qO( + s, + u, + t, + n + ); + if (g) return { affectedFile: _, emitKind: g }; + }); + } + function aBe(e, t) { + var n; + if ((n = e.emitDiagnosticsPerFile) != null && n.size) + return hl(e.emitDiagnosticsPerFile, (i, s) => { + var o; + const c = e.program.getSourceFileByPath(s); + if (!c || !Mb(c, e.program)) { + e.emitDiagnosticsPerFile.delete(s); + return; + } + const _ = ((o = e.seenEmittedFiles) == null ? void 0 : o.get(c.resolvedPath)) || 0; + if (!(_ & xU(t))) return { affectedFile: c, diagnostics: i, seenKind: _ }; + }); + } + function Jve(e) { + if (!e.cleanedDiagnosticsOfLibFiles) { + e.cleanedDiagnosticsOfLibFiles = !0; + const t = e.program.getCompilerOptions(); + lr(e.program.getSourceFiles(), (n) => e.program.isSourceFileDefaultLibrary(n) && !Uee(n, t, e.program) && Wie(e, n.resolvedPath)); + } + } + function oBe(e, t, n, i) { + if (Wie(e, t.resolvedPath), e.allFilesExcludingDefaultLibraryFile === e.affectedFiles) { + Jve(e), Md.updateShapeSignature( + e, + e.program, + t, + n, + i + ); + return; + } + e.compilerOptions.assumeChangesOnlyAffectDirectDependencies || cBe( + e, + t, + n, + i + ); + } + function zie(e, t, n, i, s) { + if (Wie(e, t), !e.changedFilesSet.has(t)) { + const o = e.program.getSourceFileByPath(t); + o && (Md.updateShapeSignature( + e, + e.program, + o, + i, + s, + /*useFileVersionAsSignature*/ + !0 + ), n ? DU( + e, + t, + e1(e.compilerOptions) + ) : J_(e.compilerOptions) && DU( + e, + t, + e.compilerOptions.declarationMap ? 56 : 24 + /* Dts */ + )); + } + } + function Wie(e, t) { + return e.semanticDiagnosticsFromOldState ? (e.semanticDiagnosticsFromOldState.delete(t), e.semanticDiagnosticsPerFile.delete(t), !e.semanticDiagnosticsFromOldState.size) : !0; + } + function zve(e, t) { + const n = E.checkDefined(e.oldSignatures).get(t) || void 0; + return E.checkDefined(e.fileInfos.get(t)).signature !== n; + } + function Uie(e, t, n, i, s) { + var o; + return (o = e.fileInfos.get(t)) != null && o.affectsGlobalScope ? (Md.getAllFilesExcludingDefaultLibraryFile( + e, + e.program, + /*firstSourceFile*/ + void 0 + ).forEach( + (c) => zie( + e, + c.resolvedPath, + n, + i, + s + ) + ), Jve(e), !0) : !1; + } + function cBe(e, t, n, i) { + var s, o; + if (!e.referencedMap || !e.changedFilesSet.has(t.resolvedPath) || !zve(e, t.resolvedPath)) return; + if (zp(e.compilerOptions)) { + const u = /* @__PURE__ */ new Map(); + u.set(t.resolvedPath, !0); + const g = Md.getReferencedByPaths(e, t.resolvedPath); + for (; g.length > 0; ) { + const m = g.pop(); + if (!u.has(m)) { + if (u.set(m, !0), Uie( + e, + m, + /*invalidateJsFiles*/ + !1, + n, + i + )) return; + if (zie( + e, + m, + /*invalidateJsFiles*/ + !1, + n, + i + ), zve(e, m)) { + const h = e.program.getSourceFileByPath(m); + g.push(...Md.getReferencedByPaths(e, h.resolvedPath)); + } + } + } + } + const c = /* @__PURE__ */ new Set(), _ = !!((s = t.symbol) != null && s.exports) && !!hl( + t.symbol.exports, + (u) => { + if ((u.flags & 128) !== 0) return !0; + const g = eu(u, e.program.getTypeChecker()); + return g === u ? !1 : (g.flags & 128) !== 0 && ot(g.declarations, (m) => xr(m) === t); + } + ); + (o = e.referencedMap.getKeys(t.resolvedPath)) == null || o.forEach((u) => { + if (Uie(e, u, _, n, i)) return !0; + const g = e.referencedMap.getKeys(u); + return g && Ag(g, (m) => Wve( + e, + m, + _, + c, + n, + i + )); + }); + } + function Wve(e, t, n, i, s, o) { + var c; + if (u0(i, t)) { + if (Uie(e, t, n, s, o)) return !0; + zie(e, t, n, s, o), (c = e.referencedMap.getKeys(t)) == null || c.forEach( + (_) => Wve( + e, + _, + n, + i, + s, + o + ) + ); + } + } + function kU(e, t, n, i) { + return e.compilerOptions.noCheck ? Ge : Bi( + lBe(e, t, n, i), + e.program.getProgramDiagnostics(t) + ); + } + function lBe(e, t, n, i) { + i ?? (i = e.semanticDiagnosticsPerFile); + const s = t.resolvedPath, o = i.get(s); + if (o) + return WO(o, e.compilerOptions); + const c = e.program.getBindAndCheckDiagnostics(t, n); + return i.set(s, c), e.buildInfoEmitPending = !0, WO(c, e.compilerOptions); + } + function Vie(e) { + var t; + return !!((t = e.options) != null && t.outFile); + } + function NA(e) { + return !!e.fileNames; + } + function uBe(e) { + return !NA(e) && !!e.root; + } + function Uve(e) { + e.hasErrors === void 0 && (Wb(e.compilerOptions) ? e.hasErrors = !ot(e.program.getSourceFiles(), (t) => { + var n, i; + const s = e.semanticDiagnosticsPerFile.get(t.resolvedPath); + return s === void 0 || // Missing semantic diagnostics in cache will be encoded in buildInfo + !!s.length || // cached semantic diagnostics will be encoded in buildInfo + !!((i = (n = e.emitDiagnosticsPerFile) == null ? void 0 : n.get(t.resolvedPath)) != null && i.length); + }) && (Vve(e) || ot(e.program.getSourceFiles(), (t) => !!e.program.getProgramDiagnostics(t).length)) : e.hasErrors = ot(e.program.getSourceFiles(), (t) => { + var n, i; + const s = e.semanticDiagnosticsPerFile.get(t.resolvedPath); + return !!s?.length || // If has semantic diagnostics + !!((i = (n = e.emitDiagnosticsPerFile) == null ? void 0 : n.get(t.resolvedPath)) != null && i.length); + }) || Vve(e)); + } + function Vve(e) { + return !!e.program.getConfigFileParsingDiagnostics().length || !!e.program.getSyntacticDiagnostics().length || !!e.program.getOptionsDiagnostics().length || !!e.program.getGlobalDiagnostics().length; + } + function qve(e) { + return Uve(e), e.buildInfoEmitPending ?? (e.buildInfoEmitPending = !!e.hasErrorsFromOldState != !!e.hasErrors); + } + function _Be(e) { + var t, n; + const i = e.program.getCurrentDirectory(), s = Hn(Qi(hv(e.compilerOptions), i)), o = e.latestChangedDtsFile ? O(e.latestChangedDtsFile) : void 0, c = [], _ = /* @__PURE__ */ new Map(), u = new Set(e.program.getRootFileNames().map((q) => oo(q, i, e.program.getCanonicalFileName))); + if (Uve(e), !Wb(e.compilerOptions)) + return { + root: is(u, (be) => F(be)), + errors: e.hasErrors ? !0 : void 0, + checkPending: e.checkPending, + version: ep + }; + const g = []; + if (e.compilerOptions.outFile) { + const q = is(e.fileInfos.entries(), ([je, me]) => { + const Z = R(je); + return U(je, Z), me.impliedFormat ? { version: me.version, impliedFormat: me.impliedFormat, signature: void 0, affectsGlobalScope: void 0 } : me.version; + }); + return { + fileNames: c, + fileInfos: q, + root: g, + resolvedRoot: $(), + options: W(e.compilerOptions), + semanticDiagnosticsPerFile: e.changedFilesSet.size ? void 0 : K(), + emitDiagnosticsPerFile: V(), + changeFileSet: he(), + outSignature: e.outSignature, + latestChangedDtsFile: o, + pendingEmit: e.programEmitPending ? ( + // Pending is undefined or None is encoded as undefined + e.programEmitPending === e1(e.compilerOptions) ? !1 : ( + // Pending emit is same as deteremined by compilerOptions + e.programEmitPending + ) + ) : void 0, + // Actual value + errors: e.hasErrors ? !0 : void 0, + checkPending: e.checkPending, + version: ep + }; + } + let m, h, S; + const T = is(e.fileInfos.entries(), ([q, be]) => { + var je, me; + const Z = R(q); + U(q, Z), E.assert(c[Z - 1] === F(q)); + const pe = (je = e.oldSignatures) == null ? void 0 : je.get(q), Te = pe !== void 0 ? pe || void 0 : be.signature; + if (e.compilerOptions.composite) { + const Fe = e.program.getSourceFileByPath(q); + if (!ap(Fe) && Mb(Fe, e.program)) { + const Ye = (me = e.emitSignatures) == null ? void 0 : me.get(q); + Ye !== Te && (S = Er( + S, + Ye === void 0 ? Z : ( + // There is no emit, encode as false + // fileId, signature: emptyArray if signature only differs in dtsMap option than our own compilerOptions otherwise EmitSignature + [Z, !gs(Ye) && Ye[0] === Te ? Ge : Ye] + ) + )); + } + } + return be.version === Te ? be.affectsGlobalScope || be.impliedFormat ? ( + // If file version is same as signature, dont serialize signature + { version: be.version, signature: void 0, affectsGlobalScope: be.affectsGlobalScope, impliedFormat: be.impliedFormat } + ) : ( + // If file info only contains version and signature and both are same we can just write string + be.version + ) : Te !== void 0 ? ( + // If signature is not same as version, encode signature in the fileInfo + pe === void 0 ? ( + // If we havent computed signature, use fileInfo as is + be + ) : ( + // Serialize fileInfo with new updated signature + { version: be.version, signature: Te, affectsGlobalScope: be.affectsGlobalScope, impliedFormat: be.impliedFormat } + ) + ) : ( + // Signature of the FileInfo is undefined, serialize it as false + { version: be.version, signature: !1, affectsGlobalScope: be.affectsGlobalScope, impliedFormat: be.impliedFormat } + ); + }); + let k; + (t = e.referencedMap) != null && t.size() && (k = is(e.referencedMap.keys()).sort(_u).map((q) => [ + R(q), + B(e.referencedMap.getValues(q)) + ])); + const D = K(); + let P; + if ((n = e.affectedFilesPendingEmit) != null && n.size) { + const q = e1(e.compilerOptions), be = /* @__PURE__ */ new Set(); + for (const je of is(e.affectedFilesPendingEmit.keys()).sort(_u)) + if (u0(be, je)) { + const me = e.program.getSourceFileByPath(je); + if (!me || !Mb(me, e.program)) continue; + const Z = R(je), pe = e.affectedFilesPendingEmit.get(je); + P = Er( + P, + pe === q ? Z : ( + // Pending full emit per options + pe === 24 ? [Z] : ( + // Pending on Dts only + [Z, pe] + ) + ) + // Anything else + ); + } + } + return { + fileNames: c, + fileIdsList: m, + fileInfos: T, + root: g, + resolvedRoot: $(), + options: W(e.compilerOptions), + referencedMap: k, + semanticDiagnosticsPerFile: D, + emitDiagnosticsPerFile: V(), + changeFileSet: he(), + affectedFilesPendingEmit: P, + emitSignatures: S, + latestChangedDtsFile: o, + errors: e.hasErrors ? !0 : void 0, + checkPending: e.checkPending, + version: ep + }; + function O(q) { + return F(Qi(q, i)); + } + function F(q) { + return X2(Nf(s, q, e.program.getCanonicalFileName)); + } + function R(q) { + let be = _.get(q); + return be === void 0 && (c.push(F(q)), _.set(q, be = c.length)), be; + } + function B(q) { + const be = is(q.keys(), R).sort(ho), je = be.join(); + let me = h?.get(je); + return me === void 0 && (m = Er(m, be), (h ?? (h = /* @__PURE__ */ new Map())).set(je, me = m.length)), me; + } + function U(q, be) { + const je = e.program.getSourceFile(q); + if (!e.program.getFileIncludeReasons().get(je.path).some( + (Te) => Te.kind === 0 + /* RootFile */ + )) return; + if (!g.length) return g.push(be); + const me = g[g.length - 1], Z = as(me); + if (Z && me[1] === be - 1) return me[1] = be; + if (Z || g.length === 1 || me !== be - 1) return g.push(be); + const pe = g[g.length - 2]; + return !dy(pe) || pe !== me - 1 ? g.push(be) : (g[g.length - 2] = [pe, be], g.length = g.length - 1); + } + function $() { + let q; + return u.forEach((be) => { + const je = e.program.getSourceFileByPath(be); + je && be !== je.resolvedPath && (q = Er(q, [R(je.resolvedPath), R(be)])); + }), q; + } + function W(q) { + let be; + const { optionsNameMap: je } = w6(); + for (const me of rm(q).sort(_u)) { + const Z = je.get(me.toLowerCase()); + Z?.affectsBuildInfo && ((be || (be = {}))[me] = _e( + Z, + q[me] + )); + } + return be; + } + function _e(q, be) { + if (q) { + if (E.assert(q.type !== "listOrElement"), q.type === "list") { + const je = be; + if (q.element.isFilePath && je.length) + return je.map(O); + } else if (q.isFilePath) + return O(be); + } + return be; + } + function K() { + let q; + return e.fileInfos.forEach((be, je) => { + const me = e.semanticDiagnosticsPerFile.get(je); + me ? me.length && (q = Er(q, [ + R(je), + ae(me, je) + ])) : e.changedFilesSet.has(je) || (q = Er(q, R(je))); + }), q; + } + function V() { + var q; + let be; + if (!((q = e.emitDiagnosticsPerFile) != null && q.size)) return be; + for (const je of is(e.emitDiagnosticsPerFile.keys()).sort(_u)) { + const me = e.emitDiagnosticsPerFile.get(je); + be = Er(be, [ + R(je), + ae(me, je) + ]); + } + return be; + } + function ae(q, be) { + return E.assert(!!q.length), q.map((je) => { + const me = se(je, be); + me.reportsUnnecessary = je.reportsUnnecessary, me.reportDeprecated = je.reportsDeprecated, me.source = je.source, me.skippedOn = je.skippedOn; + const { relatedInformation: Z } = je; + return me.relatedInformation = Z ? Z.length ? Z.map((pe) => se(pe, be)) : [] : void 0, me; + }); + } + function se(q, be) { + const { file: je } = q; + return { + ...q, + file: je ? je.resolvedPath === be ? void 0 : F(je.resolvedPath) : !1, + messageText: gs(q.messageText) ? q.messageText : ce(q.messageText) + }; + } + function ce(q) { + if (q.repopulateInfo) + return { + info: q.repopulateInfo(), + next: fe(q.next) + }; + const be = fe(q.next); + return be === q.next ? q : { ...q, next: be }; + } + function fe(q) { + return q && (lr(q, (be, je) => { + const me = ce(be); + if (be === me) return; + const Z = je > 0 ? q.slice(0, je - 1) : []; + Z.push(me); + for (let pe = je + 1; pe < q.length; pe++) + Z.push(ce(q[pe])); + return Z; + }) || q); + } + function he() { + let q; + if (e.changedFilesSet.size) + for (const be of is(e.changedFilesSet.keys()).sort(_u)) + q = Er(q, R(be)); + return q; + } + } + var qie = /* @__PURE__ */ ((e) => (e[e.SemanticDiagnosticsBuilderProgram = 0] = "SemanticDiagnosticsBuilderProgram", e[e.EmitAndSemanticDiagnosticsBuilderProgram = 1] = "EmitAndSemanticDiagnosticsBuilderProgram", e))(qie || {}); + function HO(e, t, n, i, s, o) { + let c, _, u; + return e === void 0 ? (E.assert(t === void 0), c = n, u = i, E.assert(!!u), _ = u.getProgram()) : as(e) ? (u = i, _ = wA({ + rootNames: e, + options: t, + host: n, + oldProgram: u && u.getProgramOrUndefined(), + configFileParsingDiagnostics: s, + projectReferences: o + }), c = n) : (_ = e, c = t, u = n, s = i), { host: c, newProgram: _, oldProgram: u, configFileParsingDiagnostics: s || Ge }; + } + function Hve(e, t) { + return t?.sourceMapUrlPos !== void 0 ? e.substring(0, t.sourceMapUrlPos) : e; + } + function CU(e, t, n, i, s) { + var o; + n = Hve(n, s); + let c; + return (o = s?.diagnostics) != null && o.length && (n += s.diagnostics.map((g) => `${u(g)}${n7[g.category]}${g.code}: ${_(g.messageText)}`).join(` +`)), (i.createHash ?? uD)(n); + function _(g) { + return gs(g) ? g : g === void 0 ? "" : g.next ? g.messageText + g.next.map(_).join(` +`) : g.messageText; + } + function u(g) { + return g.file.resolvedPath === t.resolvedPath ? `(${g.start},${g.length})` : (c === void 0 && (c = Hn(t.resolvedPath)), `${X2(Nf( + c, + g.file.resolvedPath, + e.getCanonicalFileName + ))}(${g.start},${g.length})`); + } + } + function fBe(e, t, n) { + return (t.createHash ?? uD)(Hve(e, n)); + } + function EU(e, { newProgram: t, host: n, oldProgram: i, configFileParsingDiagnostics: s }) { + let o = i && i.state; + if (o && t === o.program && s === t.getConfigFileParsingDiagnostics()) + return t = void 0, o = void 0, i; + const c = nBe(t, o); + t.getBuildInfo = () => _Be(tBe(c)), t = void 0, i = void 0, o = void 0; + const _ = PU(c, s); + return _.state = c, _.hasChangedEmitSignature = () => !!c.hasChangedEmitSignature, _.getAllDependencies = (O) => Md.getAllDependencies( + c, + E.checkDefined(c.program), + O + ), _.getSemanticDiagnostics = A, _.getDeclarationDiagnostics = D, _.emit = T, _.releaseProgram = () => iBe(c), e === 0 ? _.getSemanticDiagnosticsOfNextAffectedFile = P : e === 1 ? (_.getSemanticDiagnosticsOfNextAffectedFile = P, _.emitNextAffectedFile = h, _.emitBuildInfo = u) : Vs(), _; + function u(O, F) { + if (E.assert(B6(c)), qve(c)) { + const R = c.program.emitBuildInfo( + O || Os(n, n.writeFile), + F + ); + return c.buildInfoEmitPending = !1, R; + } + return bU; + } + function g(O, F, R, B, U) { + var $, W, _e, K; + E.assert(B6(c)); + let V = jve(c, F, n); + const ae = e1(c.compilerOptions); + let se = U ? 8 : R ? ae & 56 : ae; + if (!V) { + if (c.compilerOptions.outFile) { + if (c.programEmitPending && (se = qO( + c.programEmitPending, + c.seenProgramEmit, + R, + U + ), se && (V = c.program)), !V && (($ = c.emitDiagnosticsPerFile) != null && $.size)) { + const he = c.seenProgramEmit || 0; + if (!(he & xU(U))) { + c.seenProgramEmit = xU(U) | he; + const q = []; + return c.emitDiagnosticsPerFile.forEach((be) => In(q, be)), { + result: { emitSkipped: !0, diagnostics: q }, + affected: c.program + }; + } + } + } else { + const he = sBe( + c, + R, + U + ); + if (he) + ({ affectedFile: V, emitKind: se } = he); + else { + const q = aBe( + c, + U + ); + if (q) + return (c.seenEmittedFiles ?? (c.seenEmittedFiles = /* @__PURE__ */ new Map())).set( + q.affectedFile.resolvedPath, + q.seenKind | xU(U) + ), { + result: { emitSkipped: !0, diagnostics: q.diagnostics }, + affected: q.affectedFile + }; + } + } + if (!V) { + if (U || !qve(c)) return; + const he = c.program, q = he.emitBuildInfo( + O || Os(n, n.writeFile), + F + ); + return c.buildInfoEmitPending = !1, { result: q, affected: he }; + } + } + let ce; + se & 7 && (ce = 0), se & 56 && (ce = ce === void 0 ? 1 : void 0); + const fe = U ? { + emitSkipped: !0, + diagnostics: c.program.getDeclarationDiagnostics( + V === c.program ? void 0 : V, + F + ) + } : c.program.emit( + V === c.program ? void 0 : V, + S(O, B), + F, + ce, + B, + /*forceDtsEmit*/ + void 0, + /*skipBuildInfo*/ + !0 + ); + if (V !== c.program) { + const he = V; + c.seenAffectedFiles.add(he.resolvedPath), c.affectedFilesIndex !== void 0 && c.affectedFilesIndex++, c.buildInfoEmitPending = !0; + const q = ((W = c.seenEmittedFiles) == null ? void 0 : W.get(he.resolvedPath)) || 0; + (c.seenEmittedFiles ?? (c.seenEmittedFiles = /* @__PURE__ */ new Map())).set(he.resolvedPath, se | q); + const be = ((_e = c.affectedFilesPendingEmit) == null ? void 0 : _e.get(he.resolvedPath)) || ae, je = VO(be, se | q); + je ? (c.affectedFilesPendingEmit ?? (c.affectedFilesPendingEmit = /* @__PURE__ */ new Map())).set(he.resolvedPath, je) : (K = c.affectedFilesPendingEmit) == null || K.delete(he.resolvedPath), fe.diagnostics.length && (c.emitDiagnosticsPerFile ?? (c.emitDiagnosticsPerFile = /* @__PURE__ */ new Map())).set(he.resolvedPath, fe.diagnostics); + } else + c.changedFilesSet.clear(), c.programEmitPending = c.changedFilesSet.size ? VO(ae, se) : c.programEmitPending ? VO(c.programEmitPending, se) : void 0, c.seenProgramEmit = se | (c.seenProgramEmit || 0), m(fe.diagnostics), c.buildInfoEmitPending = !0; + return { result: fe, affected: V }; + } + function m(O) { + let F; + O.forEach((R) => { + if (!R.file) return; + let B = F?.get(R.file.resolvedPath); + B || (F ?? (F = /* @__PURE__ */ new Map())).set(R.file.resolvedPath, B = []), B.push(R); + }), F && (c.emitDiagnosticsPerFile = F); + } + function h(O, F, R, B) { + return g( + O, + F, + R, + B, + /*isForDtsErrors*/ + !1 + ); + } + function S(O, F) { + return E.assert(B6(c)), J_(c.compilerOptions) ? (R, B, U, $, W, _e) => { + var K, V, ae; + if (Il(R)) + if (c.compilerOptions.outFile) { + if (c.compilerOptions.composite) { + const ce = se( + c.outSignature, + /*newSignature*/ + void 0 + ); + if (!ce) return _e.skippedDtsWrite = !0; + c.outSignature = ce; + } + } else { + E.assert(W?.length === 1); + let ce; + if (!F) { + const fe = W[0], he = c.fileInfos.get(fe.resolvedPath); + if (he.signature === fe.version) { + const q = CU( + c.program, + fe, + B, + n, + _e + ); + (K = _e?.diagnostics) != null && K.length || (ce = q), q !== fe.version && (n.storeSignatureInfo && (c.signatureInfo ?? (c.signatureInfo = /* @__PURE__ */ new Map())).set( + fe.resolvedPath, + 1 + /* StoredSignatureAtEmit */ + ), c.affectedFiles && ((V = c.oldSignatures) == null ? void 0 : V.get(fe.resolvedPath)) === void 0 && (c.oldSignatures ?? (c.oldSignatures = /* @__PURE__ */ new Map())).set(fe.resolvedPath, he.signature || !1), he.signature = q); + } + } + if (c.compilerOptions.composite) { + const fe = W[0].resolvedPath; + if (ce = se((ae = c.emitSignatures) == null ? void 0 : ae.get(fe), ce), !ce) return _e.skippedDtsWrite = !0; + (c.emitSignatures ?? (c.emitSignatures = /* @__PURE__ */ new Map())).set(fe, ce); + } + } + O ? O(R, B, U, $, W, _e) : n.writeFile ? n.writeFile(R, B, U, $, W, _e) : c.program.writeFile(R, B, U, $, W, _e); + function se(ce, fe) { + const he = !ce || gs(ce) ? ce : ce[0]; + if (fe ?? (fe = fBe(B, n, _e)), fe === he) { + if (ce === he) return; + _e ? _e.differsOnlyInMap = !0 : _e = { differsOnlyInMap: !0 }; + } else + c.hasChangedEmitSignature = !0, c.latestChangedDtsFile = R; + return fe; + } + } : O || Os(n, n.writeFile); + } + function T(O, F, R, B, U) { + E.assert(B6(c)), e === 1 && Jie(c, O); + const $ = SU(_, O, F, R); + if ($) return $; + if (!O) + if (e === 1) { + let _e = [], K = !1, V, ae = [], se; + for (; se = h( + F, + R, + B, + U + ); ) + K = K || se.result.emitSkipped, V = In(V, se.result.diagnostics), ae = In(ae, se.result.emittedFiles), _e = In(_e, se.result.sourceMaps); + return { + emitSkipped: K, + diagnostics: V || Ge, + emittedFiles: ae, + sourceMaps: _e + }; + } else + Bve( + c, + B, + /*isForDtsErrors*/ + !1 + ); + const W = c.program.emit( + O, + S(F, U), + R, + B, + U + ); + return k( + O, + B, + /*isForDtsErrors*/ + !1, + W.diagnostics + ), W; + } + function k(O, F, R, B) { + !O && e !== 1 && (Bve(c, F, R), m(B)); + } + function D(O, F) { + var R; + if (E.assert(B6(c)), e === 1) { + Jie(c, O); + let B, U; + for (; B = g( + /*writeFile*/ + void 0, + F, + /*emitOnlyDtsFiles*/ + void 0, + /*customTransformers*/ + void 0, + /*isForDtsErrors*/ + !0 + ); ) + O || (U = In(U, B.result.diagnostics)); + return (O ? (R = c.emitDiagnosticsPerFile) == null ? void 0 : R.get(O.resolvedPath) : U) || Ge; + } else { + const B = c.program.getDeclarationDiagnostics(O, F); + return k( + O, + /*emitOnlyDtsFiles*/ + void 0, + /*isForDtsErrors*/ + !0, + B + ), B; + } + } + function P(O, F) { + for (E.assert(B6(c)); ; ) { + const R = jve(c, O, n); + let B; + if (R) + if (R !== c.program) { + const U = R; + if ((!F || !F(U)) && (B = kU(c, U, O)), c.seenAffectedFiles.add(U.resolvedPath), c.affectedFilesIndex++, c.buildInfoEmitPending = !0, !B) continue; + } else { + let U; + const $ = /* @__PURE__ */ new Map(); + c.program.getSourceFiles().forEach( + (W) => U = In( + U, + kU( + c, + W, + O, + $ + ) + ) + ), c.semanticDiagnosticsPerFile = $, B = U || Ge, c.changedFilesSet.clear(), c.programEmitPending = e1(c.compilerOptions), c.compilerOptions.noCheck || (c.checkPending = void 0), c.buildInfoEmitPending = !0; + } + else { + c.checkPending && !c.compilerOptions.noCheck && (c.checkPending = void 0, c.buildInfoEmitPending = !0); + return; + } + return { result: B, affected: R }; + } + } + function A(O, F) { + if (E.assert(B6(c)), Jie(c, O), O) + return kU(c, O, F); + for (; ; ) { + const B = P(F); + if (!B) break; + if (B.affected === c.program) return B.result; + } + let R; + for (const B of c.program.getSourceFiles()) + R = In(R, kU(c, B, F)); + return c.checkPending && !c.compilerOptions.noCheck && (c.checkPending = void 0, c.buildInfoEmitPending = !0), R || Ge; + } + } + function DU(e, t, n) { + var i, s; + const o = ((i = e.affectedFilesPendingEmit) == null ? void 0 : i.get(t)) || 0; + (e.affectedFilesPendingEmit ?? (e.affectedFilesPendingEmit = /* @__PURE__ */ new Map())).set(t, o | n), (s = e.emitDiagnosticsPerFile) == null || s.delete(t); + } + function Hie(e) { + return gs(e) ? { version: e, signature: e, affectsGlobalScope: void 0, impliedFormat: void 0 } : gs(e.signature) ? e : { version: e.version, signature: e.signature === !1 ? void 0 : e.version, affectsGlobalScope: e.affectsGlobalScope, impliedFormat: e.impliedFormat }; + } + function Gie(e, t) { + return dy(e) ? t : e[1] || 24; + } + function $ie(e, t) { + return e || e1(t || {}); + } + function Xie(e, t, n) { + var i, s, o, c; + const _ = Hn(Qi(t, n.getCurrentDirectory())), u = Zl(n.useCaseSensitiveFileNames()); + let g; + const m = (i = e.fileNames) == null ? void 0 : i.map(D); + let h; + const S = e.latestChangedDtsFile ? P(e.latestChangedDtsFile) : void 0, T = /* @__PURE__ */ new Map(), k = new Set(hr(e.changeFileSet, A)); + if (Vie(e)) + e.fileInfos.forEach((U, $) => { + const W = A($ + 1); + T.set(W, gs(U) ? { version: U, signature: void 0, affectsGlobalScope: void 0, impliedFormat: void 0 } : U); + }), g = { + fileInfos: T, + compilerOptions: e.options ? tO(e.options, P) : {}, + semanticDiagnosticsPerFile: R(e.semanticDiagnosticsPerFile), + emitDiagnosticsPerFile: B(e.emitDiagnosticsPerFile), + hasReusableDiagnostic: !0, + changedFilesSet: k, + latestChangedDtsFile: S, + outSignature: e.outSignature, + programEmitPending: e.pendingEmit === void 0 ? void 0 : $ie(e.pendingEmit, e.options), + hasErrors: e.errors, + checkPending: e.checkPending + }; + else { + h = (s = e.fileIdsList) == null ? void 0 : s.map((W) => new Set(W.map(A))); + const U = (o = e.options) != null && o.composite && !e.options.outFile ? /* @__PURE__ */ new Map() : void 0; + e.fileInfos.forEach((W, _e) => { + const K = A(_e + 1), V = Hie(W); + T.set(K, V), U && V.signature && U.set(K, V.signature); + }), (c = e.emitSignatures) == null || c.forEach((W) => { + if (dy(W)) U.delete(A(W)); + else { + const _e = A(W[0]); + U.set( + _e, + !gs(W[1]) && !W[1].length ? ( + // File signature is emit signature but differs in map + [U.get(_e)] + ) : W[1] + ); + } + }); + const $ = e.affectedFilesPendingEmit ? e1(e.options || {}) : void 0; + g = { + fileInfos: T, + compilerOptions: e.options ? tO(e.options, P) : {}, + referencedMap: F(e.referencedMap, e.options ?? {}), + semanticDiagnosticsPerFile: R(e.semanticDiagnosticsPerFile), + emitDiagnosticsPerFile: B(e.emitDiagnosticsPerFile), + hasReusableDiagnostic: !0, + changedFilesSet: k, + affectedFilesPendingEmit: e.affectedFilesPendingEmit && hC(e.affectedFilesPendingEmit, (W) => A(dy(W) ? W : W[0]), (W) => Gie(W, $)), + latestChangedDtsFile: S, + emitSignatures: U?.size ? U : void 0, + hasErrors: e.errors, + checkPending: e.checkPending + }; + } + return { + state: g, + getProgram: Vs, + getProgramOrUndefined: vb, + releaseProgram: Ha, + getCompilerOptions: () => g.compilerOptions, + getSourceFile: Vs, + getSourceFiles: Vs, + getOptionsDiagnostics: Vs, + getGlobalDiagnostics: Vs, + getConfigFileParsingDiagnostics: Vs, + getSyntacticDiagnostics: Vs, + getDeclarationDiagnostics: Vs, + getSemanticDiagnostics: Vs, + emit: Vs, + getAllDependencies: Vs, + getCurrentDirectory: Vs, + emitNextAffectedFile: Vs, + getSemanticDiagnosticsOfNextAffectedFile: Vs, + emitBuildInfo: Vs, + close: Ha, + hasChangedEmitSignature: mh + }; + function D(U) { + return oo(U, _, u); + } + function P(U) { + return Qi(U, _); + } + function A(U) { + return m[U - 1]; + } + function O(U) { + return h[U - 1]; + } + function F(U, $) { + const W = Md.createReferencedMap($); + return !W || !U || U.forEach(([_e, K]) => W.set(A(_e), O(K))), W; + } + function R(U) { + const $ = new Map( + uy( + T.keys(), + (W) => k.has(W) ? void 0 : [W, Ge] + ) + ); + return U?.forEach((W) => { + dy(W) ? $.delete(A(W)) : $.set(A(W[0]), W[1]); + }), $; + } + function B(U) { + return U && hC(U, ($) => A($[0]), ($) => $[1]); + } + } + function wU(e, t, n) { + const i = Hn(Qi(t, n.getCurrentDirectory())), s = Zl(n.useCaseSensitiveFileNames()), o = /* @__PURE__ */ new Map(); + let c = 0; + const _ = /* @__PURE__ */ new Map(), u = new Map(e.resolvedRoot); + return e.fileInfos.forEach((m, h) => { + const S = oo(e.fileNames[h], i, s), T = gs(m) ? m : m.version; + if (o.set(S, T), c < e.root.length) { + const k = e.root[c], D = h + 1; + as(k) ? k[0] <= D && D <= k[1] && (g(D, S), k[1] === D && c++) : k === D && (g(D, S), c++); + } + }), { fileInfos: o, roots: _ }; + function g(m, h) { + const S = u.get(m); + S ? _.set(oo(e.fileNames[S - 1], i, s), h) : _.set(h, void 0); + } + } + function Qie(e, t, n) { + if (!uBe(e)) return; + const i = Hn(Qi(t, n.getCurrentDirectory())), s = Zl(n.useCaseSensitiveFileNames()); + return e.root.map((o) => oo(o, i, s)); + } + function PU(e, t) { + return { + state: void 0, + getProgram: n, + getProgramOrUndefined: () => e.program, + releaseProgram: () => e.program = void 0, + getCompilerOptions: () => e.compilerOptions, + getSourceFile: (i) => n().getSourceFile(i), + getSourceFiles: () => n().getSourceFiles(), + getOptionsDiagnostics: (i) => n().getOptionsDiagnostics(i), + getGlobalDiagnostics: (i) => n().getGlobalDiagnostics(i), + getConfigFileParsingDiagnostics: () => t, + getSyntacticDiagnostics: (i, s) => n().getSyntacticDiagnostics(i, s), + getDeclarationDiagnostics: (i, s) => n().getDeclarationDiagnostics(i, s), + getSemanticDiagnostics: (i, s) => n().getSemanticDiagnostics(i, s), + emit: (i, s, o, c, _) => n().emit(i, s, o, c, _), + emitBuildInfo: (i, s) => n().emitBuildInfo(i, s), + getAllDependencies: Vs, + getCurrentDirectory: () => n().getCurrentDirectory(), + close: Ha + }; + function n() { + return E.checkDefined(e.program); + } + } + function Gve(e, t, n, i, s, o) { + return EU( + 0, + HO( + e, + t, + n, + i, + s, + o + ) + ); + } + function NU(e, t, n, i, s, o) { + return EU( + 1, + HO( + e, + t, + n, + i, + s, + o + ) + ); + } + function $ve(e, t, n, i, s, o) { + const { newProgram: c, configFileParsingDiagnostics: _ } = HO( + e, + t, + n, + i, + s, + o + ); + return PU( + { program: c, compilerOptions: c.getCompilerOptions() }, + _ + ); + } + function GO(e) { + return wo(e, "/node_modules/.staging") ? bC(e, "/.staging") : ot(a7, (t) => e.includes(t)) ? void 0 : e; + } + function Yie(e, t) { + if (t <= 1) return 1; + let n = 1, i = e[0].search(/[a-z]:/i) === 0; + if (e[0] !== So && !i && // Non dos style paths + e[1].search(/[a-z]\$$/i) === 0) { + if (t === 2) return 2; + n = 2, i = !0; + } + return i && !e[n].match(/^users$/i) ? n : e[n].match(/^workspaces$/i) ? n + 1 : n + 2; + } + function AU(e, t) { + if (t === void 0 && (t = e.length), t <= 2) return !1; + const n = Yie(e, t); + return t > n + 1; + } + function AA(e) { + return AU(fu(e)); + } + function Zie(e) { + return Qve(Hn(e)); + } + function Xve(e, t) { + if (t.length < e.length) return !1; + for (let n = 0; n < e.length; n++) + if (t[n] !== e[n]) return !1; + return !0; + } + function Qve(e) { + return AA(e); + } + function Kie(e) { + return Qve(e); + } + function IU(e, t, n, i, s, o, c, _) { + const u = fu(t); + e = Z_(e) ? Hs(e) : Qi(e, c()); + const g = fu(e), m = Yie(u, u.length); + if (u.length <= m + 1) return; + const h = u.indexOf("node_modules"); + if (h !== -1 && h + 1 <= m + 1) return; + const S = u.lastIndexOf("node_modules"); + return o && Xve(s, u) ? u.length > s.length + 1 ? ese( + g, + u, + Math.max(s.length + 1, m + 1), + S + ) : { + dir: n, + dirPath: i, + nonRecursive: !0 + } : Yve( + g, + u, + u.length - 1, + m, + h, + s, + S, + _ + ); + } + function Yve(e, t, n, i, s, o, c, _) { + if (s !== -1) + return ese( + e, + t, + s + 1, + c + ); + let u = !0, g = n; + if (!_) { + for (let m = 0; m < n; m++) + if (t[m] !== o[m]) { + u = !1, g = Math.max(m + 1, i + 1); + break; + } + } + return ese( + e, + t, + g, + c, + u + ); + } + function ese(e, t, n, i, s) { + let o; + return i !== -1 && i + 1 >= n && i + 2 < t.length && (Ui(t[i + 1], "@") ? i + 3 < t.length && (o = i + 3) : o = i + 2), { + dir: B1(e, n), + dirPath: B1(t, n), + nonRecursive: s, + packageDir: o !== void 0 ? B1(e, o) : void 0, + packageDirPath: o !== void 0 ? B1(t, o) : void 0 + }; + } + function tse(e, t, n, i, s, o, c, _) { + const u = fu(t); + if (s && Xve(i, u)) + return n; + e = Z_(e) ? Hs(e) : Qi(e, o()); + const g = Yve( + fu(e), + u, + u.length, + Yie(u, u.length), + u.indexOf("node_modules"), + i, + u.lastIndexOf("node_modules"), + c + ); + return g && _(g.dirPath) ? g.dirPath : void 0; + } + function rse(e, t) { + const n = Qi(e, t()); + return yj(n) ? n : _0(n); + } + function $O(e) { + var t; + return ((t = e.getCompilerHost) == null ? void 0 : t.call(e)) || e; + } + function nse(e, t, n, i, s) { + return { + nameAndMode: RO, + resolve: (o, c) => pBe( + i, + s, + o, + e, + n, + t, + c + ) + }; + } + function pBe(e, t, n, i, s, o, c) { + const _ = $O(e), u = MS(n, i, s, _, t, o, c); + if (!e.getGlobalTypingsCacheLocation) + return u; + const g = e.getGlobalTypingsCacheLocation(); + if (g !== void 0 && !Dl(n) && !(u.resolvedModule && nF(u.resolvedModule.extension))) { + const { resolvedModule: m, failedLookupLocations: h, affectingLocations: S, resolutionDiagnostics: T } = dne( + E.checkDefined(e.globalCacheResolutionModuleName)(n), + e.projectName, + s, + _, + g, + t + ); + if (m) + return u.resolvedModule = m, u.failedLookupLocations = P6(u.failedLookupLocations, h), u.affectingLocations = P6(u.affectingLocations, S), u.resolutionDiagnostics = P6(u.resolutionDiagnostics, T), u; + } + return u; + } + function FU(e, t, n) { + let i, s, o; + const c = /* @__PURE__ */ new Set(), _ = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Set(), g = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(); + let h = !1, S, T, k, D, P, A = !1; + const O = Uu(() => e.getCurrentDirectory()), F = e.getCachedDirectoryStructureHost(), R = /* @__PURE__ */ new Map(), B = A6( + O(), + e.getCanonicalFileName, + e.getCompilationSettings() + ), U = /* @__PURE__ */ new Map(), $ = _O( + O(), + e.getCanonicalFileName, + e.getCompilationSettings(), + B.getPackageJsonInfoCache(), + B.optionsToRedirectsKey + ), W = /* @__PURE__ */ new Map(), _e = A6( + O(), + e.getCanonicalFileName, + dW(e.getCompilationSettings()), + B.getPackageJsonInfoCache() + ), K = /* @__PURE__ */ new Map(), V = /* @__PURE__ */ new Map(), ae = rse(t, O), se = e.toPath(ae), ce = fu(se), fe = AU(ce), he = /* @__PURE__ */ new Map(), q = /* @__PURE__ */ new Map(), be = /* @__PURE__ */ new Map(), je = /* @__PURE__ */ new Map(); + return { + rootDirForResolution: t, + resolvedModuleNames: R, + resolvedTypeReferenceDirectives: U, + resolvedLibraries: W, + resolvedFileToResolution: g, + resolutionsWithFailedLookups: _, + resolutionsWithOnlyAffectingLocations: u, + directoryWatchesOfFailedLookups: K, + fileWatchesOfAffectingLocations: V, + packageDirWatchers: q, + dirPathToSymlinkPackageRefCount: be, + watchFailedLookupLocationsOfExternalModuleResolutions: Wt, + getModuleResolutionCache: () => B, + startRecordingFilesWithChangedResolutions: pe, + finishRecordingFilesWithChangedResolutions: Te, + // perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update + // (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution) + startCachingPerDirectoryResolution: ne, + finishCachingPerDirectoryResolution: ie, + resolveModuleNameLiterals: Bt, + resolveTypeReferenceDirectiveReferences: St, + resolveLibrary: tr, + resolveSingleModuleNameWithoutWatching: Nr, + removeResolutionsFromProjectReferenceRedirects: Un, + removeResolutionsOfFile: ki, + hasChangedAutomaticTypeDirectiveNames: () => h, + invalidateResolutionOfFile: Ks, + invalidateResolutionsOfFailedLookupLocations: Et, + setFilesWithInvalidatedNonRelativeUnresolvedImports: yr, + createHasInvalidatedResolutions: Ye, + isFileWithInvalidatedNonRelativeUnresolvedImports: Fe, + updateTypeRootsWatch: Ke, + closeTypeRootsWatch: Ae, + clear: me, + onChangesAffectModuleResolution: Z + }; + function me() { + B_(K, gp), B_(V, gp), he.clear(), q.clear(), be.clear(), c.clear(), Ae(), R.clear(), U.clear(), g.clear(), _.clear(), u.clear(), k = void 0, D = void 0, P = void 0, T = void 0, S = void 0, A = !1, B.clear(), $.clear(), B.update(e.getCompilationSettings()), $.update(e.getCompilationSettings()), _e.clear(), m.clear(), W.clear(), h = !1; + } + function Z() { + A = !0, B.clearAllExceptPackageJsonInfoCache(), $.clearAllExceptPackageJsonInfoCache(), B.update(e.getCompilationSettings()), $.update(e.getCompilationSettings()); + } + function pe() { + i = []; + } + function Te() { + const Le = i; + return i = void 0, Le; + } + function Fe(Le) { + if (!o) + return !1; + const mt = o.get(Le); + return !!mt && !!mt.length; + } + function Ye(Le, mt) { + Et(); + const pt = s; + return s = void 0, { + hasInvalidatedResolutions: (Ct) => Le(Ct) || A || !!pt?.has(Ct) || Fe(Ct), + hasInvalidatedLibResolutions: (Ct) => { + var qe; + return mt(Ct) || !!((qe = W?.get(Ct)) != null && qe.isInvalidated); + } + }; + } + function ne() { + B.isReadonly = void 0, $.isReadonly = void 0, _e.isReadonly = void 0, B.getPackageJsonInfoCache().isReadonly = void 0, B.clearAllExceptPackageJsonInfoCache(), $.clearAllExceptPackageJsonInfoCache(), _e.clearAllExceptPackageJsonInfoCache(), ai(), he.clear(); + } + function Se(Le) { + W.forEach((mt, pt) => { + var Ct; + (Ct = Le?.resolvedLibReferences) != null && Ct.has(pt) || (ft( + mt, + e.toPath(BO(e.getCompilationSettings(), O(), pt)), + _x + ), W.delete(pt)); + }); + } + function ie(Le, mt) { + o = void 0, A = !1, ai(), Le !== mt && (Se(Le), Le?.getSourceFiles().forEach((pt) => { + var Ct; + const qe = ((Ct = pt.packageJsonLocations) == null ? void 0 : Ct.length) ?? 0, Lt = m.get(pt.resolvedPath) ?? Ge; + for (let rn = Lt.length; rn < qe; rn++) + Dt( + pt.packageJsonLocations[rn], + /*forResolution*/ + !1 + ); + if (Lt.length > qe) + for (let rn = qe; rn < Lt.length; rn++) + V.get(Lt[rn]).files--; + qe ? m.set(pt.resolvedPath, pt.packageJsonLocations) : m.delete(pt.resolvedPath); + }), m.forEach((pt, Ct) => { + const qe = Le?.getSourceFileByPath(Ct); + (!qe || qe.resolvedPath !== Ct) && (pt.forEach((Lt) => V.get(Lt).files--), m.delete(Ct)); + })), K.forEach(Ee), V.forEach(Ce), q.forEach(Ne), h = !1, B.isReadonly = !0, $.isReadonly = !0, _e.isReadonly = !0, B.getPackageJsonInfoCache().isReadonly = !0, he.clear(); + } + function Ne(Le, mt) { + Le.dirPathToWatcher.size === 0 && q.delete(mt); + } + function Ee(Le, mt) { + Le.refCount === 0 && (K.delete(mt), Le.watcher.close()); + } + function Ce(Le, mt) { + var pt; + Le.files === 0 && Le.resolutions === 0 && !((pt = Le.symlinks) != null && pt.size) && (V.delete(mt), Le.watcher.close()); + } + function Ve({ + entries: Le, + containingFile: mt, + containingSourceFile: pt, + redirectedReference: Ct, + options: qe, + perFileCache: Lt, + reusedNames: rn, + loader: Pe, + getResolutionWithResolvedFileName: yt, + deferWatchingNonRelativeResolution: ue, + shouldRetryResolution: M, + logChanges: ye + }) { + var Q; + const dt = e.toPath(mt), Mt = Lt.get(dt) || Lt.set(dt, N6()).get(dt), ke = [], at = ye && Fe(dt), wt = e.getCurrentProgram(), Zr = wt && ((Q = wt.getRedirectFromSourceFile(mt)) == null ? void 0 : Q.resolvedRef), Rr = Zr ? !Ct || Ct.sourceFile.path !== Zr.sourceFile.path : !!Ct, Pr = N6(); + for (const vt of Le) { + const Nt = Pe.nameAndMode.getName(vt), Jt = Pe.nameAndMode.getMode(vt, pt, Ct?.commandLine.options || qe); + let _r = Mt.get(Nt, Jt); + if (!Pr.has(Nt, Jt) && (A || Rr || !_r || _r.isInvalidated || // If the name is unresolved import that was invalidated, recalculate + at && !Dl(Nt) && M(_r))) { + const nr = _r; + _r = Pe.resolve(Nt, Jt), e.onDiscoveredSymlink && dBe(_r) && e.onDiscoveredSymlink(), Mt.set(Nt, Jt, _r), _r !== nr && (Wt(Nt, _r, dt, yt, ue), nr && ft(nr, dt, yt)), ye && i && !rt(nr, _r) && (i.push(dt), ye = !1); + } else { + const nr = $O(e); + if (Xy(qe, nr) && !Pr.has(Nt, Jt)) { + const kt = yt(_r); + ts( + nr, + Lt === R ? kt?.resolvedFileName ? kt.packageId ? p.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : p.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : p.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved : kt?.resolvedFileName ? kt.packageId ? p.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : p.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : p.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved, + Nt, + mt, + kt?.resolvedFileName, + kt?.packageId && U1(kt.packageId) + ); + } + } + E.assert(_r !== void 0 && !_r.isInvalidated), Pr.set(Nt, Jt, !0), ke.push(_r); + } + return rn?.forEach( + (vt) => Pr.set( + Pe.nameAndMode.getName(vt), + Pe.nameAndMode.getMode(vt, pt, Ct?.commandLine.options || qe), + !0 + ) + ), Mt.size() !== Pr.size() && Mt.forEach((vt, Nt, Jt) => { + Pr.has(Nt, Jt) || (ft(vt, dt, yt), Mt.delete(Nt, Jt)); + }), ke; + function rt(vt, Nt) { + if (vt === Nt) + return !0; + if (!vt || !Nt) + return !1; + const Jt = yt(vt), _r = yt(Nt); + return Jt === _r ? !0 : !Jt || !_r ? !1 : Jt.resolvedFileName === _r.resolvedFileName; + } + } + function St(Le, mt, pt, Ct, qe, Lt) { + return Ve({ + entries: Le, + containingFile: mt, + containingSourceFile: qe, + redirectedReference: pt, + options: Ct, + reusedNames: Lt, + perFileCache: U, + loader: jO( + mt, + pt, + Ct, + $O(e), + $ + ), + getResolutionWithResolvedFileName: B7, + shouldRetryResolution: (rn) => rn.resolvedTypeReferenceDirective === void 0, + deferWatchingNonRelativeResolution: !1 + }); + } + function Bt(Le, mt, pt, Ct, qe, Lt) { + return Ve({ + entries: Le, + containingFile: mt, + containingSourceFile: qe, + redirectedReference: pt, + options: Ct, + reusedNames: Lt, + perFileCache: R, + loader: nse( + mt, + pt, + Ct, + e, + B + ), + getResolutionWithResolvedFileName: _x, + shouldRetryResolution: (rn) => !rn.resolvedModule || !f4(rn.resolvedModule.extension), + logChanges: n, + deferWatchingNonRelativeResolution: !0 + // Defer non relative resolution watch because we could be using ambient modules + }); + } + function tr(Le, mt, pt, Ct) { + const qe = $O(e); + let Lt = W?.get(Ct); + if (!Lt || Lt.isInvalidated) { + const rn = Lt; + Lt = fO(Le, mt, pt, qe, _e); + const Pe = e.toPath(mt); + Wt( + Le, + Lt, + Pe, + _x, + /*deferWatchingNonRelativeResolution*/ + !1 + ), W.set(Ct, Lt), rn && ft(rn, Pe, _x); + } else if (Xy(pt, qe)) { + const rn = _x(Lt); + ts( + qe, + rn?.resolvedFileName ? rn.packageId ? p.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : p.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : p.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved, + Le, + mt, + rn?.resolvedFileName, + rn?.packageId && U1(rn.packageId) + ); + } + return Lt; + } + function Nr(Le, mt) { + var pt, Ct; + const qe = e.toPath(mt), Lt = R.get(qe), rn = Lt?.get( + Le, + /*mode*/ + void 0 + ); + if (rn && !rn.isInvalidated) return rn; + const Pe = (pt = e.beforeResolveSingleModuleNameWithoutWatching) == null ? void 0 : pt.call(e, B), yt = $O(e), ue = MS( + Le, + mt, + e.getCompilationSettings(), + yt, + B + ); + return (Ct = e.afterResolveSingleModuleNameWithoutWatching) == null || Ct.call(e, B, Le, mt, ue, Pe), ue; + } + function st(Le) { + return wo(Le, "/node_modules/@types"); + } + function Wt(Le, mt, pt, Ct, qe) { + if ((mt.files ?? (mt.files = /* @__PURE__ */ new Set())).add(pt), mt.files.size !== 1) return; + !qe || Dl(Le) ? ui(mt) : c.add(mt); + const Lt = Ct(mt); + if (Lt && Lt.resolvedFileName) { + const rn = e.toPath(Lt.resolvedFileName); + let Pe = g.get(rn); + Pe || g.set(rn, Pe = /* @__PURE__ */ new Set()), Pe.add(mt); + } + } + function Jr(Le, mt) { + const pt = e.toPath(Le), Ct = IU( + Le, + pt, + ae, + se, + ce, + fe, + O, + e.preferNonRecursiveWatch + ); + if (Ct) { + const { dir: qe, dirPath: Lt, nonRecursive: rn, packageDir: Pe, packageDirPath: yt } = Ct; + Lt === se ? (E.assert(rn), E.assert(!Pe), mt = !0) : pn(qe, Lt, Pe, yt, rn); + } + return mt; + } + function ui(Le) { + var mt; + E.assert(!!((mt = Le.files) != null && mt.size)); + const { failedLookupLocations: pt, affectingLocations: Ct, alternateResult: qe } = Le; + if (!pt?.length && !Ct?.length && !qe) return; + (pt?.length || qe) && _.add(Le); + let Lt = !1; + if (pt) + for (const rn of pt) + Lt = Jr(rn, Lt); + qe && (Lt = Jr(qe, Lt)), Lt && pn( + ae, + se, + /*packageDir*/ + void 0, + /*packageDirPath*/ + void 0, + /*nonRecursive*/ + !0 + ), Ji(Le, !pt?.length && !qe); + } + function Ji(Le, mt) { + var pt; + E.assert(!!((pt = Le.files) != null && pt.size)); + const { affectingLocations: Ct } = Le; + if (Ct?.length) { + mt && u.add(Le); + for (const qe of Ct) + Dt( + qe, + /*forResolution*/ + !0 + ); + } + } + function Dt(Le, mt) { + const pt = V.get(Le); + if (pt) { + mt ? pt.resolutions++ : pt.files++; + return; + } + let Ct = Le, qe = !1, Lt; + e.realpath && (Ct = e.realpath(Le), Le !== Ct && (qe = !0, Lt = V.get(Ct))); + const rn = mt ? 1 : 0, Pe = mt ? 0 : 1; + if (!qe || !Lt) { + const yt = { + watcher: Kie(e.toPath(Ct)) ? e.watchAffectingFileLocation(Ct, (ue, M) => { + F?.addOrDeleteFile(ue, e.toPath(Ct), M), Mn(Ct, B.getPackageJsonInfoCache().getInternalMap()), e.scheduleInvalidateResolutionsOfFailedLookupLocations(); + }) : z6, + resolutions: qe ? 0 : rn, + files: qe ? 0 : Pe, + symlinks: void 0 + }; + V.set(Ct, yt), qe && (Lt = yt); + } + if (qe) { + E.assert(!!Lt); + const yt = { + watcher: { + close: () => { + var ue; + const M = V.get(Ct); + (ue = M?.symlinks) != null && ue.delete(Le) && !M.symlinks.size && !M.resolutions && !M.files && (V.delete(Ct), M.watcher.close()); + } + }, + resolutions: rn, + files: Pe, + symlinks: void 0 + }; + V.set(Le, yt), (Lt.symlinks ?? (Lt.symlinks = /* @__PURE__ */ new Set())).add(Le); + } + } + function Mn(Le, mt) { + var pt; + const Ct = V.get(Le); + Ct?.resolutions && (T ?? (T = /* @__PURE__ */ new Set())).add(Le), Ct?.files && (S ?? (S = /* @__PURE__ */ new Set())).add(Le), (pt = Ct?.symlinks) == null || pt.forEach((qe) => Mn(qe, mt)), mt?.delete(e.toPath(Le)); + } + function ai() { + c.forEach(ui), c.clear(); + } + function fi(Le, mt, pt, Ct, qe) { + E.assert(!qe); + let Lt = he.get(Ct), rn = q.get(Ct); + if (Lt === void 0) { + const ue = e.realpath(pt); + Lt = ue !== pt && e.toPath(ue) !== Ct, he.set(Ct, Lt), rn ? rn.isSymlink !== Lt && (rn.dirPathToWatcher.forEach((M) => { + er(rn.isSymlink ? Ct : mt), M.watcher = yt(); + }), rn.isSymlink = Lt) : q.set( + Ct, + rn = { + dirPathToWatcher: /* @__PURE__ */ new Map(), + isSymlink: Lt + } + ); + } else + E.assertIsDefined(rn), E.assert(Lt === rn.isSymlink); + const Pe = rn.dirPathToWatcher.get(mt); + Pe ? Pe.refCount++ : (rn.dirPathToWatcher.set(mt, { + watcher: yt(), + refCount: 1 + }), Lt && be.set(mt, (be.get(mt) ?? 0) + 1)); + function yt() { + return Lt ? _i(pt, Ct, qe) : _i(Le, mt, qe); + } + } + function pn(Le, mt, pt, Ct, qe) { + !Ct || !e.realpath ? _i(Le, mt, qe) : fi(Le, mt, pt, Ct, qe); + } + function _i(Le, mt, pt) { + let Ct = K.get(mt); + return Ct ? (E.assert(!!pt == !!Ct.nonRecursive), Ct.refCount++) : K.set(mt, Ct = { watcher: qr(Le, mt, pt), refCount: 1, nonRecursive: pt }), Ct; + } + function Je(Le, mt) { + const pt = e.toPath(Le), Ct = IU( + Le, + pt, + ae, + se, + ce, + fe, + O, + e.preferNonRecursiveWatch + ); + if (Ct) { + const { dirPath: qe, packageDirPath: Lt } = Ct; + if (qe === se) + mt = !0; + else if (Lt && e.realpath) { + const rn = q.get(Lt), Pe = rn.dirPathToWatcher.get(qe); + if (Pe.refCount--, Pe.refCount === 0 && (er(rn.isSymlink ? Lt : qe), rn.dirPathToWatcher.delete(qe), rn.isSymlink)) { + const yt = be.get(qe) - 1; + yt === 0 ? be.delete(qe) : be.set(qe, yt); + } + } else + er(qe); + } + return mt; + } + function ft(Le, mt, pt) { + if (E.checkDefined(Le.files).delete(mt), Le.files.size) return; + Le.files = void 0; + const Ct = pt(Le); + if (Ct && Ct.resolvedFileName) { + const Pe = e.toPath(Ct.resolvedFileName), yt = g.get(Pe); + yt?.delete(Le) && !yt.size && g.delete(Pe); + } + const { failedLookupLocations: qe, affectingLocations: Lt, alternateResult: rn } = Le; + if (_.delete(Le)) { + let Pe = !1; + if (qe) + for (const yt of qe) + Pe = Je(yt, Pe); + rn && (Pe = Je(rn, Pe)), Pe && er(se); + } else Lt?.length && u.delete(Le); + if (Lt) + for (const Pe of Lt) { + const yt = V.get(Pe); + yt.resolutions--; + } + } + function er(Le) { + const mt = K.get(Le); + mt.refCount--; + } + function qr(Le, mt, pt) { + return e.watchDirectoryOfFailedLookupLocation( + Le, + (Ct) => { + const qe = e.toPath(Ct); + F && F.addOrDeleteFileOrDirectory(Ct, qe), bs(qe, mt === qe); + }, + pt ? 0 : 1 + /* Recursive */ + ); + } + function Jn(Le, mt, pt) { + const Ct = Le.get(mt); + Ct && (Ct.forEach( + (qe) => ft( + qe, + mt, + pt + ) + ), Le.delete(mt)); + } + function Un(Le) { + if (!Xo( + Le, + ".json" + /* Json */ + )) return; + const mt = e.getCurrentProgram(); + if (!mt) return; + const pt = mt.getResolvedProjectReferenceByPath(Le); + pt && pt.commandLine.fileNames.forEach((Ct) => ki(e.toPath(Ct))); + } + function ki(Le) { + Jn(R, Le, _x), Jn(U, Le, B7); + } + function Ds(Le, mt) { + if (!Le) return !1; + let pt = !1; + return Le.forEach((Ct) => { + if (!(Ct.isInvalidated || !mt(Ct))) { + Ct.isInvalidated = pt = !0; + for (const qe of E.checkDefined(Ct.files)) + (s ?? (s = /* @__PURE__ */ new Set())).add(qe), h = h || wo(qe, cw); + } + }), pt; + } + function Ks(Le) { + ki(Le); + const mt = h; + Ds(g.get(Le), yb) && h && !mt && e.onChangedAutomaticTypeDirectiveNames(); + } + function yr(Le) { + E.assert(o === Le || o === void 0), o = Le; + } + function bs(Le, mt) { + if (mt) + (P || (P = /* @__PURE__ */ new Set())).add(Le); + else { + const pt = GO(Le); + if (!pt || (Le = pt, e.fileIsOpen(Le))) + return !1; + const Ct = Hn(Le); + if (st(Le) || _7(Le) || st(Ct) || _7(Ct)) + (k || (k = /* @__PURE__ */ new Set())).add(Le), (D || (D = /* @__PURE__ */ new Set())).add(Le); + else { + if (xie(e.getCurrentProgram(), Le) || Xo(Le, ".map")) + return !1; + (k || (k = /* @__PURE__ */ new Set())).add(Le), (D || (D = /* @__PURE__ */ new Set())).add(Le); + const qe = lA( + Le, + /*isFolder*/ + !0 + ); + qe && (D || (D = /* @__PURE__ */ new Set())).add(qe); + } + } + e.scheduleInvalidateResolutionsOfFailedLookupLocations(); + } + function Xe() { + const Le = B.getPackageJsonInfoCache().getInternalMap(); + Le && (k || D || P) && Le.forEach((mt, pt) => it(pt) ? Le.delete(pt) : void 0); + } + function Et() { + var Le; + if (A) + return S = void 0, Xe(), (k || D || P || T) && Ds(W, re), k = void 0, D = void 0, P = void 0, T = void 0, !0; + let mt = !1; + return S && ((Le = e.getCurrentProgram()) == null || Le.getSourceFiles().forEach((pt) => { + ot(pt.packageJsonLocations, (Ct) => S.has(Ct)) && ((s ?? (s = /* @__PURE__ */ new Set())).add(pt.path), mt = !0); + }), S = void 0), !k && !D && !P && !T || (mt = Ds(_, re) || mt, Xe(), k = void 0, D = void 0, P = void 0, mt = Ds(u, Y) || mt, T = void 0), mt; + } + function re(Le) { + var mt; + return Y(Le) ? !0 : !k && !D && !P ? !1 : ((mt = Le.failedLookupLocations) == null ? void 0 : mt.some((pt) => it(e.toPath(pt)))) || !!Le.alternateResult && it(e.toPath(Le.alternateResult)); + } + function it(Le) { + return k?.has(Le) || MP(D?.keys() || [], (mt) => Ui(Le, mt) ? !0 : void 0) || MP(P?.keys() || [], (mt) => Le.length > mt.length && Ui(Le, mt) && (yj(mt) || Le[mt.length] === So) ? !0 : void 0); + } + function Y(Le) { + var mt; + return !!T && ((mt = Le.affectingLocations) == null ? void 0 : mt.some((pt) => T.has(pt))); + } + function Ae() { + B_(je, od); + } + function $e(Le) { + return Tt(Le) ? e.watchTypeRootsDirectory( + Le, + (mt) => { + const pt = e.toPath(mt); + F && F.addOrDeleteFileOrDirectory(mt, pt), h = !0, e.onChangedAutomaticTypeDirectiveNames(); + const Ct = tse( + Le, + e.toPath(Le), + se, + ce, + fe, + O, + e.preferNonRecursiveWatch, + (qe) => K.has(qe) || be.has(qe) + ); + Ct && bs(pt, Ct === pt); + }, + 1 + /* Recursive */ + ) : z6; + } + function Ke() { + const Le = e.getCompilationSettings(); + if (Le.types) { + Ae(); + return; + } + const mt = q4(Le, { getCurrentDirectory: O }); + mt ? o4( + je, + new Set(mt), + { + createNewValue: $e, + onDeleteValue: od + } + ) : Ae(); + } + function Tt(Le) { + return e.getCompilationSettings().typeRoots ? !0 : Zie(e.toPath(Le)); + } + } + function dBe(e) { + var t, n; + return !!((t = e.resolvedModule) != null && t.originalPath || (n = e.resolvedTypeReferenceDirective) != null && n.originalPath); + } + var Zve = ml ? { + getCurrentDirectory: () => ml.getCurrentDirectory(), + getNewLine: () => ml.newLine, + getCanonicalFileName: Zl(ml.useCaseSensitiveFileNames) + } : void 0; + function lk(e, t) { + const n = e === ml && Zve ? Zve : { + getCurrentDirectory: () => e.getCurrentDirectory(), + getNewLine: () => e.newLine, + getCanonicalFileName: Zl(e.useCaseSensitiveFileNames) + }; + if (!t) + return (s) => e.write(pU(s, n)); + const i = new Array(1); + return (s) => { + i[0] = s, e.write(Nie(i, n) + n.getNewLine()), i[0] = void 0; + }; + } + function Kve(e, t, n) { + return e.clearScreen && !n.preserveWatchOutput && !n.extendedDiagnostics && !n.diagnostics && ms(ebe, t.code) ? (e.clearScreen(), !0) : !1; + } + var ebe = [ + p.Starting_compilation_in_watch_mode.code, + p.File_change_detected_Starting_incremental_compilation.code + ]; + function mBe(e, t) { + return ms(ebe, e.code) ? t + t : t; + } + function IA(e) { + return e.now ? ( + // On some systems / builds of Node, there's a non-breaking space between the time and AM/PM. + // This branch is solely for testing, so just switch it to a normal space for baseline stability. + // See: + // - https://github.com/nodejs/node/issues/45171 + // - https://github.com/nodejs/node/issues/45753 + e.now().toLocaleTimeString("en-US", { timeZone: "UTC" }).replace(" ", " ") + ) : (/* @__PURE__ */ new Date()).toLocaleTimeString(); + } + function OU(e, t) { + return t ? (n, i, s) => { + Kve(e, n, s); + let o = `[${s2( + IA(e), + "\x1B[90m" + /* Grey */ + )}] `; + o += `${km(n.messageText, e.newLine)}${i + i}`, e.write(o); + } : (n, i, s) => { + let o = ""; + Kve(e, n, s) || (o += i), o += `${IA(e)} - `, o += `${km(n.messageText, e.newLine)}${mBe(n, i)}`, e.write(o); + }; + } + function ise(e, t, n, i, s, o) { + const c = s; + c.onUnRecoverableConfigFileDiagnostic = (u) => nbe(s, o, u); + const _ = rA(e, t, c, n, i); + return c.onUnRecoverableConfigFileDiagnostic = void 0, _; + } + function XO(e) { + return l0( + e, + (t) => t.category === 1 + /* Error */ + ); + } + function QO(e) { + return kn( + e, + (n) => n.category === 1 + /* Error */ + ).map( + (n) => { + if (n.file !== void 0) + return `${n.file.fileName}`; + } + ).map((n) => { + if (n === void 0) + return; + const i = Nn(e, (s) => s.file !== void 0 && s.file.fileName === n); + if (i !== void 0) { + const { line: s } = js(i.file, i.start); + return { + fileName: n, + line: s + 1 + }; + } + }); + } + function LU(e) { + return e === 1 ? p.Found_1_error_Watching_for_file_changes : p.Found_0_errors_Watching_for_file_changes; + } + function tbe(e, t) { + const n = s2( + ":" + e.line, + "\x1B[90m" + /* Grey */ + ); + return _D(e.fileName) && _D(t) ? Nf( + t, + e.fileName, + /*ignoreCase*/ + !1 + ) + n : e.fileName + n; + } + function MU(e, t, n, i) { + if (e === 0) return ""; + const s = t.filter((m) => m !== void 0), o = s.map((m) => `${m.fileName}:${m.line}`).filter((m, h, S) => S.indexOf(m) === h), c = s[0] && tbe(s[0], i.getCurrentDirectory()); + let _; + e === 1 ? _ = t[0] !== void 0 ? [p.Found_1_error_in_0, c] : [p.Found_1_error] : _ = o.length === 0 ? [p.Found_0_errors, e] : o.length === 1 ? [p.Found_0_errors_in_the_same_file_starting_at_Colon_1, e, c] : [p.Found_0_errors_in_1_files, e, o.length]; + const u = Yo(..._), g = o.length > 1 ? gBe(s, i) : ""; + return `${n}${km(u.messageText, n)}${n}${n}${g}`; + } + function gBe(e, t) { + const n = e.filter((h, S, T) => S === T.findIndex((k) => k?.fileName === h?.fileName)); + if (n.length === 0) return ""; + const i = (h) => Math.log(h) * Math.LOG10E + 1, s = n.map((h) => [h, l0(e, (S) => S.fileName === h.fileName)]), o = BR(s, 0, (h) => h[1]), c = p.Errors_Files.message, _ = c.split(" ")[0].length, u = Math.max(_, i(o)), g = Math.max(i(o) - _, 0); + let m = ""; + return m += " ".repeat(g) + c + ` +`, s.forEach((h) => { + const [S, T] = h, k = Math.log(T) * Math.LOG10E + 1 | 0, D = k < u ? " ".repeat(u - k) : "", P = tbe(S, t.getCurrentDirectory()); + m += `${D}${T} ${P} +`; + }), m; + } + function RU(e) { + return !!e.state; + } + function hBe(e, t) { + const n = e.getCompilerOptions(); + n.explainFiles ? jU(RU(e) ? e.getProgram() : e, t) : (n.listFiles || n.listFilesOnly) && lr(e.getSourceFiles(), (i) => { + t(i.fileName); + }); + } + function jU(e, t) { + var n, i; + const s = e.getFileIncludeReasons(), o = (c) => fD(c, e.getCurrentDirectory(), e.getCanonicalFileName); + for (const c of e.getSourceFiles()) + t(`${J6(c, o)}`), (n = s.get(c.path)) == null || n.forEach((_) => t(` ${WU(e, _, o).messageText}`)), (i = BU(c, e.getCompilerOptionsForFile(c), o)) == null || i.forEach((_) => t(` ${_.messageText}`)); + } + function BU(e, t, n) { + var i; + let s; + if (e.path !== e.resolvedPath && (s ?? (s = [])).push(Ts( + /*details*/ + void 0, + p.File_is_output_of_project_reference_source_0, + J6(e.originalFileName, n) + )), e.redirectInfo && (s ?? (s = [])).push(Ts( + /*details*/ + void 0, + p.File_redirects_to_file_0, + J6(e.redirectInfo.redirectTarget, n) + )), tf(e)) + switch (zS(e, t)) { + case 99: + e.packageJsonScope && (s ?? (s = [])).push(Ts( + /*details*/ + void 0, + p.File_is_ECMAScript_module_because_0_has_field_type_with_value_module, + J6(pa(e.packageJsonLocations), n) + )); + break; + case 1: + e.packageJsonScope ? (s ?? (s = [])).push(Ts( + /*details*/ + void 0, + e.packageJsonScope.contents.packageJsonContent.type ? p.File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module : p.File_is_CommonJS_module_because_0_does_not_have_field_type, + J6(pa(e.packageJsonLocations), n) + )) : (i = e.packageJsonLocations) != null && i.length && (s ?? (s = [])).push(Ts( + /*details*/ + void 0, + p.File_is_CommonJS_module_because_package_json_was_not_found + )); + break; + } + return s; + } + function JU(e, t) { + var n; + const i = e.getCompilerOptions().configFile; + if (!((n = i?.configFileSpecs) != null && n.validatedFilesSpec)) return; + const s = e.getCanonicalFileName(t), o = Hn(Qi(i.fileName, e.getCurrentDirectory())), c = oc(i.configFileSpecs.validatedFilesSpec, (_) => e.getCanonicalFileName(Qi(_, o)) === s); + return c !== -1 ? i.configFileSpecs.validatedFilesSpecBeforeSubstitution[c] : void 0; + } + function zU(e, t) { + var n, i; + const s = e.getCompilerOptions().configFile; + if (!((n = s?.configFileSpecs) != null && n.validatedIncludeSpecs)) return; + if (s.configFileSpecs.isDefaultIncludeSpec) return !0; + const o = Xo( + t, + ".json" + /* Json */ + ), c = Hn(Qi(s.fileName, e.getCurrentDirectory())), _ = e.useCaseSensitiveFileNames(), u = oc((i = s?.configFileSpecs) == null ? void 0 : i.validatedIncludeSpecs, (g) => { + if (o && !wo( + g, + ".json" + /* Json */ + )) return !1; + const m = PJ(g, c, "files"); + return !!m && b0(`(?:${m})$`, _).test(t); + }); + return u !== -1 ? s.configFileSpecs.validatedIncludeSpecsBeforeSubstitution[u] : void 0; + } + function WU(e, t, n) { + var i, s; + const o = e.getCompilerOptions(); + if (yv(t)) { + const c = lw(e, t), _ = j6(c) ? c.file.text.substring(c.pos, c.end) : `"${c.text}"`; + let u; + switch (E.assert(j6(c) || t.kind === 3, "Only synthetic references are imports"), t.kind) { + case 3: + j6(c) ? u = c.packageId ? p.Imported_via_0_from_file_1_with_packageId_2 : p.Imported_via_0_from_file_1 : c.text === Py ? u = c.packageId ? p.Imported_via_0_from_file_1_with_packageId_2_to_import_importHelpers_as_specified_in_compilerOptions : p.Imported_via_0_from_file_1_to_import_importHelpers_as_specified_in_compilerOptions : u = c.packageId ? p.Imported_via_0_from_file_1_with_packageId_2_to_import_jsx_and_jsxs_factory_functions : p.Imported_via_0_from_file_1_to_import_jsx_and_jsxs_factory_functions; + break; + case 4: + E.assert(!c.packageId), u = p.Referenced_via_0_from_file_1; + break; + case 5: + u = c.packageId ? p.Type_library_referenced_via_0_from_file_1_with_packageId_2 : p.Type_library_referenced_via_0_from_file_1; + break; + case 7: + E.assert(!c.packageId), u = p.Library_referenced_via_0_from_file_1; + break; + default: + E.assertNever(t); + } + return Ts( + /*details*/ + void 0, + u, + _, + J6(c.file, n), + c.packageId && U1(c.packageId) + ); + } + switch (t.kind) { + case 0: + if (!((i = o.configFile) != null && i.configFileSpecs)) return Ts( + /*details*/ + void 0, + p.Root_file_specified_for_compilation + ); + const c = Qi(e.getRootFileNames()[t.index], e.getCurrentDirectory()); + if (JU(e, c)) return Ts( + /*details*/ + void 0, + p.Part_of_files_list_in_tsconfig_json + ); + const u = zU(e, c); + return gs(u) ? Ts( + /*details*/ + void 0, + p.Matched_by_include_pattern_0_in_1, + u, + J6(o.configFile, n) + ) : ( + // Could be additional files specified as roots or matched by default include + Ts( + /*details*/ + void 0, + u ? p.Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk : p.Root_file_specified_for_compilation + ) + ); + case 1: + case 2: + const g = t.kind === 2, m = E.checkDefined((s = e.getResolvedProjectReferences()) == null ? void 0 : s[t.index]); + return Ts( + /*details*/ + void 0, + o.outFile ? g ? p.Output_from_referenced_project_0_included_because_1_specified : p.Source_from_referenced_project_0_included_because_1_specified : g ? p.Output_from_referenced_project_0_included_because_module_is_specified_as_none : p.Source_from_referenced_project_0_included_because_module_is_specified_as_none, + J6(m.sourceFile.fileName, n), + o.outFile ? "--outFile" : "--out" + ); + case 8: { + const h = o.types ? t.packageId ? [p.Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1, t.typeReference, U1(t.packageId)] : [p.Entry_point_of_type_library_0_specified_in_compilerOptions, t.typeReference] : t.packageId ? [p.Entry_point_for_implicit_type_library_0_with_packageId_1, t.typeReference, U1(t.packageId)] : [p.Entry_point_for_implicit_type_library_0, t.typeReference]; + return Ts( + /*details*/ + void 0, + ...h + ); + } + case 6: { + if (t.index !== void 0) return Ts( + /*details*/ + void 0, + p.Library_0_specified_in_compilerOptions, + o.lib[t.index] + ); + const h = q5(da(o)), S = h ? [p.Default_library_for_target_0, h] : [p.Default_library]; + return Ts( + /*details*/ + void 0, + ...S + ); + } + default: + E.assertNever(t); + } + } + function J6(e, t) { + const n = gs(e) ? e : e.fileName; + return t ? t(n) : n; + } + function YO(e, t, n, i, s, o, c, _) { + const u = e.getCompilerOptions(), g = e.getConfigFileParsingDiagnostics().slice(), m = g.length; + In(g, e.getSyntacticDiagnostics( + /*sourceFile*/ + void 0, + o + )), g.length === m && (In(g, e.getOptionsDiagnostics(o)), u.listFilesOnly || (In(g, e.getGlobalDiagnostics(o)), g.length === m && In(g, e.getSemanticDiagnostics( + /*sourceFile*/ + void 0, + o + )), u.noEmit && J_(u) && g.length === m && In(g, e.getDeclarationDiagnostics( + /*sourceFile*/ + void 0, + o + )))); + const h = u.listFilesOnly ? { emitSkipped: !0, diagnostics: Ge } : e.emit( + /*targetSourceFile*/ + void 0, + s, + o, + c, + _ + ); + In(g, h.diagnostics); + const S = DC(g); + if (S.forEach(t), n) { + const T = e.getCurrentDirectory(); + lr(h.emittedFiles, (k) => { + const D = Qi(k, T); + n(`TSFILE: ${D}`); + }), hBe(e, n); + } + return i && i(XO(S), QO(S)), { + emitResult: h, + diagnostics: S + }; + } + function UU(e, t, n, i, s, o, c, _) { + const { emitResult: u, diagnostics: g } = YO( + e, + t, + n, + i, + s, + o, + c, + _ + ); + return u.emitSkipped && g.length > 0 ? 1 : g.length > 0 ? 2 : 0; + } + var z6 = { close: Ha }, _w = () => z6; + function VU(e = ml, t) { + return { + onWatchStatusChange: t || OU(e), + watchFile: Os(e, e.watchFile) || _w, + watchDirectory: Os(e, e.watchDirectory) || _w, + setTimeout: Os(e, e.setTimeout) || Ha, + clearTimeout: Os(e, e.clearTimeout) || Ha, + preferNonRecursiveWatch: e.preferNonRecursiveWatch + }; + } + var Fl = { + ConfigFile: "Config file", + ExtendedConfigFile: "Extended config file", + SourceFile: "Source file", + MissingFile: "Missing file", + WildcardDirectory: "Wild card directory", + FailedLookupLocations: "Failed Lookup Locations", + AffectingFileLocation: "File location affecting resolution", + TypeRoots: "Type roots", + ConfigFileOfReferencedProject: "Config file of referened project", + ExtendedConfigOfReferencedProject: "Extended config file of referenced project", + WildcardDirectoryOfReferencedProject: "Wild card directory of referenced project", + PackageJson: "package.json file", + ClosedScriptInfo: "Closed Script info", + ConfigFileForInferredRoot: "Config file for the inferred project root", + NodeModules: "node_modules for closed script infos and package.jsons affecting module specifier cache", + MissingSourceMapFile: "Missing source map file", + NoopConfigFileForInferredRoot: "Noop Config file for the inferred project root", + MissingGeneratedFile: "Missing generated file", + NodeModulesForModuleSpecifierCache: "node_modules for module specifier cache invalidation", + TypingInstallerLocationFile: "File location for typing installer", + TypingInstallerLocationDirectory: "Directory location for typing installer" + }; + function qU(e, t) { + const n = e.trace ? t.extendedDiagnostics ? 2 : t.diagnostics ? 1 : 0 : 0, i = n !== 0 ? (o) => e.trace(o) : Ha, s = cU(e, n, i); + return s.writeLog = i, s; + } + function HU(e, t, n = e) { + const i = e.useCaseSensitiveFileNames(), s = { + getSourceFile: _U( + (o, c) => c ? e.readFile(o, c) : s.readFile(o), + /*setParentNodes*/ + void 0 + ), + getDefaultLibLocation: Os(e, e.getDefaultLibLocation), + getDefaultLibFileName: (o) => e.getDefaultLibFileName(o), + writeFile: fU( + (o, c, _) => e.writeFile(o, c, _), + (o) => e.createDirectory(o), + (o) => e.directoryExists(o) + ), + getCurrentDirectory: Uu(() => e.getCurrentDirectory()), + useCaseSensitiveFileNames: () => i, + getCanonicalFileName: Zl(i), + getNewLine: () => v0(t()), + fileExists: (o) => e.fileExists(o), + readFile: (o) => e.readFile(o), + trace: Os(e, e.trace), + directoryExists: Os(n, n.directoryExists), + getDirectories: Os(n, n.getDirectories), + realpath: Os(e, e.realpath), + getEnvironmentVariable: Os(e, e.getEnvironmentVariable) || (() => ""), + createHash: Os(e, e.createHash), + readDirectory: Os(e, e.readDirectory), + storeSignatureInfo: e.storeSignatureInfo, + jsDocParsingMode: e.jsDocParsingMode + }; + return s; + } + function ZO(e, t) { + if (t.match(Pne)) { + let n = t.length, i = n; + for (let s = n - 1; s >= 0; s--) { + const o = t.charCodeAt(s); + switch (o) { + case 10: + s && t.charCodeAt(s - 1) === 13 && s--; + // falls through + case 13: + break; + default: + if (o < 127 || !Cu(o)) { + i = s; + continue; + } + break; + } + const c = t.substring(i, n); + if (c.match(LW)) { + t = t.substring(0, i); + break; + } else if (!c.match(MW)) + break; + n = i; + } + } + return (e.createHash || uD)(t); + } + function KO(e) { + const t = e.getSourceFile; + e.getSourceFile = (...n) => { + const i = t.call(e, ...n); + return i && (i.version = ZO(e, i.text)), i; + }; + } + function GU(e, t) { + const n = Uu(() => Hn(Hs(e.getExecutingFilePath()))); + return { + useCaseSensitiveFileNames: () => e.useCaseSensitiveFileNames, + getNewLine: () => e.newLine, + getCurrentDirectory: Uu(() => e.getCurrentDirectory()), + getDefaultLibLocation: n, + getDefaultLibFileName: (i) => On(n(), ZP(i)), + fileExists: (i) => e.fileExists(i), + readFile: (i, s) => e.readFile(i, s), + directoryExists: (i) => e.directoryExists(i), + getDirectories: (i) => e.getDirectories(i), + readDirectory: (i, s, o, c, _) => e.readDirectory(i, s, o, c, _), + realpath: Os(e, e.realpath), + getEnvironmentVariable: Os(e, e.getEnvironmentVariable), + trace: (i) => e.write(i + e.newLine), + createDirectory: (i) => e.createDirectory(i), + writeFile: (i, s, o) => e.writeFile(i, s, o), + createHash: Os(e, e.createHash), + createProgram: t || NU, + storeSignatureInfo: e.storeSignatureInfo, + now: Os(e, e.now) + }; + } + function rbe(e = ml, t, n, i) { + const s = (c) => e.write(c + e.newLine), o = GU(e, t); + return RR(o, VU(e, i)), o.afterProgramCreate = (c) => { + const _ = c.getCompilerOptions(), u = v0(_); + YO( + c, + n, + s, + (g) => o.onWatchStatusChange( + Yo(LU(g), g), + u, + _, + g + ) + ); + }, o; + } + function nbe(e, t, n) { + t(n), e.exit( + 1 + /* DiagnosticsPresent_OutputsSkipped */ + ); + } + function $U({ + configFileName: e, + optionsToExtend: t, + watchOptionsToExtend: n, + extraFileExtensions: i, + system: s, + createProgram: o, + reportDiagnostic: c, + reportWatchStatus: _ + }) { + const u = c || lk(s), g = rbe(s, o, u, _); + return g.onUnRecoverableConfigFileDiagnostic = (m) => nbe(s, u, m), g.configFileName = e, g.optionsToExtend = t, g.watchOptionsToExtend = n, g.extraFileExtensions = i, g; + } + function XU({ + rootFiles: e, + options: t, + watchOptions: n, + projectReferences: i, + system: s, + createProgram: o, + reportDiagnostic: c, + reportWatchStatus: _ + }) { + const u = rbe(s, o, c || lk(s), _); + return u.rootFiles = e, u.options = t, u.watchOptions = n, u.projectReferences = i, u; + } + function sse(e) { + const t = e.system || ml, n = e.host || (e.host = t9(e.options, t)), i = ase(e), s = UU( + i, + e.reportDiagnostic || lk(t), + (o) => n.trace && n.trace(o), + e.reportErrorSummary || e.options.pretty ? (o, c) => t.write(MU(o, c, t.newLine, n)) : void 0 + ); + return e.afterProgramEmitAndDiagnostics && e.afterProgramEmitAndDiagnostics(i), s; + } + function e9(e, t) { + const n = hv(e); + if (!n) return; + let i; + if (t.getBuildInfo) + i = t.getBuildInfo(n, e.configFilePath); + else { + const s = t.readFile(n); + if (!s) return; + i = iU(n, s); + } + if (!(!i || i.version !== ep || !NA(i))) + return Xie(i, n, t); + } + function t9(e, t = ml) { + const n = LO( + e, + /*setParentNodes*/ + void 0, + t + ); + return n.createHash = Os(t, t.createHash), n.storeSignatureInfo = t.storeSignatureInfo, KO(n), ow(n, (i) => oo(i, n.getCurrentDirectory(), n.getCanonicalFileName)), n; + } + function ase({ + rootNames: e, + options: t, + configFileParsingDiagnostics: n, + projectReferences: i, + host: s, + createProgram: o + }) { + s = s || t9(t), o = o || NU; + const c = e9(t, s); + return o(e, t, s, c, n, i); + } + function ibe(e, t, n, i, s, o, c, _) { + return as(e) ? XU({ + rootFiles: e, + options: t, + watchOptions: _, + projectReferences: c, + system: n, + createProgram: i, + reportDiagnostic: s, + reportWatchStatus: o + }) : $U({ + configFileName: e, + optionsToExtend: t, + watchOptionsToExtend: c, + extraFileExtensions: _, + system: n, + createProgram: i, + reportDiagnostic: s, + reportWatchStatus: o + }); + } + function QU(e) { + let t, n, i, s, o = /* @__PURE__ */ new Map([[void 0, void 0]]), c, _, u, g, m = e.extendedConfigCache, h = !1; + const S = /* @__PURE__ */ new Map(); + let T, k = !1; + const D = e.useCaseSensitiveFileNames(), P = e.getCurrentDirectory(), { configFileName: A, optionsToExtend: O = {}, watchOptionsToExtend: F, extraFileExtensions: R, createProgram: B } = e; + let { rootFiles: U, options: $, watchOptions: W, projectReferences: _e } = e, K, V, ae = !1, se = !1; + const ce = A === void 0 ? void 0 : IO(e, P, D), fe = ce || e, he = UO(e, fe); + let q = Nr(); + A && e.configFileParsingResult && (yr(e.configFileParsingResult), q = Nr()), fi(p.Starting_compilation_in_watch_mode), A && !e.configFileParsingResult && (q = v0(O), E.assert(!U), Ks(), q = Nr()), E.assert($), E.assert(U); + const { watchFile: be, watchDirectory: je, writeLog: me } = qU(e, $), Z = Zl(D); + me(`Current directory: ${P} CaseSensitiveFileNames: ${D}`); + let pe; + A && (pe = be(A, qr, 2e3, W, Fl.ConfigFile)); + const Te = HU(e, () => $, fe); + KO(Te); + const Fe = Te.getSourceFile; + Te.getSourceFile = (pt, ...Ct) => Ji(pt, st(pt), ...Ct), Te.getSourceFileByPath = Ji, Te.getNewLine = () => q, Te.fileExists = ui, Te.onReleaseOldSourceFile = ai, Te.onReleaseParsedCommandLine = Et, Te.toPath = st, Te.getCompilationSettings = () => $, Te.useSourceOfProjectReferenceRedirect = Os(e, e.useSourceOfProjectReferenceRedirect), Te.preferNonRecursiveWatch = e.preferNonRecursiveWatch, Te.watchDirectoryOfFailedLookupLocation = (pt, Ct, qe) => je(pt, Ct, qe, W, Fl.FailedLookupLocations), Te.watchAffectingFileLocation = (pt, Ct) => be(pt, Ct, 2e3, W, Fl.AffectingFileLocation), Te.watchTypeRootsDirectory = (pt, Ct, qe) => je(pt, Ct, qe, W, Fl.TypeRoots), Te.getCachedDirectoryStructureHost = () => ce, Te.scheduleInvalidateResolutionsOfFailedLookupLocations = Je, Te.onInvalidatedResolution = er, Te.onChangedAutomaticTypeDirectiveNames = er, Te.fileIsOpen = mh, Te.getCurrentProgram = Ve, Te.writeLog = me, Te.getParsedCommandLine = bs; + const Ye = FU( + Te, + A ? Hn(Qi(A, P)) : P, + /*logChangesWhenResolvingModule*/ + !1 + ); + Te.resolveModuleNameLiterals = Os(e, e.resolveModuleNameLiterals), Te.resolveModuleNames = Os(e, e.resolveModuleNames), !Te.resolveModuleNameLiterals && !Te.resolveModuleNames && (Te.resolveModuleNameLiterals = Ye.resolveModuleNameLiterals.bind(Ye)), Te.resolveTypeReferenceDirectiveReferences = Os(e, e.resolveTypeReferenceDirectiveReferences), Te.resolveTypeReferenceDirectives = Os(e, e.resolveTypeReferenceDirectives), !Te.resolveTypeReferenceDirectiveReferences && !Te.resolveTypeReferenceDirectives && (Te.resolveTypeReferenceDirectiveReferences = Ye.resolveTypeReferenceDirectiveReferences.bind(Ye)), Te.resolveLibrary = e.resolveLibrary ? e.resolveLibrary.bind(e) : Ye.resolveLibrary.bind(Ye), Te.getModuleResolutionCache = e.resolveModuleNameLiterals || e.resolveModuleNames ? Os(e, e.getModuleResolutionCache) : () => Ye.getModuleResolutionCache(); + const Se = !!e.resolveModuleNameLiterals || !!e.resolveTypeReferenceDirectiveReferences || !!e.resolveModuleNames || !!e.resolveTypeReferenceDirectives ? Os(e, e.hasInvalidatedResolutions) || yb : mh, ie = e.resolveLibrary ? Os(e, e.hasInvalidatedLibResolutions) || yb : mh; + return t = e9($, Te), St(), A ? { getCurrentProgram: Ce, getProgram: Un, close: Ne, getResolutionCache: Ee } : { getCurrentProgram: Ce, getProgram: Un, updateRootFileNames: tr, close: Ne, getResolutionCache: Ee }; + function Ne() { + _i(), Ye.clear(), B_(S, (pt) => { + pt && pt.fileWatcher && (pt.fileWatcher.close(), pt.fileWatcher = void 0); + }), pe && (pe.close(), pe = void 0), m?.clear(), m = void 0, g && (B_(g, gp), g = void 0), s && (B_(s, gp), s = void 0), i && (B_(i, od), i = void 0), u && (B_(u, (pt) => { + var Ct; + (Ct = pt.watcher) == null || Ct.close(), pt.watcher = void 0, pt.watchedDirectories && B_(pt.watchedDirectories, gp), pt.watchedDirectories = void 0; + }), u = void 0), t = void 0; + } + function Ee() { + return Ye; + } + function Ce() { + return t; + } + function Ve() { + return t && t.getProgramOrUndefined(); + } + function St() { + me("Synchronizing program"), E.assert($), E.assert(U), _i(); + const pt = Ce(); + k && (q = Nr(), pt && R7(pt.getCompilerOptions(), $) && Ye.onChangesAffectModuleResolution()); + const { hasInvalidatedResolutions: Ct, hasInvalidatedLibResolutions: qe } = Ye.createHasInvalidatedResolutions(Se, ie), { + originalReadFile: Lt, + originalFileExists: rn, + originalDirectoryExists: Pe, + originalCreateDirectory: yt, + originalWriteFile: ue, + readFileWithCache: M + } = ow(Te, st); + return vU(Ve(), U, $, (ye) => Mn(ye, M), (ye) => Te.fileExists(ye), Ct, qe, pn, bs, _e) ? se && (h && fi(p.File_change_detected_Starting_incremental_compilation), t = B( + /*rootNames*/ + void 0, + /*options*/ + void 0, + Te, + t, + V, + _e + ), se = !1) : (h && fi(p.File_change_detected_Starting_incremental_compilation), Bt(Ct, qe)), h = !1, e.afterProgramCreate && pt !== t && e.afterProgramCreate(t), Te.readFile = Lt, Te.fileExists = rn, Te.directoryExists = Pe, Te.createDirectory = yt, Te.writeFile = ue, o?.forEach((ye, Q) => { + if (!Q) + Ke(), A && Le(st(A), $, W, Fl.ExtendedConfigFile); + else { + const dt = u?.get(Q); + dt && mt(ye, Q, dt); + } + }), o = void 0, t; + } + function Bt(pt, Ct) { + me("CreatingProgramWith::"), me(` roots: ${JSON.stringify(U)}`), me(` options: ${JSON.stringify($)}`), _e && me(` projectReferences: ${JSON.stringify(_e)}`); + const qe = k || !Ve(); + k = !1, se = !1, Ye.startCachingPerDirectoryResolution(), Te.hasInvalidatedResolutions = pt, Te.hasInvalidatedLibResolutions = Ct, Te.hasChangedAutomaticTypeDirectiveNames = pn; + const Lt = Ve(); + if (t = B(U, $, Te, t, V, _e), Ye.finishCachingPerDirectoryResolution(t.getProgram(), Lt), oU( + t.getProgram(), + i || (i = /* @__PURE__ */ new Map()), + Ae + ), qe && Ye.updateTypeRootsWatch(), T) { + for (const rn of T) + i.has(rn) || S.delete(rn); + T = void 0; + } + } + function tr(pt) { + E.assert(!A, "Cannot update root file names with config file watch mode"), U = pt, er(); + } + function Nr() { + return v0($ || O); + } + function st(pt) { + return oo(pt, P, Z); + } + function Wt(pt) { + return typeof pt == "boolean"; + } + function Jr(pt) { + return typeof pt.version == "boolean"; + } + function ui(pt) { + const Ct = st(pt); + return Wt(S.get(Ct)) ? !1 : fe.fileExists(pt); + } + function Ji(pt, Ct, qe, Lt, rn) { + const Pe = S.get(Ct); + if (Wt(Pe)) + return; + const yt = typeof qe == "object" ? qe.impliedNodeFormat : void 0; + if (Pe === void 0 || rn || Jr(Pe) || Pe.sourceFile.impliedNodeFormat !== yt) { + const ue = Fe(pt, qe, Lt); + if (Pe) + ue ? (Pe.sourceFile = ue, Pe.version = ue.version, Pe.fileWatcher || (Pe.fileWatcher = re(Ct, pt, it, 250, W, Fl.SourceFile))) : (Pe.fileWatcher && Pe.fileWatcher.close(), S.set(Ct, !1)); + else if (ue) { + const M = re(Ct, pt, it, 250, W, Fl.SourceFile); + S.set(Ct, { sourceFile: ue, version: ue.version, fileWatcher: M }); + } else + S.set(Ct, !1); + return ue; + } + return Pe.sourceFile; + } + function Dt(pt) { + const Ct = S.get(pt); + Ct !== void 0 && (Wt(Ct) ? S.set(pt, { version: !1 }) : Ct.version = !1); + } + function Mn(pt, Ct) { + const qe = S.get(pt); + if (!qe) return; + if (qe.version) return qe.version; + const Lt = Ct(pt); + return Lt !== void 0 ? ZO(Te, Lt) : void 0; + } + function ai(pt, Ct, qe) { + const Lt = S.get(pt.resolvedPath); + Lt !== void 0 && (Wt(Lt) ? (T || (T = [])).push(pt.path) : Lt.sourceFile === pt && (Lt.fileWatcher && Lt.fileWatcher.close(), S.delete(pt.resolvedPath), qe || Ye.removeResolutionsOfFile(pt.path))); + } + function fi(pt) { + e.onWatchStatusChange && e.onWatchStatusChange(Yo(pt), q, $ || O); + } + function pn() { + return Ye.hasChangedAutomaticTypeDirectiveNames(); + } + function _i() { + return _ ? (e.clearTimeout(_), _ = void 0, !0) : !1; + } + function Je() { + if (!e.setTimeout || !e.clearTimeout) + return Ye.invalidateResolutionsOfFailedLookupLocations(); + const pt = _i(); + me(`Scheduling invalidateFailedLookup${pt ? ", Cancelled earlier one" : ""}`), _ = e.setTimeout(ft, 250, "timerToInvalidateFailedLookupResolutions"); + } + function ft() { + _ = void 0, Ye.invalidateResolutionsOfFailedLookupLocations() && er(); + } + function er() { + !e.setTimeout || !e.clearTimeout || (c && e.clearTimeout(c), me("Scheduling update"), c = e.setTimeout(Jn, 250, "timerToUpdateProgram")); + } + function qr() { + E.assert(!!A), n = 2, er(); + } + function Jn() { + c = void 0, h = !0, Un(); + } + function Un() { + switch (n) { + case 1: + ki(); + break; + case 2: + Ds(); + break; + default: + St(); + break; + } + return Ce(); + } + function ki() { + me("Reloading new file names and options"), E.assert($), E.assert(A), n = 0, U = U4($.configFile.configFileSpecs, Qi(Hn(A), P), $, he, R), iO( + U, + Qi(A, P), + $.configFile.configFileSpecs, + V, + ae + ) && (se = !0), St(); + } + function Ds() { + E.assert(A), me(`Reloading config file: ${A}`), n = 0, ce && ce.clearCache(), Ks(), k = !0, (o ?? (o = /* @__PURE__ */ new Map())).set(void 0, void 0), St(); + } + function Ks() { + E.assert(A), yr( + rA( + A, + O, + he, + m || (m = /* @__PURE__ */ new Map()), + F, + R + ) + ); + } + function yr(pt) { + U = pt.fileNames, $ = pt.options, W = pt.watchOptions, _e = pt.projectReferences, K = pt.wildcardDirectories, V = a2(pt).slice(), ae = oA(pt.raw), se = !0; + } + function bs(pt) { + const Ct = st(pt); + let qe = u?.get(Ct); + if (qe) { + if (!qe.updateLevel) return qe.parsedCommandLine; + if (qe.parsedCommandLine && qe.updateLevel === 1 && !e.getParsedCommandLine) { + me("Reloading new file names and options"), E.assert($); + const rn = U4( + qe.parsedCommandLine.options.configFile.configFileSpecs, + Qi(Hn(pt), P), + $, + he + ); + return qe.parsedCommandLine = { ...qe.parsedCommandLine, fileNames: rn }, qe.updateLevel = void 0, qe.parsedCommandLine; + } + } + me(`Loading config file: ${pt}`); + const Lt = e.getParsedCommandLine ? e.getParsedCommandLine(pt) : Xe(pt); + return qe ? (qe.parsedCommandLine = Lt, qe.updateLevel = void 0) : (u || (u = /* @__PURE__ */ new Map())).set(Ct, qe = { parsedCommandLine: Lt }), (o ?? (o = /* @__PURE__ */ new Map())).set(Ct, pt), Lt; + } + function Xe(pt) { + const Ct = he.onUnRecoverableConfigFileDiagnostic; + he.onUnRecoverableConfigFileDiagnostic = Ha; + const qe = rA( + pt, + /*optionsToExtend*/ + void 0, + he, + m || (m = /* @__PURE__ */ new Map()), + F + ); + return he.onUnRecoverableConfigFileDiagnostic = Ct, qe; + } + function Et(pt) { + var Ct; + const qe = st(pt), Lt = u?.get(qe); + Lt && (u.delete(qe), Lt.watchedDirectories && B_(Lt.watchedDirectories, gp), (Ct = Lt.watcher) == null || Ct.close(), aU(qe, g)); + } + function re(pt, Ct, qe, Lt, rn, Pe) { + return be(Ct, (yt, ue) => qe(yt, ue, pt), Lt, rn, Pe); + } + function it(pt, Ct, qe) { + Y(pt, qe, Ct), Ct === 2 && S.has(qe) && Ye.invalidateResolutionOfFile(qe), Dt(qe), er(); + } + function Y(pt, Ct, qe) { + ce && ce.addOrDeleteFile(pt, Ct, qe); + } + function Ae(pt, Ct) { + return u?.has(pt) ? z6 : re( + pt, + Ct, + $e, + 500, + W, + Fl.MissingFile + ); + } + function $e(pt, Ct, qe) { + Y(pt, qe, Ct), Ct === 0 && i.has(qe) && (i.get(qe).close(), i.delete(qe), Dt(qe), er()); + } + function Ke() { + xA( + s || (s = /* @__PURE__ */ new Map()), + K, + Tt + ); + } + function Tt(pt, Ct) { + return je( + pt, + (qe) => { + E.assert(A), E.assert($); + const Lt = st(qe); + ce && ce.addOrDeleteFileOrDirectory(qe, Lt), Dt(Lt), !kA({ + watchedDirPath: st(pt), + fileOrDirectory: qe, + fileOrDirectoryPath: Lt, + configFileName: A, + extraFileExtensions: R, + options: $, + program: Ce() || U, + currentDirectory: P, + useCaseSensitiveFileNames: D, + writeLog: me, + toPath: st + }) && n !== 2 && (n = 1, er()); + }, + Ct, + W, + Fl.WildcardDirectory + ); + } + function Le(pt, Ct, qe, Lt) { + FO( + pt, + Ct, + g || (g = /* @__PURE__ */ new Map()), + (rn, Pe) => be( + rn, + (yt, ue) => { + var M; + Y(rn, Pe, ue), m && OO(m, Pe, st); + const ye = (M = g.get(Pe)) == null ? void 0 : M.projects; + ye?.size && ye.forEach((Q) => { + if (A && st(A) === Q) + n = 2; + else { + const dt = u?.get(Q); + dt && (dt.updateLevel = 2), Ye.removeResolutionsFromProjectReferenceRedirects(Q); + } + er(); + }); + }, + 2e3, + qe, + Lt + ), + st + ); + } + function mt(pt, Ct, qe) { + var Lt, rn, Pe, yt; + qe.watcher || (qe.watcher = be( + pt, + (ue, M) => { + Y(pt, Ct, M); + const ye = u?.get(Ct); + ye && (ye.updateLevel = 2), Ye.removeResolutionsFromProjectReferenceRedirects(Ct), er(); + }, + 2e3, + ((Lt = qe.parsedCommandLine) == null ? void 0 : Lt.watchOptions) || W, + Fl.ConfigFileOfReferencedProject + )), xA( + qe.watchedDirectories || (qe.watchedDirectories = /* @__PURE__ */ new Map()), + (rn = qe.parsedCommandLine) == null ? void 0 : rn.wildcardDirectories, + (ue, M) => { + var ye; + return je( + ue, + (Q) => { + const dt = st(Q); + ce && ce.addOrDeleteFileOrDirectory(Q, dt), Dt(dt); + const Mt = u?.get(Ct); + Mt?.parsedCommandLine && (kA({ + watchedDirPath: st(ue), + fileOrDirectory: Q, + fileOrDirectoryPath: dt, + configFileName: pt, + options: Mt.parsedCommandLine.options, + program: Mt.parsedCommandLine.fileNames, + currentDirectory: P, + useCaseSensitiveFileNames: D, + writeLog: me, + toPath: st + }) || Mt.updateLevel !== 2 && (Mt.updateLevel = 1, er())); + }, + M, + ((ye = qe.parsedCommandLine) == null ? void 0 : ye.watchOptions) || W, + Fl.WildcardDirectoryOfReferencedProject + ); + } + ), Le( + Ct, + (Pe = qe.parsedCommandLine) == null ? void 0 : Pe.options, + ((yt = qe.parsedCommandLine) == null ? void 0 : yt.watchOptions) || W, + Fl.ExtendedConfigOfReferencedProject + ); + } + } + var ose = /* @__PURE__ */ ((e) => (e[e.Unbuildable = 0] = "Unbuildable", e[e.UpToDate = 1] = "UpToDate", e[e.UpToDateWithUpstreamTypes = 2] = "UpToDateWithUpstreamTypes", e[e.OutputMissing = 3] = "OutputMissing", e[e.ErrorReadingFile = 4] = "ErrorReadingFile", e[e.OutOfDateWithSelf = 5] = "OutOfDateWithSelf", e[e.OutOfDateWithUpstream = 6] = "OutOfDateWithUpstream", e[e.OutOfDateBuildInfoWithPendingEmit = 7] = "OutOfDateBuildInfoWithPendingEmit", e[e.OutOfDateBuildInfoWithErrors = 8] = "OutOfDateBuildInfoWithErrors", e[e.OutOfDateOptions = 9] = "OutOfDateOptions", e[e.OutOfDateRoots = 10] = "OutOfDateRoots", e[e.UpstreamOutOfDate = 11] = "UpstreamOutOfDate", e[e.UpstreamBlocked = 12] = "UpstreamBlocked", e[e.ComputingUpstream = 13] = "ComputingUpstream", e[e.TsVersionOutputOfDate = 14] = "TsVersionOutputOfDate", e[e.UpToDateWithInputFileText = 15] = "UpToDateWithInputFileText", e[e.ContainerOnly = 16] = "ContainerOnly", e[e.ForceBuild = 17] = "ForceBuild", e))(ose || {}); + function YU(e) { + return Xo( + e, + ".json" + /* Json */ + ) ? e : On(e, "tsconfig.json"); + } + var yBe = /* @__PURE__ */ new Date(-864e13); + function vBe(e, t, n) { + const i = e.get(t); + let s; + return i || (s = n(), e.set(t, s)), i || s; + } + function cse(e, t) { + return vBe(e, t, () => /* @__PURE__ */ new Map()); + } + function ZU(e) { + return e.now ? e.now() : /* @__PURE__ */ new Date(); + } + function uk(e) { + return !!e && !!e.buildOrder; + } + function FA(e) { + return uk(e) ? e.buildOrder : e; + } + function r9(e, t) { + return (n) => { + let i = t ? `[${s2( + IA(e), + "\x1B[90m" + /* Grey */ + )}] ` : `${IA(e)} - `; + i += `${km(n.messageText, e.newLine)}${e.newLine + e.newLine}`, e.write(i); + }; + } + function sbe(e, t, n, i) { + const s = GU(e, t); + return s.getModifiedTime = e.getModifiedTime ? (o) => e.getModifiedTime(o) : vb, s.setModifiedTime = e.setModifiedTime ? (o, c) => e.setModifiedTime(o, c) : Ha, s.deleteFile = e.deleteFile ? (o) => e.deleteFile(o) : Ha, s.reportDiagnostic = n || lk(e), s.reportSolutionBuilderStatus = i || r9(e), s.now = Os(e, e.now), s; + } + function lse(e = ml, t, n, i, s) { + const o = sbe(e, t, n, i); + return o.reportErrorSummary = s, o; + } + function use(e = ml, t, n, i, s) { + const o = sbe(e, t, n, i), c = VU(e, s); + return RR(o, c), o; + } + function bBe(e) { + const t = {}; + return GF.forEach((n) => { + eo(e, n.name) && (t[n.name] = e[n.name]); + }), t.tscBuild = !0, t; + } + function _se(e, t, n) { + return Ebe( + /*watch*/ + !1, + e, + t, + n + ); + } + function fse(e, t, n, i) { + return Ebe( + /*watch*/ + !0, + e, + t, + n, + i + ); + } + function SBe(e, t, n, i, s) { + const o = t, c = t, _ = bBe(i), u = HU(o, () => D.projectCompilerOptions); + KO(u), u.getParsedCommandLine = (P) => W6(D, P, ng(D, P)), u.resolveModuleNameLiterals = Os(o, o.resolveModuleNameLiterals), u.resolveTypeReferenceDirectiveReferences = Os(o, o.resolveTypeReferenceDirectiveReferences), u.resolveLibrary = Os(o, o.resolveLibrary), u.resolveModuleNames = Os(o, o.resolveModuleNames), u.resolveTypeReferenceDirectives = Os(o, o.resolveTypeReferenceDirectives), u.getModuleResolutionCache = Os(o, o.getModuleResolutionCache); + let g, m; + !u.resolveModuleNameLiterals && !u.resolveModuleNames && (g = A6(u.getCurrentDirectory(), u.getCanonicalFileName), u.resolveModuleNameLiterals = (P, A, O, F, R) => EA( + P, + A, + O, + F, + R, + o, + g, + hU + ), u.getModuleResolutionCache = () => g), !u.resolveTypeReferenceDirectiveReferences && !u.resolveTypeReferenceDirectives && (m = _O( + u.getCurrentDirectory(), + u.getCanonicalFileName, + /*options*/ + void 0, + g?.getPackageJsonInfoCache(), + g?.optionsToRedirectsKey + ), u.resolveTypeReferenceDirectiveReferences = (P, A, O, F, R) => EA( + P, + A, + O, + F, + R, + o, + m, + jO + )); + let h; + u.resolveLibrary || (h = A6( + u.getCurrentDirectory(), + u.getCanonicalFileName, + /*options*/ + void 0, + g?.getPackageJsonInfoCache() + ), u.resolveLibrary = (P, A, O) => fO( + P, + A, + O, + o, + h + )), u.getBuildInfo = (P, A) => hbe( + D, + P, + ng(D, A), + /*modifiedTime*/ + void 0 + ); + const { watchFile: S, watchDirectory: T, writeLog: k } = qU(c, i), D = { + host: o, + hostWithWatch: c, + parseConfigFileHost: UO(o), + write: Os(o, o.trace), + // State of solution + options: i, + baseCompilerOptions: _, + rootNames: n, + baseWatchOptions: s, + resolvedConfigFilePaths: /* @__PURE__ */ new Map(), + configFileCache: /* @__PURE__ */ new Map(), + projectStatus: /* @__PURE__ */ new Map(), + extendedConfigCache: /* @__PURE__ */ new Map(), + buildInfoCache: /* @__PURE__ */ new Map(), + outputTimeStamps: /* @__PURE__ */ new Map(), + builderPrograms: /* @__PURE__ */ new Map(), + diagnostics: /* @__PURE__ */ new Map(), + projectPendingBuild: /* @__PURE__ */ new Map(), + projectErrorsReported: /* @__PURE__ */ new Map(), + compilerHost: u, + moduleResolutionCache: g, + typeReferenceDirectiveResolutionCache: m, + libraryResolutionCache: h, + // Mutable state + buildOrder: void 0, + readFileWithCache: (P) => o.readFile(P), + projectCompilerOptions: _, + cache: void 0, + allProjectBuildPending: !0, + needsSummary: !0, + watchAllProjectsPending: e, + // Watch state + watch: e, + allWatchedWildcardDirectories: /* @__PURE__ */ new Map(), + allWatchedInputFiles: /* @__PURE__ */ new Map(), + allWatchedConfigFiles: /* @__PURE__ */ new Map(), + allWatchedExtendedConfigFiles: /* @__PURE__ */ new Map(), + allWatchedPackageJsonFiles: /* @__PURE__ */ new Map(), + filesWatched: /* @__PURE__ */ new Map(), + lastCachedPackageJsonLookups: /* @__PURE__ */ new Map(), + timerToBuildInvalidatedProject: void 0, + reportFileChangeDetected: !1, + watchFile: S, + watchDirectory: T, + writeLog: k + }; + return D; + } + function fd(e, t) { + return oo(t, e.compilerHost.getCurrentDirectory(), e.compilerHost.getCanonicalFileName); + } + function ng(e, t) { + const { resolvedConfigFilePaths: n } = e, i = n.get(t); + if (i !== void 0) return i; + const s = fd(e, t); + return n.set(t, s), s; + } + function abe(e) { + return !!e.options; + } + function TBe(e, t) { + const n = e.configFileCache.get(t); + return n && abe(n) ? n : void 0; + } + function W6(e, t, n) { + const { configFileCache: i } = e, s = i.get(n); + if (s) + return abe(s) ? s : void 0; + Ko("SolutionBuilder::beforeConfigFileParsing"); + let o; + const { parseConfigFileHost: c, baseCompilerOptions: _, baseWatchOptions: u, extendedConfigCache: g, host: m } = e; + let h; + return m.getParsedCommandLine ? (h = m.getParsedCommandLine(t), h || (o = Yo(p.File_0_not_found, t))) : (c.onUnRecoverableConfigFileDiagnostic = (S) => o = S, h = rA(t, _, c, g, u), c.onUnRecoverableConfigFileDiagnostic = Ha), i.set(n, h || o), Ko("SolutionBuilder::afterConfigFileParsing"), rp("SolutionBuilder::Config file parsing", "SolutionBuilder::beforeConfigFileParsing", "SolutionBuilder::afterConfigFileParsing"), h; + } + function OA(e, t) { + return YU(by(e.compilerHost.getCurrentDirectory(), t)); + } + function obe(e, t) { + const n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), s = []; + let o, c; + for (const u of t) + _(u); + return c ? { buildOrder: o || Ge, circularDiagnostics: c } : o || Ge; + function _(u, g) { + const m = ng(e, u); + if (i.has(m)) return; + if (n.has(m)) { + g || (c || (c = [])).push( + Yo( + p.Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0, + s.join(`\r +`) + ) + ); + return; + } + n.set(m, !0), s.push(u); + const h = W6(e, u, m); + if (h && h.projectReferences) + for (const S of h.projectReferences) { + const T = OA(e, S.path); + _(T, g || S.circular); + } + s.pop(), i.set(m, !0), (o || (o = [])).push(u); + } + } + function n9(e) { + return e.buildOrder || xBe(e); + } + function xBe(e) { + const t = obe(e, e.rootNames.map((s) => OA(e, s))); + e.resolvedConfigFilePaths.clear(); + const n = new Set( + FA(t).map( + (s) => ng(e, s) + ) + ), i = { onDeleteValue: Ha }; + return Rg(e.configFileCache, n, i), Rg(e.projectStatus, n, i), Rg(e.builderPrograms, n, i), Rg(e.diagnostics, n, i), Rg(e.projectPendingBuild, n, i), Rg(e.projectErrorsReported, n, i), Rg(e.buildInfoCache, n, i), Rg(e.outputTimeStamps, n, i), Rg(e.lastCachedPackageJsonLookups, n, i), e.watch && (Rg( + e.allWatchedConfigFiles, + n, + { onDeleteValue: od } + ), e.allWatchedExtendedConfigFiles.forEach((s) => { + s.projects.forEach((o) => { + n.has(o) || s.projects.delete(o); + }), s.close(); + }), Rg( + e.allWatchedWildcardDirectories, + n, + { onDeleteValue: (s) => s.forEach(gp) } + ), Rg( + e.allWatchedInputFiles, + n, + { onDeleteValue: (s) => s.forEach(od) } + ), Rg( + e.allWatchedPackageJsonFiles, + n, + { onDeleteValue: (s) => s.forEach(od) } + )), e.buildOrder = t; + } + function cbe(e, t, n) { + const i = t && OA(e, t), s = n9(e); + if (uk(s)) return s; + if (i) { + const c = ng(e, i); + if (oc( + s, + (u) => ng(e, u) === c + ) === -1) return; + } + const o = i ? obe(e, [i]) : s; + return E.assert(!uk(o)), E.assert(!n || i !== void 0), E.assert(!n || o[o.length - 1] === i), n ? o.slice(0, o.length - 1) : o; + } + function lbe(e) { + e.cache && pse(e); + const { compilerHost: t, host: n } = e, i = e.readFileWithCache, s = t.getSourceFile, { + originalReadFile: o, + originalFileExists: c, + originalDirectoryExists: _, + originalCreateDirectory: u, + originalWriteFile: g, + getSourceFileWithCache: m, + readFileWithCache: h + } = ow( + n, + (S) => fd(e, S), + (...S) => s.call(t, ...S) + ); + e.readFileWithCache = h, t.getSourceFile = m, e.cache = { + originalReadFile: o, + originalFileExists: c, + originalDirectoryExists: _, + originalCreateDirectory: u, + originalWriteFile: g, + originalReadFileWithCache: i, + originalGetSourceFile: s + }; + } + function pse(e) { + if (!e.cache) return; + const { cache: t, host: n, compilerHost: i, extendedConfigCache: s, moduleResolutionCache: o, typeReferenceDirectiveResolutionCache: c, libraryResolutionCache: _ } = e; + n.readFile = t.originalReadFile, n.fileExists = t.originalFileExists, n.directoryExists = t.originalDirectoryExists, n.createDirectory = t.originalCreateDirectory, n.writeFile = t.originalWriteFile, i.getSourceFile = t.originalGetSourceFile, e.readFileWithCache = t.originalReadFileWithCache, s.clear(), o?.clear(), c?.clear(), _?.clear(), e.cache = void 0; + } + function ube(e, t) { + e.projectStatus.delete(t), e.diagnostics.delete(t); + } + function _be({ projectPendingBuild: e }, t, n) { + const i = e.get(t); + (i === void 0 || i < n) && e.set(t, n); + } + function fbe(e, t) { + if (!e.allProjectBuildPending) return; + e.allProjectBuildPending = !1, e.options.watch && Tse(e, p.Starting_compilation_in_watch_mode), lbe(e), FA(n9(e)).forEach( + (i) => e.projectPendingBuild.set( + ng(e, i), + 0 + /* Update */ + ) + ), t && t.throwIfCancellationRequested(); + } + var dse = /* @__PURE__ */ ((e) => (e[e.Build = 0] = "Build", e[e.UpdateOutputFileStamps = 1] = "UpdateOutputFileStamps", e))(dse || {}); + function pbe(e, t) { + return e.projectPendingBuild.delete(t), e.diagnostics.has(t) ? 1 : 0; + } + function kBe(e, t, n, i, s) { + let o = !0; + return { + kind: 1, + project: t, + projectPath: n, + buildOrder: s, + getCompilerOptions: () => i.options, + getCurrentDirectory: () => e.compilerHost.getCurrentDirectory(), + updateOutputFileStatmps: () => { + vbe(e, i, n), o = !1; + }, + done: () => (o && vbe(e, i, n), Ko("SolutionBuilder::Timestamps only updates"), pbe(e, n)) + }; + } + function CBe(e, t, n, i, s, o, c) { + let _ = 0, u, g; + return { + kind: 0, + project: t, + projectPath: n, + buildOrder: c, + getCompilerOptions: () => s.options, + getCurrentDirectory: () => e.compilerHost.getCurrentDirectory(), + getBuilderProgram: () => h(go), + getProgram: () => h( + (P) => P.getProgramOrUndefined() + ), + getSourceFile: (P) => h( + (A) => A.getSourceFile(P) + ), + getSourceFiles: () => S( + (P) => P.getSourceFiles() + ), + getOptionsDiagnostics: (P) => S( + (A) => A.getOptionsDiagnostics(P) + ), + getGlobalDiagnostics: (P) => S( + (A) => A.getGlobalDiagnostics(P) + ), + getConfigFileParsingDiagnostics: () => S( + (P) => P.getConfigFileParsingDiagnostics() + ), + getSyntacticDiagnostics: (P, A) => S( + (O) => O.getSyntacticDiagnostics(P, A) + ), + getAllDependencies: (P) => S( + (A) => A.getAllDependencies(P) + ), + getSemanticDiagnostics: (P, A) => S( + (O) => O.getSemanticDiagnostics(P, A) + ), + getSemanticDiagnosticsOfNextAffectedFile: (P, A) => h( + (O) => O.getSemanticDiagnosticsOfNextAffectedFile && O.getSemanticDiagnosticsOfNextAffectedFile(P, A) + ), + emit: (P, A, O, F, R) => P || F ? h( + (B) => { + var U, $; + return B.emit(P, A, O, F, R || (($ = (U = e.host).getCustomTransformers) == null ? void 0 : $.call(U, t))); + } + ) : (D(0, O), k(A, O, R)), + done: m + }; + function m(P, A, O) { + return D(3, P, A, O), Ko("SolutionBuilder::Projects built"), pbe(e, n); + } + function h(P) { + return D( + 0 + /* CreateProgram */ + ), u && P(u); + } + function S(P) { + return h(P) || Ge; + } + function T() { + var P, A, O; + if (E.assert(u === void 0), e.options.dry) { + uf(e, p.A_non_dry_build_would_build_project_0, t), g = 1, _ = 2; + return; + } + if (e.options.verbose && uf(e, p.Building_project_0, t), s.fileNames.length === 0) { + LA(e, n, a2(s)), g = 0, _ = 2; + return; + } + const { host: F, compilerHost: R } = e; + if (e.projectCompilerOptions = s.options, (P = e.moduleResolutionCache) == null || P.update(s.options), (A = e.typeReferenceDirectiveResolutionCache) == null || A.update(s.options), u = F.createProgram( + s.fileNames, + s.options, + R, + EBe(e, n, s), + a2(s), + s.projectReferences + ), e.watch) { + const B = (O = e.moduleResolutionCache) == null ? void 0 : O.getPackageJsonInfoCache().getInternalMap(); + e.lastCachedPackageJsonLookups.set( + n, + B && new Set(is( + B.values(), + (U) => e.host.realpath && (uO(U) || U.directoryExists) ? e.host.realpath(On(U.packageDirectory, "package.json")) : On(U.packageDirectory, "package.json") + )) + ), e.builderPrograms.set(n, u); + } + _++; + } + function k(P, A, O) { + var F, R, B; + E.assertIsDefined(u), E.assert( + _ === 1 + /* Emit */ + ); + const { host: U, compilerHost: $ } = e, W = /* @__PURE__ */ new Map(), _e = u.getCompilerOptions(), K = Wb(_e); + let V, ae; + const { emitResult: se, diagnostics: ce } = YO( + u, + (fe) => U.reportDiagnostic(fe), + e.write, + /*reportSummary*/ + void 0, + (fe, he, q, be, je, me) => { + var Z; + const pe = fd(e, fe); + if (W.set(fd(e, fe), fe), me?.buildInfo) { + ae || (ae = ZU(e.host)); + const Fe = (Z = u.hasChangedEmitSignature) == null ? void 0 : Z.call(u), Ye = tV(e, fe, n); + Ye ? (Ye.buildInfo = me.buildInfo, Ye.modifiedTime = ae, Fe && (Ye.latestChangedDtsTime = ae)) : e.buildInfoCache.set(n, { + path: fd(e, fe), + buildInfo: me.buildInfo, + modifiedTime: ae, + latestChangedDtsTime: Fe ? ae : void 0 + }); + } + const Te = me?.differsOnlyInMap ? KT(e.host, fe) : void 0; + (P || $.writeFile)( + fe, + he, + q, + be, + je, + me + ), me?.differsOnlyInMap ? e.host.setModifiedTime(fe, Te) : !K && e.watch && (V || (V = gse(e, n))).set(pe, ae || (ae = ZU(e.host))); + }, + A, + /*emitOnlyDtsFiles*/ + void 0, + O || ((R = (F = e.host).getCustomTransformers) == null ? void 0 : R.call(F, t)) + ); + return (!_e.noEmitOnError || !ce.length) && (W.size || o.type !== 8) && ybe(e, s, n, p.Updating_unchanged_output_timestamps_of_project_0, W), e.projectErrorsReported.set(n, !0), g = (B = u.hasChangedEmitSignature) != null && B.call(u) ? 0 : 2, ce.length ? (e.diagnostics.set(n, ce), e.projectStatus.set(n, { type: 0, reason: "it had errors" }), g |= 4) : (e.diagnostics.delete(n), e.projectStatus.set(n, { + type: 1, + oldestOutputFileName: XI(W.values()) ?? tU(s, !U.useCaseSensitiveFileNames()) + })), DBe(e, u), _ = 2, se; + } + function D(P, A, O, F) { + for (; _ <= P && _ < 3; ) { + const R = _; + switch (_) { + case 0: + T(); + break; + case 1: + k(O, A, F); + break; + case 2: + ABe(e, t, n, i, s, c, E.checkDefined(g)), _++; + break; + } + E.assert(_ > R); + } + } + } + function dbe(e, t, n) { + if (!e.projectPendingBuild.size || uk(t)) return; + const { options: i, projectPendingBuild: s } = e; + for (let o = 0; o < t.length; o++) { + const c = t[o], _ = ng(e, c), u = e.projectPendingBuild.get(_); + if (u === void 0) continue; + n && (n = !1, Pbe(e, t)); + const g = W6(e, c, _); + if (!g) { + Dbe(e, _), s.delete(_); + continue; + } + u === 2 ? (xbe(e, c, _, g), kbe(e, _, g), Cbe(e, c, _, g), bse(e, c, _, g), Sse(e, c, _, g)) : u === 1 && (g.fileNames = U4(g.options.configFile.configFileSpecs, Hn(c), g.options, e.parseConfigFileHost), iO( + g.fileNames, + c, + g.options.configFile.configFileSpecs, + g.errors, + oA(g.raw) + ), bse(e, c, _, g), Sse(e, c, _, g)); + const m = yse(e, g, _); + if (!i.force) { + if (m.type === 1) { + nV(e, c, m), LA(e, _, a2(g)), s.delete(_), i.dry && uf(e, p.Project_0_is_up_to_date, c); + continue; + } + if (m.type === 2 || m.type === 15) + return LA(e, _, a2(g)), { + kind: 1, + status: m, + project: c, + projectPath: _, + projectIndex: o, + config: g + }; + } + if (m.type === 12) { + nV(e, c, m), LA(e, _, a2(g)), s.delete(_), i.verbose && uf( + e, + m.upstreamProjectBlocked ? p.Skipping_build_of_project_0_because_its_dependency_1_was_not_built : p.Skipping_build_of_project_0_because_its_dependency_1_has_errors, + c, + m.upstreamProjectName + ); + continue; + } + if (m.type === 16) { + nV(e, c, m), LA(e, _, a2(g)), s.delete(_); + continue; + } + return { + kind: 0, + status: m, + project: c, + projectPath: _, + projectIndex: o, + config: g + }; + } + } + function mbe(e, t, n) { + return nV(e, t.project, t.status), t.kind !== 1 ? CBe( + e, + t.project, + t.projectPath, + t.projectIndex, + t.config, + t.status, + n + ) : kBe( + e, + t.project, + t.projectPath, + t.config, + n + ); + } + function mse(e, t, n) { + const i = dbe(e, t, n); + return i && mbe(e, i, t); + } + function EBe({ options: e, builderPrograms: t, compilerHost: n }, i, s) { + if (e.force) return; + const o = t.get(i); + return o || e9(s.options, n); + } + function DBe(e, t) { + t && (e.host.afterProgramEmitAndDiagnostics && e.host.afterProgramEmitAndDiagnostics(t), t.releaseProgram()), e.projectCompilerOptions = e.baseCompilerOptions; + } + function KU(e) { + return !!e.watcher; + } + function gbe(e, t) { + const n = fd(e, t), i = e.filesWatched.get(n); + if (e.watch && i) { + if (!KU(i)) return i; + if (i.modifiedTime) return i.modifiedTime; + } + const s = KT(e.host, t); + return e.watch && (i ? i.modifiedTime = s : e.filesWatched.set(n, s)), s; + } + function eV(e, t, n, i, s, o, c) { + const _ = fd(e, t), u = e.filesWatched.get(_); + if (u && KU(u)) + u.callbacks.push(n); + else { + const g = e.watchFile( + t, + (m, h, S) => { + const T = E.checkDefined(e.filesWatched.get(_)); + E.assert(KU(T)), T.modifiedTime = S, T.callbacks.forEach((k) => k(m, h, S)); + }, + i, + s, + o, + c + ); + e.filesWatched.set(_, { callbacks: [n], watcher: g, modifiedTime: u }); + } + return { + close: () => { + const g = E.checkDefined(e.filesWatched.get(_)); + E.assert(KU(g)), g.callbacks.length === 1 ? (e.filesWatched.delete(_), gp(g)) : YT(g.callbacks, n); + } + }; + } + function gse(e, t) { + if (!e.watch) return; + let n = e.outputTimeStamps.get(t); + return n || e.outputTimeStamps.set(t, n = /* @__PURE__ */ new Map()), n; + } + function tV(e, t, n) { + const i = fd(e, t), s = e.buildInfoCache.get(n); + return s?.path === i ? s : void 0; + } + function hbe(e, t, n, i) { + const s = fd(e, t), o = e.buildInfoCache.get(n); + if (o !== void 0 && o.path === s) + return o.buildInfo || void 0; + const c = e.readFileWithCache(t), _ = c ? iU(t, c) : void 0; + return e.buildInfoCache.set(n, { path: s, buildInfo: _ || !1, modifiedTime: i || Y_ }), _; + } + function hse(e, t, n, i) { + const s = gbe(e, t); + if (n < s) + return { + type: 5, + outOfDateOutputFileName: i, + newerInputFileName: t + }; + } + function wBe(e, t, n) { + var i, s, o, c, _; + if (cW(t)) return { + type: 16 + /* ContainerOnly */ + }; + let u; + const g = !!e.options.force; + if (t.projectReferences) { + e.projectStatus.set(n, { + type: 13 + /* ComputingUpstream */ + }); + for (const ce of t.projectReferences) { + const fe = ck(ce), he = ng(e, fe), q = W6(e, fe, he), be = yse(e, q, he); + if (!(be.type === 13 || be.type === 16)) { + if (e.options.stopBuildOnErrors && (be.type === 0 || be.type === 12)) + return { + type: 12, + upstreamProjectName: ce.path, + upstreamProjectBlocked: be.type === 12 + /* UpstreamBlocked */ + }; + g || (u || (u = [])).push({ ref: ce, refStatus: be, resolvedRefPath: he, resolvedConfig: q }); + } + } + } + if (g) return { + type: 17 + /* ForceBuild */ + }; + const { host: m } = e, h = hv(t.options), S = Wb(t.options); + let T = tV(e, h, n); + const k = T?.modifiedTime || KT(m, h); + if (k === Y_) + return T || e.buildInfoCache.set(n, { + path: fd(e, h), + buildInfo: !1, + modifiedTime: k + }), { + type: 3, + missingOutputFileName: h + }; + const D = hbe(e, h, n, k); + if (!D) + return { + type: 4, + fileName: h + }; + const P = S && NA(D) ? D : void 0; + if ((P || !S) && D.version !== ep) + return { + type: 14, + version: D.version + }; + if (!t.options.noCheck && (D.errors || // TODO: syntax errors???? + D.checkPending)) + return { + type: 8, + buildInfoFile: h + }; + if (P) { + if (!t.options.noCheck && ((i = P.changeFileSet) != null && i.length || (s = P.semanticDiagnosticsPerFile) != null && s.length || J_(t.options) && ((o = P.emitDiagnosticsPerFile) != null && o.length))) + return { + type: 8, + buildInfoFile: h + }; + if (!t.options.noEmit && ((c = P.changeFileSet) != null && c.length || (_ = P.affectedFilesPendingEmit) != null && _.length || P.pendingEmit !== void 0)) + return { + type: 7, + buildInfoFile: h + }; + if ((!t.options.noEmit || t.options.noEmit && J_(t.options)) && qO( + t.options, + P.options || {}, + /*emitOnlyDtsFiles*/ + void 0, + !!t.options.noEmit + )) + return { + type: 9, + buildInfoFile: h + }; + } + let A = k, O = h, F, R = yBe, B = !1; + const U = /* @__PURE__ */ new Set(); + let $; + for (const ce of t.fileNames) { + const fe = gbe(e, ce); + if (fe === Y_) + return { + type: 0, + reason: `${ce} does not exist` + }; + const he = fd(e, ce); + if (k < fe) { + let q, be; + if (P) { + $ || ($ = wU(P, h, m)); + const je = $.roots.get(he); + q = $.fileInfos.get(je ?? he); + const me = q ? e.readFileWithCache(je ?? ce) : void 0; + be = me !== void 0 ? ZO(m, me) : void 0, q && q === be && (B = !0); + } + if (!q || q !== be) + return { + type: 5, + outOfDateOutputFileName: h, + newerInputFileName: ce + }; + } + fe > R && (F = ce, R = fe), U.add(he); + } + let W; + if (P ? ($ || ($ = wU(P, h, m)), W = hl( + $.roots, + // File was root file when project was built but its not any more + (ce, fe) => U.has(fe) ? void 0 : fe + )) : W = lr( + Qie(D, h, m), + (ce) => U.has(ce) ? void 0 : ce + ), W) + return { + type: 10, + buildInfoFile: h, + inputFile: W + }; + if (!S) { + const ce = AO(t, !m.useCaseSensitiveFileNames()), fe = gse(e, n); + for (const he of ce) { + if (he === h) continue; + const q = fd(e, he); + let be = fe?.get(q); + if (be || (be = KT(e.host, he), fe?.set(q, be)), be === Y_) + return { + type: 3, + missingOutputFileName: he + }; + if (be < R) + return { + type: 5, + outOfDateOutputFileName: he, + newerInputFileName: F + }; + be < A && (A = be, O = he); + } + } + let _e = !1; + if (u) + for (const { ref: ce, refStatus: fe, resolvedConfig: he, resolvedRefPath: q } of u) { + if (fe.newestInputFileTime && fe.newestInputFileTime <= A) + continue; + if (PBe(e, T ?? (T = e.buildInfoCache.get(n)), q)) + return { + type: 6, + outOfDateOutputFileName: h, + newerProjectName: ce.path + }; + const be = NBe(e, he.options, q); + if (be && be <= A) { + _e = !0; + continue; + } + return E.assert(O !== void 0, "Should have an oldest output filename here"), { + type: 6, + outOfDateOutputFileName: O, + newerProjectName: ce.path + }; + } + const K = hse(e, t.options.configFilePath, A, O); + if (K) return K; + const V = lr(t.options.configFile.extendedSourceFiles || Ge, (ce) => hse(e, ce, A, O)); + if (V) return V; + const ae = e.lastCachedPackageJsonLookups.get(n), se = ae && Ag( + ae, + (ce) => hse(e, ce, A, O) + ); + return se || { + type: _e ? 2 : B ? 15 : 1, + newestInputFileTime: R, + newestInputFileName: F, + oldestOutputFileName: O + }; + } + function PBe(e, t, n) { + return e.buildInfoCache.get(n).path === t.path; + } + function yse(e, t, n) { + if (t === void 0) + return { type: 0, reason: "config file deleted mid-build" }; + const i = e.projectStatus.get(n); + if (i !== void 0) + return i; + Ko("SolutionBuilder::beforeUpToDateCheck"); + const s = wBe(e, t, n); + return Ko("SolutionBuilder::afterUpToDateCheck"), rp("SolutionBuilder::Up-to-date check", "SolutionBuilder::beforeUpToDateCheck", "SolutionBuilder::afterUpToDateCheck"), e.projectStatus.set(n, s), s; + } + function ybe(e, t, n, i, s) { + if (t.options.noEmit) return; + let o; + const c = hv(t.options), _ = Wb(t.options); + if (c && _) { + s?.has(fd(e, c)) || (e.options.verbose && uf(e, i, t.options.configFilePath), e.host.setModifiedTime(c, o = ZU(e.host)), tV(e, c, n).modifiedTime = o), e.outputTimeStamps.delete(n); + return; + } + const { host: u } = e, g = AO(t, !u.useCaseSensitiveFileNames()), m = gse(e, n), h = m ? /* @__PURE__ */ new Set() : void 0; + if (!s || g.length !== s.size) { + let S = !!e.options.verbose; + for (const T of g) { + const k = fd(e, T); + s?.has(k) || (S && (S = !1, uf(e, i, t.options.configFilePath)), u.setModifiedTime(T, o || (o = ZU(e.host))), T === c ? tV(e, c, n).modifiedTime = o : m && (m.set(k, o), h.add(k))); + } + } + m?.forEach((S, T) => { + !s?.has(T) && !h.has(T) && m.delete(T); + }); + } + function NBe(e, t, n) { + if (!t.composite) return; + const i = E.checkDefined(e.buildInfoCache.get(n)); + if (i.latestChangedDtsTime !== void 0) return i.latestChangedDtsTime || void 0; + const s = i.buildInfo && NA(i.buildInfo) && i.buildInfo.latestChangedDtsFile ? e.host.getModifiedTime(Qi(i.buildInfo.latestChangedDtsFile, Hn(i.path))) : void 0; + return i.latestChangedDtsTime = s || !1, s; + } + function vbe(e, t, n) { + if (e.options.dry) + return uf(e, p.A_non_dry_build_would_update_timestamps_for_output_of_project_0, t.options.configFilePath); + ybe(e, t, n, p.Updating_output_timestamps_of_project_0), e.projectStatus.set(n, { + type: 1, + oldestOutputFileName: tU(t, !e.host.useCaseSensitiveFileNames()) + }); + } + function ABe(e, t, n, i, s, o, c) { + if (!(e.options.stopBuildOnErrors && c & 4) && s.options.composite) + for (let _ = i + 1; _ < o.length; _++) { + const u = o[_], g = ng(e, u); + if (e.projectPendingBuild.has(g)) continue; + const m = W6(e, u, g); + if (!(!m || !m.projectReferences)) + for (const h of m.projectReferences) { + const S = OA(e, h.path); + if (ng(e, S) !== n) continue; + const T = e.projectStatus.get(g); + if (T) + switch (T.type) { + case 1: + if (c & 2) { + T.type = 2; + break; + } + // falls through + case 15: + case 2: + c & 2 || e.projectStatus.set(g, { + type: 6, + outOfDateOutputFileName: T.oldestOutputFileName, + newerProjectName: t + }); + break; + case 12: + ng(e, OA(e, T.upstreamProjectName)) === n && ube(e, g); + break; + } + _be( + e, + g, + 0 + /* Update */ + ); + break; + } + } + } + function bbe(e, t, n, i, s, o) { + Ko("SolutionBuilder::beforeBuild"); + const c = IBe(e, t, n, i, s, o); + return Ko("SolutionBuilder::afterBuild"), rp("SolutionBuilder::Build", "SolutionBuilder::beforeBuild", "SolutionBuilder::afterBuild"), c; + } + function IBe(e, t, n, i, s, o) { + const c = cbe(e, t, o); + if (!c) return 3; + fbe(e, n); + let _ = !0, u = 0; + for (; ; ) { + const g = mse(e, c, _); + if (!g) break; + _ = !1, g.done(n, i, s?.(g.project)), e.diagnostics.has(g.projectPath) || u++; + } + return pse(e), wbe(e, c), MBe(e, c), uk(c) ? 4 : c.some((g) => e.diagnostics.has(ng(e, g))) ? u ? 2 : 1 : 0; + } + function Sbe(e, t, n) { + Ko("SolutionBuilder::beforeClean"); + const i = FBe(e, t, n); + return Ko("SolutionBuilder::afterClean"), rp("SolutionBuilder::Clean", "SolutionBuilder::beforeClean", "SolutionBuilder::afterClean"), i; + } + function FBe(e, t, n) { + const i = cbe(e, t, n); + if (!i) return 3; + if (uk(i)) + return rV(e, i.circularDiagnostics), 4; + const { options: s, host: o } = e, c = s.dry ? [] : void 0; + for (const _ of i) { + const u = ng(e, _), g = W6(e, _, u); + if (g === void 0) { + Dbe(e, u); + continue; + } + const m = AO(g, !o.useCaseSensitiveFileNames()); + if (!m.length) continue; + const h = new Set(g.fileNames.map((S) => fd(e, S))); + for (const S of m) + h.has(fd(e, S)) || o.fileExists(S) && (c ? c.push(S) : (o.deleteFile(S), vse( + e, + u, + 0 + /* Update */ + ))); + } + return c && uf(e, p.A_non_dry_build_would_delete_the_following_files_Colon_0, c.map((_) => `\r + * ${_}`).join("")), 0; + } + function vse(e, t, n) { + e.host.getParsedCommandLine && n === 1 && (n = 2), n === 2 && (e.configFileCache.delete(t), e.buildOrder = void 0), e.needsSummary = !0, ube(e, t), _be(e, t, n), lbe(e); + } + function i9(e, t, n) { + e.reportFileChangeDetected = !0, vse(e, t, n), Tbe( + e, + 250, + /*changeDetected*/ + !0 + ); + } + function Tbe(e, t, n) { + const { hostWithWatch: i } = e; + !i.setTimeout || !i.clearTimeout || (e.timerToBuildInvalidatedProject && i.clearTimeout(e.timerToBuildInvalidatedProject), e.timerToBuildInvalidatedProject = i.setTimeout(OBe, t, "timerToBuildInvalidatedProject", e, n)); + } + function OBe(e, t, n) { + Ko("SolutionBuilder::beforeBuild"); + const i = LBe(t, n); + Ko("SolutionBuilder::afterBuild"), rp("SolutionBuilder::Build", "SolutionBuilder::beforeBuild", "SolutionBuilder::afterBuild"), i && wbe(t, i); + } + function LBe(e, t) { + e.timerToBuildInvalidatedProject = void 0, e.reportFileChangeDetected && (e.reportFileChangeDetected = !1, e.projectErrorsReported.clear(), Tse(e, p.File_change_detected_Starting_incremental_compilation)); + let n = 0; + const i = n9(e), s = mse( + e, + i, + /*reportQueue*/ + !1 + ); + if (s) + for (s.done(), n++; e.projectPendingBuild.size; ) { + if (e.timerToBuildInvalidatedProject) return; + const o = dbe( + e, + i, + /*reportQueue*/ + !1 + ); + if (!o) break; + if (o.kind !== 1 && (t || n === 5)) { + Tbe( + e, + 100, + /*changeDetected*/ + !1 + ); + return; + } + mbe(e, o, i).done(), o.kind !== 1 && n++; + } + return pse(e), i; + } + function xbe(e, t, n, i) { + !e.watch || e.allWatchedConfigFiles.has(n) || e.allWatchedConfigFiles.set( + n, + eV( + e, + t, + () => i9( + e, + n, + 2 + /* Full */ + ), + 2e3, + i?.watchOptions, + Fl.ConfigFile, + t + ) + ); + } + function kbe(e, t, n) { + FO( + t, + n?.options, + e.allWatchedExtendedConfigFiles, + (i, s) => eV( + e, + i, + () => { + var o; + return (o = e.allWatchedExtendedConfigFiles.get(s)) == null ? void 0 : o.projects.forEach((c) => i9( + e, + c, + 2 + /* Full */ + )); + }, + 2e3, + n?.watchOptions, + Fl.ExtendedConfigFile + ), + (i) => fd(e, i) + ); + } + function Cbe(e, t, n, i) { + e.watch && xA( + cse(e.allWatchedWildcardDirectories, n), + i.wildcardDirectories, + (s, o) => e.watchDirectory( + s, + (c) => { + var _; + kA({ + watchedDirPath: fd(e, s), + fileOrDirectory: c, + fileOrDirectoryPath: fd(e, c), + configFileName: t, + currentDirectory: e.compilerHost.getCurrentDirectory(), + options: i.options, + program: e.builderPrograms.get(n) || ((_ = TBe(e, n)) == null ? void 0 : _.fileNames), + useCaseSensitiveFileNames: e.parseConfigFileHost.useCaseSensitiveFileNames, + writeLog: (u) => e.writeLog(u), + toPath: (u) => fd(e, u) + }) || i9( + e, + n, + 1 + /* RootNamesAndUpdate */ + ); + }, + o, + i?.watchOptions, + Fl.WildcardDirectory, + t + ) + ); + } + function bse(e, t, n, i) { + e.watch && o4( + cse(e.allWatchedInputFiles, n), + new Set(i.fileNames), + { + createNewValue: (s) => eV( + e, + s, + () => i9( + e, + n, + 0 + /* Update */ + ), + 250, + i?.watchOptions, + Fl.SourceFile, + t + ), + onDeleteValue: od + } + ); + } + function Sse(e, t, n, i) { + !e.watch || !e.lastCachedPackageJsonLookups || o4( + cse(e.allWatchedPackageJsonFiles, n), + e.lastCachedPackageJsonLookups.get(n), + { + createNewValue: (s) => eV( + e, + s, + () => i9( + e, + n, + 0 + /* Update */ + ), + 2e3, + i?.watchOptions, + Fl.PackageJson, + t + ), + onDeleteValue: od + } + ); + } + function MBe(e, t) { + if (e.watchAllProjectsPending) { + Ko("SolutionBuilder::beforeWatcherCreation"), e.watchAllProjectsPending = !1; + for (const n of FA(t)) { + const i = ng(e, n), s = W6(e, n, i); + xbe(e, n, i, s), kbe(e, i, s), s && (Cbe(e, n, i, s), bse(e, n, i, s), Sse(e, n, i, s)); + } + Ko("SolutionBuilder::afterWatcherCreation"), rp("SolutionBuilder::Watcher creation", "SolutionBuilder::beforeWatcherCreation", "SolutionBuilder::afterWatcherCreation"); + } + } + function RBe(e) { + B_(e.allWatchedConfigFiles, od), B_(e.allWatchedExtendedConfigFiles, gp), B_(e.allWatchedWildcardDirectories, (t) => B_(t, gp)), B_(e.allWatchedInputFiles, (t) => B_(t, od)), B_(e.allWatchedPackageJsonFiles, (t) => B_(t, od)); + } + function Ebe(e, t, n, i, s) { + const o = SBe(e, t, n, i, s); + return { + build: (c, _, u, g) => bbe(o, c, _, u, g), + clean: (c) => Sbe(o, c), + buildReferences: (c, _, u, g) => bbe( + o, + c, + _, + u, + g, + /*onlyReferences*/ + !0 + ), + cleanReferences: (c) => Sbe( + o, + c, + /*onlyReferences*/ + !0 + ), + getNextInvalidatedProject: (c) => (fbe(o, c), mse( + o, + n9(o), + /*reportQueue*/ + !1 + )), + getBuildOrder: () => n9(o), + getUpToDateStatusOfProject: (c) => { + const _ = OA(o, c), u = ng(o, _); + return yse(o, W6(o, _, u), u); + }, + invalidateProject: (c, _) => vse( + o, + c, + _ || 0 + /* Update */ + ), + close: () => RBe(o) + }; + } + function iu(e, t) { + return fD(t, e.compilerHost.getCurrentDirectory(), e.compilerHost.getCanonicalFileName); + } + function uf(e, t, ...n) { + e.host.reportSolutionBuilderStatus(Yo(t, ...n)); + } + function Tse(e, t, ...n) { + var i, s; + (s = (i = e.hostWithWatch).onWatchStatusChange) == null || s.call(i, Yo(t, ...n), e.host.getNewLine(), e.baseCompilerOptions); + } + function rV({ host: e }, t) { + t.forEach((n) => e.reportDiagnostic(n)); + } + function LA(e, t, n) { + rV(e, n), e.projectErrorsReported.set(t, !0), n.length && e.diagnostics.set(t, n); + } + function Dbe(e, t) { + LA(e, t, [e.configFileCache.get(t)]); + } + function wbe(e, t) { + if (!e.needsSummary) return; + e.needsSummary = !1; + const n = e.watch || !!e.host.reportErrorSummary, { diagnostics: i } = e; + let s = 0, o = []; + uk(t) ? (Pbe(e, t.buildOrder), rV(e, t.circularDiagnostics), n && (s += XO(t.circularDiagnostics)), n && (o = [...o, ...QO(t.circularDiagnostics)])) : (t.forEach((c) => { + const _ = ng(e, c); + e.projectErrorsReported.has(_) || rV(e, i.get(_) || Ge); + }), n && i.forEach((c) => s += XO(c)), n && i.forEach((c) => [...o, ...QO(c)])), e.watch ? Tse(e, LU(s), s) : e.host.reportErrorSummary && e.host.reportErrorSummary(s, o); + } + function Pbe(e, t) { + e.options.verbose && uf(e, p.Projects_in_this_build_Colon_0, t.map((n) => `\r + * ` + iu(e, n)).join("")); + } + function jBe(e, t, n) { + switch (n.type) { + case 5: + return uf( + e, + p.Project_0_is_out_of_date_because_output_1_is_older_than_input_2, + iu(e, t), + iu(e, n.outOfDateOutputFileName), + iu(e, n.newerInputFileName) + ); + case 6: + return uf( + e, + p.Project_0_is_out_of_date_because_output_1_is_older_than_input_2, + iu(e, t), + iu(e, n.outOfDateOutputFileName), + iu(e, n.newerProjectName) + ); + case 3: + return uf( + e, + p.Project_0_is_out_of_date_because_output_file_1_does_not_exist, + iu(e, t), + iu(e, n.missingOutputFileName) + ); + case 4: + return uf( + e, + p.Project_0_is_out_of_date_because_there_was_error_reading_file_1, + iu(e, t), + iu(e, n.fileName) + ); + case 7: + return uf( + e, + p.Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_were_not_emitted, + iu(e, t), + iu(e, n.buildInfoFile) + ); + case 8: + return uf( + e, + p.Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_program_needs_to_report_errors, + iu(e, t), + iu(e, n.buildInfoFile) + ); + case 9: + return uf( + e, + p.Project_0_is_out_of_date_because_buildinfo_file_1_indicates_there_is_change_in_compilerOptions, + iu(e, t), + iu(e, n.buildInfoFile) + ); + case 10: + return uf( + e, + p.Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_file_2_was_root_file_of_compilation_but_not_any_more, + iu(e, t), + iu(e, n.buildInfoFile), + iu(e, n.inputFile) + ); + case 1: + if (n.newestInputFileTime !== void 0) + return uf( + e, + p.Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2, + iu(e, t), + iu(e, n.newestInputFileName || ""), + iu(e, n.oldestOutputFileName || "") + ); + break; + case 2: + return uf( + e, + p.Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies, + iu(e, t) + ); + case 15: + return uf( + e, + p.Project_0_is_up_to_date_but_needs_to_update_timestamps_of_output_files_that_are_older_than_input_files, + iu(e, t) + ); + case 11: + return uf( + e, + p.Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date, + iu(e, t), + iu(e, n.upstreamProjectName) + ); + case 12: + return uf( + e, + n.upstreamProjectBlocked ? p.Project_0_can_t_be_built_because_its_dependency_1_was_not_built : p.Project_0_can_t_be_built_because_its_dependency_1_has_errors, + iu(e, t), + iu(e, n.upstreamProjectName) + ); + case 0: + return uf( + e, + p.Project_0_is_out_of_date_because_1, + iu(e, t), + n.reason + ); + case 14: + return uf( + e, + p.Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_current_version_2, + iu(e, t), + n.version, + ep + ); + case 17: + return uf( + e, + p.Project_0_is_being_forcibly_rebuilt, + iu(e, t) + ); + } + } + function nV(e, t, n) { + e.options.verbose && jBe(e, t, n); + } + var xse = /* @__PURE__ */ ((e) => (e[e.time = 0] = "time", e[e.count = 1] = "count", e[e.memory = 2] = "memory", e))(xse || {}); + function BBe(e) { + const t = JBe(); + return lr(e.getSourceFiles(), (n) => { + const i = zBe(e, n), s = kg(n).length; + t.set(i, t.get(i) + s); + }), t; + } + function JBe() { + const e = /* @__PURE__ */ new Map(); + return e.set("Library", 0), e.set("Definitions", 0), e.set("TypeScript", 0), e.set("JavaScript", 0), e.set("JSON", 0), e.set("Other", 0), e; + } + function zBe(e, t) { + if (e.isSourceFileDefaultLibrary(t)) + return "Library"; + if (t.isDeclarationFile) + return "Definitions"; + const n = t.path; + return xc(n, AJ) ? "TypeScript" : xc(n, s6) ? "JavaScript" : Xo( + n, + ".json" + /* Json */ + ) ? "JSON" : "Other"; + } + function iV(e, t, n) { + return s9(e, n) ? lk( + e, + /*pretty*/ + !0 + ) : t; + } + function Nbe(e) { + return !!e.writeOutputIsTTY && e.writeOutputIsTTY() && !e.getEnvironmentVariable("NO_COLOR"); + } + function s9(e, t) { + return !t || typeof t.pretty > "u" ? Nbe(e) : t.pretty; + } + function Abe(e) { + return e.options.all ? X_(_d.concat(OS), (t, n) => zP(t.name, n.name)) : kn(_d.concat(OS), (t) => !!t.showInSimplifiedHelpView); + } + function sV(e) { + e.write(D_(p.Version_0, ep) + e.newLine); + } + function aV(e) { + if (!Nbe(e)) + return { + bold: (m) => m, + blue: (m) => m, + blueBackground: (m) => m, + brightWhite: (m) => m + }; + function n(m) { + return `\x1B[1m${m}\x1B[22m`; + } + const i = e.getEnvironmentVariable("OS") && e.getEnvironmentVariable("OS").toLowerCase().includes("windows"), s = e.getEnvironmentVariable("WT_SESSION"), o = e.getEnvironmentVariable("TERM_PROGRAM") && e.getEnvironmentVariable("TERM_PROGRAM") === "vscode"; + function c(m) { + return i && !s && !o ? g(m) : `\x1B[94m${m}\x1B[39m`; + } + const _ = e.getEnvironmentVariable("COLORTERM") === "truecolor" || e.getEnvironmentVariable("TERM") === "xterm-256color"; + function u(m) { + return _ ? `\x1B[48;5;68m${m}\x1B[39;49m` : `\x1B[44m${m}\x1B[39;49m`; + } + function g(m) { + return `\x1B[97m${m}\x1B[39m`; + } + return { + bold: n, + blue: c, + brightWhite: g, + blueBackground: u + }; + } + function Ibe(e) { + return `--${e.name}${e.shortName ? `, -${e.shortName}` : ""}`; + } + function WBe(e, t, n, i) { + var s; + const o = [], c = aV(e), _ = Ibe(t), u = k(t), g = typeof t.defaultValueDescription == "object" ? D_(t.defaultValueDescription) : h( + t.defaultValueDescription, + t.type === "list" || t.type === "listOrElement" ? t.element.type : t.type + ), m = ((s = e.getWidthOfTerminal) == null ? void 0 : s.call(e)) ?? 0; + if (m >= 80) { + let D = ""; + t.description && (D = D_(t.description)), o.push(...T( + _, + D, + n, + i, + m, + /*colorLeft*/ + !0 + ), e.newLine), S(u, t) && (u && o.push(...T( + u.valueType, + u.possibleValues, + n, + i, + m, + /*colorLeft*/ + !1 + ), e.newLine), g && o.push(...T( + D_(p.default_Colon), + g, + n, + i, + m, + /*colorLeft*/ + !1 + ), e.newLine)), o.push(e.newLine); + } else { + if (o.push(c.blue(_), e.newLine), t.description) { + const D = D_(t.description); + o.push(D); + } + if (o.push(e.newLine), S(u, t)) { + if (u && o.push(`${u.valueType} ${u.possibleValues}`), g) { + u && o.push(e.newLine); + const D = D_(p.default_Colon); + o.push(`${D} ${g}`); + } + o.push(e.newLine); + } + o.push(e.newLine); + } + return o; + function h(D, P) { + return D !== void 0 && typeof P == "object" ? is(P.entries()).filter(([, A]) => A === D).map(([A]) => A).join("/") : String(D); + } + function S(D, P) { + const A = ["string"], O = [void 0, "false", "n/a"], F = P.defaultValueDescription; + return !(P.category === p.Command_line_Options || ms(A, D?.possibleValues) && ms(O, F)); + } + function T(D, P, A, O, F, R) { + const B = []; + let U = !0, $ = P; + const W = F - O; + for (; $.length > 0; ) { + let _e = ""; + U ? (_e = D.padStart(A), _e = _e.padEnd(O), _e = R ? c.blue(_e) : _e) : _e = "".padStart(O); + const K = $.substr(0, W); + $ = $.slice(W), B.push(`${_e}${K}`), U = !1; + } + return B; + } + function k(D) { + if (D.type === "object") + return; + return { + valueType: P(D), + possibleValues: A(D) + }; + function P(O) { + switch (E.assert(O.type !== "listOrElement"), O.type) { + case "string": + case "number": + case "boolean": + return D_(p.type_Colon); + case "list": + return D_(p.one_or_more_Colon); + default: + return D_(p.one_of_Colon); + } + } + function A(O) { + let F; + switch (O.type) { + case "string": + case "number": + case "boolean": + F = O.type; + break; + case "list": + case "listOrElement": + F = A(O.element); + break; + case "object": + F = ""; + break; + default: + const R = {}; + return O.type.forEach((B, U) => { + var $; + ($ = O.deprecatedKeys) != null && $.has(U) || (R[B] || (R[B] = [])).push(U); + }), Object.entries(R).map(([, B]) => B.join("/")).join(", "); + } + return F; + } + } + } + function Fbe(e, t) { + let n = 0; + for (const c of t) { + const _ = Ibe(c).length; + n = n > _ ? n : _; + } + const i = n + 2, s = i + 2; + let o = []; + for (const c of t) { + const _ = WBe(e, c, i, s); + o = [...o, ..._]; + } + return o[o.length - 2] !== e.newLine && o.push(e.newLine), o; + } + function MA(e, t, n, i, s, o) { + let c = []; + if (c.push(aV(e).bold(t) + e.newLine + e.newLine), s && c.push(s + e.newLine + e.newLine), !i) + return c = [...c, ...Fbe(e, n)], o && c.push(o + e.newLine + e.newLine), c; + const _ = /* @__PURE__ */ new Map(); + for (const u of n) { + if (!u.category) + continue; + const g = D_(u.category), m = _.get(g) ?? []; + m.push(u), _.set(g, m); + } + return _.forEach((u, g) => { + c.push(`### ${g}${e.newLine}${e.newLine}`), c = [...c, ...Fbe(e, u)]; + }), o && c.push(o + e.newLine + e.newLine), c; + } + function UBe(e, t) { + const n = aV(e); + let i = [...oV(e, `${D_(p.tsc_Colon_The_TypeScript_Compiler)} - ${D_(p.Version_0, ep)}`)]; + i.push(n.bold(D_(p.COMMON_COMMANDS)) + e.newLine + e.newLine), c("tsc", p.Compiles_the_current_project_tsconfig_json_in_the_working_directory), c("tsc app.ts util.ts", p.Ignoring_tsconfig_json_compiles_the_specified_files_with_default_compiler_options), c("tsc -b", p.Build_a_composite_project_in_the_working_directory), c("tsc --init", p.Creates_a_tsconfig_json_with_the_recommended_settings_in_the_working_directory), c("tsc -p ./path/to/tsconfig.json", p.Compiles_the_TypeScript_project_located_at_the_specified_path), c("tsc --help --all", p.An_expanded_version_of_this_information_showing_all_possible_compiler_options), c(["tsc --noEmit", "tsc --target esnext"], p.Compiles_the_current_project_with_additional_settings); + const s = t.filter((_) => _.isCommandLineOnly || _.category === p.Command_line_Options), o = t.filter((_) => !ms(s, _)); + i = [ + ...i, + ...MA( + e, + D_(p.COMMAND_LINE_FLAGS), + s, + /*subCategory*/ + !1, + /*beforeOptionsDescription*/ + void 0, + /*afterOptionsDescription*/ + void 0 + ), + ...MA( + e, + D_(p.COMMON_COMPILER_OPTIONS), + o, + /*subCategory*/ + !1, + /*beforeOptionsDescription*/ + void 0, + Nx(p.You_can_learn_about_all_of_the_compiler_options_at_0, "https://aka.ms/tsc") + ) + ]; + for (const _ of i) + e.write(_); + function c(_, u) { + const g = typeof _ == "string" ? [_] : _; + for (const m of g) + i.push(" " + n.blue(m) + e.newLine); + i.push(" " + D_(u) + e.newLine + e.newLine); + } + } + function VBe(e, t, n, i) { + let s = [...oV(e, `${D_(p.tsc_Colon_The_TypeScript_Compiler)} - ${D_(p.Version_0, ep)}`)]; + s = [...s, ...MA( + e, + D_(p.ALL_COMPILER_OPTIONS), + t, + /*subCategory*/ + !0, + /*beforeOptionsDescription*/ + void 0, + Nx(p.You_can_learn_about_all_of_the_compiler_options_at_0, "https://aka.ms/tsc") + )], s = [...s, ...MA( + e, + D_(p.WATCH_OPTIONS), + i, + /*subCategory*/ + !1, + D_(p.Including_watch_w_will_start_watching_the_current_project_for_the_file_changes_Once_set_you_can_config_watch_mode_with_Colon) + )], s = [...s, ...MA( + e, + D_(p.BUILD_OPTIONS), + kn(n, (o) => o !== OS), + /*subCategory*/ + !1, + Nx(p.Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_trigger_building_composite_projects_which_you_can_learn_more_about_at_0, "https://aka.ms/tsc-composite-builds") + )]; + for (const o of s) + e.write(o); + } + function Obe(e, t) { + let n = [...oV(e, `${D_(p.tsc_Colon_The_TypeScript_Compiler)} - ${D_(p.Version_0, ep)}`)]; + n = [...n, ...MA( + e, + D_(p.BUILD_OPTIONS), + kn(t, (i) => i !== OS), + /*subCategory*/ + !1, + Nx(p.Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_trigger_building_composite_projects_which_you_can_learn_more_about_at_0, "https://aka.ms/tsc-composite-builds") + )]; + for (const i of n) + e.write(i); + } + function oV(e, t) { + var n; + const i = aV(e), s = [], o = ((n = e.getWidthOfTerminal) == null ? void 0 : n.call(e)) ?? 0, c = 5, _ = i.blueBackground("".padStart(c)), u = i.blueBackground(i.brightWhite("TS ".padStart(c))); + if (o >= t.length + c) { + const m = (o > 120 ? 120 : o) - c; + s.push(t.padEnd(m) + _ + e.newLine), s.push("".padStart(m) + u + e.newLine); + } else + s.push(t + e.newLine), s.push(e.newLine); + return s; + } + function Lbe(e, t) { + t.options.all ? VBe(e, Abe(t), Yz, rk) : UBe(e, Abe(t)); + } + function Mbe(e, t, n) { + let i = lk(e), s; + if (n.options.locale && Aj(n.options.locale, e, n.errors), n.errors.length > 0) + return n.errors.forEach(i), e.exit( + 1 + /* DiagnosticsPresent_OutputsSkipped */ + ); + if (n.options.init) + return $Be(e, i, n.options), e.exit( + 0 + /* Success */ + ); + if (n.options.version) + return sV(e), e.exit( + 0 + /* Success */ + ); + if (n.options.help || n.options.all) + return Lbe(e, n), e.exit( + 0 + /* Success */ + ); + if (n.options.watch && n.options.listFilesOnly) + return i(Yo(p.Options_0_and_1_cannot_be_combined, "watch", "listFilesOnly")), e.exit( + 1 + /* DiagnosticsPresent_OutputsSkipped */ + ); + if (n.options.project) { + if (n.fileNames.length !== 0) + return i(Yo(p.Option_project_cannot_be_mixed_with_source_files_on_a_command_line)), e.exit( + 1 + /* DiagnosticsPresent_OutputsSkipped */ + ); + const _ = Hs(n.options.project); + if (!_ || e.directoryExists(_)) { + if (s = On(_, "tsconfig.json"), !e.fileExists(s)) + return i(Yo(p.Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0, n.options.project)), e.exit( + 1 + /* DiagnosticsPresent_OutputsSkipped */ + ); + } else if (s = _, !e.fileExists(s)) + return i(Yo(p.The_specified_path_does_not_exist_Colon_0, n.options.project)), e.exit( + 1 + /* DiagnosticsPresent_OutputsSkipped */ + ); + } else if (n.fileNames.length === 0) { + const _ = Hs(e.getCurrentDirectory()); + s = lU(_, (u) => e.fileExists(u)); + } + if (n.fileNames.length === 0 && !s) + return n.options.showConfig ? i(Yo(p.Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0, Hs(e.getCurrentDirectory()))) : (sV(e), Lbe(e, n)), e.exit( + 1 + /* DiagnosticsPresent_OutputsSkipped */ + ); + const o = e.getCurrentDirectory(), c = tO( + n.options, + (_) => Qi(_, o) + ); + if (s) { + const _ = /* @__PURE__ */ new Map(), u = ise(s, c, _, n.watchOptions, e, i); + if (c.showConfig) + return u.errors.length !== 0 ? (i = iV( + e, + i, + u.options + ), u.errors.forEach(i), e.exit( + 1 + /* DiagnosticsPresent_OutputsSkipped */ + )) : (e.write(JSON.stringify(iW(u, s, e), null, 4) + e.newLine), e.exit( + 0 + /* Success */ + )); + if (i = iV( + e, + i, + u.options + ), mJ(u.options)) + return Cse(e, i) ? void 0 : qBe( + e, + t, + i, + u, + c, + n.watchOptions, + _ + ); + Wb(u.options) ? Jbe( + e, + t, + i, + u + ) : Bbe( + e, + t, + i, + u + ); + } else { + if (c.showConfig) + return e.write(JSON.stringify(iW(n, On(o, "tsconfig.json"), e), null, 4) + e.newLine), e.exit( + 0 + /* Success */ + ); + if (i = iV( + e, + i, + c + ), mJ(c)) + return Cse(e, i) ? void 0 : HBe( + e, + t, + i, + n.fileNames, + c, + n.watchOptions + ); + Wb(c) ? Jbe( + e, + t, + i, + { ...n, options: c } + ) : Bbe( + e, + t, + i, + { ...n, options: c } + ); + } + } + function kse(e) { + if (e.length > 0 && e[0].charCodeAt(0) === 45) { + const t = e[0].slice(e[0].charCodeAt(1) === 45 ? 2 : 1).toLowerCase(); + return t === OS.name || t === OS.shortName; + } + return !1; + } + function Rbe(e, t, n) { + if (kse(n)) { + const { buildOptions: s, watchOptions: o, projects: c, errors: _ } = Bre(n); + if (s.generateCpuProfile && e.enableCPUProfiler) + e.enableCPUProfiler(s.generateCpuProfile, () => jbe( + e, + t, + s, + o, + c, + _ + )); + else + return jbe( + e, + t, + s, + o, + c, + _ + ); + } + const i = Rre(n, (s) => e.readFile(s)); + if (i.options.generateCpuProfile && e.enableCPUProfiler) + e.enableCPUProfiler(i.options.generateCpuProfile, () => Mbe( + e, + t, + i + )); + else + return Mbe(e, t, i); + } + function Cse(e, t) { + return !e.watchFile || !e.watchDirectory ? (t(Yo(p.The_current_host_does_not_support_the_0_option, "--watch")), e.exit( + 1 + /* DiagnosticsPresent_OutputsSkipped */ + ), !0) : !1; + } + var a9 = 2; + function jbe(e, t, n, i, s, o) { + const c = iV( + e, + lk(e), + n + ); + if (n.locale && Aj(n.locale, e, o), o.length > 0) + return o.forEach(c), e.exit( + 1 + /* DiagnosticsPresent_OutputsSkipped */ + ); + if (n.help || s.length === 0) + return sV(e), Obe(e, tA), e.exit( + 0 + /* Success */ + ); + if (!e.getModifiedTime || !e.setModifiedTime || n.clean && !e.deleteFile) + return c(Yo(p.The_current_host_does_not_support_the_0_option, "--build")), e.exit( + 1 + /* DiagnosticsPresent_OutputsSkipped */ + ); + if (n.watch) { + if (Cse(e, c)) return; + const h = use( + e, + /*createProgram*/ + void 0, + c, + r9(e, s9(e, n)), + Dse(e, n) + ); + h.jsDocParsingMode = a9; + const S = Vbe(e, n); + zbe(e, t, h, S); + const T = h.onWatchStatusChange; + let k = !1; + h.onWatchStatusChange = (P, A, O, F) => { + T?.(P, A, O, F), k && (P.code === p.Found_0_errors_Watching_for_file_changes.code || P.code === p.Found_1_error_Watching_for_file_changes.code) && wse(D, S); + }; + const D = fse(h, s, n, i); + return D.build(), wse(D, S), k = !0, D; + } + const _ = lse( + e, + /*createProgram*/ + void 0, + c, + r9(e, s9(e, n)), + Ese(e, n) + ); + _.jsDocParsingMode = a9; + const u = Vbe(e, n); + zbe(e, t, _, u); + const g = _se(_, s, n), m = n.clean ? g.clean() : g.build(); + return wse(g, u), PQ(), e.exit(m); + } + function Ese(e, t) { + return s9(e, t) ? (n, i) => e.write(MU(n, i, e.newLine, e)) : void 0; + } + function Bbe(e, t, n, i) { + const { fileNames: s, options: o, projectReferences: c } = i, _ = LO( + o, + /*setParentNodes*/ + void 0, + e + ); + _.jsDocParsingMode = a9; + const u = _.getCurrentDirectory(), g = Zl(_.useCaseSensitiveFileNames()); + ow(_, (T) => oo(T, u, g)), Pse( + e, + o, + /*isBuildMode*/ + !1 + ); + const m = { + rootNames: s, + options: o, + projectReferences: c, + host: _, + configFileParsingDiagnostics: a2(i) + }, h = wA(m), S = UU( + h, + n, + (T) => e.write(T + e.newLine), + Ese(e, o) + ); + return lV( + e, + h, + /*solutionPerformance*/ + void 0 + ), t(h), e.exit(S); + } + function Jbe(e, t, n, i) { + const { options: s, fileNames: o, projectReferences: c } = i; + Pse( + e, + s, + /*isBuildMode*/ + !1 + ); + const _ = t9(s, e); + _.jsDocParsingMode = a9; + const u = sse({ + host: _, + system: e, + rootNames: o, + options: s, + configFileParsingDiagnostics: a2(i), + projectReferences: c, + reportDiagnostic: n, + reportErrorSummary: Ese(e, s), + afterProgramEmitAndDiagnostics: (g) => { + lV( + e, + g.getProgram(), + /*solutionPerformance*/ + void 0 + ), t(g); + } + }); + return e.exit(u); + } + function zbe(e, t, n, i) { + Wbe( + e, + n, + /*isBuildMode*/ + !0 + ), n.afterProgramEmitAndDiagnostics = (s) => { + lV(e, s.getProgram(), i), t(s); + }; + } + function Wbe(e, t, n) { + const i = t.createProgram; + t.createProgram = (s, o, c, _, u, g) => (E.assert(s !== void 0 || o === void 0 && !!_), o !== void 0 && Pse(e, o, n), i(s, o, c, _, u, g)); + } + function Ube(e, t, n) { + n.jsDocParsingMode = a9, Wbe( + e, + n, + /*isBuildMode*/ + !1 + ); + const i = n.afterProgramCreate; + n.afterProgramCreate = (s) => { + i(s), lV( + e, + s.getProgram(), + /*solutionPerformance*/ + void 0 + ), t(s); + }; + } + function Dse(e, t) { + return OU(e, s9(e, t)); + } + function qBe(e, t, n, i, s, o, c) { + const _ = $U({ + configFileName: i.options.configFilePath, + optionsToExtend: s, + watchOptionsToExtend: o, + system: e, + reportDiagnostic: n, + reportWatchStatus: Dse(e, i.options) + }); + return Ube(e, t, _), _.configFileParsingResult = i, _.extendedConfigCache = c, QU(_); + } + function HBe(e, t, n, i, s, o) { + const c = XU({ + rootFiles: i, + options: s, + watchOptions: o, + system: e, + reportDiagnostic: n, + reportWatchStatus: Dse(e, s) + }); + return Ube(e, t, c), QU(c); + } + function Vbe(e, t) { + if (e === ml && t.extendedDiagnostics) + return QR(), GBe(); + } + function GBe() { + let e; + return { + addAggregateStatistic: t, + forEachAggregateStatistics: n, + clear: i + }; + function t(s) { + const o = e?.get(s.name); + o ? o.type === 2 ? o.value = Math.max(o.value, s.value) : o.value += s.value : (e ?? (e = /* @__PURE__ */ new Map())).set(s.name, s); + } + function n(s) { + e?.forEach(s); + } + function i() { + e = void 0; + } + } + function wse(e, t) { + if (!t) return; + if (!EQ()) { + ml.write(p.Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_native_implementation_of_the_Web_Performance_API_could_not_be_found.message + ` +`); + return; + } + const n = []; + n.push( + { + name: "Projects in scope", + value: FA(e.getBuildOrder()).length, + type: 1 + /* count */ + } + ), i("SolutionBuilder::Projects built"), i("SolutionBuilder::Timestamps only updates"), i("SolutionBuilder::Bundles updated"), t.forEachAggregateStatistics((o) => { + o.name = `Aggregate ${o.name}`, n.push(o); + }), XR((o, c) => { + cV(o) && n.push({ + name: `${s(o)} time`, + value: c, + type: 0 + /* time */ + }); + }), DQ(), QR(), t.clear(), Gbe(ml, n); + function i(o) { + const c = wge(o); + c && n.push({ + name: s(o), + value: c, + type: 1 + /* count */ + }); + } + function s(o) { + return o.replace("SolutionBuilder::", ""); + } + } + function qbe(e, t) { + return e === ml && (t.diagnostics || t.extendedDiagnostics); + } + function Hbe(e, t) { + return e === ml && t.generateTrace; + } + function Pse(e, t, n) { + qbe(e, t) && QR(e), Hbe(e, t) && wQ(n ? "build" : "project", t.generateTrace, t.configFilePath); + } + function cV(e) { + return Ui(e, "SolutionBuilder::"); + } + function lV(e, t, n) { + var i; + const s = t.getCompilerOptions(); + Hbe(e, s) && ((i = on) == null || i.stopTracing()); + let o; + if (qbe(e, s)) { + o = []; + const g = e.getMemoryUsage ? e.getMemoryUsage() : -1; + _("Files", t.getSourceFiles().length); + const m = BBe(t); + if (s.extendedDiagnostics) + for (const [P, A] of m.entries()) + _("Lines of " + P, A); + else + _("Lines", ZX(m.values(), (P, A) => P + A, 0)); + _("Identifiers", t.getIdentifierCount()), _("Symbols", t.getSymbolCount()), _("Types", t.getTypeCount()), _("Instantiations", t.getInstantiationCount()), g >= 0 && c( + { + name: "Memory used", + value: g, + type: 2 + /* memory */ + }, + /*aggregate*/ + !0 + ); + const h = EQ(), S = h ? cD("Program") : 0, T = h ? cD("Bind") : 0, k = h ? cD("Check") : 0, D = h ? cD("Emit") : 0; + if (s.extendedDiagnostics) { + const P = t.getRelationCacheSizes(); + _("Assignability cache size", P.assignable), _("Identity cache size", P.identity), _("Subtype cache size", P.subtype), _("Strict subtype cache size", P.strictSubtype), h && XR((A, O) => { + cV(A) || u( + `${A} time`, + O, + /*aggregate*/ + !0 + ); + }); + } else h && (u( + "I/O read", + cD("I/O Read"), + /*aggregate*/ + !0 + ), u( + "I/O write", + cD("I/O Write"), + /*aggregate*/ + !0 + ), u( + "Parse time", + S, + /*aggregate*/ + !0 + ), u( + "Bind time", + T, + /*aggregate*/ + !0 + ), u( + "Check time", + k, + /*aggregate*/ + !0 + ), u( + "Emit time", + D, + /*aggregate*/ + !0 + )); + h && u( + "Total time", + S + T + k + D, + /*aggregate*/ + !1 + ), Gbe(e, o), h ? n ? (XR((P) => { + cV(P) || Nge(P); + }), Pge((P) => { + cV(P) || Age(P); + })) : DQ() : e.write(p.Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_native_implementation_of_the_Web_Performance_API_could_not_be_found.message + ` +`); + } + function c(g, m) { + o.push(g), m && n?.addAggregateStatistic(g); + } + function _(g, m) { + c( + { + name: g, + value: m, + type: 1 + /* count */ + }, + /*aggregate*/ + !0 + ); + } + function u(g, m, h) { + c({ + name: g, + value: m, + type: 0 + /* time */ + }, h); + } + } + function Gbe(e, t) { + let n = 0, i = 0; + for (const s of t) { + s.name.length > n && (n = s.name.length); + const o = $be(s); + o.length > i && (i = o.length); + } + for (const s of t) + e.write(`${s.name}:`.padEnd(n + 2) + $be(s).toString().padStart(i) + e.newLine); + } + function $be(e) { + switch (e.type) { + case 1: + return "" + e.value; + case 0: + return (e.value / 1e3).toFixed(2) + "s"; + case 2: + return Math.round(e.value / 1e3) + "K"; + default: + E.assertNever(e.type); + } + } + function $Be(e, t, n) { + const i = e.getCurrentDirectory(), s = Hs(On(i, "tsconfig.json")); + if (e.fileExists(s)) + t(Yo(p.A_tsconfig_json_file_is_already_defined_at_Colon_0, s)); + else { + e.writeFile(s, Ure(n, e.newLine)); + const o = [e.newLine, ...oV(e, "Created a new tsconfig.json")]; + o.push("You can learn more at https://aka.ms/tsconfig" + e.newLine); + for (const c of o) + e.write(c); + } + } + function Cm(e, t = !0) { + return { type: e, reportFallback: t }; + } + var Xbe = Cm( + /*type*/ + void 0, + /*reportFallback*/ + !1 + ), Qbe = Cm( + /*type*/ + void 0, + /*reportFallback*/ + !1 + ), fw = Cm( + /*type*/ + void 0, + /*reportFallback*/ + !0 + ); + function Nse(e, t) { + const n = du(e, "strictNullChecks"); + return { + serializeTypeOfDeclaration: m, + serializeReturnTypeForSignature: S, + serializeTypeOfExpression: g, + serializeTypeOfAccessor: u, + tryReuseExistingTypeNode(ie, Ne) { + if (t.canReuseTypeNode(ie, Ne)) + return s(ie, Ne); + } + }; + function i(ie, Ne, Ee = Ne) { + return Ne === void 0 ? void 0 : t.markNodeReuse(ie, Ne.flags & 16 ? Ne : N.cloneNode(Ne), Ee ?? Ne); + } + function s(ie, Ne) { + const { finalizeBoundary: Ee, startRecoveryScope: Ce, hadError: Ve, markError: St } = t.createRecoveryBoundary(ie), Bt = Qe(Ne, tr, li); + if (!Ee()) + return; + return ie.approximateLength += Ne.end - Ne.pos, Bt; + function tr(Dt) { + if (Ve()) return Dt; + const Mn = Ce(), ai = ate(Dt) ? t.enterNewScope(ie, Dt) : void 0, fi = Ji(Dt); + return ai?.(), Ve() ? li(Dt) && !Vx(Dt) ? (Mn(), t.serializeExistingTypeNode(ie, Dt)) : Dt : fi ? t.markNodeReuse(ie, fi, Dt) : void 0; + } + function Nr(Dt) { + const Mn = VD(Dt); + switch (Mn.kind) { + case 184: + return ui(Mn); + case 187: + return Jr(Mn); + case 200: + return st(Mn); + case 199: + const ai = Mn; + if (ai.operator === 143) + return Wt(ai); + } + return Qe(Dt, tr, li); + } + function st(Dt) { + const Mn = Nr(Dt.objectType); + if (Mn !== void 0) + return N.updateIndexedAccessTypeNode(Dt, Mn, Qe(Dt.indexType, tr, li)); + } + function Wt(Dt) { + E.assertEqual( + Dt.operator, + 143 + /* KeyOfKeyword */ + ); + const Mn = Nr(Dt.type); + if (Mn !== void 0) + return N.updateTypeOperatorNode(Dt, Mn); + } + function Jr(Dt) { + const { introducesError: Mn, node: ai } = t.trackExistingEntityName(ie, Dt.exprName); + if (!Mn) + return N.updateTypeQueryNode( + Dt, + ai, + Ar(Dt.typeArguments, tr, li) + ); + const fi = t.serializeTypeName( + ie, + Dt.exprName, + /*isTypeOf*/ + !0 + ); + if (fi) + return t.markNodeReuse(ie, fi, Dt.exprName); + } + function ui(Dt) { + if (t.canReuseTypeNode(ie, Dt)) { + const { introducesError: Mn, node: ai } = t.trackExistingEntityName(ie, Dt.typeName), fi = Ar(Dt.typeArguments, tr, li); + if (Mn) { + const pn = t.serializeTypeName( + ie, + Dt.typeName, + /*isTypeOf*/ + !1, + fi + ); + if (pn) + return t.markNodeReuse(ie, pn, Dt.typeName); + } else { + const pn = N.updateTypeReferenceNode( + Dt, + ai, + fi + ); + return t.markNodeReuse(ie, pn, Dt); + } + } + } + function Ji(Dt) { + var Mn; + if (lv(Dt)) + return Qe(Dt.type, tr, li); + if (Xte(Dt) || Dt.kind === 320) + return N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ); + if (Qte(Dt)) + return N.createKeywordTypeNode( + 159 + /* UnknownKeyword */ + ); + if (v6(Dt)) + return N.createUnionTypeNode([Qe(Dt.type, tr, li), N.createLiteralTypeNode(N.createNull())]); + if (bz(Dt)) + return N.createUnionTypeNode([Qe(Dt.type, tr, li), N.createKeywordTypeNode( + 157 + /* UndefinedKeyword */ + )]); + if (AF(Dt)) + return Qe(Dt.type, tr); + if (IF(Dt)) + return N.createArrayTypeNode(Qe(Dt.type, tr, li)); + if (AS(Dt)) + return N.createTypeLiteralNode(hr(Dt.jsDocPropertyTags, (ft) => { + const er = Qe(Me(ft.name) ? ft.name : ft.name.right, tr, Me), qr = t.getJsDocPropertyOverride(ie, Dt, ft); + return N.createPropertySignature( + /*modifiers*/ + void 0, + er, + ft.isBracketed || ft.typeExpression && bz(ft.typeExpression.type) ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, + qr || ft.typeExpression && Qe(ft.typeExpression.type, tr, li) || N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ) + ); + })); + if (of(Dt) && Me(Dt.typeName) && Dt.typeName.escapedText === "") + return Cn(N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ), Dt); + if ((Dh(Dt) || of(Dt)) && u5(Dt)) + return N.createTypeLiteralNode([N.createIndexSignature( + /*modifiers*/ + void 0, + [N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "x", + /*questionToken*/ + void 0, + Qe(Dt.typeArguments[0], tr, li) + )], + Qe(Dt.typeArguments[1], tr, li) + )]); + if (b6(Dt)) + if (vx(Dt)) { + let ft; + return N.createConstructorTypeNode( + /*modifiers*/ + void 0, + Ar(Dt.typeParameters, tr, Lo), + Fi(Dt.parameters, (er, qr) => er.name && Me(er.name) && er.name.escapedText === "new" ? (ft = er.type, void 0) : N.createParameterDeclaration( + /*modifiers*/ + void 0, + pn(er), + t.markNodeReuse(ie, N.createIdentifier(_i(er, qr)), er), + N.cloneNode(er.questionToken), + Qe(er.type, tr, li), + /*initializer*/ + void 0 + )), + Qe(ft || Dt.type, tr, li) || N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ) + ); + } else + return N.createFunctionTypeNode( + Ar(Dt.typeParameters, tr, Lo), + hr(Dt.parameters, (ft, er) => N.createParameterDeclaration( + /*modifiers*/ + void 0, + pn(ft), + t.markNodeReuse(ie, N.createIdentifier(_i(ft, er)), ft), + N.cloneNode(ft.questionToken), + Qe(ft.type, tr, li), + /*initializer*/ + void 0 + )), + Qe(Dt.type, tr, li) || N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ) + ); + if (A4(Dt)) + return t.canReuseTypeNode(ie, Dt) || St(), Dt; + if (Lo(Dt)) { + const { node: ft } = t.trackExistingEntityName(ie, Dt.name); + return N.updateTypeParameterDeclaration( + Dt, + Ar(Dt.modifiers, tr, Zs), + // resolver.markNodeReuse(context, typeParameterToName(getDeclaredTypeOfSymbol(getSymbolOfDeclaration(node)), context), node), + ft, + Qe(Dt.constraint, tr, li), + Qe(Dt.default, tr, li) + ); + } + if ($b(Dt)) { + const ft = st(Dt); + return ft || (St(), Dt); + } + if (of(Dt)) { + const ft = ui(Dt); + return ft || (St(), Dt); + } + if (bh(Dt)) { + if (((Mn = Dt.attributes) == null ? void 0 : Mn.token) === 132) + return St(), Dt; + if (!t.canReuseTypeNode(ie, Dt)) + return t.serializeExistingTypeNode(ie, Dt); + const ft = Je(Dt, Dt.argument.literal), er = ft === Dt.argument.literal ? i(ie, Dt.argument.literal) : ft; + return N.updateImportTypeNode( + Dt, + er === Dt.argument.literal ? i(ie, Dt.argument) : N.createLiteralTypeNode(er), + Qe(Dt.attributes, tr, PS), + Qe(Dt.qualifier, tr, r_), + Ar(Dt.typeArguments, tr, li), + Dt.isTypeOf + ); + } + if (wl(Dt) && Dt.name.kind === 168 && !t.hasLateBindableName(Dt)) { + if (!Th(Dt)) + return ai(Dt, tr); + if (t.shouldRemoveDeclaration(ie, Dt)) + return; + } + if (Es(Dt) && !Dt.type || os(Dt) && !Dt.type && !Dt.initializer || $u(Dt) && !Dt.type && !Dt.initializer || Ii(Dt) && !Dt.type && !Dt.initializer) { + let ft = ai(Dt, tr); + return ft === Dt && (ft = t.markNodeReuse(ie, N.cloneNode(Dt), Dt)), ft.type = N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ), Ii(Dt) && (ft.modifiers = void 0), ft; + } + if (Hb(Dt)) { + const ft = Jr(Dt); + return ft || (St(), Dt); + } + if (Gs(Dt) && to(Dt.expression)) { + const { node: ft, introducesError: er } = t.trackExistingEntityName(ie, Dt.expression); + if (er) { + const qr = t.serializeTypeOfExpression(ie, Dt.expression); + let Jn; + if (E0(qr)) + Jn = qr.literal; + else { + const Un = t.evaluateEntityNameExpression(Dt.expression), ki = typeof Un.value == "string" ? N.createStringLiteral( + Un.value, + /*isSingleQuote*/ + void 0 + ) : typeof Un.value == "number" ? N.createNumericLiteral( + Un.value, + /*numericLiteralFlags*/ + 0 + ) : void 0; + if (!ki) + return ym(qr) && t.trackComputedName(ie, Dt.expression), Dt; + Jn = ki; + } + return Jn.kind === 11 && R_(Jn.text, da(e)) ? N.createIdentifier(Jn.text) : Jn.kind === 9 && !Jn.text.startsWith("-") ? Jn : N.updateComputedPropertyName(Dt, Jn); + } else + return N.updateComputedPropertyName(Dt, ft); + } + if (Vx(Dt)) { + let ft; + if (Me(Dt.parameterName)) { + const { node: er, introducesError: qr } = t.trackExistingEntityName(ie, Dt.parameterName); + qr && St(), ft = er; + } else + ft = N.cloneNode(Dt.parameterName); + return N.updateTypePredicateNode(Dt, N.cloneNode(Dt.assertsModifier), ft, Qe(Dt.type, tr, li)); + } + if (qx(Dt) || a_(Dt) || CS(Dt)) { + const ft = ai(Dt, tr), er = t.markNodeReuse(ie, ft === Dt ? N.cloneNode(Dt) : ft, Dt), qr = Ea(er); + return un(er, qr | (ie.flags & 1024 && a_(Dt) ? 0 : 1)), er; + } + if (ca(Dt) && ie.flags & 268435456 && !Dt.singleQuote) { + const ft = N.cloneNode(Dt); + return ft.singleQuote = !0, ft; + } + if (Gb(Dt)) { + const ft = Qe(Dt.checkType, tr, li), er = t.enterNewScope(ie, Dt), qr = Qe(Dt.extendsType, tr, li), Jn = Qe(Dt.trueType, tr, li); + er(); + const Un = Qe(Dt.falseType, tr, li); + return N.updateConditionalTypeNode( + Dt, + ft, + qr, + Jn, + Un + ); + } + if (rv(Dt)) { + if (Dt.operator === 158 && Dt.type.kind === 155) { + if (!t.canReuseTypeNode(ie, Dt)) + return St(), Dt; + } else if (Dt.operator === 143) { + const ft = Wt(Dt); + return ft || (St(), Dt); + } + } + return ai(Dt, tr); + function ai(ft, er) { + const qr = !ie.enclosingFile || ie.enclosingFile !== xr(ft); + return br( + ft, + er, + /*context*/ + void 0, + qr ? fi : void 0 + ); + } + function fi(ft, er, qr, Jn, Un) { + let ki = Ar(ft, er, qr, Jn, Un); + return ki && (ki.pos !== -1 || ki.end !== -1) && (ki === ft && (ki = N.createNodeArray(ft.slice(), ft.hasTrailingComma)), Ad(ki, -1, -1)), ki; + } + function pn(ft) { + return ft.dotDotDotToken || (ft.type && IF(ft.type) ? N.createToken( + 26 + /* DotDotDotToken */ + ) : void 0); + } + function _i(ft, er) { + return ft.name && Me(ft.name) && ft.name.escapedText === "this" ? "this" : pn(ft) ? "args" : `arg${er}`; + } + function Je(ft, er) { + const qr = t.getModuleSpecifierOverride(ie, ft, er); + return qr ? Cn(N.createStringLiteral(qr), er) : er; + } + } + } + function o(ie, Ne, Ee) { + if (!ie) return; + let Ce; + return (!Ee || Fe(ie)) && t.canReuseTypeNode(Ne, ie) && (Ce = s(Ne, ie), Ce !== void 0 && (Ce = Te( + Ce, + Ee, + /*owner*/ + void 0, + Ne + ))), Ce; + } + function c(ie, Ne, Ee, Ce, Ve, St = Ve !== void 0) { + if (!ie || !t.canReuseTypeNodeAnnotation(Ne, Ee, ie, Ce, Ve) && (!Ve || !t.canReuseTypeNodeAnnotation( + Ne, + Ee, + ie, + Ce, + /*requiresAddingUndefined*/ + !1 + ))) + return; + let Bt; + return (!Ve || Fe(ie)) && (Bt = o(ie, Ne, Ve)), Bt !== void 0 || !St ? Bt : (Ne.tracker.reportInferenceFallback(Ee), t.serializeExistingTypeNode(Ne, ie, Ve) ?? N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + )); + } + function _(ie, Ne, Ee, Ce) { + if (!ie) return; + const Ve = o(ie, Ne, Ee); + return Ve !== void 0 ? Ve : (Ne.tracker.reportInferenceFallback(ie), t.serializeExistingTypeNode(Ne, ie, Ee) ?? N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + )); + } + function u(ie, Ne, Ee) { + return D(ie, Ne, Ee) ?? $(ie, t.getAllAccessorDeclarations(ie), Ee, Ne); + } + function g(ie, Ne, Ee, Ce) { + const Ve = K( + ie, + Ne, + /*isConstContext*/ + !1, + Ee, + Ce + ); + return Ve.type !== void 0 ? Ve.type : B(ie, Ne, Ve.reportFallback); + } + function m(ie, Ne, Ee) { + switch (ie.kind) { + case 170: + case 342: + return A(ie, Ne, Ee); + case 261: + return P(ie, Ne, Ee); + case 172: + case 349: + case 173: + return F(ie, Ne, Ee); + case 209: + return R(ie, Ne, Ee); + case 278: + return g( + ie.expression, + Ee, + /*addUndefined*/ + void 0, + /*preserveLiterals*/ + !0 + ); + case 212: + case 213: + case 227: + return O(ie, Ne, Ee); + case 304: + case 305: + return h(ie, Ne, Ee); + default: + E.assertNever(ie, `Node needs to be an inferrable node, found ${E.formatSyntaxKind(ie.kind)}`); + } + } + function h(ie, Ne, Ee) { + const Ce = Kc(ie); + let Ve; + if (Ce && t.canReuseTypeNodeAnnotation(Ee, ie, Ce, Ne) && (Ve = o(Ce, Ee)), !Ve && ie.kind === 304) { + const St = ie.initializer, Bt = Kb(St) ? x6(St) : St.kind === 235 || St.kind === 217 ? St.type : void 0; + Bt && !nd(Bt) && t.canReuseTypeNodeAnnotation(Ee, ie, Bt, Ne) && (Ve = o(Bt, Ee)); + } + return Ve ?? R( + ie, + Ne, + Ee, + /*reportFallback*/ + !1 + ); + } + function S(ie, Ne, Ee) { + switch (ie.kind) { + case 178: + return u(ie, Ne, Ee); + case 175: + case 263: + case 181: + case 174: + case 180: + case 177: + case 179: + case 182: + case 185: + case 186: + case 219: + case 220: + case 318: + case 324: + return Ye(ie, Ne, Ee); + default: + E.assertNever(ie, `Node needs to be an inferrable node, found ${E.formatSyntaxKind(ie.kind)}`); + } + } + function T(ie) { + if (ie) + return ie.kind === 178 ? an(ie) && f0(ie) || nf(ie) : tJ(ie); + } + function k(ie, Ne) { + let Ee = T(ie); + return !Ee && ie !== Ne.firstAccessor && (Ee = T(Ne.firstAccessor)), !Ee && Ne.secondAccessor && ie !== Ne.secondAccessor && (Ee = T(Ne.secondAccessor)), Ee; + } + function D(ie, Ne, Ee) { + const Ce = t.getAllAccessorDeclarations(ie), Ve = k(ie, Ce); + if (Ve && !Vx(Ve)) + return W(Ee, ie, () => c(Ve, Ee, ie, Ne) ?? R(ie, Ne, Ee)); + if (Ce.getAccessor) + return W(Ee, Ce.getAccessor, () => Ye(Ce.getAccessor, Ne, Ee)); + } + function P(ie, Ne, Ee) { + var Ce; + const Ve = Kc(ie); + let St = fw; + return Ve ? St = Cm(c(Ve, Ee, ie, Ne)) : ie.initializer && (((Ce = Ne.declarations) == null ? void 0 : Ce.length) === 1 || l0(Ne.declarations, ei) === 1) && !t.isExpandoFunctionDeclaration(ie) && !Se(ie) && (St = K( + ie.initializer, + Ee, + /*isConstContext*/ + void 0, + /*requiresAddingUndefined*/ + void 0, + fK(ie) + )), St.type !== void 0 ? St.type : R(ie, Ne, Ee, St.reportFallback); + } + function A(ie, Ne, Ee) { + const Ce = ie.parent; + if (Ce.kind === 179) + return u( + Ce, + /*symbol*/ + void 0, + Ee + ); + const Ve = Kc(ie), St = t.requiresAddingImplicitUndefined(ie, Ne, Ee.enclosingDeclaration); + let Bt = fw; + return Ve ? Bt = Cm(c(Ve, Ee, ie, Ne, St)) : Ii(ie) && ie.initializer && Me(ie.name) && !Se(ie) && (Bt = K( + ie.initializer, + Ee, + /*isConstContext*/ + void 0, + St + )), Bt.type !== void 0 ? Bt.type : R(ie, Ne, Ee, Bt.reportFallback); + } + function O(ie, Ne, Ee) { + const Ce = Kc(ie); + let Ve; + Ce && (Ve = c(Ce, Ee, ie, Ne)); + const St = Ee.suppressReportInferenceFallback; + Ee.suppressReportInferenceFallback = !0; + const Bt = Ve ?? R( + ie, + Ne, + Ee, + /*reportFallback*/ + !1 + ); + return Ee.suppressReportInferenceFallback = St, Bt; + } + function F(ie, Ne, Ee) { + const Ce = Kc(ie), Ve = t.requiresAddingImplicitUndefined(ie, Ne, Ee.enclosingDeclaration); + let St = fw; + if (Ce) + St = Cm(c(Ce, Ee, ie, Ne, Ve)); + else { + const Bt = os(ie) ? ie.initializer : void 0; + if (Bt && !Se(ie)) { + const tr = C3(ie); + St = K( + Bt, + Ee, + /*isConstContext*/ + void 0, + Ve, + tr + ); + } + } + return St.type !== void 0 ? St.type : R(ie, Ne, Ee, St.reportFallback); + } + function R(ie, Ne, Ee, Ce = !0) { + return Ce && Ee.tracker.reportInferenceFallback(ie), Ee.noInferenceFallback === !0 ? N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ) : t.serializeTypeOfDeclaration(Ee, ie, Ne); + } + function B(ie, Ne, Ee = !0, Ce) { + return E.assert(!Ce), Ee && Ne.tracker.reportInferenceFallback(ie), Ne.noInferenceFallback === !0 ? N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ) : t.serializeTypeOfExpression(Ne, ie) ?? N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ); + } + function U(ie, Ne, Ee, Ce) { + return Ce && Ne.tracker.reportInferenceFallback(ie), Ne.noInferenceFallback === !0 ? N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ) : t.serializeReturnTypeForSignature(Ne, ie, Ee) ?? N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ); + } + function $(ie, Ne, Ee, Ce, Ve = !0) { + return ie.kind === 178 ? Ye(ie, Ce, Ee, Ve) : (Ve && Ee.tracker.reportInferenceFallback(ie), (Ne.getAccessor && Ye(Ne.getAccessor, Ce, Ee, Ve)) ?? t.serializeTypeOfDeclaration(Ee, ie, Ce) ?? N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + )); + } + function W(ie, Ne, Ee) { + const Ce = t.enterNewScope(ie, Ne), Ve = Ee(); + return Ce(), Ve; + } + function _e(ie, Ne, Ee, Ce) { + return nd(Ne) ? K( + ie, + Ee, + /*isConstContext*/ + !0, + Ce + ) : Cm(_(Ne, Ee, Ce)); + } + function K(ie, Ne, Ee = !1, Ce = !1, Ve = !1) { + switch (ie.kind) { + case 218: + return Kb(ie) ? _e(ie.expression, x6(ie), Ne, Ce) : K(ie.expression, Ne, Ee, Ce); + case 80: + if (t.isUndefinedIdentifierExpression(ie)) + return Cm(Z()); + break; + case 106: + return Cm(n ? Te(N.createLiteralTypeNode(N.createNull()), Ce, ie, Ne) : N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + )); + case 220: + case 219: + return E.type(ie), W(Ne, ie, () => V(ie, Ne)); + case 217: + case 235: + const St = ie; + return _e(St.expression, St.type, Ne, Ce); + case 225: + const Bt = ie; + if (_F(Bt)) + return pe( + Bt.operator === 40 ? Bt.operand : Bt, + Bt.operand.kind === 10 ? 163 : 150, + Ne, + Ee || Ve, + Ce + ); + break; + case 210: + return se(ie, Ne, Ee, Ce); + case 211: + return fe(ie, Ne, Ee, Ce); + case 232: + return Cm(B( + ie, + Ne, + /*reportFallback*/ + !0, + Ce + )); + case 229: + if (!Ee && !Ve) + return Cm(N.createKeywordTypeNode( + 154 + /* StringKeyword */ + )); + break; + default: + let tr, Nr = ie; + switch (ie.kind) { + case 9: + tr = 150; + break; + case 15: + Nr = N.createStringLiteral(ie.text), tr = 154; + break; + case 11: + tr = 154; + break; + case 10: + tr = 163; + break; + case 112: + case 97: + tr = 136; + break; + } + if (tr) + return pe(Nr, tr, Ne, Ee || Ve, Ce); + } + return fw; + } + function V(ie, Ne) { + const Ee = Ye( + ie, + /*symbol*/ + void 0, + Ne + ), Ce = be(ie.typeParameters, Ne), Ve = ie.parameters.map((St) => q(St, Ne)); + return Cm( + N.createFunctionTypeNode( + Ce, + Ve, + Ee + ) + ); + } + function ae(ie, Ne, Ee) { + if (!Ee) + return Ne.tracker.reportInferenceFallback(ie), !1; + for (const Ce of ie.elements) + if (Ce.kind === 231) + return Ne.tracker.reportInferenceFallback(Ce), !1; + return !0; + } + function se(ie, Ne, Ee, Ce) { + if (!ae(ie, Ne, Ee)) + return Ce || Pl(ad(ie).parent) ? Qbe : Cm(B( + ie, + Ne, + /*reportFallback*/ + !1, + Ce + )); + const Ve = Ne.noInferenceFallback; + Ne.noInferenceFallback = !0; + const St = []; + for (const tr of ie.elements) + if (E.assert( + tr.kind !== 231 + /* SpreadElement */ + ), tr.kind === 233) + St.push( + Z() + ); + else { + const Nr = K(tr, Ne, Ee), st = Nr.type !== void 0 ? Nr.type : B(tr, Ne, Nr.reportFallback); + St.push(st); + } + const Bt = N.createTupleTypeNode(St); + return Bt.emitNode = { flags: 1, autoGenerate: void 0, internalFlags: 0 }, Ne.noInferenceFallback = Ve, Xbe; + } + function ce(ie, Ne) { + let Ee = !0; + for (const Ce of ie.properties) { + if (Ce.flags & 262144) { + Ee = !1; + break; + } + if (Ce.kind === 305 || Ce.kind === 306) + Ne.tracker.reportInferenceFallback(Ce), Ee = !1; + else if (Ce.name.flags & 262144) { + Ee = !1; + break; + } else if (Ce.name.kind === 81) + Ee = !1; + else if (Ce.name.kind === 168) { + const Ve = Ce.name.expression; + !_F( + Ve, + /*includeBigInt*/ + !1 + ) && !t.isDefinitelyReferenceToGlobalSymbolObject(Ve) && (Ne.tracker.reportInferenceFallback(Ce.name), Ee = !1); + } + } + return Ee; + } + function fe(ie, Ne, Ee, Ce) { + if (!ce(ie, Ne)) + return Ce || Pl(ad(ie).parent) ? Qbe : Cm(B( + ie, + Ne, + /*reportFallback*/ + !1, + Ce + )); + const Ve = Ne.noInferenceFallback; + Ne.noInferenceFallback = !0; + const St = [], Bt = Ne.flags; + Ne.flags |= 4194304; + for (const Nr of ie.properties) { + E.assert(!gu(Nr) && !Vg(Nr)); + const st = Nr.name; + let Wt; + switch (Nr.kind) { + case 175: + Wt = W(Ne, Nr, () => je(Nr, st, Ne, Ee)); + break; + case 304: + Wt = he(Nr, st, Ne, Ee); + break; + case 179: + case 178: + Wt = me(Nr, st, Ne); + break; + } + Wt && (el(Wt, Nr), St.push(Wt)); + } + Ne.flags = Bt; + const tr = N.createTypeLiteralNode(St); + return Ne.flags & 1024 || un( + tr, + 1 + /* SingleLine */ + ), Ne.noInferenceFallback = Ve, Xbe; + } + function he(ie, Ne, Ee, Ce) { + const Ve = Ce ? [N.createModifier( + 148 + /* ReadonlyKeyword */ + )] : [], St = K(ie.initializer, Ee, Ce), Bt = St.type !== void 0 ? St.type : R( + ie, + /*symbol*/ + void 0, + Ee, + St.reportFallback + ); + return N.createPropertySignature( + Ve, + i(Ee, Ne), + /*questionToken*/ + void 0, + Bt + ); + } + function q(ie, Ne) { + return N.updateParameterDeclaration( + ie, + /*modifiers*/ + void 0, + i(Ne, ie.dotDotDotToken), + t.serializeNameOfParameter(Ne, ie), + t.isOptionalParameter(ie) ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, + A( + ie, + /*symbol*/ + void 0, + Ne + ), + // Ignore private param props, since this type is going straight back into a param + /*initializer*/ + void 0 + ); + } + function be(ie, Ne) { + return ie?.map((Ee) => { + var Ce; + const { node: Ve } = t.trackExistingEntityName(Ne, Ee.name); + return N.updateTypeParameterDeclaration( + Ee, + (Ce = Ee.modifiers) == null ? void 0 : Ce.map((St) => i(Ne, St)), + Ve, + _(Ee.constraint, Ne), + _(Ee.default, Ne) + ); + }); + } + function je(ie, Ne, Ee, Ce) { + const Ve = Ye( + ie, + /*symbol*/ + void 0, + Ee + ), St = be(ie.typeParameters, Ee), Bt = ie.parameters.map((tr) => q(tr, Ee)); + return Ce ? N.createPropertySignature( + [N.createModifier( + 148 + /* ReadonlyKeyword */ + )], + i(Ee, Ne), + i(Ee, ie.questionToken), + N.createFunctionTypeNode( + St, + Bt, + Ve + ) + ) : (Me(Ne) && Ne.escapedText === "new" && (Ne = N.createStringLiteral("new")), N.createMethodSignature( + [], + i(Ee, Ne), + i(Ee, ie.questionToken), + St, + Bt, + Ve + )); + } + function me(ie, Ne, Ee) { + const Ce = t.getAllAccessorDeclarations(ie), Ve = Ce.getAccessor && T(Ce.getAccessor), St = Ce.setAccessor && T(Ce.setAccessor); + if (Ve !== void 0 && St !== void 0) + return W(Ee, ie, () => { + const Bt = ie.parameters.map((tr) => q(tr, Ee)); + return Pg(ie) ? N.updateGetAccessorDeclaration( + ie, + [], + i(Ee, Ne), + Bt, + _(Ve, Ee), + /*body*/ + void 0 + ) : N.updateSetAccessorDeclaration( + ie, + [], + i(Ee, Ne), + Bt, + /*body*/ + void 0 + ); + }); + if (Ce.firstAccessor === ie) { + const tr = (Ve ? W(Ee, Ce.getAccessor, () => _(Ve, Ee)) : St ? W(Ee, Ce.setAccessor, () => _(St, Ee)) : void 0) ?? $( + ie, + Ce, + Ee, + /*symbol*/ + void 0 + ); + return N.createPropertySignature( + Ce.setAccessor === void 0 ? [N.createModifier( + 148 + /* ReadonlyKeyword */ + )] : [], + i(Ee, Ne), + /*questionToken*/ + void 0, + tr + ); + } + } + function Z() { + return n ? N.createKeywordTypeNode( + 157 + /* UndefinedKeyword */ + ) : N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ); + } + function pe(ie, Ne, Ee, Ce, Ve) { + let St; + return Ce ? (ie.kind === 225 && ie.operator === 40 && (St = N.createLiteralTypeNode(i(Ee, ie.operand))), St = N.createLiteralTypeNode(i(Ee, ie))) : St = N.createKeywordTypeNode(Ne), Cm(Te(St, Ve, ie, Ee)); + } + function Te(ie, Ne, Ee, Ce) { + const Ve = Ee && ad(Ee).parent, St = Ve && Pl(Ve) && Ox(Ve); + return !n || !(Ne || St) ? ie : (Fe(ie) || Ce.tracker.reportInferenceFallback(ie), C0(ie) ? N.createUnionTypeNode([...ie.types, N.createKeywordTypeNode( + 157 + /* UndefinedKeyword */ + )]) : N.createUnionTypeNode([ie, N.createKeywordTypeNode( + 157 + /* UndefinedKeyword */ + )])); + } + function Fe(ie) { + return !n || k_(ie.kind) || ie.kind === 202 || ie.kind === 185 || ie.kind === 186 || ie.kind === 189 || ie.kind === 190 || ie.kind === 188 || ie.kind === 204 || ie.kind === 198 ? !0 : ie.kind === 197 ? Fe(ie.type) : ie.kind === 193 || ie.kind === 194 ? ie.types.every(Fe) : !1; + } + function Ye(ie, Ne, Ee, Ce = !0) { + let Ve = fw; + const St = vx(ie) ? Kc(ie.parameters[0]) : nf(ie); + return St ? Ve = Cm(c(St, Ee, ie, Ne)) : pS(ie) && (Ve = ne(ie, Ee)), Ve.type !== void 0 ? Ve.type : U(ie, Ee, Ne, Ce && Ve.reportFallback && !St); + } + function ne(ie, Ne) { + let Ee; + if (ie && !lc(ie.body)) { + if (Mc(ie) & 3) return fw; + const Ve = ie.body; + Ve && Ns(Ve) ? Fy(Ve, (St) => { + if (St.parent !== Ve) + return Ee = void 0, !0; + if (!Ee) + Ee = St.expression; + else + return Ee = void 0, !0; + }) : Ee = Ve; + } + if (Ee) + if (Se(Ee)) { + const Ce = Kb(Ee) ? x6(Ee) : d6(Ee) || DF(Ee) ? Ee.type : void 0; + if (Ce && !nd(Ce)) + return Cm(o(Ce, Ne)); + } else + return K(Ee, Ne); + return fw; + } + function Se(ie) { + return dr(ie.parent, (Ne) => Ps(Ne) || !io(Ne) && !!Kc(Ne) || Sm(Ne) || h6(Ne)); + } + } + var t1 = {}; + Na(t1, { + NameValidationResult: () => n2e, + discoverTypings: () => YBe, + isTypingUpToDate: () => t2e, + loadSafeList: () => XBe, + loadTypesMap: () => QBe, + nonRelativeModuleNameForTypingCache: () => r2e, + renderPackageNameValidationFailure: () => KBe, + validatePackageName: () => ZBe + }); + var o9 = "action::set", c9 = "action::invalidate", l9 = "action::packageInstalled", uV = "event::typesRegistry", _V = "event::beginInstallTypes", fV = "event::endInstallTypes", Ase = "event::initializationFailed", RA = "action::watchTypingLocations", pV; + ((e) => { + e.GlobalCacheLocation = "--globalTypingsCacheLocation", e.LogFile = "--logFile", e.EnableTelemetry = "--enableTelemetry", e.TypingSafeListLocation = "--typingSafeListLocation", e.TypesMapLocation = "--typesMapLocation", e.NpmLocation = "--npmLocation", e.ValidateDefaultNpmLocation = "--validateDefaultNpmLocation"; + })(pV || (pV = {})); + function Ybe(e) { + return ml.args.includes(e); + } + function Zbe(e) { + const t = ml.args.indexOf(e); + return t >= 0 && t < ml.args.length - 1 ? ml.args[t + 1] : void 0; + } + function Kbe() { + const e = /* @__PURE__ */ new Date(); + return `${e.getHours().toString().padStart(2, "0")}:${e.getMinutes().toString().padStart(2, "0")}:${e.getSeconds().toString().padStart(2, "0")}.${e.getMilliseconds().toString().padStart(3, "0")}`; + } + var e2e = ` + `; + function pw(e) { + return e2e + e.replace(/\n/g, e2e); + } + function vv(e) { + return pw(JSON.stringify(e, void 0, 2)); + } + function t2e(e, t) { + return new xd(jP(t, `ts${q2}`) || jP(t, "latest")).compareTo(e.version) <= 0; + } + function r2e(e) { + return c6.has(e) ? "node" : e; + } + function XBe(e, t) { + const n = nA(t, (i) => e.readFile(i)); + return new Map(Object.entries(n.config)); + } + function QBe(e, t) { + var n; + const i = nA(t, (s) => e.readFile(s)); + if ((n = i.config) != null && n.simpleMap) + return new Map(Object.entries(i.config.simpleMap)); + } + function YBe(e, t, n, i, s, o, c, _, u, g) { + if (!c || !c.enable) + return { cachedTypingPaths: [], newTypingNames: [], filesToWatch: [] }; + const m = /* @__PURE__ */ new Map(); + n = Fi(n, (R) => { + const B = Hs(R); + if (Bg(B)) + return B; + }); + const h = []; + c.include && A(c.include, "Explicitly included types"); + const S = c.exclude || []; + if (!g.types) { + const R = new Set(n.map(Hn)); + R.add(i), R.forEach((B) => { + O(B, "bower.json", "bower_components", h), O(B, "package.json", "node_modules", h); + }); + } + if (c.disableFilenameBasedTypeAcquisition || F(n), _) { + const R = hb( + _.map(r2e), + bb, + _u + ); + A(R, "Inferred typings from unresolved imports"); + } + for (const R of S) + m.delete(R) && t && t(`Typing for ${R} is in exclude list, will be ignored.`); + o.forEach((R, B) => { + const U = u.get(B); + m.get(B) === !1 && U !== void 0 && t2e(R, U) && m.set(B, R.typingLocation); + }); + const T = [], k = []; + m.forEach((R, B) => { + R ? k.push(R) : T.push(B); + }); + const D = { cachedTypingPaths: k, newTypingNames: T, filesToWatch: h }; + return t && t(`Finished typings discovery:${vv(D)}`), D; + function P(R) { + m.has(R) || m.set(R, !1); + } + function A(R, B) { + t && t(`${B}: ${JSON.stringify(R)}`), lr(R, P); + } + function O(R, B, U, $) { + const W = On(R, B); + let _e, K; + e.fileExists(W) && ($.push(W), _e = nA(W, (ce) => e.readFile(ce)).config, K = ka([_e.dependencies, _e.devDependencies, _e.optionalDependencies, _e.peerDependencies], rm), A(K, `Typing names in '${W}' dependencies`)); + const V = On(R, U); + if ($.push(V), !e.directoryExists(V)) + return; + const ae = [], se = K ? K.map((ce) => On(V, ce, B)) : e.readDirectory( + V, + [ + ".json" + /* Json */ + ], + /*excludes*/ + void 0, + /*includes*/ + void 0, + /*depth*/ + 3 + ).filter((ce) => { + if (Zc(ce) !== B) + return !1; + const fe = fu(Hs(ce)), he = fe[fe.length - 3][0] === "@"; + return he && my(fe[fe.length - 4]) === U || // `node_modules/@foo/bar` + !he && my(fe[fe.length - 3]) === U; + }); + t && t(`Searching for typing names in ${V}; all files: ${JSON.stringify(se)}`); + for (const ce of se) { + const fe = Hs(ce), q = nA(fe, (je) => e.readFile(je)).config; + if (!q.name) + continue; + const be = q.types || q.typings; + if (be) { + const je = Qi(be, Hn(fe)); + e.fileExists(je) ? (t && t(` Package '${q.name}' provides its own types.`), m.set(q.name, je)) : t && t(` Package '${q.name}' provides its own types but they are missing.`); + } else + ae.push(q.name); + } + A(ae, " Found package names"); + } + function F(R) { + const B = Fi(R, ($) => { + if (!Bg($)) return; + const W = Gu(my(Zc($))), _e = UR(W); + return s.get(_e); + }); + B.length && A(B, "Inferred typings from file names"), ot(R, ($) => Xo( + $, + ".jsx" + /* Jsx */ + )) && (t && t("Inferred 'react' typings due to presence of '.jsx' extension"), P("react")); + } + } + var n2e = /* @__PURE__ */ ((e) => (e[e.Ok = 0] = "Ok", e[e.EmptyName = 1] = "EmptyName", e[e.NameTooLong = 2] = "NameTooLong", e[e.NameStartsWithDot = 3] = "NameStartsWithDot", e[e.NameStartsWithUnderscore = 4] = "NameStartsWithUnderscore", e[e.NameContainsNonURISafeCharacters = 5] = "NameContainsNonURISafeCharacters", e))(n2e || {}), i2e = 214; + function ZBe(e) { + return Ise( + e, + /*supportScopedPackage*/ + !0 + ); + } + function Ise(e, t) { + if (!e) + return 1; + if (e.length > i2e) + return 2; + if (e.charCodeAt(0) === 46) + return 3; + if (e.charCodeAt(0) === 95) + return 4; + if (t) { + const n = /^@([^/]+)\/([^/]+)$/.exec(e); + if (n) { + const i = Ise( + n[1], + /*supportScopedPackage*/ + !1 + ); + if (i !== 0) + return { name: n[1], isScopeName: !0, result: i }; + const s = Ise( + n[2], + /*supportScopedPackage*/ + !1 + ); + return s !== 0 ? { name: n[2], isScopeName: !1, result: s } : 0; + } + } + return encodeURIComponent(e) !== e ? 5 : 0; + } + function KBe(e, t) { + return typeof e == "object" ? s2e(t, e.result, e.name, e.isScopeName) : s2e( + t, + e, + t, + /*isScopeName*/ + !1 + ); + } + function s2e(e, t, n, i) { + const s = i ? "Scope" : "Package"; + switch (t) { + case 1: + return `'${e}':: ${s} name '${n}' cannot be empty`; + case 2: + return `'${e}':: ${s} name '${n}' should be less than ${i2e} characters`; + case 3: + return `'${e}':: ${s} name '${n}' cannot start with '.'`; + case 4: + return `'${e}':: ${s} name '${n}' cannot start with '_'`; + case 5: + return `'${e}':: ${s} name '${n}' contains non URI safe characters`; + case 0: + return E.fail(); + // Shouldn't have called this. + default: + E.assertNever(t); + } + } + var u9; + ((e) => { + class t { + constructor(s) { + this.text = s; + } + getText(s, o) { + return s === 0 && o === this.text.length ? this.text : this.text.substring(s, o); + } + getLength() { + return this.text.length; + } + getChangeRange() { + } + } + function n(i) { + return new t(i); + } + e.fromString = n; + })(u9 || (u9 = {})); + var Fse = /* @__PURE__ */ ((e) => (e[e.Dependencies = 1] = "Dependencies", e[e.DevDependencies = 2] = "DevDependencies", e[e.PeerDependencies = 4] = "PeerDependencies", e[e.OptionalDependencies = 8] = "OptionalDependencies", e[e.All = 15] = "All", e))(Fse || {}), Ose = /* @__PURE__ */ ((e) => (e[e.Off = 0] = "Off", e[e.On = 1] = "On", e[e.Auto = 2] = "Auto", e))(Ose || {}), Lse = /* @__PURE__ */ ((e) => (e[e.Semantic = 0] = "Semantic", e[e.PartialSemantic = 1] = "PartialSemantic", e[e.Syntactic = 2] = "Syntactic", e))(Lse || {}), qp = {}, Mse = /* @__PURE__ */ ((e) => (e.Original = "original", e.TwentyTwenty = "2020", e))(Mse || {}), dV = /* @__PURE__ */ ((e) => (e.All = "All", e.SortAndCombine = "SortAndCombine", e.RemoveUnused = "RemoveUnused", e))(dV || {}), mV = /* @__PURE__ */ ((e) => (e[e.Invoked = 1] = "Invoked", e[e.TriggerCharacter = 2] = "TriggerCharacter", e[e.TriggerForIncompleteCompletions = 3] = "TriggerForIncompleteCompletions", e))(mV || {}), Rse = /* @__PURE__ */ ((e) => (e.Type = "Type", e.Parameter = "Parameter", e.Enum = "Enum", e))(Rse || {}), jse = /* @__PURE__ */ ((e) => (e.none = "none", e.definition = "definition", e.reference = "reference", e.writtenReference = "writtenReference", e))(jse || {}), Bse = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Block = 1] = "Block", e[e.Smart = 2] = "Smart", e))(Bse || {}), gV = /* @__PURE__ */ ((e) => (e.Ignore = "ignore", e.Insert = "insert", e.Remove = "remove", e))(gV || {}); + function _9(e) { + return { + indentSize: 4, + tabSize: 4, + newLineCharacter: e || ` +`, + convertTabsToSpaces: !0, + indentStyle: 2, + insertSpaceAfterConstructor: !1, + insertSpaceAfterCommaDelimiter: !0, + insertSpaceAfterSemicolonInForStatements: !0, + insertSpaceBeforeAndAfterBinaryOperators: !0, + insertSpaceAfterKeywordsInControlFlowStatements: !0, + insertSpaceAfterFunctionKeywordForAnonymousFunctions: !1, + insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: !1, + insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: !1, + insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: !0, + insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: !1, + insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: !1, + insertSpaceBeforeFunctionParenthesis: !1, + placeOpenBraceOnNewLineForFunctions: !1, + placeOpenBraceOnNewLineForControlBlocks: !1, + semicolons: "ignore", + trimTrailingWhitespace: !0, + indentSwitchCase: !0 + }; + } + var a2e = _9(` +`), f9 = /* @__PURE__ */ ((e) => (e[e.aliasName = 0] = "aliasName", e[e.className = 1] = "className", e[e.enumName = 2] = "enumName", e[e.fieldName = 3] = "fieldName", e[e.interfaceName = 4] = "interfaceName", e[e.keyword = 5] = "keyword", e[e.lineBreak = 6] = "lineBreak", e[e.numericLiteral = 7] = "numericLiteral", e[e.stringLiteral = 8] = "stringLiteral", e[e.localName = 9] = "localName", e[e.methodName = 10] = "methodName", e[e.moduleName = 11] = "moduleName", e[e.operator = 12] = "operator", e[e.parameterName = 13] = "parameterName", e[e.propertyName = 14] = "propertyName", e[e.punctuation = 15] = "punctuation", e[e.space = 16] = "space", e[e.text = 17] = "text", e[e.typeParameterName = 18] = "typeParameterName", e[e.enumMemberName = 19] = "enumMemberName", e[e.functionName = 20] = "functionName", e[e.regularExpressionLiteral = 21] = "regularExpressionLiteral", e[e.link = 22] = "link", e[e.linkName = 23] = "linkName", e[e.linkText = 24] = "linkText", e))(f9 || {}), Jse = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.MayIncludeAutoImports = 1] = "MayIncludeAutoImports", e[e.IsImportStatementCompletion = 2] = "IsImportStatementCompletion", e[e.IsContinuation = 4] = "IsContinuation", e[e.ResolvedModuleSpecifiers = 8] = "ResolvedModuleSpecifiers", e[e.ResolvedModuleSpecifiersBeyondLimit = 16] = "ResolvedModuleSpecifiersBeyondLimit", e[e.MayIncludeMethodSnippets = 32] = "MayIncludeMethodSnippets", e))(Jse || {}), zse = /* @__PURE__ */ ((e) => (e.Comment = "comment", e.Region = "region", e.Code = "code", e.Imports = "imports", e))(zse || {}), Wse = /* @__PURE__ */ ((e) => (e[e.JavaScript = 0] = "JavaScript", e[e.SourceMap = 1] = "SourceMap", e[e.Declaration = 2] = "Declaration", e))(Wse || {}), Use = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.InMultiLineCommentTrivia = 1] = "InMultiLineCommentTrivia", e[e.InSingleQuoteStringLiteral = 2] = "InSingleQuoteStringLiteral", e[e.InDoubleQuoteStringLiteral = 3] = "InDoubleQuoteStringLiteral", e[e.InTemplateHeadOrNoSubstitutionTemplate = 4] = "InTemplateHeadOrNoSubstitutionTemplate", e[e.InTemplateMiddleOrTail = 5] = "InTemplateMiddleOrTail", e[e.InTemplateSubstitutionPosition = 6] = "InTemplateSubstitutionPosition", e))(Use || {}), Vse = /* @__PURE__ */ ((e) => (e[e.Punctuation = 0] = "Punctuation", e[e.Keyword = 1] = "Keyword", e[e.Operator = 2] = "Operator", e[e.Comment = 3] = "Comment", e[e.Whitespace = 4] = "Whitespace", e[e.Identifier = 5] = "Identifier", e[e.NumberLiteral = 6] = "NumberLiteral", e[e.BigIntLiteral = 7] = "BigIntLiteral", e[e.StringLiteral = 8] = "StringLiteral", e[e.RegExpLiteral = 9] = "RegExpLiteral", e))(Vse || {}), qse = /* @__PURE__ */ ((e) => (e.unknown = "", e.warning = "warning", e.keyword = "keyword", e.scriptElement = "script", e.moduleElement = "module", e.classElement = "class", e.localClassElement = "local class", e.interfaceElement = "interface", e.typeElement = "type", e.enumElement = "enum", e.enumMemberElement = "enum member", e.variableElement = "var", e.localVariableElement = "local var", e.variableUsingElement = "using", e.variableAwaitUsingElement = "await using", e.functionElement = "function", e.localFunctionElement = "local function", e.memberFunctionElement = "method", e.memberGetAccessorElement = "getter", e.memberSetAccessorElement = "setter", e.memberVariableElement = "property", e.memberAccessorVariableElement = "accessor", e.constructorImplementationElement = "constructor", e.callSignatureElement = "call", e.indexSignatureElement = "index", e.constructSignatureElement = "construct", e.parameterElement = "parameter", e.typeParameterElement = "type parameter", e.primitiveType = "primitive type", e.label = "label", e.alias = "alias", e.constElement = "const", e.letElement = "let", e.directory = "directory", e.externalModuleName = "external module name", e.jsxAttribute = "JSX attribute", e.string = "string", e.link = "link", e.linkName = "link name", e.linkText = "link text", e))(qse || {}), Hse = /* @__PURE__ */ ((e) => (e.none = "", e.publicMemberModifier = "public", e.privateMemberModifier = "private", e.protectedMemberModifier = "protected", e.exportedModifier = "export", e.ambientModifier = "declare", e.staticModifier = "static", e.abstractModifier = "abstract", e.optionalModifier = "optional", e.deprecatedModifier = "deprecated", e.dtsModifier = ".d.ts", e.tsModifier = ".ts", e.tsxModifier = ".tsx", e.jsModifier = ".js", e.jsxModifier = ".jsx", e.jsonModifier = ".json", e.dmtsModifier = ".d.mts", e.mtsModifier = ".mts", e.mjsModifier = ".mjs", e.dctsModifier = ".d.cts", e.ctsModifier = ".cts", e.cjsModifier = ".cjs", e))(Hse || {}), Gse = /* @__PURE__ */ ((e) => (e.comment = "comment", e.identifier = "identifier", e.keyword = "keyword", e.numericLiteral = "number", e.bigintLiteral = "bigint", e.operator = "operator", e.stringLiteral = "string", e.whiteSpace = "whitespace", e.text = "text", e.punctuation = "punctuation", e.className = "class name", e.enumName = "enum name", e.interfaceName = "interface name", e.moduleName = "module name", e.typeParameterName = "type parameter name", e.typeAliasName = "type alias name", e.parameterName = "parameter name", e.docCommentTagName = "doc comment tag name", e.jsxOpenTagName = "jsx open tag name", e.jsxCloseTagName = "jsx close tag name", e.jsxSelfClosingTagName = "jsx self closing tag name", e.jsxAttribute = "jsx attribute", e.jsxText = "jsx text", e.jsxAttributeStringLiteralValue = "jsx attribute string literal value", e))(Gse || {}), hV = /* @__PURE__ */ ((e) => (e[e.comment = 1] = "comment", e[e.identifier = 2] = "identifier", e[e.keyword = 3] = "keyword", e[e.numericLiteral = 4] = "numericLiteral", e[e.operator = 5] = "operator", e[e.stringLiteral = 6] = "stringLiteral", e[e.regularExpressionLiteral = 7] = "regularExpressionLiteral", e[e.whiteSpace = 8] = "whiteSpace", e[e.text = 9] = "text", e[e.punctuation = 10] = "punctuation", e[e.className = 11] = "className", e[e.enumName = 12] = "enumName", e[e.interfaceName = 13] = "interfaceName", e[e.moduleName = 14] = "moduleName", e[e.typeParameterName = 15] = "typeParameterName", e[e.typeAliasName = 16] = "typeAliasName", e[e.parameterName = 17] = "parameterName", e[e.docCommentTagName = 18] = "docCommentTagName", e[e.jsxOpenTagName = 19] = "jsxOpenTagName", e[e.jsxCloseTagName = 20] = "jsxCloseTagName", e[e.jsxSelfClosingTagName = 21] = "jsxSelfClosingTagName", e[e.jsxAttribute = 22] = "jsxAttribute", e[e.jsxText = 23] = "jsxText", e[e.jsxAttributeStringLiteralValue = 24] = "jsxAttributeStringLiteralValue", e[e.bigintLiteral = 25] = "bigintLiteral", e))(hV || {}), ql = Dg( + 99, + /*skipTrivia*/ + !0 + ), $se = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Value = 1] = "Value", e[e.Type = 2] = "Type", e[e.Namespace = 4] = "Namespace", e[e.All = 7] = "All", e))($se || {}); + function p9(e) { + switch (e.kind) { + case 261: + return an(e) && Lj(e) ? 7 : 1; + case 170: + case 209: + case 173: + case 172: + case 304: + case 305: + case 175: + case 174: + case 177: + case 178: + case 179: + case 263: + case 219: + case 220: + case 300: + case 292: + return 1; + case 169: + case 265: + case 266: + case 188: + return 2; + case 347: + return e.name === void 0 ? 3 : 2; + case 307: + case 264: + return 3; + case 268: + return Vu(e) || Ah(e) === 1 ? 5 : 4; + case 267: + case 276: + case 277: + case 272: + case 273: + case 278: + case 279: + return 7; + // An external module can be a Value + case 308: + return 5; + } + return 7; + } + function WS(e) { + e = NV(e); + const t = e.parent; + return e.kind === 308 ? 1 : Mo(t) || Nu(t) || wh(t) || Xu(t) || ld(t) || _l(t) && e === t.name ? 7 : d9(e) ? eJe(e) : Qm(e) ? p9(t) : r_(e) && dr(e, Q_(M4, cx, uv)) ? 7 : iJe(e) ? 2 : tJe(e) ? 4 : Lo(t) ? (E.assert(Up(t.parent)), 2) : E0(t) ? 3 : 1; + } + function eJe(e) { + const t = e.kind === 167 ? e : s_(e.parent) && e.parent.right === e ? e.parent : void 0; + return t && t.parent.kind === 272 ? 7 : 4; + } + function d9(e) { + if (!e.parent) + return !1; + for (; e.parent.kind === 167; ) + e = e.parent; + return cS(e.parent) && e.parent.moduleReference === e; + } + function tJe(e) { + return rJe(e) || nJe(e); + } + function rJe(e) { + let t = e, n = !0; + if (t.parent.kind === 167) { + for (; t.parent && t.parent.kind === 167; ) + t = t.parent; + n = t.right === e; + } + return t.parent.kind === 184 && !n; + } + function nJe(e) { + let t = e, n = !0; + if (t.parent.kind === 212) { + for (; t.parent && t.parent.kind === 212; ) + t = t.parent; + n = t.name === e; + } + if (!n && t.parent.kind === 234 && t.parent.parent.kind === 299) { + const i = t.parent.parent.parent; + return i.kind === 264 && t.parent.parent.token === 119 || i.kind === 265 && t.parent.parent.token === 96; + } + return !1; + } + function iJe(e) { + switch (r4(e) && (e = e.parent), e.kind) { + case 110: + return !Xm(e); + case 198: + return !0; + } + switch (e.parent.kind) { + case 184: + return !0; + case 206: + return !e.parent.isTypeOf; + case 234: + return lm(e.parent); + } + return !1; + } + function yV(e, t = !1, n = !1) { + return jA(e, Ps, bV, t, n); + } + function dw(e, t = !1, n = !1) { + return jA(e, Xb, bV, t, n); + } + function vV(e, t = !1, n = !1) { + return jA(e, sm, bV, t, n); + } + function Xse(e, t = !1, n = !1) { + return jA(e, nv, sJe, t, n); + } + function Qse(e, t = !1, n = !1) { + return jA(e, ul, bV, t, n); + } + function Yse(e, t = !1, n = !1) { + return jA(e, wu, aJe, t, n); + } + function bV(e) { + return e.expression; + } + function sJe(e) { + return e.tag; + } + function aJe(e) { + return e.tagName; + } + function jA(e, t, n, i, s) { + let o = i ? oJe(e) : m9(e); + return s && (o = hc(o)), !!o && !!o.parent && t(o.parent) && n(o.parent) === o; + } + function m9(e) { + return U6(e) ? e.parent : e; + } + function oJe(e) { + return U6(e) || kV(e) ? e.parent : e; + } + function g9(e, t) { + for (; e; ) { + if (e.kind === 257 && e.label.escapedText === t) + return e.label; + e = e.parent; + } + } + function BA(e, t) { + return wn(e.expression) ? e.expression.name.text === t : !1; + } + function JA(e) { + var t; + return Me(e) && ((t = Bn(e.parent, xD)) == null ? void 0 : t.label) === e; + } + function SV(e) { + var t; + return Me(e) && ((t = Bn(e.parent, Gy)) == null ? void 0 : t.label) === e; + } + function TV(e) { + return SV(e) || JA(e); + } + function xV(e) { + var t; + return ((t = Bn(e.parent, OC)) == null ? void 0 : t.tagName) === e; + } + function Zse(e) { + var t; + return ((t = Bn(e.parent, s_)) == null ? void 0 : t.right) === e; + } + function U6(e) { + var t; + return ((t = Bn(e.parent, wn)) == null ? void 0 : t.name) === e; + } + function kV(e) { + var t; + return ((t = Bn(e.parent, uo)) == null ? void 0 : t.argumentExpression) === e; + } + function CV(e) { + var t; + return ((t = Bn(e.parent, jc)) == null ? void 0 : t.name) === e; + } + function EV(e) { + var t; + return Me(e) && ((t = Bn(e.parent, Es)) == null ? void 0 : t.name) === e; + } + function h9(e) { + switch (e.parent.kind) { + case 173: + case 172: + case 304: + case 307: + case 175: + case 174: + case 178: + case 179: + case 268: + return _s(e.parent) === e; + case 213: + return e.parent.argumentExpression === e; + case 168: + return !0; + case 202: + return e.parent.parent.kind === 200; + default: + return !1; + } + } + function Kse(e) { + return H1(e.parent.parent) && jD(e.parent.parent) === e; + } + function US(e) { + for (jp(e) && (e = e.parent.parent); ; ) { + if (e = e.parent, !e) + return; + switch (e.kind) { + case 308: + case 175: + case 174: + case 263: + case 219: + case 178: + case 179: + case 264: + case 265: + case 267: + case 268: + return e; + } + } + } + function o2(e) { + switch (e.kind) { + case 308: + return fl(e) ? "module" : "script"; + case 268: + return "module"; + case 264: + case 232: + return "class"; + case 265: + return "interface"; + case 266: + case 339: + case 347: + return "type"; + case 267: + return "enum"; + case 261: + return t(e); + case 209: + return t(_m(e)); + case 220: + case 263: + case 219: + return "function"; + case 178: + return "getter"; + case 179: + return "setter"; + case 175: + case 174: + return "method"; + case 304: + const { initializer: n } = e; + return Es(n) ? "method" : "property"; + case 173: + case 172: + case 305: + case 306: + return "property"; + case 182: + return "index"; + case 181: + return "construct"; + case 180: + return "call"; + case 177: + case 176: + return "constructor"; + case 169: + return "type parameter"; + case 307: + return "enum member"; + case 170: + return Gn( + e, + 31 + /* ParameterPropertyModifier */ + ) ? "property" : "parameter"; + case 272: + case 277: + case 282: + case 275: + case 281: + return "alias"; + case 227: + const i = Ac(e), { right: s } = e; + switch (i) { + case 7: + case 8: + case 9: + case 0: + return ""; + case 1: + case 2: + const c = o2(s); + return c === "" ? "const" : c; + case 3: + return yo(s) ? "method" : "property"; + case 4: + return "property"; + // property + case 5: + return yo(s) ? "method" : "property"; + case 6: + return "local class"; + default: + return ""; + } + case 80: + return ld(e.parent) ? "alias" : ""; + case 278: + const o = o2(e.expression); + return o === "" ? "const" : o; + default: + return ""; + } + function t(n) { + return BC(n) ? "const" : X7(n) ? "let" : "var"; + } + } + function V6(e) { + switch (e.kind) { + case 110: + return !0; + case 80: + return eJ(e) && e.parent.kind === 170; + default: + return !1; + } + } + var cJe = /^\/\/\/\s*= n; + } + function mw(e, t, n) { + return v9(e.pos, e.end, t, n); + } + function y9(e, t, n, i) { + return v9(e.getStart(t), e.end, n, i); + } + function v9(e, t, n, i) { + const s = Math.max(e, n), o = Math.min(t, i); + return s < o; + } + function DV(e, t, n) { + return E.assert(e.pos <= t), t < e.end || !Rd(e, n); + } + function Rd(e, t) { + if (e === void 0 || lc(e)) + return !1; + switch (e.kind) { + case 264: + case 265: + case 267: + case 211: + case 207: + case 188: + case 242: + case 269: + case 270: + case 276: + case 280: + return wV(e, 20, t); + case 300: + return Rd(e.block, t); + case 215: + if (!e.arguments) + return !0; + // falls through + case 214: + case 218: + case 197: + return wV(e, 22, t); + case 185: + case 186: + return Rd(e.type, t); + case 177: + case 178: + case 179: + case 263: + case 219: + case 175: + case 174: + case 181: + case 180: + case 220: + return e.body ? Rd(e.body, t) : e.type ? Rd(e.type, t) : PV(e, 22, t); + case 268: + return !!e.body && Rd(e.body, t); + case 246: + return e.elseStatement ? Rd(e.elseStatement, t) : Rd(e.thenStatement, t); + case 245: + return Rd(e.expression, t) || PV(e, 27, t); + case 210: + case 208: + case 213: + case 168: + case 190: + return wV(e, 24, t); + case 182: + return e.type ? Rd(e.type, t) : PV(e, 24, t); + case 297: + case 298: + return !1; + case 249: + case 250: + case 251: + case 248: + return Rd(e.statement, t); + case 247: + return PV(e, 117, t) ? wV(e, 22, t) : Rd(e.statement, t); + case 187: + return Rd(e.exprName, t); + case 222: + case 221: + case 223: + case 230: + case 231: + return Rd(e.expression, t); + case 216: + return Rd(e.template, t); + case 229: + const i = Do(e.templateSpans); + return Rd(i, t); + case 240: + return Mp(e.literal); + case 279: + case 273: + return Mp(e.moduleSpecifier); + case 225: + return Rd(e.operand, t); + case 227: + return Rd(e.right, t); + case 228: + return Rd(e.whenFalse, t); + default: + return !0; + } + } + function wV(e, t, n) { + const i = e.getChildren(n); + if (i.length) { + const s = pa(i); + if (s.kind === t) + return !0; + if (s.kind === 27 && i.length !== 1) + return i[i.length - 2].kind === t; + } + return !1; + } + function tae(e) { + const t = b9(e); + if (!t) + return; + const n = t.getChildren(); + return { + listItemIndex: MC(n, e), + list: t + }; + } + function PV(e, t, n) { + return !!Ya(e, t, n); + } + function Ya(e, t, n) { + return Nn(e.getChildren(n), (i) => i.kind === t); + } + function b9(e) { + const t = Nn(e.parent.getChildren(), (n) => T6(n) && C_(n, e)); + return E.assert(!t || ms(t.getChildren(), e)), t; + } + function o2e(e) { + return e.kind === 90; + } + function lJe(e) { + return e.kind === 86; + } + function uJe(e) { + return e.kind === 100; + } + function _Je(e) { + if (wl(e)) + return e.name; + if (tl(e)) { + const t = e.modifiers && Nn(e.modifiers, o2e); + if (t) return t; + } + if (Rc(e)) { + const t = Nn(e.getChildren(), lJe); + if (t) return t; + } + } + function fJe(e) { + if (wl(e)) + return e.name; + if (Cc(e)) { + const t = Nn(e.modifiers, o2e); + if (t) return t; + } + if (yo(e)) { + const t = Nn(e.getChildren(), uJe); + if (t) return t; + } + } + function pJe(e) { + let t; + return dr(e, (n) => (li(n) && (t = n), !s_(n.parent) && !li(n.parent) && !kb(n.parent))), t; + } + function S9(e, t) { + if (e.flags & 16777216) return; + const n = R9(e, t); + if (n) return n; + const i = pJe(e); + return i && t.getTypeAtLocation(i); + } + function dJe(e, t) { + if (!t) + switch (e.kind) { + case 264: + case 232: + return _Je(e); + case 263: + case 219: + return fJe(e); + case 177: + return e; + } + if (wl(e)) + return e.name; + } + function c2e(e, t) { + if (e.importClause) { + if (e.importClause.name && e.importClause.namedBindings) + return; + if (e.importClause.name) + return e.importClause.name; + if (e.importClause.namedBindings) { + if (bm(e.importClause.namedBindings)) { + const n = xg(e.importClause.namedBindings.elements); + return n ? n.name : void 0; + } else if (Ug(e.importClause.namedBindings)) + return e.importClause.namedBindings.name; + } + } + if (!t) + return e.moduleSpecifier; + } + function l2e(e, t) { + if (e.exportClause) { + if (mp(e.exportClause)) + return xg(e.exportClause.elements) ? e.exportClause.elements[0].name : void 0; + if (Km(e.exportClause)) + return e.exportClause.name; + } + if (!t) + return e.moduleSpecifier; + } + function mJe(e) { + if (e.types.length === 1) + return e.types[0].expression; + } + function u2e(e, t) { + const { parent: n } = e; + if (Zs(e) && (t || e.kind !== 90) ? Vp(n) && ms(n.modifiers, e) : e.kind === 86 ? tl(n) || Rc(e) : e.kind === 100 ? Cc(n) || yo(e) : e.kind === 120 ? Vl(n) : e.kind === 94 ? ov(n) : e.kind === 156 ? Wp(n) : e.kind === 145 || e.kind === 144 ? jc(n) : e.kind === 102 ? _l(n) : e.kind === 139 ? pp(n) : e.kind === 153 && z_(n)) { + const i = dJe(n, t); + if (i) + return i; + } + if ((e.kind === 115 || e.kind === 87 || e.kind === 121) && Ul(n) && n.declarations.length === 1) { + const i = n.declarations[0]; + if (Me(i.name)) + return i.name; + } + if (e.kind === 156) { + if (ld(n) && n.isTypeOnly) { + const i = c2e(n.parent, t); + if (i) + return i; + } + if (Bc(n) && n.isTypeOnly) { + const i = l2e(n, t); + if (i) + return i; + } + } + if (e.kind === 130) { + if (Xu(n) && n.propertyName || Nu(n) && n.propertyName || Ug(n) || Km(n)) + return n.name; + if (Bc(n) && n.exportClause && Km(n.exportClause)) + return n.exportClause.name; + } + if (e.kind === 102 && qo(n)) { + const i = c2e(n, t); + if (i) + return i; + } + if (e.kind === 95) { + if (Bc(n)) { + const i = l2e(n, t); + if (i) + return i; + } + if (Mo(n)) + return hc(n.expression); + } + if (e.kind === 149 && wh(n)) + return n.expression; + if (e.kind === 161 && (qo(n) || Bc(n)) && n.moduleSpecifier) + return n.moduleSpecifier; + if ((e.kind === 96 || e.kind === 119) && cf(n) && n.token === e.kind) { + const i = mJe(n); + if (i) + return i; + } + if (e.kind === 96) { + if (Lo(n) && n.constraint && of(n.constraint)) + return n.constraint.typeName; + if (Gb(n) && of(n.extendsType)) + return n.extendsType.typeName; + } + if (e.kind === 140 && xS(n)) + return n.typeParameter.name; + if (e.kind === 103 && Lo(n) && CS(n.parent)) + return n.name; + if (e.kind === 143 && rv(n) && n.operator === 143 && of(n.type)) + return n.type.typeName; + if (e.kind === 148 && rv(n) && n.operator === 148 && jN(n.type) && of(n.type.elementType)) + return n.type.elementType.typeName; + if (!t) { + if ((e.kind === 105 && Xb(n) || e.kind === 116 && Gx(n) || e.kind === 114 && p6(n) || e.kind === 135 && Hy(n) || e.kind === 127 && BN(n) || e.kind === 91 && jte(n)) && n.expression) + return hc(n.expression); + if ((e.kind === 103 || e.kind === 104) && _n(n) && n.operatorToken === e) + return hc(n.right); + if (e.kind === 130 && d6(n) && of(n.type)) + return n.type.typeName; + if (e.kind === 103 && PF(n) || e.kind === 165 && JN(n)) + return hc(n.expression); + } + return e; + } + function NV(e) { + return u2e( + e, + /*forRename*/ + !1 + ); + } + function T9(e) { + return u2e( + e, + /*forRename*/ + !0 + ); + } + function w_(e, t) { + return H6(e, t, (n) => um(n) || k_(n.kind) || Ai(n)); + } + function H6(e, t, n) { + return _2e( + e, + t, + /*allowPositionInLeadingTrivia*/ + !1, + n, + /*includeEndPosition*/ + !1 + ); + } + function vi(e, t) { + return _2e( + e, + t, + /*allowPositionInLeadingTrivia*/ + !0, + /*includePrecedingTokenAtEndPosition*/ + void 0, + /*includeEndPosition*/ + !1 + ); + } + function _2e(e, t, n, i, s) { + let o = e, c; + e: + for (; ; ) { + const u = o.getChildren(e), g = $T(u, t, (m, h) => h, (m, h) => { + const S = u[m].getEnd(); + if (S < t) + return -1; + const T = n ? u[m].getFullStart() : u[m].getStart( + e, + /*includeJsDocComment*/ + !0 + ); + return T > t ? 1 : _(u[m], T, S) ? u[m - 1] && _(u[m - 1]) ? 1 : 0 : i && T === t && u[m - 1] && u[m - 1].getEnd() === t && _(u[m - 1]) ? 1 : -1; + }); + if (c) + return c; + if (g >= 0 && u[g]) { + o = u[g]; + continue e; + } + return o; + } + function _(u, g, m) { + if (m ?? (m = u.getEnd()), m < t || (g ?? (g = n ? u.getFullStart() : u.getStart( + e, + /*includeJsDocComment*/ + !0 + )), g > t)) + return !1; + if (t < m || t === m && (u.kind === 1 || s)) + return !0; + if (i && m === t) { + const h = pl(t, e, u); + if (h && i(h)) + return c = h, !0; + } + return !1; + } + } + function rae(e, t) { + let n = vi(e, t); + for (; x9(n); ) { + const i = c2(n, n.parent, e); + if (!i) return; + n = i; + } + return n; + } + function gw(e, t) { + const n = vi(e, t); + return ix(n) && t > n.getStart(e) && t < n.getEnd() ? n : pl(t, e); + } + function c2(e, t, n) { + return i(t); + function i(s) { + return ix(s) && s.pos === e.end ? s : Lc(s.getChildren(n), (o) => /* previous token is enclosed somewhere in the child */ (o.pos <= e.pos && o.end > e.end || // previous token ends exactly at the beginning of child + o.pos === e.end) && cae(o, n) ? i(o) : void 0); + } + } + function pl(e, t, n, i) { + const s = o(n || t); + return E.assert(!(s && x9(s))), s; + function o(c) { + if (f2e(c) && c.kind !== 1) + return c; + const _ = c.getChildren(t), u = $T(_, e, (m, h) => h, (m, h) => e < _[m].end ? !_[m - 1] || e >= _[m - 1].end ? 0 : 1 : -1); + if (u >= 0 && _[u]) { + const m = _[u]; + if (e < m.end) + if (m.getStart( + t, + /*includeJsDoc*/ + !i + ) >= e || // cursor in the leading trivia + !cae(m, t) || x9(m)) { + const T = iae( + _, + /*exclusiveStartPosition*/ + u, + t, + c.kind + ); + return T ? !i && F7(T) && T.getChildren(t).length ? o(T) : nae(T, t) : void 0; + } else + return o(m); + } + E.assert(n !== void 0 || c.kind === 308 || c.kind === 1 || F7(c)); + const g = iae( + _, + /*exclusiveStartPosition*/ + _.length, + t, + c.kind + ); + return g && nae(g, t); + } + } + function f2e(e) { + return ix(e) && !x9(e); + } + function nae(e, t) { + if (f2e(e)) + return e; + const n = e.getChildren(t); + if (n.length === 0) + return e; + const i = iae( + n, + /*exclusiveStartPosition*/ + n.length, + t, + e.kind + ); + return i && nae(i, t); + } + function iae(e, t, n, i) { + for (let s = t - 1; s >= 0; s--) { + const o = e[s]; + if (x9(o)) + s === 0 && (i === 12 || i === 286) && E.fail("`JsxText` tokens should not be the first child of `JsxElement | JsxSelfClosingElement`"); + else if (cae(e[s], n)) + return e[s]; + } + } + function _k(e, t, n = pl(t, e)) { + if (n && Wj(n)) { + const i = n.getStart(e), s = n.getEnd(); + if (i < t && t < s) + return !0; + if (t === s) + return !!n.isUnterminated; + } + return !1; + } + function sae(e, t) { + const n = vi(e, t); + return n ? !!(n.kind === 12 || n.kind === 30 && n.parent.kind === 12 || n.kind === 30 && n.parent.kind === 295 || n && n.kind === 20 && n.parent.kind === 295 || n.kind === 30 && n.parent.kind === 288) : !1; + } + function x9(e) { + return Bx(e) && e.containsOnlyTriviaWhiteSpaces; + } + function AV(e, t) { + const n = vi(e, t); + return ky(n.kind) && t > n.getStart(e); + } + function aae(e, t) { + const n = vi(e, t); + return !!(Bx(n) || n.kind === 19 && h6(n.parent) && Sm(n.parent.parent) || n.kind === 30 && wu(n.parent) && Sm(n.parent.parent)); + } + function k9(e, t) { + function n(i) { + for (; i; ) + if (i.kind >= 286 && i.kind <= 295 || i.kind === 12 || i.kind === 30 || i.kind === 32 || i.kind === 80 || i.kind === 20 || i.kind === 19 || i.kind === 44) + i = i.parent; + else if (i.kind === 285) { + if (t > i.getStart(e)) return !0; + i = i.parent; + } else + return !1; + return !1; + } + return n(vi(e, t)); + } + function C9(e, t, n) { + const i = qs(e.kind), s = qs(t), o = e.getFullStart(), c = n.text.lastIndexOf(s, o); + if (c === -1) + return; + if (n.text.lastIndexOf(i, o - 1) < c) { + const g = pl(c + 1, n); + if (g && g.kind === t) + return g; + } + const _ = e.kind; + let u = 0; + for (; ; ) { + const g = pl(e.getFullStart(), n); + if (!g) + return; + if (e = g, e.kind === t) { + if (u === 0) + return e; + u--; + } else e.kind === _ && u++; + } + } + function gJe(e, t, n) { + return t ? e.getNonNullableType() : n ? e.getNonOptionalType() : e; + } + function UA(e, t, n) { + const i = FV(e, t); + return i !== void 0 && (lm(i.called) || IV(i.called, i.nTypeArguments, n).length !== 0 || UA(i.called, t, n)); + } + function IV(e, t, n) { + let i = n.getTypeAtLocation(e); + return Eu(e.parent) && (i = gJe( + i, + SD(e.parent), + /*isOptionalChain*/ + !0 + )), (Xb(e.parent) ? i.getConstructSignatures() : i.getCallSignatures()).filter((o) => !!o.typeParameters && o.typeParameters.length >= t); + } + function FV(e, t) { + if (t.text.lastIndexOf("<", e ? e.pos : t.text.length) === -1) + return; + let n = e, i = 0, s = 0; + for (; n; ) { + switch (n.kind) { + case 30: + if (n = pl(n.getFullStart(), t), n && n.kind === 29 && (n = pl(n.getFullStart(), t)), !n || !Me(n)) return; + if (!i) + return Qm(n) ? void 0 : { called: n, nTypeArguments: s }; + i--; + break; + case 50: + i = 3; + break; + case 49: + i = 2; + break; + case 32: + i++; + break; + case 20: + if (n = C9(n, 19, t), !n) return; + break; + case 22: + if (n = C9(n, 21, t), !n) return; + break; + case 24: + if (n = C9(n, 23, t), !n) return; + break; + // Valid tokens in a type name. Skip. + case 28: + s++; + break; + case 39: + // falls through + case 80: + case 11: + case 9: + case 10: + case 112: + case 97: + // falls through + case 114: + case 96: + case 143: + case 25: + case 52: + case 58: + case 59: + break; + default: + if (li(n)) + break; + return; + } + n = pl(n.getFullStart(), t); + } + } + function P0(e, t, n) { + return nl.getRangeOfEnclosingComment( + e, + t, + /*precedingToken*/ + void 0, + n + ); + } + function oae(e, t) { + const n = vi(e, t); + return !!dr(n, Od); + } + function cae(e, t) { + return e.kind === 1 ? !!e.jsDoc : e.getWidth(t) !== 0; + } + function hw(e, t = 0) { + const n = [], i = Pl(e) ? Nj(e) & ~t : 0; + return i & 2 && n.push( + "private" + /* privateMemberModifier */ + ), i & 4 && n.push( + "protected" + /* protectedMemberModifier */ + ), i & 1 && n.push( + "public" + /* publicMemberModifier */ + ), (i & 256 || kc(e)) && n.push( + "static" + /* staticModifier */ + ), i & 64 && n.push( + "abstract" + /* abstractModifier */ + ), i & 32 && n.push( + "export" + /* exportedModifier */ + ), i & 65536 && n.push( + "deprecated" + /* deprecatedModifier */ + ), e.flags & 33554432 && n.push( + "declare" + /* ambientModifier */ + ), e.kind === 278 && n.push( + "export" + /* exportedModifier */ + ), n.length > 0 ? n.join(",") : ""; + } + function lae(e) { + if (e.kind === 184 || e.kind === 214) + return e.typeArguments; + if (Es(e) || e.kind === 264 || e.kind === 265) + return e.typeParameters; + } + function E9(e) { + return e === 2 || e === 3; + } + function OV(e) { + return !!(e === 11 || e === 14 || ky(e)); + } + function p2e(e, t, n) { + return !!(t.flags & 4) && e.isEmptyAnonymousObjectType(n); + } + function uae(e) { + if (!e.isIntersection()) + return !1; + const { types: t, checker: n } = e; + return t.length === 2 && (p2e(n, t[0], t[1]) || p2e(n, t[1], t[0])); + } + function VA(e, t, n) { + return ky(e.kind) && e.getStart(n) < t && t < e.end || !!e.isUnterminated && t === e.end; + } + function LV(e) { + switch (e) { + case 125: + case 123: + case 124: + return !0; + } + return !1; + } + function MV(e) { + const t = cQ(e); + return aW(t, e && e.configFile), t; + } + function N0(e) { + return !!((e.kind === 210 || e.kind === 211) && (e.parent.kind === 227 && e.parent.left === e && e.parent.operatorToken.kind === 64 || e.parent.kind === 251 && e.parent.initializer === e || N0(e.parent.kind === 304 ? e.parent.parent : e.parent))); + } + function _ae(e, t) { + return d2e( + e, + t, + /*shouldBeReference*/ + !0 + ); + } + function fae(e, t) { + return d2e( + e, + t, + /*shouldBeReference*/ + !1 + ); + } + function d2e(e, t, n) { + const i = P0( + e, + t, + /*tokenAtPosition*/ + void 0 + ); + return !!i && n === cJe.test(e.text.substring(i.pos, i.end)); + } + function RV(e, t) { + if (e) + switch (e.kind) { + case 11: + case 15: + return jV(e, t); + default: + return u_(e); + } + } + function u_(e, t, n) { + return Nc(e.getStart(t), (n || e).getEnd()); + } + function jV(e, t) { + let n = e.getEnd() - 1; + if (e.isUnterminated) { + if (e.getStart() === n) return; + n = Math.min(t, e.getEnd()); + } + return Nc(e.getStart() + 1, n); + } + function BV(e, t) { + return cp(e.getStart(t), e.end); + } + function A0(e) { + return Nc(e.pos, e.end); + } + function D9(e) { + return cp(e.start, e.start + e.length); + } + function w9(e, t, n) { + return qA(Kl(e, t), n); + } + function qA(e, t) { + return { span: e, newText: t }; + } + var JV = [ + 133, + 131, + 163, + 136, + 97, + 140, + 143, + 146, + 106, + 150, + 151, + 148, + 154, + 155, + 114, + 112, + 116, + 157, + 158, + 159 + /* UnknownKeyword */ + ]; + function yw(e) { + return ms(JV, e); + } + function m2e(e) { + return e.kind === 156; + } + function P9(e) { + return m2e(e) || Me(e) && e.text === "type"; + } + function G6() { + const e = []; + return (t) => { + const n = Ma(t); + return !e[n] && (e[n] = !0); + }; + } + function fk(e) { + return e.getText(0, e.getLength()); + } + function HA(e, t) { + let n = ""; + for (let i = 0; i < t; i++) + n += e; + return n; + } + function zV(e) { + return e.isTypeParameter() && e.getConstraint() || e; + } + function GA(e) { + return e.kind === 168 ? If(e.expression) ? e.expression.text : void 0 : Ai(e) ? An(e) : op(e); + } + function pae(e) { + return e.getSourceFiles().some((t) => !t.isDeclarationFile && !e.isSourceFileFromExternalLibrary(t) && !!(t.externalModuleIndicator || t.commonJsModuleIndicator)); + } + function dae(e) { + return e.getSourceFiles().some((t) => !t.isDeclarationFile && !e.isSourceFileFromExternalLibrary(t) && !!t.externalModuleIndicator); + } + function WV(e) { + return !!e.module || da(e) >= 2 || !!e.noEmit; + } + function bv(e, t) { + return { + fileExists: (n) => e.fileExists(n), + getCurrentDirectory: () => t.getCurrentDirectory(), + readFile: Os(t, t.readFile), + useCaseSensitiveFileNames: Os(t, t.useCaseSensitiveFileNames) || e.useCaseSensitiveFileNames, + getSymlinkCache: Os(t, t.getSymlinkCache) || e.getSymlinkCache, + getModuleSpecifierCache: Os(t, t.getModuleSpecifierCache), + getPackageJsonInfoCache: () => { + var n; + return (n = e.getModuleResolutionCache()) == null ? void 0 : n.getPackageJsonInfoCache(); + }, + getGlobalTypingsCacheLocation: Os(t, t.getGlobalTypingsCacheLocation), + redirectTargetsMap: e.redirectTargetsMap, + getRedirectFromSourceFile: (n) => e.getRedirectFromSourceFile(n), + isSourceOfProjectReferenceRedirect: (n) => e.isSourceOfProjectReferenceRedirect(n), + getNearestAncestorDirectoryWithPackageJson: Os(t, t.getNearestAncestorDirectoryWithPackageJson), + getFileIncludeReasons: () => e.getFileIncludeReasons(), + getCommonSourceDirectory: () => e.getCommonSourceDirectory(), + getDefaultResolutionModeForFile: (n) => e.getDefaultResolutionModeForFile(n), + getModeForResolutionAtIndex: (n, i) => e.getModeForResolutionAtIndex(n, i) + }; + } + function UV(e, t) { + return { + ...bv(e, t), + getCommonSourceDirectory: () => e.getCommonSourceDirectory() + }; + } + function N9(e) { + return e === 2 || e >= 3 && e <= 99 || e === 100; + } + function r1(e, t, n, i, s) { + return N.createImportDeclaration( + /*modifiers*/ + void 0, + e || t ? N.createImportClause(s ? 156 : void 0, e, t && t.length ? N.createNamedImports(t) : void 0) : void 0, + typeof n == "string" ? vw(n, i) : n, + /*attributes*/ + void 0 + ); + } + function vw(e, t) { + return N.createStringLiteral( + e, + t === 0 + /* Single */ + ); + } + var mae = /* @__PURE__ */ ((e) => (e[e.Single = 0] = "Single", e[e.Double = 1] = "Double", e))(mae || {}); + function VV(e, t) { + return _5(e, t) ? 1 : 0; + } + function _f(e, t) { + if (t.quotePreference && t.quotePreference !== "auto") + return t.quotePreference === "single" ? 0 : 1; + { + const n = Og(e) && e.imports && Nn(e.imports, (i) => ca(i) && !lo(i.parent)); + return n ? VV(n, e) : 1; + } + } + function qV(e) { + switch (e) { + case 0: + return "'"; + case 1: + return '"'; + default: + return E.assertNever(e); + } + } + function HV(e) { + const t = A9(e); + return t === void 0 ? void 0 : Si(t); + } + function A9(e) { + return e.escapedName !== "default" ? e.escapedName : Lc(e.declarations, (t) => { + const n = _s(t); + return n && n.kind === 80 ? n.escapedText : void 0; + }); + } + function I9(e) { + return ja(e) && (wh(e.parent) || qo(e.parent) || xm(e.parent) || x_( + e.parent, + /*requireStringLiteralLikeArgument*/ + !1 + ) && e.parent.arguments[0] === e || T_(e.parent) && e.parent.arguments[0] === e); + } + function $A(e) { + return ya(e) && Of(e.parent) && Me(e.name) && !e.propertyName; + } + function F9(e, t) { + const n = e.getTypeAtLocation(t.parent); + return n && e.getPropertyOfType(n, t.name.text); + } + function XA(e, t, n) { + if (e) + for (; e.parent; ) { + if (Di(e.parent) || !hJe(n, e.parent, t)) + return e; + e = e.parent; + } + } + function hJe(e, t, n) { + return Dj(e, t.getStart(n)) && t.getEnd() <= ec(e); + } + function $6(e, t) { + return Vp(e) ? Nn(e.modifiers, (n) => n.kind === t) : void 0; + } + function GV(e, t, n, i, s) { + var o; + const _ = (as(n) ? n[0] : n).kind === 244 ? M3 : px, u = kn(t.statements, _), { comparer: g, isSorted: m } = Dv.getOrganizeImportsStringComparerWithDetection(u, s), h = as(n) ? X_(n, (S, T) => Dv.compareImportsOrRequireStatements(S, T, g)) : [n]; + if (!u?.length) { + if (Og(t)) + e.insertNodesAtTopOfFile(t, h, i); + else + for (const S of h) + e.insertStatementsInNewFile(t.fileName, [S], (o = Vo(S)) == null ? void 0 : o.getSourceFile()); + return; + } + if (E.assert(Og(t)), u && m) + for (const S of h) { + const T = Dv.getImportDeclarationInsertionIndex(u, S, g); + if (T === 0) { + const k = u[0] === t.statements[0] ? { leadingTriviaOption: cn.LeadingTriviaOption.Exclude } : {}; + e.insertNodeBefore( + t, + u[0], + S, + /*blankLineBetween*/ + !1, + k + ); + } else { + const k = u[T - 1]; + e.insertNodeAfter(t, k, S); + } + } + else { + const S = Do(u); + S ? e.insertNodesAfter(t, S, h) : e.insertNodesAtTopOfFile(t, h, i); + } + } + function $V(e, t) { + return E.assert(e.isTypeOnly), Us(e.getChildAt(0, t), m2e); + } + function X6(e, t) { + return !!e && !!t && e.start === t.start && e.length === t.length; + } + function XV(e, t, n) { + return (n ? bb : hy)(e.fileName, t.fileName) && X6(e.textSpan, t.textSpan); + } + function QV(e) { + return (t, n) => XV(t, n, e); + } + function YV(e, t) { + if (e) { + for (let n = 0; n < e.length; n++) + if (e.indexOf(e[n]) === n) { + const i = t(e[n], n); + if (i) + return i; + } + } + } + function gae(e, t, n) { + for (let i = t; i < n; i++) + if (!Cg(e.charCodeAt(i))) + return !1; + return !0; + } + function bw(e, t, n) { + const i = t.tryGetSourcePosition(e); + return i && (!n || n(Hs(i.fileName)) ? i : void 0); + } + function O9(e, t, n) { + const { fileName: i, textSpan: s } = e, o = bw({ fileName: i, pos: s.start }, t, n); + if (!o) return; + const c = bw({ fileName: i, pos: s.start + s.length }, t, n), _ = c ? c.pos - o.pos : s.length; + return { + fileName: o.fileName, + textSpan: { + start: o.pos, + length: _ + }, + originalFileName: e.fileName, + originalTextSpan: e.textSpan, + contextSpan: ZV(e, t, n), + originalContextSpan: e.contextSpan + }; + } + function ZV(e, t, n) { + const i = e.contextSpan && bw( + { fileName: e.fileName, pos: e.contextSpan.start }, + t, + n + ), s = e.contextSpan && bw( + { fileName: e.fileName, pos: e.contextSpan.start + e.contextSpan.length }, + t, + n + ); + return i && s ? { start: i.pos, length: s.pos - i.pos } : void 0; + } + function KV(e) { + const t = e.declarations ? Yc(e.declarations) : void 0; + return !!dr(t, (n) => Ii(n) ? !0 : ya(n) || Of(n) || D0(n) ? !1 : "quit"); + } + var hae = /* @__PURE__ */ new Map(); + function yJe(e) { + return e = e || ND, hae.has(e) || hae.set(e, vJe(e)), hae.get(e); + } + function vJe(e) { + const t = e * 10; + let n, i, s, o; + h(); + const c = (S) => u( + S, + 17 + /* text */ + ); + return { + displayParts: () => { + const S = n.length && n[n.length - 1].text; + return o > t && S && S !== "..." && (Cg(S.charCodeAt(S.length - 1)) || n.push(W_( + " ", + 16 + /* space */ + )), n.push(W_( + "...", + 15 + /* punctuation */ + ))), n; + }, + writeKeyword: (S) => u( + S, + 5 + /* keyword */ + ), + writeOperator: (S) => u( + S, + 12 + /* operator */ + ), + writePunctuation: (S) => u( + S, + 15 + /* punctuation */ + ), + writeTrailingSemicolon: (S) => u( + S, + 15 + /* punctuation */ + ), + writeSpace: (S) => u( + S, + 16 + /* space */ + ), + writeStringLiteral: (S) => u( + S, + 8 + /* stringLiteral */ + ), + writeParameter: (S) => u( + S, + 13 + /* parameterName */ + ), + writeProperty: (S) => u( + S, + 14 + /* propertyName */ + ), + writeLiteral: (S) => u( + S, + 8 + /* stringLiteral */ + ), + writeSymbol: g, + writeLine: m, + write: c, + writeComment: c, + getText: () => "", + getTextPos: () => 0, + getColumn: () => 0, + getLine: () => 0, + isAtStartOfLine: () => !1, + hasTrailingWhitespace: () => !1, + hasTrailingComment: () => !1, + rawWrite: Vs, + getIndent: () => s, + increaseIndent: () => { + s++; + }, + decreaseIndent: () => { + s--; + }, + clear: h + }; + function _() { + if (!(o > t) && i) { + const S = T5(s); + S && (o += S.length, n.push(W_( + S, + 16 + /* space */ + ))), i = !1; + } + } + function u(S, T) { + o > t || (_(), o += S.length, n.push(W_(S, T))); + } + function g(S, T) { + o > t || (_(), o += S.length, n.push(bJe(S, T))); + } + function m() { + o > t || (o += 1, n.push(Q6()), i = !0); + } + function h() { + n = [], i = !0, s = 0, o = 0; + } + } + function bJe(e, t) { + return W_(e, n(t)); + function n(i) { + const s = i.flags; + return s & 3 ? KV(i) ? 13 : 9 : s & 4 || s & 32768 || s & 65536 ? 14 : s & 8 ? 19 : s & 16 ? 20 : s & 32 ? 1 : s & 64 ? 4 : s & 384 ? 2 : s & 1536 ? 11 : s & 8192 ? 10 : s & 262144 ? 18 : s & 524288 || s & 2097152 ? 0 : 17; + } + } + function W_(e, t) { + return { text: e, kind: f9[t] }; + } + function fc() { + return W_( + " ", + 16 + /* space */ + ); + } + function ff(e) { + return W_( + qs(e), + 5 + /* keyword */ + ); + } + function Fu(e) { + return W_( + qs(e), + 15 + /* punctuation */ + ); + } + function Sw(e) { + return W_( + qs(e), + 12 + /* operator */ + ); + } + function yae(e) { + return W_( + e, + 13 + /* parameterName */ + ); + } + function vae(e) { + return W_( + e, + 14 + /* propertyName */ + ); + } + function eq(e) { + const t = Q2(e); + return t === void 0 ? Bf(e) : ff(t); + } + function Bf(e) { + return W_( + e, + 17 + /* text */ + ); + } + function bae(e) { + return W_( + e, + 0 + /* aliasName */ + ); + } + function Sae(e) { + return W_( + e, + 18 + /* typeParameterName */ + ); + } + function Tae(e) { + return W_( + e, + 24 + /* linkText */ + ); + } + function SJe(e, t) { + return { + text: e, + kind: f9[ + 23 + /* linkName */ + ], + target: { + fileName: xr(t).fileName, + textSpan: u_(t) + } + }; + } + function g2e(e) { + return W_( + e, + 22 + /* link */ + ); + } + function xae(e, t) { + var n; + const i = Gte(e) ? "link" : $te(e) ? "linkcode" : "linkplain", s = [g2e(`{@${i} `)]; + if (!e.name) + e.text && s.push(Tae(e.text)); + else { + const o = t?.getSymbolAtLocation(e.name), c = o && t ? nq(o, t) : void 0, _ = xJe(e.text), u = Qo(e.name) + e.text.slice(0, _), g = TJe(e.text.slice(_)), m = c?.valueDeclaration || ((n = c?.declarations) == null ? void 0 : n[0]); + if (m) + s.push(SJe(u, m)), g && s.push(Tae(g)); + else { + const h = _ === 0 || e.text.charCodeAt(_) === 124 && u.charCodeAt(u.length - 1) !== 32 ? " " : ""; + s.push(Tae(u + h + g)); + } + } + return s.push(g2e("}")), s; + } + function TJe(e) { + let t = 0; + if (e.charCodeAt(t++) === 124) { + for (; t < e.length && e.charCodeAt(t) === 32; ) t++; + return e.slice(t); + } + return e; + } + function xJe(e) { + let t = e.indexOf("://"); + if (t === 0) { + for (; t < e.length && e.charCodeAt(t) !== 124; ) t++; + return t; + } + if (e.indexOf("()") === 0) return 2; + if (e.charAt(0) === "<") { + let n = 0, i = 0; + for (; i < e.length; ) + if (e[i] === "<" && n++, e[i] === ">" && n--, i++, !n) return i; + } + return 0; + } + var kJe = ` +`; + function Fh(e, t) { + var n; + return t?.newLineCharacter || ((n = e.getNewLine) == null ? void 0 : n.call(e)) || kJe; + } + function Q6() { + return W_( + ` +`, + 6 + /* lineBreak */ + ); + } + function n1(e, t) { + const n = yJe(t); + try { + return e(n), n.displayParts(); + } finally { + n.clear(); + } + } + function QA(e, t, n, i = 0, s, o, c) { + return n1((_) => { + e.writeType(t, n, i | 1024 | 16384, _, s, o, c); + }, s); + } + function Tw(e, t, n, i, s = 0) { + return n1((o) => { + e.writeSymbol(t, n, i, s | 8, o); + }); + } + function tq(e, t, n, i = 0, s, o, c) { + return i |= 25632, n1((_) => { + e.writeSignature( + t, + n, + i, + /*kind*/ + void 0, + _, + s, + o, + c + ); + }, s); + } + function kae(e) { + return !!e.parent && Cy(e.parent) && e.parent.propertyName === e; + } + function rq(e, t) { + return Z5(e, t.getScriptKind && t.getScriptKind(e)); + } + function nq(e, t) { + let n = e; + for (; CJe(n) || Ng(n) && n.links.target; ) + Ng(n) && n.links.target ? n = n.links.target : n = eu(n, t); + return n; + } + function CJe(e) { + return (e.flags & 2097152) !== 0; + } + function Cae(e, t) { + return Xs(eu(e, t)); + } + function Eae(e, t) { + for (; Cg(e.charCodeAt(t)); ) + t += 1; + return t; + } + function L9(e, t) { + for (; t > -1 && im(e.charCodeAt(t)); ) + t -= 1; + return t + 1; + } + function VS(e, t) { + const n = e.getSourceFile(), i = n.text; + EJe(e, i) ? Y6(e, t, n) : ZA(e, t, n), xw(e, t, n); + } + function EJe(e, t) { + const n = e.getFullStart(), i = e.getStart(); + for (let s = n; s < i; s++) + if (t.charCodeAt(s) === 10) return !0; + return !1; + } + function qS(e, t) { + let n = e; + for (let i = 1; !W7(t, n); i++) + n = `${e}_${i}`; + return n; + } + function YA(e, t, n, i) { + let s = 0, o = -1; + for (const { fileName: c, textChanges: _ } of e) { + E.assert(c === t); + for (const u of _) { + const { span: g, newText: m } = u, h = DJe(m, Ym(n)); + if (h !== -1 && (o = g.start + s + h, !i)) + return o; + s += m.length - g.length; + } + } + return E.assert(i), E.assert(o >= 0), o; + } + function Y6(e, t, n, i, s) { + XP(n.text, e.pos, Dae(t, n, i, s, Uy)); + } + function xw(e, t, n, i, s) { + QP(n.text, e.end, Dae(t, n, i, s, C4)); + } + function ZA(e, t, n, i, s) { + QP(n.text, e.pos, Dae(t, n, i, s, Uy)); + } + function Dae(e, t, n, i, s) { + return (o, c, _, u) => { + _ === 3 ? (o += 2, c -= 2) : o += 2, s(e, n || _, t.text.slice(o, c), i !== void 0 ? i : u); + }; + } + function DJe(e, t) { + if (Ui(e, t)) return 0; + let n = e.indexOf(" " + t); + return n === -1 && (n = e.indexOf("." + t)), n === -1 && (n = e.indexOf('"' + t)), n === -1 ? -1 : n + 1; + } + function M9(e) { + return _n(e) && e.operatorToken.kind === 28 || _a(e) || (d6(e) || m6(e)) && _a(e.expression); + } + function R9(e, t, n) { + const i = ad(e.parent); + switch (i.kind) { + case 215: + return t.getContextualType(i, n); + case 227: { + const { left: s, operatorToken: o, right: c } = i; + return j9(o.kind) ? t.getTypeAtLocation(e === c ? s : c) : t.getContextualType(e, n); + } + case 297: + return sq(i, t); + default: + return t.getContextualType(e, n); + } + } + function kw(e, t, n) { + const i = _f(e, t), s = JSON.stringify(n); + return i === 0 ? `'${Bp(s).replace(/'/g, () => "\\'").replace(/\\"/g, '"')}'` : s; + } + function j9(e) { + switch (e) { + case 37: + case 35: + case 38: + case 36: + return !0; + default: + return !1; + } + } + function wae(e) { + switch (e.kind) { + case 11: + case 15: + case 229: + case 216: + return !0; + default: + return !1; + } + } + function iq(e) { + return !!e.getStringIndexType() || !!e.getNumberIndexType(); + } + function sq(e, t) { + return t.getTypeAtLocation(e.parent.parent.expression); + } + var aq = "anonymous function"; + function Cw(e, t, n, i) { + const s = n.getTypeChecker(); + let o = !0; + const c = () => o = !1, _ = s.typeToTypeNode(e, t, 1, 8, { + trackSymbol: (u, g, m) => (o = o && s.isSymbolAccessible( + u, + g, + m, + /*shouldComputeAliasToMarkVisible*/ + !1 + ).accessibility === 0, !o), + reportInaccessibleThisError: c, + reportPrivateInBaseOfClassExpression: c, + reportInaccessibleUniqueSymbolError: c, + moduleResolverHost: UV(n, i) + }); + return o ? _ : void 0; + } + function Pae(e) { + return e === 180 || e === 181 || e === 182 || e === 172 || e === 174; + } + function h2e(e) { + return e === 263 || e === 177 || e === 175 || e === 178 || e === 179; + } + function y2e(e) { + return e === 268; + } + function Nae(e) { + return e === 244 || e === 245 || e === 247 || e === 252 || e === 253 || e === 254 || e === 258 || e === 260 || e === 173 || e === 266 || e === 273 || e === 272 || e === 279 || e === 271 || e === 278; + } + var wJe = Q_( + Pae, + h2e, + y2e, + Nae + ); + function PJe(e, t) { + const n = e.getLastToken(t); + if (n && n.kind === 27) + return !1; + if (Pae(e.kind)) { + if (n && n.kind === 28) + return !1; + } else if (y2e(e.kind)) { + const _ = pa(e.getChildren(t)); + if (_ && vm(_)) + return !1; + } else if (h2e(e.kind)) { + const _ = pa(e.getChildren(t)); + if (_ && Nb(_)) + return !1; + } else if (!Nae(e.kind)) + return !1; + if (e.kind === 247) + return !0; + const i = dr(e, (_) => !_.parent), s = c2(e, i, t); + if (!s || s.kind === 20) + return !0; + const o = t.getLineAndCharacterOfPosition(e.getEnd()).line, c = t.getLineAndCharacterOfPosition(s.getStart(t)).line; + return o !== c; + } + function B9(e, t, n) { + const i = dr(t, (s) => s.end !== e ? "quit" : wJe(s.kind)); + return !!i && PJe(i, n); + } + function KA(e) { + let t = 0, n = 0; + const i = 5; + return xs(e, function s(o) { + if (Nae(o.kind)) { + const c = o.getLastToken(e); + c?.kind === 27 ? t++ : n++; + } else if (Pae(o.kind)) { + const c = o.getLastToken(e); + if (c?.kind === 27) + t++; + else if (c && c.kind !== 28) { + const _ = js(e, c.getStart(e)).line, u = js(e, om(e, c.end).start).line; + _ !== u && n++; + } + } + return t + n >= i ? !0 : xs(o, s); + }), t === 0 && n <= 1 ? !0 : t / n > 1 / i; + } + function J9(e, t) { + return Aae(e, e.getDirectories, t) || []; + } + function oq(e, t, n, i, s) { + return Aae(e, e.readDirectory, t, n, i, s) || Ge; + } + function Ew(e, t) { + return Aae(e, e.fileExists, t); + } + function z9(e, t) { + return W9(() => Pd(t, e)) || !1; + } + function W9(e) { + try { + return e(); + } catch { + return; + } + } + function Aae(e, t, ...n) { + return W9(() => t && t.apply(e, n)); + } + function cq(e, t) { + const n = []; + return eg( + t, + e, + (i) => { + const s = On(i, "package.json"); + Ew(t, s) && n.push(s); + } + ), n; + } + function Iae(e, t) { + let n; + return eg( + t, + e, + (i) => { + if (i === "node_modules" || (n = lU(i, (s) => Ew(t, s), "package.json"), n)) + return !0; + } + ), n; + } + function NJe(e, t) { + if (!t.fileExists) + return []; + const n = []; + return eg( + t, + Hn(e), + (i) => { + const s = On(i, "package.json"); + if (t.fileExists(s)) { + const o = lq(s, t); + o && n.push(o); + } + } + ), n; + } + function lq(e, t) { + if (!t.readFile) + return; + const n = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"], i = t.readFile(e) || "", s = lN(i), o = {}; + if (s) + for (const u of n) { + const g = s[u]; + if (!g) + continue; + const m = /* @__PURE__ */ new Map(); + for (const h in g) + m.set(h, g[h]); + o[u] = m; + } + const c = [ + [1, o.dependencies], + [2, o.devDependencies], + [8, o.optionalDependencies], + [4, o.peerDependencies] + ]; + return { + ...o, + parseable: !!s, + fileName: e, + get: _, + has(u, g) { + return !!_(u, g); + } + }; + function _(u, g = 15) { + for (const [m, h] of c) + if (h && g & m) { + const S = h.get(u); + if (S !== void 0) + return S; + } + } + } + function Z6(e, t, n) { + const i = (n.getPackageJsonsVisibleToFile && n.getPackageJsonsVisibleToFile(e.fileName) || NJe(e.fileName, n)).filter((k) => k.parseable); + let s, o, c; + return { + allowsImportingAmbientModule: u, + getSourceFileInfo: g, + allowsImportingSpecifier: m + }; + function _(k) { + const D = T(k); + for (const P of i) + if (P.has(D) || P.has(mO(D))) + return !0; + return !1; + } + function u(k, D) { + if (!i.length || !k.valueDeclaration) + return !0; + if (!o) + o = /* @__PURE__ */ new Map(); + else { + const R = o.get(k); + if (R !== void 0) + return R; + } + const P = Bp(k.getName()); + if (h(P)) + return o.set(k, !0), !0; + const A = k.valueDeclaration.getSourceFile(), O = S(A.fileName, D); + if (typeof O > "u") + return o.set(k, !0), !0; + const F = _(O) || _(P); + return o.set(k, F), F; + } + function g(k, D) { + if (!i.length) + return { importable: !0, packageName: void 0 }; + if (!c) + c = /* @__PURE__ */ new Map(); + else { + const F = c.get(k); + if (F !== void 0) + return F; + } + const P = S(k.fileName, D); + if (!P) { + const F = { importable: !0, packageName: P }; + return c.set(k, F), F; + } + const O = { importable: _(P), packageName: P }; + return c.set(k, O), O; + } + function m(k) { + return !i.length || h(k) || xf(k) || Z_(k) ? !0 : _(k); + } + function h(k) { + return !!(Og(e) && n_(e) && c6.has(k) && (s === void 0 && (s = U9(e)), s)); + } + function S(k, D) { + if (!k.includes("node_modules")) + return; + const P = Ih.getNodeModulesPackageName( + n.getCompilationSettings(), + e, + k, + D, + t + ); + if (P && !xf(P) && !Z_(P)) + return T(P); + } + function T(k) { + const D = fu(X4(k)).slice(1); + return Ui(D[0], "@") ? `${D[0]}/${D[1]}` : D[0]; + } + } + function U9(e) { + return ot(e.imports, ({ text: t }) => c6.has(t)); + } + function e8(e) { + return ms(fu(e), "node_modules"); + } + function v2e(e) { + return e.file !== void 0 && e.start !== void 0 && e.length !== void 0; + } + function Fae(e, t) { + const n = u_(e), i = $T(t, n, go, QI); + if (i >= 0) { + const s = t[i]; + return E.assertEqual(s.file, e.getSourceFile(), "Diagnostics proided to 'findDiagnosticForNode' must be from a single SourceFile"), Us(s, v2e); + } + } + function Oae(e, t) { + var n; + let i = $T(t, e.start, (c) => c.start, ho); + for (i < 0 && (i = ~i); ((n = t[i - 1]) == null ? void 0 : n.start) === e.start; ) + i--; + const s = [], o = ec(e); + for (; ; ) { + const c = Bn(t[i], v2e); + if (!c || c.start > o) + break; + GY(e, c) && s.push(c), i++; + } + return s; + } + function pk({ startPosition: e, endPosition: t }) { + return Nc(e, t === void 0 ? e : t); + } + function uq(e, t) { + const n = vi(e, t.start); + return dr(n, (s) => s.getStart(e) < t.start || s.getEnd() > ec(t) ? "quit" : ut(s) && X6(t, u_(s, e))); + } + function _q(e, t, n = go) { + return e ? as(e) ? n(hr(e, t)) : t(e, 0) : void 0; + } + function fq(e) { + return as(e) ? Ca(e) : e; + } + function V9(e, t, n) { + return e.escapedName === "export=" || e.escapedName === "default" ? pq(e) || t8(AJe(e), t, !!n) : e.name; + } + function pq(e) { + return Lc(e.declarations, (t) => { + var n, i, s; + if (Mo(t)) + return (n = Bn(hc(t.expression), Me)) == null ? void 0 : n.text; + if (Nu(t) && t.symbol.flags === 2097152) + return (i = Bn(t.propertyName, Me)) == null ? void 0 : i.text; + const o = (s = Bn(_s(t), Me)) == null ? void 0 : s.text; + if (o) + return o; + if (e.parent && !lx(e.parent)) + return e.parent.getName(); + }); + } + function AJe(e) { + var t; + return E.checkDefined( + e.parent, + `Symbol parent was undefined. Flags: ${E.formatSymbolFlags(e.flags)}. Declarations: ${(t = e.declarations) == null ? void 0 : t.map((n) => { + const i = E.formatSyntaxKind(n.kind), s = an(n), { expression: o } = n; + return (s ? "[JS]" : "") + i + (o ? ` (expression: ${E.formatSyntaxKind(o.kind)})` : ""); + }).join(", ")}.` + ); + } + function t8(e, t, n) { + return r8(Gu(Bp(e.name)), t, n); + } + function r8(e, t, n) { + const i = Zc(bC(Gu(e), "/index")); + let s = "", o = !0; + const c = i.charCodeAt(0); + Vm(c, t) ? (s += String.fromCharCode(c), n && (s = s.toUpperCase())) : o = !1; + for (let _ = 1; _ < i.length; _++) { + const u = i.charCodeAt(_), g = hh(u, t); + if (g) { + let m = String.fromCharCode(u); + o || (m = m.toUpperCase()), s += m; + } + o = g; + } + return Sx(s) ? `_${s}` : s || "_"; + } + function Lae(e, t, n) { + const i = t.length; + if (i + n > e.length) + return !1; + for (let s = 0; s < i; s++) + if (t.charCodeAt(s) !== e.charCodeAt(s + n)) return !1; + return !0; + } + function dq(e) { + return e.charCodeAt(0) === 95; + } + function q9(e) { + return !!(Nj(e) & 65536); + } + function H9(e, t) { + let n; + for (const i of e.imports) + if (c6.has(i.text) && !pF.has(i.text)) { + if (Ui(i.text, "node:")) + return !0; + n = !1; + } + return n ?? t.usesUriStyleNodeCoreModules; + } + function n8(e) { + return e === ` +` ? 1 : 0; + } + function l2(e) { + return as(e) ? jg(Ss(e[0]), e.slice(1)) : Ss(e); + } + function G9({ options: e }, t) { + const n = !e.semicolons || e.semicolons === "ignore", i = e.semicolons === "remove" || n && !KA(t); + return { + ...e, + semicolons: i ? "remove" : "ignore" + /* Ignore */ + }; + } + function mq(e) { + return e === 2 || e === 3; + } + function K6(e, t) { + return e.isSourceFileFromExternalLibrary(t) || e.isSourceFileDefaultLibrary(t); + } + function $9(e, t) { + const n = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(); + for (const _ of t) + if (!L4(_)) { + const u = Ba(_.expression); + if (eS(u)) + switch (u.kind) { + case 15: + case 11: + n.add(u.text); + break; + case 9: + i.add(parseInt(u.text)); + break; + case 10: + const g = Vee(wo(u.text, "n") ? u.text.slice(0, -1) : u.text); + g && s.add(Ub(g)); + break; + } + else { + const g = e.getSymbolAtLocation(_.expression); + if (g && g.valueDeclaration && Ph(g.valueDeclaration)) { + const m = e.getConstantValue(g.valueDeclaration); + m !== void 0 && o(m); + } + } + } + return { + addValue: o, + hasValue: c + }; + function o(_) { + switch (typeof _) { + case "string": + n.add(_); + break; + case "number": + i.add(_); + } + } + function c(_) { + switch (typeof _) { + case "string": + return n.has(_); + case "number": + return i.has(_); + case "object": + return s.has(Ub(_)); + } + } + } + function gq(e, t, n, i) { + var s; + const o = typeof e == "string" ? e : e.fileName; + if (!Bg(o)) + return !1; + const c = typeof e == "string" ? t.getCompilerOptions() : t.getCompilerOptionsForFile(e), _ = Hu(c), u = typeof e == "string" ? { + fileName: e, + impliedNodeFormat: DA(oo(e, n.getCurrentDirectory(), xh(n)), (s = t.getPackageJsonInfoCache) == null ? void 0 : s.call(t), n, c) + } : e, g = zS(u, c); + if (g === 99) + return !1; + if (g === 1 || c.verbatimModuleSyntax && _ === 1) + return !0; + if (c.verbatimModuleSyntax && hN(_)) + return !1; + if (typeof e == "object") { + if (e.commonJsModuleIndicator) + return !0; + if (e.externalModuleIndicator) + return !1; + } + return i; + } + function dk(e) { + switch (e.kind) { + case 242: + case 308: + case 269: + case 297: + return !0; + default: + return !1; + } + } + function X9(e, t, n, i) { + var s; + const o = JO(e, (s = n.getPackageJsonInfoCache) == null ? void 0 : s.call(n), i, n.getCompilerOptions()); + let c, _; + return typeof o == "object" && (c = o.impliedNodeFormat, _ = o.packageJsonScope), { + path: oo(e, n.getCurrentDirectory(), n.getCanonicalFileName), + fileName: e, + externalModuleIndicator: t === 99 ? !0 : void 0, + commonJsModuleIndicator: t === 1 ? !0 : void 0, + impliedNodeFormat: c, + packageJsonScope: _, + statements: Ge, + imports: Ge + }; + } + var Mae = /* @__PURE__ */ ((e) => (e[e.Named = 0] = "Named", e[e.Default = 1] = "Default", e[e.Namespace = 2] = "Namespace", e[e.CommonJS = 3] = "CommonJS", e))(Mae || {}), Rae = /* @__PURE__ */ ((e) => (e[e.Named = 0] = "Named", e[e.Default = 1] = "Default", e[e.ExportEquals = 2] = "ExportEquals", e[e.UMD = 3] = "UMD", e[e.Module = 4] = "Module", e))(Rae || {}); + function hq(e) { + let t = 1; + const n = Fp(), i = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(); + let o; + const c = { + isUsableByFile: (T) => T === o, + isEmpty: () => !n.size, + clear: () => { + n.clear(), i.clear(), o = void 0; + }, + add: (T, k, D, P, A, O, F, R) => { + T !== o && (c.clear(), o = T); + let B; + if (A) { + const he = oF(A.fileName); + if (he) { + const { topLevelNodeModulesIndex: q, topLevelPackageNameIndex: be, packageRootIndex: je } = he; + if (B = _A(X4(A.fileName.substring(be + 1, je))), Ui(T, A.path.substring(0, q))) { + const me = s.get(B), Z = A.fileName.substring(0, be + 1); + if (me) { + const pe = me.indexOf(qg); + q > pe && s.set(B, Z); + } else + s.set(B, Z); + } + } + } + const $ = O === 1 && n4(k) || k, W = O === 0 || lx($) ? Si(D) : FJe( + $, + R, + /*scriptTarget*/ + void 0 + ), _e = typeof W == "string" ? W : W[0], K = typeof W == "string" ? void 0 : W[1], V = Bp(P.name), ae = t++, se = eu(k, R), ce = k.flags & 33554432 ? void 0 : k, fe = P.flags & 33554432 ? void 0 : P; + (!ce || !fe) && i.set(ae, [k, P]), n.add(u(_e, k, Dl(V) ? void 0 : V, R), { + id: ae, + symbolTableKey: D, + symbolName: _e, + capitalizedSymbolName: K, + moduleName: V, + moduleFile: A, + moduleFileName: A?.fileName, + packageName: B, + exportKind: O, + targetFlags: se.flags, + isFromPackageJson: F, + symbol: ce, + moduleSymbol: fe + }); + }, + get: (T, k) => { + if (T !== o) return; + const D = n.get(k); + return D?.map(_); + }, + search: (T, k, D, P) => { + if (T === o) + return hl(n, (A, O) => { + const { symbolName: F, ambientModuleName: R } = g(O), B = k && A[0].capitalizedSymbolName || F; + if (D(B, A[0].targetFlags)) { + const $ = A.map(_).filter((W, _e) => S(W, A[_e].packageName)); + if ($.length) { + const W = P($, B, !!R, O); + if (W !== void 0) return W; + } + } + }); + }, + releaseSymbols: () => { + i.clear(); + }, + onFileChanged: (T, k, D) => m(T) && m(k) ? !1 : o && o !== k.path || // If ATA is enabled, auto-imports uses existing imports to guess whether you want auto-imports from node. + // Adding or removing imports from node could change the outcome of that guess, so could change the suggestions list. + D && U9(T) !== U9(k) || // Module agumentation and ambient module changes can add or remove exports available to be auto-imported. + // Changes elsewhere in the file can change the *type* of an export in a module augmentation, + // but type info is gathered in getCompletionEntryDetails, which doesn't use the cache. + !Tf(T.moduleAugmentations, k.moduleAugmentations) || !h(T, k) ? (c.clear(), !0) : (o = k.path, !1) + }; + return E.isDebugging && Object.defineProperty(c, "__cache", { value: n }), c; + function _(T) { + if (T.symbol && T.moduleSymbol) return T; + const { id: k, exportKind: D, targetFlags: P, isFromPackageJson: A, moduleFileName: O } = T, [F, R] = i.get(k) || Ge; + if (F && R) + return { + symbol: F, + moduleSymbol: R, + moduleFileName: O, + exportKind: D, + targetFlags: P, + isFromPackageJson: A + }; + const B = (A ? e.getPackageJsonAutoImportProvider() : e.getCurrentProgram()).getTypeChecker(), U = T.moduleSymbol || R || E.checkDefined( + T.moduleFile ? B.getMergedSymbol(T.moduleFile.symbol) : B.tryFindAmbientModule(T.moduleName) + ), $ = T.symbol || F || E.checkDefined( + D === 2 ? B.resolveExternalModuleSymbol(U) : B.tryGetMemberInModuleExportsAndProperties(Si(T.symbolTableKey), U), + `Could not find symbol '${T.symbolName}' by key '${T.symbolTableKey}' in module ${U.name}` + ); + return i.set(k, [$, U]), { + symbol: $, + moduleSymbol: U, + moduleFileName: O, + exportKind: D, + targetFlags: P, + isFromPackageJson: A + }; + } + function u(T, k, D, P) { + const A = D || ""; + return `${T.length} ${Xs(eu(k, P))} ${T} ${A}`; + } + function g(T) { + const k = T.indexOf(" "), D = T.indexOf(" ", k + 1), P = parseInt(T.substring(0, k), 10), A = T.substring(D + 1), O = A.substring(0, P), F = A.substring(P + 1); + return { symbolName: O, ambientModuleName: F === "" ? void 0 : F }; + } + function m(T) { + return !T.commonJsModuleIndicator && !T.externalModuleIndicator && !T.moduleAugmentations && !T.ambientModuleNames; + } + function h(T, k) { + if (!Tf(T.ambientModuleNames, k.ambientModuleNames)) + return !1; + let D = -1, P = -1; + for (const A of k.ambientModuleNames) { + const O = (F) => uB(F) && F.name.text === A; + if (D = oc(T.statements, O, D + 1), P = oc(k.statements, O, P + 1), T.statements[D] !== k.statements[P]) + return !1; + } + return !0; + } + function S(T, k) { + if (!k || !T.moduleFileName) return !0; + const D = e.getGlobalTypingsCacheLocation(); + if (D && Ui(T.moduleFileName, D)) return !0; + const P = s.get(k); + return !P || Ui(T.moduleFileName, P); + } + } + function yq(e, t, n, i, s, o, c, _) { + var u; + if (!n) { + let T; + const k = Bp(i.name); + return c6.has(k) && (T = H9(t, e)) !== void 0 ? T === Ui(k, "node:") : !o || o.allowsImportingAmbientModule(i, c) || jae(t, k); + } + if (E.assertIsDefined(n), t === n) return !1; + const g = _?.get(t.path, n.path, s, {}); + if (g?.isBlockedByPackageJsonDependencies !== void 0) + return !g.isBlockedByPackageJsonDependencies || !!g.packageName && jae(t, g.packageName); + const m = xh(c), h = (u = c.getGlobalTypingsCacheLocation) == null ? void 0 : u.call(c), S = !!Ih.forEachFileNameOfModule( + t.fileName, + n.fileName, + c, + /*preferSymlinks*/ + !1, + (T) => { + const k = e.getSourceFile(T); + return (k === n || !k) && IJe( + t.fileName, + T, + m, + h, + c + ); + } + ); + if (o) { + const T = S ? o.getSourceFileInfo(n, c) : void 0; + return _?.setBlockedByPackageJsonDependencies(t.path, n.path, s, {}, T?.packageName, !T?.importable), !!T?.importable || S && !!T?.packageName && jae(t, T.packageName); + } + return S; + } + function jae(e, t) { + return e.imports && e.imports.some((n) => n.text === t || n.text.startsWith(t + "/")); + } + function IJe(e, t, n, i, s) { + const o = eg( + s, + t, + (_) => Zc(_) === "node_modules" ? _ : void 0 + ), c = o && Hn(n(o)); + return c === void 0 || Ui(n(e), c) || !!i && Ui(n(i), c); + } + function vq(e, t, n, i, s) { + var o, c; + const _ = mS(t), u = n.autoImportFileExcludePatterns && b2e(n, _); + S2e(e.getTypeChecker(), e.getSourceFiles(), u, t, (m, h) => s( + m, + h, + e, + /*isFromPackageJson*/ + !1 + )); + const g = i && ((o = t.getPackageJsonAutoImportProvider) == null ? void 0 : o.call(t)); + if (g) { + const m = ao(), h = e.getTypeChecker(); + S2e(g.getTypeChecker(), g.getSourceFiles(), u, t, (S, T) => { + (T && !e.getSourceFile(T.fileName) || !T && !h.resolveName( + S.name, + /*location*/ + void 0, + 1536, + /*excludeGlobals*/ + !1 + )) && s( + S, + T, + g, + /*isFromPackageJson*/ + !0 + ); + }), (c = t.log) == null || c.call(t, `forEachExternalModuleToImportFrom autoImportProvider: ${ao() - m}`); + } + } + function b2e(e, t) { + return Fi(e.autoImportFileExcludePatterns, (n) => { + const i = Q5(n, "", "exclude"); + return i ? b0(i, t) : void 0; + }); + } + function S2e(e, t, n, i, s) { + var o; + const c = n && T2e(n, i); + for (const _ of e.getAmbientModules()) + !_.name.includes("*") && !(n && ((o = _.declarations) != null && o.every((u) => c(u.getSourceFile())))) && s( + _, + /*sourceFile*/ + void 0 + ); + for (const _ of t) + tf(_) && !c?.(_) && s(e.getMergedSymbol(_.symbol), _); + } + function T2e(e, t) { + var n; + const i = (n = t.getSymlinkCache) == null ? void 0 : n.call(t).getSymlinkedDirectoriesByRealpath(); + return ({ fileName: s, path: o }) => { + if (e.some((c) => c.test(s))) return !0; + if (i?.size && Yy(s)) { + let c = Hn(s); + return eg( + t, + Hn(o), + (_) => { + const u = i.get(gl(_)); + if (u) + return u.some((g) => e.some((m) => m.test(s.replace(c, g)))); + c = Hn(c); + } + ) ?? !1; + } + return !1; + }; + } + function Bae(e, t) { + return t.autoImportFileExcludePatterns ? T2e(b2e(t, mS(e)), e) : () => !1; + } + function i8(e, t, n, i, s) { + var o, c, _, u, g; + const m = ao(); + (o = t.getPackageJsonAutoImportProvider) == null || o.call(t); + const h = ((c = t.getCachedExportInfoMap) == null ? void 0 : c.call(t)) || hq({ + getCurrentProgram: () => n, + getPackageJsonAutoImportProvider: () => { + var T; + return (T = t.getPackageJsonAutoImportProvider) == null ? void 0 : T.call(t); + }, + getGlobalTypingsCacheLocation: () => { + var T; + return (T = t.getGlobalTypingsCacheLocation) == null ? void 0 : T.call(t); + } + }); + if (h.isUsableByFile(e.path)) + return (_ = t.log) == null || _.call(t, "getExportInfoMap: cache hit"), h; + (u = t.log) == null || u.call(t, "getExportInfoMap: cache miss or empty; calculating new results"); + let S = 0; + try { + vq( + n, + t, + i, + /*useAutoImportProvider*/ + !0, + (T, k, D, P) => { + ++S % 100 === 0 && s?.throwIfCancellationRequested(); + const A = /* @__PURE__ */ new Set(), O = D.getTypeChecker(), F = Q9(T, O); + F && x2e(F.symbol, O) && h.add( + e.path, + F.symbol, + F.exportKind === 1 ? "default" : "export=", + T, + k, + F.exportKind, + P, + O + ), O.forEachExportAndPropertyOfModule(T, (R, B) => { + R !== F?.symbol && x2e(R, O) && Jp(A, B) && h.add( + e.path, + R, + B, + T, + k, + 0, + P, + O + ); + }); + } + ); + } catch (T) { + throw h.clear(), T; + } + return (g = t.log) == null || g.call(t, `getExportInfoMap: done in ${ao() - m} ms`), h; + } + function Q9(e, t) { + const n = t.resolveExternalModuleSymbol(e); + if (n !== e) { + const s = t.tryGetMemberInModuleExports("default", n); + return s ? { + symbol: s, + exportKind: 1 + /* Default */ + } : { + symbol: n, + exportKind: 2 + /* ExportEquals */ + }; + } + const i = t.tryGetMemberInModuleExports("default", e); + if (i) return { + symbol: i, + exportKind: 1 + /* Default */ + }; + } + function x2e(e, t) { + return !t.isUndefinedSymbol(e) && !t.isUnknownSymbol(e) && !QD(e) && !zK(e); + } + function FJe(e, t, n) { + let i; + return Y9(e, t, n, (s, o) => (i = o ? [s, o] : s, !0)), E.checkDefined(i); + } + function Y9(e, t, n, i) { + let s, o = e; + const c = /* @__PURE__ */ new Set(); + for (; o; ) { + const _ = pq(o); + if (_) { + const u = i(_); + if (u) return u; + } + if (o.escapedName !== "default" && o.escapedName !== "export=") { + const u = i(o.name); + if (u) return u; + } + if (s = Er(s, o), !Jp(c, o)) break; + o = o.flags & 2097152 ? t.getImmediateAliasedSymbol(o) : void 0; + } + for (const _ of s ?? Ge) + if (_.parent && lx(_.parent)) { + const u = i( + t8( + _.parent, + n, + /*forceCapitalize*/ + !1 + ), + t8( + _.parent, + n, + /*forceCapitalize*/ + !0 + ) + ); + if (u) return u; + } + } + function k2e() { + const e = Dg( + 99, + /*skipTrivia*/ + !1 + ); + function t(i, s, o) { + return RJe(n(i, s, o), i); + } + function n(i, s, o) { + let c = 0, _ = 0; + const u = [], { prefix: g, pushTemplate: m } = JJe(s); + i = g + i; + const h = g.length; + m && u.push( + 16 + /* TemplateHead */ + ), e.setText(i); + let S = 0; + const T = []; + let k = 0; + do { + c = e.scan(), XC(c) || (D(), _ = c); + const P = e.getTokenEnd(); + if (MJe(e.getTokenStart(), P, h, UJe(c), T), P >= i.length) { + const A = LJe(e, c, Do(u)); + A !== void 0 && (S = A); + } + } while (c !== 1); + function D() { + switch (c) { + case 44: + case 69: + !OJe[_] && e.reScanSlashToken() === 14 && (c = 14); + break; + case 30: + _ === 80 && k++; + break; + case 32: + k > 0 && k--; + break; + case 133: + case 154: + case 150: + case 136: + case 155: + k > 0 && !o && (c = 80); + break; + case 16: + u.push(c); + break; + case 19: + u.length > 0 && u.push(c); + break; + case 20: + if (u.length > 0) { + const P = Do(u); + P === 16 ? (c = e.reScanTemplateToken( + /*isTaggedTemplate*/ + !1 + ), c === 18 ? u.pop() : E.assertEqual(c, 17, "Should have been a template middle.")) : (E.assertEqual(P, 19, "Should have been an open brace"), u.pop()); + } + break; + default: + if (!k_(c)) + break; + (_ === 25 || k_(_) && k_(c) && !BJe(_, c)) && (c = 80); + } + } + return { endOfLineState: S, spans: T }; + } + return { getClassificationsForLine: t, getEncodedLexicalClassifications: n }; + } + var OJe = oQ( + [ + 80, + 11, + 9, + 10, + 14, + 110, + 46, + 47, + 22, + 24, + 20, + 112, + 97 + /* FalseKeyword */ + ], + (e) => e, + () => !0 + ); + function LJe(e, t, n) { + switch (t) { + case 11: { + if (!e.isUnterminated()) return; + const i = e.getTokenText(), s = i.length - 1; + let o = 0; + for (; i.charCodeAt(s - o) === 92; ) + o++; + return (o & 1) === 0 ? void 0 : i.charCodeAt(0) === 34 ? 3 : 2; + } + case 3: + return e.isUnterminated() ? 1 : void 0; + default: + if (ky(t)) { + if (!e.isUnterminated()) + return; + switch (t) { + case 18: + return 5; + case 15: + return 4; + default: + return E.fail("Only 'NoSubstitutionTemplateLiteral's and 'TemplateTail's can be unterminated; got SyntaxKind #" + t); + } + } + return n === 16 ? 6 : void 0; + } + } + function MJe(e, t, n, i, s) { + if (i === 8) + return; + e === 0 && n > 0 && (e += n); + const o = t - e; + o > 0 && s.push(e - n, o, i); + } + function RJe(e, t) { + const n = [], i = e.spans; + let s = 0; + for (let c = 0; c < i.length; c += 3) { + const _ = i[c], u = i[c + 1], g = i[c + 2]; + if (s >= 0) { + const m = _ - s; + m > 0 && n.push({ + length: m, + classification: 4 + /* Whitespace */ + }); + } + n.push({ length: u, classification: jJe(g) }), s = _ + u; + } + const o = t.length - s; + return o > 0 && n.push({ + length: o, + classification: 4 + /* Whitespace */ + }), { entries: n, finalLexState: e.endOfLineState }; + } + function jJe(e) { + switch (e) { + case 1: + return 3; + case 3: + return 1; + case 4: + return 6; + case 25: + return 7; + case 5: + return 2; + case 6: + return 8; + case 8: + return 4; + case 10: + return 0; + case 2: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 9: + case 17: + return 5; + default: + return; + } + } + function BJe(e, t) { + if (!LV(e)) + return !0; + switch (t) { + case 139: + case 153: + case 137: + case 126: + case 129: + return !0; + // Allow things like "public get", "public constructor" and "public static". + default: + return !1; + } + } + function JJe(e) { + switch (e) { + case 3: + return { prefix: `"\\ +` }; + case 2: + return { prefix: `'\\ +` }; + case 1: + return { prefix: `/* +` }; + case 4: + return { prefix: "`\n" }; + case 5: + return { prefix: `} +`, pushTemplate: !0 }; + case 6: + return { prefix: "", pushTemplate: !0 }; + case 0: + return { prefix: "" }; + default: + return E.assertNever(e); + } + } + function zJe(e) { + switch (e) { + case 42: + case 44: + case 45: + case 40: + case 41: + case 48: + case 49: + case 50: + case 30: + case 32: + case 33: + case 34: + case 104: + case 103: + case 130: + case 152: + case 35: + case 36: + case 37: + case 38: + case 51: + case 53: + case 52: + case 56: + case 57: + case 75: + case 74: + case 79: + case 71: + case 72: + case 73: + case 65: + case 66: + case 67: + case 69: + case 70: + case 64: + case 28: + case 61: + case 76: + case 77: + case 78: + return !0; + default: + return !1; + } + } + function WJe(e) { + switch (e) { + case 40: + case 41: + case 55: + case 54: + case 46: + case 47: + return !0; + default: + return !1; + } + } + function UJe(e) { + if (k_(e)) + return 3; + if (zJe(e) || WJe(e)) + return 5; + if (e >= 19 && e <= 79) + return 10; + switch (e) { + case 9: + return 4; + case 10: + return 25; + case 11: + return 6; + case 14: + return 7; + case 7: + case 3: + case 2: + return 1; + case 5: + case 4: + return 8; + case 80: + default: + return ky(e) ? 6 : 2; + } + } + function Jae(e, t, n, i, s) { + return D2e(bq(e, t, n, i, s)); + } + function C2e(e, t) { + switch (t) { + case 268: + case 264: + case 265: + case 263: + case 232: + case 219: + case 220: + e.throwIfCancellationRequested(); + } + } + function bq(e, t, n, i, s) { + const o = []; + return n.forEachChild(function _(u) { + if (!(!u || !e3(s, u.pos, u.getFullWidth()))) { + if (C2e(t, u.kind), Me(u) && !lc(u) && i.has(u.escapedText)) { + const g = e.getSymbolAtLocation(u), m = g && E2e(g, WS(u), e); + m && c(u.getStart(n), u.getEnd(), m); + } + u.forEachChild(_); + } + }), { + spans: o, + endOfLineState: 0 + /* None */ + }; + function c(_, u, g) { + const m = u - _; + E.assert(m > 0, `Classification had non-positive length of ${m}`), o.push(_), o.push(m), o.push(g); + } + } + function E2e(e, t, n) { + const i = e.getFlags(); + if ((i & 2885600) !== 0) + return i & 32 ? 11 : i & 384 ? 12 : i & 524288 ? 16 : i & 1536 ? t & 4 || t & 1 && VJe(e) ? 14 : void 0 : i & 2097152 ? E2e(n.getAliasedSymbol(e), t, n) : t & 2 ? i & 64 ? 13 : i & 262144 ? 15 : void 0 : void 0; + } + function VJe(e) { + return ot( + e.declarations, + (t) => jc(t) && Ah(t) === 1 + /* Instantiated */ + ); + } + function qJe(e) { + switch (e) { + case 1: + return "comment"; + case 2: + return "identifier"; + case 3: + return "keyword"; + case 4: + return "number"; + case 25: + return "bigint"; + case 5: + return "operator"; + case 6: + return "string"; + case 8: + return "whitespace"; + case 9: + return "text"; + case 10: + return "punctuation"; + case 11: + return "class name"; + case 12: + return "enum name"; + case 13: + return "interface name"; + case 14: + return "module name"; + case 15: + return "type parameter name"; + case 16: + return "type alias name"; + case 17: + return "parameter name"; + case 18: + return "doc comment tag name"; + case 19: + return "jsx open tag name"; + case 20: + return "jsx close tag name"; + case 21: + return "jsx self closing tag name"; + case 22: + return "jsx attribute"; + case 23: + return "jsx text"; + case 24: + return "jsx attribute string literal value"; + default: + return; + } + } + function D2e(e) { + E.assert(e.spans.length % 3 === 0); + const t = e.spans, n = []; + for (let i = 0; i < t.length; i += 3) + n.push({ + textSpan: Kl(t[i], t[i + 1]), + classificationType: qJe(t[i + 2]) + }); + return n; + } + function zae(e, t, n) { + return D2e(Sq(e, t, n)); + } + function Sq(e, t, n) { + const i = n.start, s = n.length, o = Dg( + 99, + /*skipTrivia*/ + !1, + t.languageVariant, + t.text + ), c = Dg( + 99, + /*skipTrivia*/ + !1, + t.languageVariant, + t.text + ), _ = []; + return R(t), { + spans: _, + endOfLineState: 0 + /* None */ + }; + function u(B, U, $) { + _.push(B), _.push(U), _.push($); + } + function g(B) { + for (o.resetTokenState(B.pos); ; ) { + const U = o.getTokenEnd(); + if (!zY(t.text, U)) + return U; + const $ = o.scan(), W = o.getTokenEnd(), _e = W - U; + if (!XC($)) + return U; + switch ($) { + case 4: + case 5: + continue; + case 2: + case 3: + m(B, $, U, _e), o.resetTokenState(W); + continue; + case 7: + const K = t.text, V = K.charCodeAt(U); + if (V === 60 || V === 62) { + u( + U, + _e, + 1 + /* comment */ + ); + continue; + } + E.assert( + V === 124 || V === 61 + /* equals */ + ), D(K, U, W); + break; + case 6: + break; + default: + E.assertNever($); + } + } + } + function m(B, U, $, W) { + if (U === 3) { + const _e = xre(t.text, $, W); + if (_e && _e.jsDoc) { + za(_e.jsDoc, B), S(_e.jsDoc); + return; + } + } else if (U === 2 && T($, W)) + return; + h($, W); + } + function h(B, U) { + u( + B, + U, + 1 + /* comment */ + ); + } + function S(B) { + var U, $, W, _e, K, V, ae, se; + let ce = B.pos; + if (B.tags) + for (const he of B.tags) { + he.pos !== ce && h(ce, he.pos - ce), u( + he.pos, + 1, + 10 + /* punctuation */ + ), u( + he.tagName.pos, + he.tagName.end - he.tagName.pos, + 18 + /* docCommentTagName */ + ), ce = he.tagName.end; + let q = he.tagName.end; + switch (he.kind) { + case 342: + const be = he; + fe(be), q = be.isNameFirst && ((U = be.typeExpression) == null ? void 0 : U.end) || be.name.end; + break; + case 349: + const je = he; + q = je.isNameFirst && (($ = je.typeExpression) == null ? void 0 : $.end) || je.name.end; + break; + case 346: + k(he), ce = he.end, q = he.typeParameters.end; + break; + case 347: + const me = he; + q = ((W = me.typeExpression) == null ? void 0 : W.kind) === 310 && ((_e = me.fullName) == null ? void 0 : _e.end) || ((K = me.typeExpression) == null ? void 0 : K.end) || q; + break; + case 339: + q = he.typeExpression.end; + break; + case 345: + R(he.typeExpression), ce = he.end, q = he.typeExpression.end; + break; + case 344: + case 341: + q = he.typeExpression.end; + break; + case 343: + R(he.typeExpression), ce = he.end, q = ((V = he.typeExpression) == null ? void 0 : V.end) || q; + break; + case 348: + q = ((ae = he.name) == null ? void 0 : ae.end) || q; + break; + case 329: + case 330: + q = he.class.end; + break; + case 350: + R(he.typeExpression), ce = he.end, q = ((se = he.typeExpression) == null ? void 0 : se.end) || q; + break; + } + typeof he.comment == "object" ? h(he.comment.pos, he.comment.end - he.comment.pos) : typeof he.comment == "string" && h(q, he.end - q); + } + ce !== B.end && h(ce, B.end - ce); + return; + function fe(he) { + he.isNameFirst && (h(ce, he.name.pos - ce), u( + he.name.pos, + he.name.end - he.name.pos, + 17 + /* parameterName */ + ), ce = he.name.end), he.typeExpression && (h(ce, he.typeExpression.pos - ce), R(he.typeExpression), ce = he.typeExpression.end), he.isNameFirst || (h(ce, he.name.pos - ce), u( + he.name.pos, + he.name.end - he.name.pos, + 17 + /* parameterName */ + ), ce = he.name.end); + } + } + function T(B, U) { + const $ = /^(\/\/\/\s*)(<)(?:(\S+)((?:[^/]|\/[^>])*)(\/>)?)?/m, W = /(\s)(\S+)(\s*)(=)(\s*)('[^']+'|"[^"]+")/g, _e = t.text.substr(B, U), K = $.exec(_e); + if (!K || !K[3] || !(K[3] in i7)) + return !1; + let V = B; + h(V, K[1].length), V += K[1].length, u( + V, + K[2].length, + 10 + /* punctuation */ + ), V += K[2].length, u( + V, + K[3].length, + 21 + /* jsxSelfClosingTagName */ + ), V += K[3].length; + const ae = K[4]; + let se = V; + for (; ; ) { + const fe = W.exec(ae); + if (!fe) + break; + const he = V + fe.index + fe[1].length; + he > se && (h(se, he - se), se = he), u( + se, + fe[2].length, + 22 + /* jsxAttribute */ + ), se += fe[2].length, fe[3].length && (h(se, fe[3].length), se += fe[3].length), u( + se, + fe[4].length, + 5 + /* operator */ + ), se += fe[4].length, fe[5].length && (h(se, fe[5].length), se += fe[5].length), u( + se, + fe[6].length, + 24 + /* jsxAttributeStringLiteralValue */ + ), se += fe[6].length; + } + V += K[4].length, V > se && h(se, V - se), K[5] && (u( + V, + K[5].length, + 10 + /* punctuation */ + ), V += K[5].length); + const ce = B + U; + return V < ce && h(V, ce - V), !0; + } + function k(B) { + for (const U of B.getChildren()) + R(U); + } + function D(B, U, $) { + let W; + for (W = U; W < $ && !Cu(B.charCodeAt(W)); W++) + ; + for (u( + U, + W - U, + 1 + /* comment */ + ), c.resetTokenState(W); c.getTokenEnd() < $; ) + P(); + } + function P() { + const B = c.getTokenEnd(), U = c.scan(), $ = c.getTokenEnd(), W = F(U); + W && u(B, $ - B, W); + } + function A(B) { + if (Od(B) || lc(B)) + return !0; + const U = O(B); + if (!ix(B) && B.kind !== 12 && U === void 0) + return !1; + const $ = B.kind === 12 ? B.pos : g(B), W = B.end - $; + if (E.assert(W >= 0), W > 0) { + const _e = U || F(B.kind, B); + _e && u($, W, _e); + } + return !0; + } + function O(B) { + switch (B.parent && B.parent.kind) { + case 287: + if (B.parent.tagName === B) + return 19; + break; + case 288: + if (B.parent.tagName === B) + return 20; + break; + case 286: + if (B.parent.tagName === B) + return 21; + break; + case 292: + if (B.parent.name === B) + return 22; + break; + } + } + function F(B, U) { + if (k_(B)) + return 3; + if ((B === 30 || B === 32) && U && lae(U.parent)) + return 10; + if (RB(B)) { + if (U) { + const $ = U.parent; + if (B === 64 && ($.kind === 261 || $.kind === 173 || $.kind === 170 || $.kind === 292) || $.kind === 227 || $.kind === 225 || $.kind === 226 || $.kind === 228) + return 5; + } + return 10; + } else { + if (B === 9) + return 4; + if (B === 10) + return 25; + if (B === 11) + return U && U.parent.kind === 292 ? 24 : 6; + if (B === 14) + return 6; + if (ky(B)) + return 6; + if (B === 12) + return 23; + if (B === 80) { + if (U) { + switch (U.parent.kind) { + case 264: + return U.parent.name === U ? 11 : void 0; + case 169: + return U.parent.name === U ? 15 : void 0; + case 265: + return U.parent.name === U ? 13 : void 0; + case 267: + return U.parent.name === U ? 12 : void 0; + case 268: + return U.parent.name === U ? 14 : void 0; + case 170: + return U.parent.name === U ? Ry(U) ? 3 : 17 : void 0; + } + if (nd(U.parent)) + return 3; + } + return 2; + } + } + } + function R(B) { + if (B && t3(i, s, B.pos, B.getFullWidth())) { + C2e(e, B.kind); + for (const U of B.getChildren(t)) + A(U) || R(U); + } + } + } + var Z9; + ((e) => { + function t(V, ae, se, ce, fe) { + const he = w_(se, ce); + if (he.parent && (Id(he.parent) && he.parent.tagName === he || Qb(he.parent))) { + const { openingElement: q, closingElement: be } = he.parent.parent, je = [q, be].map(({ tagName: me }) => n(me, se)); + return [{ fileName: se.fileName, highlightSpans: je }]; + } + return i(ce, he, V, ae, fe) || s(he, se); + } + e.getDocumentHighlights = t; + function n(V, ae) { + return { + fileName: ae.fileName, + textSpan: u_(V, ae), + kind: "none" + /* none */ + }; + } + function i(V, ae, se, ce, fe) { + const he = new Set(fe.map((me) => me.fileName)), q = ko.getReferenceEntriesForNode( + V, + ae, + se, + fe, + ce, + /*options*/ + void 0, + he + ); + if (!q) return; + const be = BP(q.map(ko.toHighlightSpan), (me) => me.fileName, (me) => me.span), je = Zl(se.useCaseSensitiveFileNames()); + return is(uy(be.entries(), ([me, Z]) => { + if (!he.has(me)) { + if (!se.redirectTargetsMap.has(oo(me, se.getCurrentDirectory(), je))) + return; + const pe = se.getSourceFile(me); + me = Nn(fe, (Fe) => !!Fe.redirectInfo && Fe.redirectInfo.redirectTarget === pe).fileName, E.assert(he.has(me)); + } + return { fileName: me, highlightSpans: Z }; + })); + } + function s(V, ae) { + const se = o(V, ae); + return se && [{ fileName: ae.fileName, highlightSpans: se }]; + } + function o(V, ae) { + switch (V.kind) { + case 101: + case 93: + return sv(V.parent) ? W(V.parent, ae) : void 0; + case 107: + return ce(V.parent, Cf, R); + case 111: + return ce(V.parent, vz, F); + case 113: + case 85: + case 98: + const he = V.kind === 85 ? V.parent.parent : V.parent; + return ce(he, wS, O); + case 109: + return ce(V.parent, F4, A); + case 84: + case 90: + return L4(V.parent) || y6(V.parent) ? ce(V.parent.parent.parent, F4, A) : void 0; + case 83: + case 88: + return ce(V.parent, xD, P); + case 99: + case 117: + case 92: + return ce(V.parent, (q) => wy( + q, + /*lookInLabeledStatements*/ + !0 + ), D); + case 137: + return se(nc, [ + 137 + /* ConstructorKeyword */ + ]); + case 139: + case 153: + return se(Dy, [ + 139, + 153 + /* SetKeyword */ + ]); + case 135: + return ce(V.parent, Hy, B); + case 134: + return fe(B(V)); + case 127: + return fe(U(V)); + case 103: + case 147: + return; + default: + return Ey(V.kind) && (Pl(V.parent) || Ic(V.parent)) ? fe(S(V.kind, V.parent)) : void 0; + } + function se(he, q) { + return ce(V.parent, he, (be) => { + var je; + return Fi((je = Bn(be, Ed)) == null ? void 0 : je.symbol.declarations, (me) => he(me) ? Nn(me.getChildren(ae), (Z) => ms(q, Z.kind)) : void 0); + }); + } + function ce(he, q, be) { + return q(he) ? fe(be(he, ae)) : void 0; + } + function fe(he) { + return he && he.map((q) => n(q, ae)); + } + } + function c(V) { + return vz(V) ? [V] : wS(V) ? Bi( + V.catchClause ? c(V.catchClause) : V.tryBlock && c(V.tryBlock), + V.finallyBlock && c(V.finallyBlock) + ) : Es(V) ? void 0 : g(V, c); + } + function _(V) { + let ae = V; + for (; ae.parent; ) { + const se = ae.parent; + if (Nb(se) || se.kind === 308) + return se; + if (wS(se) && se.tryBlock === ae && se.catchClause) + return ae; + ae = se; + } + } + function u(V) { + return xD(V) ? [V] : Es(V) ? void 0 : g(V, u); + } + function g(V, ae) { + const se = []; + return V.forEachChild((ce) => { + const fe = ae(ce); + fe !== void 0 && se.push(...QT(fe)); + }), se; + } + function m(V, ae) { + const se = h(ae); + return !!se && se === V; + } + function h(V) { + return dr(V, (ae) => { + switch (ae.kind) { + case 256: + if (V.kind === 252) + return !1; + // falls through + case 249: + case 250: + case 251: + case 248: + case 247: + return !V.label || K(ae, V.label.escapedText); + default: + return Es(ae) && "quit"; + } + }); + } + function S(V, ae) { + return Fi(T(ae, kx(V)), (se) => $6(se, V)); + } + function T(V, ae) { + const se = V.parent; + switch (se.kind) { + case 269: + case 308: + case 242: + case 297: + case 298: + return ae & 64 && tl(V) ? [...V.members, V] : se.statements; + case 177: + case 175: + case 263: + return [...se.parameters, ...$n(se.parent) ? se.parent.members : []]; + case 264: + case 232: + case 265: + case 188: + const ce = se.members; + if (ae & 15) { + const fe = Nn(se.members, nc); + if (fe) + return [...ce, ...fe.parameters]; + } else if (ae & 64) + return [...ce, se]; + return ce; + // Syntactically invalid positions that the parser might produce anyway + default: + return; + } + } + function k(V, ae, ...se) { + return ae && ms(se, ae.kind) ? (V.push(ae), !0) : !1; + } + function D(V) { + const ae = []; + if (k( + ae, + V.getFirstToken(), + 99, + 117, + 92 + /* DoKeyword */ + ) && V.kind === 247) { + const se = V.getChildren(); + for (let ce = se.length - 1; ce >= 0 && !k( + ae, + se[ce], + 117 + /* WhileKeyword */ + ); ce--) + ; + } + return lr(u(V.statement), (se) => { + m(V, se) && k( + ae, + se.getFirstToken(), + 83, + 88 + /* ContinueKeyword */ + ); + }), ae; + } + function P(V) { + const ae = h(V); + if (ae) + switch (ae.kind) { + case 249: + case 250: + case 251: + case 247: + case 248: + return D(ae); + case 256: + return A(ae); + } + } + function A(V) { + const ae = []; + return k( + ae, + V.getFirstToken(), + 109 + /* SwitchKeyword */ + ), lr(V.caseBlock.clauses, (se) => { + k( + ae, + se.getFirstToken(), + 84, + 90 + /* DefaultKeyword */ + ), lr(u(se), (ce) => { + m(V, ce) && k( + ae, + ce.getFirstToken(), + 83 + /* BreakKeyword */ + ); + }); + }), ae; + } + function O(V, ae) { + const se = []; + if (k( + se, + V.getFirstToken(), + 113 + /* TryKeyword */ + ), V.catchClause && k( + se, + V.catchClause.getFirstToken(), + 85 + /* CatchKeyword */ + ), V.finallyBlock) { + const ce = Ya(V, 98, ae); + k( + se, + ce, + 98 + /* FinallyKeyword */ + ); + } + return se; + } + function F(V, ae) { + const se = _(V); + if (!se) + return; + const ce = []; + return lr(c(se), (fe) => { + ce.push(Ya(fe, 111, ae)); + }), Nb(se) && Fy(se, (fe) => { + ce.push(Ya(fe, 107, ae)); + }), ce; + } + function R(V, ae) { + const se = Af(V); + if (!se) + return; + const ce = []; + return Fy(Us(se.body, Ns), (fe) => { + ce.push(Ya(fe, 107, ae)); + }), lr(c(se.body), (fe) => { + ce.push(Ya(fe, 111, ae)); + }), ce; + } + function B(V) { + const ae = Af(V); + if (!ae) + return; + const se = []; + return ae.modifiers && ae.modifiers.forEach((ce) => { + k( + se, + ce, + 134 + /* AsyncKeyword */ + ); + }), xs(ae, (ce) => { + $(ce, (fe) => { + Hy(fe) && k( + se, + fe.getFirstToken(), + 135 + /* AwaitKeyword */ + ); + }); + }), se; + } + function U(V) { + const ae = Af(V); + if (!ae) + return; + const se = []; + return xs(ae, (ce) => { + $(ce, (fe) => { + BN(fe) && k( + se, + fe.getFirstToken(), + 127 + /* YieldKeyword */ + ); + }); + }), se; + } + function $(V, ae) { + ae(V), !Es(V) && !$n(V) && !Vl(V) && !jc(V) && !Wp(V) && !li(V) && xs(V, (se) => $(se, ae)); + } + function W(V, ae) { + const se = _e(V, ae), ce = []; + for (let fe = 0; fe < se.length; fe++) { + if (se[fe].kind === 93 && fe < se.length - 1) { + const he = se[fe], q = se[fe + 1]; + let be = !0; + for (let je = q.getStart(ae) - 1; je >= he.end; je--) + if (!im(ae.text.charCodeAt(je))) { + be = !1; + break; + } + if (be) { + ce.push({ + fileName: ae.fileName, + textSpan: Nc(he.getStart(), q.end), + kind: "reference" + /* reference */ + }), fe++; + continue; + } + } + ce.push(n(se[fe], ae)); + } + return ce; + } + function _e(V, ae) { + const se = []; + for (; sv(V.parent) && V.parent.elseStatement === V; ) + V = V.parent; + for (; ; ) { + const ce = V.getChildren(ae); + k( + se, + ce[0], + 101 + /* IfKeyword */ + ); + for (let fe = ce.length - 1; fe >= 0 && !k( + se, + ce[fe], + 93 + /* ElseKeyword */ + ); fe--) + ; + if (!V.elseStatement || !sv(V.elseStatement)) + break; + V = V.elseStatement; + } + return se; + } + function K(V, ae) { + return !!dr(V.parent, (se) => Gy(se) ? se.label.escapedText === ae : "quit"); + } + })(Z9 || (Z9 = {})); + function s8(e) { + return !!e.sourceFile; + } + function Wae(e, t, n) { + return Tq(e, t, n); + } + function Tq(e, t = "", n, i) { + const s = /* @__PURE__ */ new Map(), o = Zl(!!e); + function c() { + const P = is(s.keys()).filter((A) => A && A.charAt(0) === "_").map((A) => { + const O = s.get(A), F = []; + return O.forEach((R, B) => { + s8(R) ? F.push({ + name: B, + scriptKind: R.sourceFile.scriptKind, + refCount: R.languageServiceRefCount + }) : R.forEach((U, $) => F.push({ name: B, scriptKind: $, refCount: U.languageServiceRefCount })); + }), F.sort((R, B) => B.refCount - R.refCount), { + bucket: A, + sourceFiles: F + }; + }); + return JSON.stringify(P, void 0, 2); + } + function _(P) { + return typeof P.getCompilationSettings == "function" ? P.getCompilationSettings() : P; + } + function u(P, A, O, F, R, B) { + const U = oo(P, t, o), $ = xq(_(A)); + return g(P, U, A, $, O, F, R, B); + } + function g(P, A, O, F, R, B, U, $) { + return T( + P, + A, + O, + F, + R, + B, + /*acquiring*/ + !0, + U, + $ + ); + } + function m(P, A, O, F, R, B) { + const U = oo(P, t, o), $ = xq(_(A)); + return h(P, U, A, $, O, F, R, B); + } + function h(P, A, O, F, R, B, U, $) { + return T( + P, + A, + _(O), + F, + R, + B, + /*acquiring*/ + !1, + U, + $ + ); + } + function S(P, A) { + const O = s8(P) ? P : P.get(E.checkDefined(A, "If there are more than one scriptKind's for same document the scriptKind should be provided")); + return E.assert(A === void 0 || !O || O.sourceFile.scriptKind === A, `Script kind should match provided ScriptKind:${A} and sourceFile.scriptKind: ${O?.sourceFile.scriptKind}, !entry: ${!O}`), O; + } + function T(P, A, O, F, R, B, U, $, W) { + var _e, K, V, ae; + $ = Z5(P, $); + const se = _(O), ce = O === se ? void 0 : O, fe = $ === 6 ? 100 : da(se), he = typeof W == "object" ? W : { + languageVersion: fe, + impliedNodeFormat: ce && DA(A, (ae = (V = (K = (_e = ce.getCompilerHost) == null ? void 0 : _e.call(ce)) == null ? void 0 : K.getModuleResolutionCache) == null ? void 0 : V.call(K)) == null ? void 0 : ae.getPackageJsonInfoCache(), ce, se), + setExternalModuleIndicator: pN(se), + jsDocParsingMode: n + }; + he.languageVersion = fe, E.assertEqual(n, he.jsDocParsingMode); + const q = s.size, be = Uae(F, he.impliedNodeFormat), je = eD(s, be, () => /* @__PURE__ */ new Map()); + if (on) { + s.size > q && on.instant(on.Phase.Session, "createdDocumentRegistryBucket", { configFilePath: se.configFilePath, key: be }); + const Te = !Il(A) && hl(s, (Fe, Ye) => Ye !== be && Fe.has(A) && Ye); + Te && on.instant(on.Phase.Session, "documentRegistryBucketOverlap", { path: A, key1: Te, key2: be }); + } + const me = je.get(A); + let Z = me && S(me, $); + if (!Z && i) { + const Te = i.getDocument(be, A); + Te && Te.scriptKind === $ && Te.text === fk(R) && (E.assert(U), Z = { + sourceFile: Te, + languageServiceRefCount: 0 + }, pe()); + } + if (Z) + Z.sourceFile.version !== B && (Z.sourceFile = rH(Z.sourceFile, R, B, R.getChangeRange(Z.sourceFile.scriptSnapshot)), i && i.setDocument(be, A, Z.sourceFile)), U && Z.languageServiceRefCount++; + else { + const Te = dL( + P, + R, + he, + B, + /*setNodeParents*/ + !1, + $ + ); + i && i.setDocument(be, A, Te), Z = { + sourceFile: Te, + languageServiceRefCount: 1 + }, pe(); + } + return E.assert(Z.languageServiceRefCount !== 0), Z.sourceFile; + function pe() { + if (!me) + je.set(A, Z); + else if (s8(me)) { + const Te = /* @__PURE__ */ new Map(); + Te.set(me.sourceFile.scriptKind, me), Te.set($, Z), je.set(A, Te); + } else + me.set($, Z); + } + } + function k(P, A, O, F) { + const R = oo(P, t, o), B = xq(A); + return D(R, B, O, F); + } + function D(P, A, O, F) { + const R = E.checkDefined(s.get(Uae(A, F))), B = R.get(P), U = S(B, O); + U.languageServiceRefCount--, E.assert(U.languageServiceRefCount >= 0), U.languageServiceRefCount === 0 && (s8(B) ? R.delete(P) : (B.delete(O), B.size === 1 && R.set(P, MP(B.values(), go)))); + } + return { + acquireDocument: u, + acquireDocumentWithKey: g, + updateDocument: m, + updateDocumentWithKey: h, + releaseDocument: k, + releaseDocumentWithKey: D, + getKeyForCompilationSettings: xq, + getDocumentRegistryBucketKeyWithMode: Uae, + reportStats: c, + getBuckets: () => s + }; + } + function xq(e) { + return pW(e, Qz); + } + function Uae(e, t) { + return t ? `${e}|${t}` : e; + } + function Vae(e, t, n, i, s, o, c) { + const _ = mS(i), u = Zl(_), g = kq(t, n, u, c), m = kq(n, t, u, c); + return cn.ChangeTracker.with({ host: i, formatContext: s, preferences: o }, (h) => { + GJe(e, h, g, t, n, i.getCurrentDirectory(), _), $Je(e, h, g, m, i, u); + }); + } + function kq(e, t, n, i) { + const s = n(e); + return (c) => { + const _ = i && i.tryGetSourcePosition({ fileName: c, pos: 0 }), u = o(_ ? _.fileName : c); + return _ ? u === void 0 ? void 0 : HJe(_.fileName, u, c, n) : u; + }; + function o(c) { + if (n(c) === s) return t; + const _ = DJ(c, s, n); + return _ === void 0 ? void 0 : t + "/" + _; + } + } + function HJe(e, t, n, i) { + const s = kC(e, t, i); + return qae(Hn(n), s); + } + function GJe(e, t, n, i, s, o, c) { + const { configFile: _ } = e.getCompilerOptions(); + if (!_) return; + const u = Hn(_.fileName), g = MD(_); + if (!g) return; + Hae(g, (T, k) => { + switch (k) { + case "files": + case "include": + case "exclude": { + if (m(T) || k !== "include" || !nu(T.initializer)) return; + const P = Fi(T.initializer.elements, (O) => ca(O) ? O.text : void 0); + if (P.length === 0) return; + const A = Y5( + u, + /*excludes*/ + [], + P, + c, + o + ); + b0(E.checkDefined(A.includeFilePattern), c).test(i) && !b0(E.checkDefined(A.includeFilePattern), c).test(s) && t.insertNodeAfter(_, pa(T.initializer.elements), N.createStringLiteral(S(s))); + return; + } + case "compilerOptions": + Hae(T.initializer, (D, P) => { + const A = Kz(P); + E.assert(A?.type !== "listOrElement"), A && (A.isFilePath || A.type === "list" && A.element.isFilePath) ? m(D) : P === "paths" && Hae(D.initializer, (O) => { + if (nu(O.initializer)) + for (const F of O.initializer.elements) + h(F); + }); + }); + return; + } + }); + function m(T) { + const k = nu(T.initializer) ? T.initializer.elements : [T.initializer]; + let D = !1; + for (const P of k) + D = h(P) || D; + return D; + } + function h(T) { + if (!ca(T)) return !1; + const k = qae(u, T.text), D = n(k); + return D !== void 0 ? (t.replaceRangeWithText(_, P2e(T, _), S(D)), !0) : !1; + } + function S(T) { + return Nf( + u, + T, + /*ignoreCase*/ + !c + ); + } + } + function $Je(e, t, n, i, s, o) { + const c = e.getSourceFiles(); + for (const _ of c) { + const u = n(_.fileName), g = u ?? _.fileName, m = Hn(g), h = i(_.fileName), S = h || _.fileName, T = Hn(S), k = u !== void 0 || h !== void 0; + YJe(_, t, (D) => { + if (!xf(D)) return; + const P = qae(T, D), A = n(P); + return A === void 0 ? void 0 : X2(Nf(m, A, o)); + }, (D) => { + const P = e.getTypeChecker().getSymbolAtLocation(D); + if (P?.declarations && P.declarations.some((O) => Vu(O))) return; + const A = h !== void 0 ? w2e(D, MS(D.text, S, e.getCompilerOptions(), s), n, c) : QJe(P, D, _, e, s, n); + return A !== void 0 && (A.updated || k && xf(D.text)) ? Ih.updateModuleSpecifier(e.getCompilerOptions(), _, g, A.newFileName, bv(e, s), D.text) : void 0; + }); + } + } + function XJe(e, t) { + return Hs(On(e, t)); + } + function qae(e, t) { + return X2(XJe(e, t)); + } + function QJe(e, t, n, i, s, o) { + if (e) { + const c = Nn(e.declarations, Di).fileName, _ = o(c); + return _ === void 0 ? { newFileName: c, updated: !1 } : { newFileName: _, updated: !0 }; + } else { + const c = i.getModeForUsageLocation(n, t), _ = s.resolveModuleNameLiterals || !s.resolveModuleNames ? i.getResolvedModuleFromModuleSpecifier(t, n) : s.getResolvedModuleWithFailedLookupLocationsFromCache && s.getResolvedModuleWithFailedLookupLocationsFromCache(t.text, n.fileName, c); + return w2e(t, _, o, i.getSourceFiles()); + } + } + function w2e(e, t, n, i) { + if (!t) return; + if (t.resolvedModule) { + const u = _(t.resolvedModule.resolvedFileName); + if (u) return u; + } + const s = lr(t.failedLookupLocations, o) || xf(e.text) && lr(t.failedLookupLocations, c); + if (s) return s; + return t.resolvedModule && { newFileName: t.resolvedModule.resolvedFileName, updated: !1 }; + function o(u) { + const g = n(u); + return g && Nn(i, (m) => m.fileName === g) ? c(u) : void 0; + } + function c(u) { + return wo(u, "/package.json") ? void 0 : _(u); + } + function _(u) { + const g = n(u); + return g && { newFileName: g, updated: !0 }; + } + } + function YJe(e, t, n, i) { + for (const s of e.referencedFiles || Ge) { + const o = n(s.fileName); + o !== void 0 && o !== e.text.slice(s.pos, s.end) && t.replaceRangeWithText(e, s, o); + } + for (const s of e.imports) { + const o = i(s); + o !== void 0 && o !== s.text && t.replaceRangeWithText(e, P2e(s, e), o); + } + } + function P2e(e, t) { + return cp(e.getStart(t) + 1, e.end - 1); + } + function Hae(e, t) { + if (_a(e)) + for (const n of e.properties) + rl(n) && ca(n.name) && t(n, n.name.text); + } + var Cq = /* @__PURE__ */ ((e) => (e[e.exact = 0] = "exact", e[e.prefix = 1] = "prefix", e[e.substring = 2] = "substring", e[e.camelCase = 3] = "camelCase", e))(Cq || {}); + function Dw(e, t) { + return { + kind: e, + isCaseSensitive: t + }; + } + function Gae(e) { + const t = /* @__PURE__ */ new Map(), n = e.trim().split(".").map((i) => tze(i.trim())); + if (n.length === 1 && n[0].totalTextChunk.text === "") + return { + getMatchForLastSegmentOfPattern: () => Dw( + 2, + /*isCaseSensitive*/ + !0 + ), + getFullMatch: () => Dw( + 2, + /*isCaseSensitive*/ + !0 + ), + patternContainsDots: !1 + }; + if (!n.some((i) => !i.subWordTextChunks.length)) + return { + getFullMatch: (i, s) => ZJe(i, s, n, t), + getMatchForLastSegmentOfPattern: (i) => $ae(i, pa(n), t), + patternContainsDots: n.length > 1 + }; + } + function ZJe(e, t, n, i) { + if (!$ae(t, pa(n), i) || n.length - 1 > e.length) + return; + let o; + for (let c = n.length - 2, _ = e.length - 1; c >= 0; c -= 1, _ -= 1) + o = I2e(o, $ae(e[_], n[c], i)); + return o; + } + function N2e(e, t) { + let n = t.get(e); + return n || t.set(e, n = eoe(e)), n; + } + function A2e(e, t, n) { + const i = rze(e, t.textLowerCase); + if (i === 0) + return Dw( + t.text.length === e.length ? 0 : 1, + /*isCaseSensitive:*/ + Ui(e, t.text) + ); + if (t.isLowerCase) { + if (i === -1) return; + const s = N2e(e, n); + for (const o of s) + if (Xae( + e, + o, + t.text, + /*ignoreCase*/ + !0 + )) + return Dw( + 2, + /*isCaseSensitive:*/ + Xae( + e, + o, + t.text, + /*ignoreCase*/ + !1 + ) + ); + if (t.text.length < e.length && eE(e.charCodeAt(i))) + return Dw( + 2, + /*isCaseSensitive*/ + !1 + ); + } else { + if (e.indexOf(t.text) > 0) + return Dw( + 2, + /*isCaseSensitive*/ + !0 + ); + if (t.characterSpans.length > 0) { + const s = N2e(e, n), o = F2e( + e, + s, + t, + /*ignoreCase*/ + !1 + ) ? !0 : F2e( + e, + s, + t, + /*ignoreCase*/ + !0 + ) ? !1 : void 0; + if (o !== void 0) + return Dw(3, o); + } + } + } + function $ae(e, t, n) { + if (Eq( + t.totalTextChunk.text, + (o) => o !== 32 && o !== 42 + /* asterisk */ + )) { + const o = A2e(e, t.totalTextChunk, n); + if (o) return o; + } + const i = t.subWordTextChunks; + let s; + for (const o of i) + s = I2e(s, A2e(e, o, n)); + return s; + } + function I2e(e, t) { + return JR([e, t], KJe); + } + function KJe(e, t) { + return e === void 0 ? 1 : t === void 0 ? -1 : ho(e.kind, t.kind) || j1(!e.isCaseSensitive, !t.isCaseSensitive); + } + function Xae(e, t, n, i, s = { start: 0, length: n.length }) { + return s.length <= t.length && R2e(0, s.length, (o) => eze(n.charCodeAt(s.start + o), e.charCodeAt(t.start + o), i)); + } + function eze(e, t, n) { + return n ? Qae(e) === Qae(t) : e === t; + } + function F2e(e, t, n, i) { + const s = n.characterSpans; + let o = 0, c = 0; + for (; ; ) { + if (c === s.length) + return !0; + if (o === t.length) + return !1; + let _ = t[o], u = !1; + for (; c < s.length; c++) { + const g = s[c]; + if (u && (!eE(n.text.charCodeAt(s[c - 1].start)) || !eE(n.text.charCodeAt(s[c].start))) || !Xae(e, _, n.text, i, g)) + break; + u = !0, _ = Kl(_.start + g.length, _.length - g.length); + } + o++; + } + } + function tze(e) { + return { + totalTextChunk: Zae(e), + subWordTextChunks: ize(e) + }; + } + function eE(e) { + if (e >= 65 && e <= 90) + return !0; + if (e < 127 || !p7( + e, + 99 + /* Latest */ + )) + return !1; + const t = String.fromCharCode(e); + return t === t.toUpperCase(); + } + function O2e(e) { + if (e >= 97 && e <= 122) + return !0; + if (e < 127 || !p7( + e, + 99 + /* Latest */ + )) + return !1; + const t = String.fromCharCode(e); + return t === t.toLowerCase(); + } + function rze(e, t) { + const n = e.length - t.length; + for (let i = 0; i <= n; i++) + if (Eq(t, (s, o) => Qae(e.charCodeAt(o + i)) === s)) + return i; + return -1; + } + function Qae(e) { + return e >= 65 && e <= 90 ? 97 + (e - 65) : e < 127 ? e : String.fromCharCode(e).toLowerCase().charCodeAt(0); + } + function Yae(e) { + return e >= 48 && e <= 57; + } + function nze(e) { + return eE(e) || O2e(e) || Yae(e) || e === 95 || e === 36; + } + function ize(e) { + const t = []; + let n = 0, i = 0; + for (let s = 0; s < e.length; s++) { + const o = e.charCodeAt(s); + nze(o) ? (i === 0 && (n = s), i++) : i > 0 && (t.push(Zae(e.substr(n, i))), i = 0); + } + return i > 0 && t.push(Zae(e.substr(n, i))), t; + } + function Zae(e) { + const t = e.toLowerCase(); + return { + text: e, + textLowerCase: t, + isLowerCase: e === t, + characterSpans: Kae(e) + }; + } + function Kae(e) { + return L2e( + e, + /*word*/ + !1 + ); + } + function eoe(e) { + return L2e( + e, + /*word*/ + !0 + ); + } + function L2e(e, t) { + const n = []; + let i = 0; + for (let s = 1; s < e.length; s++) { + const o = Yae(e.charCodeAt(s - 1)), c = Yae(e.charCodeAt(s)), _ = aze(e, t, s), u = t && sze(e, s, i); + (toe(e.charCodeAt(s - 1)) || toe(e.charCodeAt(s)) || o !== c || _ || u) && (M2e(e, i, s) || n.push(Kl(i, s - i)), i = s); + } + return M2e(e, i, e.length) || n.push(Kl(i, e.length - i)), n; + } + function toe(e) { + switch (e) { + case 33: + case 34: + case 35: + case 37: + case 38: + case 39: + case 40: + case 41: + case 42: + case 44: + case 45: + case 46: + case 47: + case 58: + case 59: + case 63: + case 64: + case 91: + case 92: + case 93: + case 95: + case 123: + case 125: + return !0; + } + return !1; + } + function M2e(e, t, n) { + return Eq(e, (i) => toe(i) && i !== 95, t, n); + } + function sze(e, t, n) { + return t !== n && t + 1 < e.length && eE(e.charCodeAt(t)) && O2e(e.charCodeAt(t + 1)) && Eq(e, eE, n, t); + } + function aze(e, t, n) { + const i = eE(e.charCodeAt(n - 1)); + return eE(e.charCodeAt(n)) && (!t || !i); + } + function R2e(e, t, n) { + for (let i = e; i < t; i++) + if (!n(i)) + return !1; + return !0; + } + function Eq(e, t, n = 0, i = e.length) { + return R2e(n, i, (s) => t(e.charCodeAt(s), s)); + } + function j2e(e, t = !0, n = !1) { + const i = { + // controls whether the token scanner considers unicode identifiers or not - shouldn't matter, since we're only using it for trivia + pragmas: void 0, + checkJsDirective: void 0, + referencedFiles: [], + typeReferenceDirectives: [], + libReferenceDirectives: [], + amdDependencies: [], + hasNoDefaultLib: void 0, + moduleName: void 0 + }, s = []; + let o, c, _, u = 0, g = !1; + function m() { + return c = _, _ = ql.scan(), _ === 19 ? u++ : _ === 20 && u--, _; + } + function h() { + const B = ql.getTokenValue(), U = ql.getTokenStart(); + return { fileName: B, pos: U, end: U + B.length }; + } + function S() { + o || (o = []), o.push({ ref: h(), depth: u }); + } + function T() { + s.push(h()), k(); + } + function k() { + u === 0 && (g = !0); + } + function D() { + let B = ql.getToken(); + return B === 138 ? (B = m(), B === 144 && (B = m(), B === 11 && S()), !0) : !1; + } + function P() { + if (c === 25) + return !1; + let B = ql.getToken(); + if (B === 102) { + if (B = m(), B === 21) { + if (B = m(), B === 11 || B === 15) + return T(), !0; + } else { + if (B === 11) + return T(), !0; + if (B === 156 && ql.lookAhead(() => { + const $ = ql.scan(); + return $ !== 161 && ($ === 42 || $ === 19 || $ === 80 || k_($)); + }) && (B = m()), B === 80 || k_(B)) + if (B = m(), B === 161) { + if (B = m(), B === 11) + return T(), !0; + } else if (B === 64) { + if (O( + /*skipCurrentToken*/ + !0 + )) + return !0; + } else if (B === 28) + B = m(); + else + return !0; + if (B === 19) { + for (B = m(); B !== 20 && B !== 1; ) + B = m(); + B === 20 && (B = m(), B === 161 && (B = m(), B === 11 && T())); + } else B === 42 && (B = m(), B === 130 && (B = m(), (B === 80 || k_(B)) && (B = m(), B === 161 && (B = m(), B === 11 && T())))); + } + return !0; + } + return !1; + } + function A() { + let B = ql.getToken(); + if (B === 95) { + if (k(), B = m(), B === 156 && ql.lookAhead(() => { + const $ = ql.scan(); + return $ === 42 || $ === 19; + }) && (B = m()), B === 19) { + for (B = m(); B !== 20 && B !== 1; ) + B = m(); + B === 20 && (B = m(), B === 161 && (B = m(), B === 11 && T())); + } else if (B === 42) + B = m(), B === 161 && (B = m(), B === 11 && T()); + else if (B === 102 && (B = m(), B === 156 && ql.lookAhead(() => { + const $ = ql.scan(); + return $ === 80 || k_($); + }) && (B = m()), (B === 80 || k_(B)) && (B = m(), B === 64 && O( + /*skipCurrentToken*/ + !0 + )))) + return !0; + return !0; + } + return !1; + } + function O(B, U = !1) { + let $ = B ? m() : ql.getToken(); + return $ === 149 ? ($ = m(), $ === 21 && ($ = m(), ($ === 11 || U && $ === 15) && T()), !0) : !1; + } + function F() { + let B = ql.getToken(); + if (B === 80 && ql.getTokenValue() === "define") { + if (B = m(), B !== 21) + return !0; + if (B = m(), B === 11 || B === 15) + if (B = m(), B === 28) + B = m(); + else + return !0; + if (B !== 23) + return !0; + for (B = m(); B !== 24 && B !== 1; ) + (B === 11 || B === 15) && T(), B = m(); + return !0; + } + return !1; + } + function R() { + for (ql.setText(e), m(); ql.getToken() !== 1; ) { + if (ql.getToken() === 16) { + const B = [ql.getToken()]; + e: + for (; wr(B); ) { + const U = ql.scan(); + switch (U) { + case 1: + break e; + case 102: + P(); + break; + case 16: + B.push(U); + break; + case 19: + wr(B) && B.push(U); + break; + case 20: + wr(B) && (Do(B) === 16 ? ql.reScanTemplateToken( + /*isTaggedTemplate*/ + !1 + ) === 18 && B.pop() : B.pop()); + break; + } + } + m(); + } + D() || P() || A() || n && (O( + /*skipCurrentToken*/ + !1, + /*allowTemplateLiterals*/ + !0 + ) || F()) || m(); + } + ql.setText(void 0); + } + if (t && R(), qz(i, e), Hz(i, Ha), g) { + if (o) + for (const B of o) + s.push(B.ref); + return { referencedFiles: i.referencedFiles, typeReferenceDirectives: i.typeReferenceDirectives, libReferenceDirectives: i.libReferenceDirectives, importedFiles: s, isLibFile: !!i.hasNoDefaultLib, ambientExternalModules: void 0 }; + } else { + let B; + if (o) + for (const U of o) + U.depth === 0 ? (B || (B = []), B.push(U.ref.fileName)) : s.push(U.ref); + return { referencedFiles: i.referencedFiles, typeReferenceDirectives: i.typeReferenceDirectives, libReferenceDirectives: i.libReferenceDirectives, importedFiles: s, isLibFile: !!i.hasNoDefaultLib, ambientExternalModules: B }; + } + } + var oze = /^data:(?:application\/json;charset=[uU][tT][fF]-8;base64,([A-Za-z0-9+/=]+)$)?/; + function roe(e) { + const t = Zl(e.useCaseSensitiveFileNames()), n = e.getCurrentDirectory(), i = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(); + return { + tryGetSourcePosition: _, + tryGetGeneratedPosition: u, + toLineColumnOffset: S, + clearCache: T, + documentPositionMappers: s + }; + function o(k) { + return oo(k, n, t); + } + function c(k, D) { + const P = o(k), A = s.get(P); + if (A) return A; + let O; + if (e.getDocumentPositionMapper) + O = e.getDocumentPositionMapper(k, D); + else if (e.readFile) { + const F = h(k); + O = F && Dq( + { getSourceFileLike: h, getCanonicalFileName: t, log: (R) => e.log(R) }, + k, + RW(F.text, kg(F)), + (R) => !e.fileExists || e.fileExists(R) ? e.readFile(R) : void 0 + ); + } + return s.set(P, O || BW), O || BW; + } + function _(k) { + if (!Il(k.fileName) || !g(k.fileName)) return; + const P = c(k.fileName).getSourcePosition(k); + return !P || P === k ? void 0 : _(P) || P; + } + function u(k) { + if (Il(k.fileName)) return; + const D = g(k.fileName); + if (!D) return; + const P = e.getProgram(); + if (P.isSourceOfProjectReferenceRedirect(D.fileName)) + return; + const O = P.getCompilerOptions().outFile, F = O ? Gu(O) + ".d.ts" : x5(k.fileName, P.getCompilerOptions(), P); + if (F === void 0) return; + const R = c(F, k.fileName).getGeneratedPosition(k); + return R === k ? void 0 : R; + } + function g(k) { + const D = e.getProgram(); + if (!D) return; + const P = o(k), A = D.getSourceFileByPath(P); + return A && A.resolvedPath === P ? A : void 0; + } + function m(k) { + const D = o(k), P = i.get(D); + if (P !== void 0) return P || void 0; + if (!e.readFile || e.fileExists && !e.fileExists(k)) { + i.set(D, !1); + return; + } + const A = e.readFile(k), O = A ? cze(A) : !1; + return i.set(D, O), O || void 0; + } + function h(k) { + return e.getSourceFileLike ? e.getSourceFileLike(k) : g(k) || m(k); + } + function S(k, D) { + return h(k).getLineAndCharacterOfPosition(D); + } + function T() { + i.clear(), s.clear(); + } + } + function Dq(e, t, n, i) { + let s = Nne(n); + if (s) { + const _ = oze.exec(s); + if (_) { + if (_[1]) { + const u = _[1]; + return B2e(e, uee(ml, u), t); + } + s = void 0; + } + } + const o = []; + s && o.push(s), o.push(t + ".map"); + const c = s && Qi(s, Hn(t)); + for (const _ of o) { + const u = Qi(_, Hn(t)), g = i(u, c); + if (gs(g)) + return B2e(e, g, u); + if (g !== void 0) + return g || void 0; + } + } + function B2e(e, t, n) { + const i = Ane(t); + if (!(!i || !i.sources || !i.file || !i.mappings) && !(i.sourcesContent && i.sourcesContent.some(gs))) + return Fne(e, i, n); + } + function cze(e, t) { + return { + text: e, + lineMap: t, + getLineAndCharacterOfPosition(n) { + return CC(kg(this), n); + } + }; + } + var noe = /* @__PURE__ */ new Map(); + function wq(e, t, n) { + var i; + t.getSemanticDiagnostics(e, n); + const s = [], o = t.getTypeChecker(); + !(t.getImpliedNodeFormatForEmit(e) === 1 || xc(e.fileName, [ + ".cts", + ".cjs" + /* Cjs */ + ])) && e.commonJsModuleIndicator && (dae(t) || WV(t.getCompilerOptions())) && lze(e) && s.push(sn(pze(e.commonJsModuleIndicator), p.File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module)); + const _ = n_(e); + if (noe.clear(), u(e), Ax(t.getCompilerOptions())) + for (const g of e.imports) { + const m = UD(g); + if (_l(m) && Gn( + m, + 32 + /* Export */ + )) continue; + const h = uze(m); + if (!h) continue; + const S = (i = t.getResolvedModuleFromModuleSpecifier(g, e)) == null ? void 0 : i.resolvedModule, T = S && t.getSourceFile(S.resolvedFileName); + T && T.externalModuleIndicator && T.externalModuleIndicator !== !0 && Mo(T.externalModuleIndicator) && T.externalModuleIndicator.isExportEquals && s.push(sn(h, p.Import_may_be_converted_to_a_default_import)); + } + return In(s, e.bindSuggestionDiagnostics), In(s, t.getSuggestionDiagnostics(e, n)), s.sort((g, m) => g.start - m.start), s; + function u(g) { + if (_) + mze(g, o) && s.push(sn(ei(g.parent) ? g.parent.name : g, p.This_constructor_function_may_be_converted_to_a_class_declaration)); + else { + if (Ic(g) && g.parent === e && g.declarationList.flags & 2 && g.declarationList.declarations.length === 1) { + const h = g.declarationList.declarations[0].initializer; + h && x_( + h, + /*requireStringLiteralLikeArgument*/ + !0 + ) && s.push(sn(h, p.require_call_may_be_converted_to_an_import)); + } + const m = Ou.getJSDocTypedefNodes(g); + for (const h of m) + s.push(sn(h, p.JSDoc_typedef_may_be_converted_to_TypeScript_type)); + Ou.parameterShouldGetTypeFromJSDoc(g) && s.push(sn(g.name || g, p.JSDoc_types_may_be_moved_to_TypeScript_types)); + } + Aq(g) && _ze(g, o, s), g.forEachChild(u); + } + } + function lze(e) { + return e.statements.some((t) => { + switch (t.kind) { + case 244: + return t.declarationList.declarations.some((n) => !!n.initializer && x_( + J2e(n.initializer), + /*requireStringLiteralLikeArgument*/ + !0 + )); + case 245: { + const { expression: n } = t; + if (!_n(n)) return x_( + n, + /*requireStringLiteralLikeArgument*/ + !0 + ); + const i = Ac(n); + return i === 1 || i === 2; + } + default: + return !1; + } + }); + } + function J2e(e) { + return wn(e) ? J2e(e.expression) : e; + } + function uze(e) { + switch (e.kind) { + case 273: + const { importClause: t, moduleSpecifier: n } = e; + return t && !t.name && t.namedBindings && t.namedBindings.kind === 275 && ca(n) ? t.namedBindings.name : void 0; + case 272: + return e.name; + default: + return; + } + } + function _ze(e, t, n) { + fze(e, t) && !noe.has(V2e(e)) && n.push(sn( + !e.name && ei(e.parent) && Me(e.parent.name) ? e.parent.name : e, + p.This_may_be_converted_to_an_async_function + )); + } + function fze(e, t) { + return !$D(e) && e.body && Ns(e.body) && dze(e.body, t) && Pq(e, t); + } + function Pq(e, t) { + const n = t.getSignatureFromDeclaration(e), i = n ? t.getReturnTypeOfSignature(n) : void 0; + return !!i && !!t.getPromisedTypeOfPromise(i); + } + function pze(e) { + return _n(e) ? e.left : e; + } + function dze(e, t) { + return !!Fy(e, (n) => K9(n, t)); + } + function K9(e, t) { + return Cf(e) && !!e.expression && Nq(e.expression, t); + } + function Nq(e, t) { + if (!z2e(e) || !W2e(e) || !e.arguments.every((i) => U2e(i, t))) + return !1; + let n = e.expression.expression; + for (; z2e(n) || wn(n); ) + if (Ps(n)) { + if (!W2e(n) || !n.arguments.every((i) => U2e(i, t))) + return !1; + n = n.expression.expression; + } else + n = n.expression; + return !0; + } + function z2e(e) { + return Ps(e) && (BA(e, "then") || BA(e, "catch") || BA(e, "finally")); + } + function W2e(e) { + const t = e.expression.name.text, n = t === "then" ? 2 : t === "catch" || t === "finally" ? 1 : 0; + return e.arguments.length > n ? !1 : e.arguments.length < n ? !0 : n === 1 || ot(e.arguments, (i) => i.kind === 106 || Me(i) && i.text === "undefined"); + } + function U2e(e, t) { + switch (e.kind) { + case 263: + case 219: + if (Mc(e) & 1) + return !1; + // falls through + case 220: + noe.set(V2e(e), !0); + // falls through + case 106: + return !0; + case 80: + case 212: { + const i = t.getSymbolAtLocation(e); + return i ? t.isUndefinedSymbol(i) || ot(eu(i, t).declarations, (s) => Es(s) || d0(s) && !!s.initializer && Es(s.initializer)) : !1; + } + default: + return !1; + } + } + function V2e(e) { + return `${e.pos.toString()}:${e.end.toString()}`; + } + function mze(e, t) { + var n, i, s, o; + if (yo(e)) { + if (ei(e.parent) && ((n = e.symbol.members) != null && n.size)) + return !0; + const c = t.getSymbolOfExpando( + e, + /*allowDeclaration*/ + !1 + ); + return !!(c && ((i = c.exports) != null && i.size || (s = c.members) != null && s.size)); + } + return Cc(e) ? !!((o = e.symbol.members) != null && o.size) : !1; + } + function Aq(e) { + switch (e.kind) { + case 263: + case 175: + case 219: + case 220: + return !0; + default: + return !1; + } + } + var gze = /* @__PURE__ */ new Set([ + "isolatedModules" + ]); + function ioe(e, t) { + return H2e( + e, + t, + /*declaration*/ + !1 + ); + } + function q2e(e, t) { + return H2e( + e, + t, + /*declaration*/ + !0 + ); + } + var hze = `/// +interface Boolean {} +interface Function {} +interface CallableFunction {} +interface NewableFunction {} +interface IArguments {} +interface Number {} +interface Object {} +interface RegExp {} +interface String {} +interface Array { length: number; [n: number]: T; } +interface SymbolConstructor { + (desc?: string | number): symbol; + for(name: string): symbol; + readonly toStringTag: symbol; +} +declare var Symbol: SymbolConstructor; +interface Symbol { + readonly [Symbol.toStringTag]: string; +}`, eL = "lib.d.ts", soe; + function H2e(e, t, n) { + soe ?? (soe = ek(eL, hze, { + languageVersion: 99 + /* Latest */ + })); + const i = [], s = t.compilerOptions ? Iq(t.compilerOptions, i) : {}, o = pL(); + for (const D in o) + eo(o, D) && s[D] === void 0 && (s[D] = o[D]); + for (const D of Ire) + s.verbatimModuleSyntax && gze.has(D.name) || (s[D.name] = D.transpileOptionValue); + s.suppressOutputPathCheck = !0, s.allowNonTsExtensions = !0, n ? (s.declaration = !0, s.emitDeclarationOnly = !0, s.isolatedDeclarations = !0) : (s.declaration = !1, s.declarationMap = !1); + const c = v0(s), _ = { + getSourceFile: (D) => D === Hs(u) ? g : D === Hs(eL) ? soe : void 0, + writeFile: (D, P) => { + Xo(D, ".map") ? (E.assertEqual(h, void 0, "Unexpected multiple source map outputs, file:", D), h = P) : (E.assertEqual(m, void 0, "Unexpected multiple outputs, file:", D), m = P); + }, + getDefaultLibFileName: () => eL, + useCaseSensitiveFileNames: () => !1, + getCanonicalFileName: (D) => D, + getCurrentDirectory: () => "", + getNewLine: () => c, + fileExists: (D) => D === u || !!n && D === eL, + readFile: () => "", + directoryExists: () => !0, + getDirectories: () => [] + }, u = t.fileName || (t.compilerOptions && t.compilerOptions.jsx ? "module.tsx" : "module.ts"), g = ek( + u, + e, + { + languageVersion: da(s), + impliedNodeFormat: DA( + oo(u, "", _.getCanonicalFileName), + /*packageJsonInfoCache*/ + void 0, + _, + s + ), + setExternalModuleIndicator: pN(s), + jsDocParsingMode: t.jsDocParsingMode ?? 0 + /* ParseAll */ + } + ); + t.moduleName && (g.moduleName = t.moduleName), t.renamedDependencies && (g.renamedDependencies = new Map(Object.entries(t.renamedDependencies))); + let m, h; + const T = wA(n ? [u, eL] : [u], s, _); + t.reportDiagnostics && (In( + /*to*/ + i, + /*from*/ + T.getSyntacticDiagnostics(g) + ), In( + /*to*/ + i, + /*from*/ + T.getOptionsDiagnostics() + )); + const k = T.emit( + /*targetSourceFile*/ + void 0, + /*writeFile*/ + void 0, + /*cancellationToken*/ + void 0, + /*emitOnlyDtsFiles*/ + n, + t.transformers, + /*forceDtsEmit*/ + n + ); + return In( + /*to*/ + i, + /*from*/ + k.diagnostics + ), m === void 0 ? E.fail("Output generation failed") : { outputText: m, diagnostics: i, sourceMapText: h }; + } + function G2e(e, t, n, i, s) { + const o = ioe(e, { compilerOptions: t, fileName: n, reportDiagnostics: !!i, moduleName: s }); + return In(i, o.diagnostics), o.outputText; + } + var aoe; + function Iq(e, t) { + aoe = aoe || kn(_d, (n) => typeof n.type == "object" && !hl(n.type, (i) => typeof i != "number")), e = MV(e); + for (const n of aoe) { + if (!eo(e, n.name)) + continue; + const i = e[n.name]; + gs(i) ? e[n.name] = QF(n, i, t) : hl(n.type, (s) => s === i) || t.push(Ore(n)); + } + return e; + } + var ooe = {}; + Na(ooe, { + getNavigateToItems: () => $2e + }); + function $2e(e, t, n, i, s, o, c) { + const _ = Gae(i); + if (!_) return Ge; + const u = [], g = e.length === 1 ? e[0] : void 0; + for (const m of e) + n.throwIfCancellationRequested(), !(o && m.isDeclarationFile) && (X2e(m, !!c, g) || m.getNamedDeclarations().forEach((h, S) => { + yze(_, S, h, t, m.fileName, !!c, g, u); + })); + return u.sort(Tze), (s === void 0 ? u : u.slice(0, s)).map(xze); + } + function X2e(e, t, n) { + return e !== n && t && (e8(e.path) || e.hasNoDefaultLib); + } + function yze(e, t, n, i, s, o, c, _) { + const u = e.getMatchForLastSegmentOfPattern(t); + if (u) { + for (const g of n) + if (vze(g, i, o, c)) + if (e.patternContainsDots) { + const m = e.getFullMatch(Sze(g), t); + m && _.push({ name: t, fileName: s, matchKind: m.kind, isCaseSensitive: m.isCaseSensitive, declaration: g }); + } else + _.push({ name: t, fileName: s, matchKind: u.kind, isCaseSensitive: u.isCaseSensitive, declaration: g }); + } + } + function vze(e, t, n, i) { + var s; + switch (e.kind) { + case 274: + case 277: + case 272: + const o = t.getSymbolAtLocation(e.name), c = t.getAliasedSymbol(o); + return o.escapedName !== c.escapedName && !((s = c.declarations) != null && s.every((_) => X2e(_.getSourceFile(), n, i))); + default: + return !0; + } + } + function bze(e, t) { + const n = _s(e); + return !!n && (Q2e(n, t) || n.kind === 168 && coe(n.expression, t)); + } + function coe(e, t) { + return Q2e(e, t) || wn(e) && (t.push(e.name.text), !0) && coe(e.expression, t); + } + function Q2e(e, t) { + return um(e) && (t.push(op(e)), !0); + } + function Sze(e) { + const t = [], n = _s(e); + if (n && n.kind === 168 && !coe(n.expression, t)) + return Ge; + t.shift(); + let i = US(e); + for (; i; ) { + if (!bze(i, t)) + return Ge; + i = US(i); + } + return t.reverse(), t; + } + function Tze(e, t) { + return ho(e.matchKind, t.matchKind) || WP(e.name, t.name); + } + function xze(e) { + const t = e.declaration, n = US(t), i = n && _s(n); + return { + name: e.name, + kind: o2(t), + kindModifiers: hw(t), + matchKind: Cq[e.matchKind], + isCaseSensitive: e.isCaseSensitive, + fileName: e.fileName, + textSpan: u_(t), + // TODO(jfreeman): What should be the containerName when the container has a computed name? + containerName: i ? i.text : "", + containerKind: i ? o2(n) : "" + /* unknown */ + }; + } + var loe = {}; + Na(loe, { + getNavigationBarItems: () => Z2e, + getNavigationTree: () => K2e + }); + var kze = /\s+/g, uoe = 150, Fq, a8, tL = [], I0, Y2e = [], tE, _oe = []; + function Z2e(e, t) { + Fq = t, a8 = e; + try { + return hr(Pze(rSe(e)), Nze); + } finally { + eSe(); + } + } + function K2e(e, t) { + Fq = t, a8 = e; + try { + return _Se(rSe(e)); + } finally { + eSe(); + } + } + function eSe() { + a8 = void 0, Fq = void 0, tL = [], I0 = void 0, _oe = []; + } + function rL(e) { + return ww(e.getText(a8)); + } + function Oq(e) { + return e.node.kind; + } + function tSe(e, t) { + e.children ? e.children.push(t) : e.children = [t]; + } + function rSe(e) { + E.assert(!tL.length); + const t = { node: e, name: void 0, additionalNodes: void 0, parent: void 0, children: void 0, indent: 0 }; + I0 = t; + for (const n of e.statements) + mk(n); + return Sv(), E.assert(!I0 && !tL.length), t; + } + function u2(e, t) { + tSe(I0, foe(e, t)); + } + function foe(e, t) { + return { + node: e, + name: t || (Pl(e) || ut(e) ? _s(e) : void 0), + additionalNodes: void 0, + parent: I0, + children: void 0, + indent: I0.indent + 1 + }; + } + function nSe(e) { + tE || (tE = /* @__PURE__ */ new Map()), tE.set(e, !0); + } + function iSe(e) { + for (let t = 0; t < e; t++) Sv(); + } + function sSe(e, t) { + const n = []; + for (; !um(t); ) { + const i = J3(t), s = Sh(t); + t = t.expression, !(s === "prototype" || Ai(i)) && n.push(i); + } + n.push(t); + for (let i = n.length - 1; i > 0; i--) { + const s = n[i]; + _2(e, s); + } + return [n.length - 1, n[0]]; + } + function _2(e, t) { + const n = foe(e, t); + tSe(I0, n), tL.push(I0), Y2e.push(tE), tE = void 0, I0 = n; + } + function Sv() { + I0.children && (Lq(I0.children, I0), moe(I0.children)), I0 = tL.pop(), tE = Y2e.pop(); + } + function Tv(e, t, n) { + _2(e, n), mk(t), Sv(); + } + function aSe(e) { + e.initializer && Ize(e.initializer) ? (_2(e), xs(e.initializer, mk), Sv()) : Tv(e, e.initializer); + } + function poe(e) { + const t = _s(e); + if (t === void 0) return !1; + if (Gs(t)) { + const n = t.expression; + return to(n) || E_(n) || If(n); + } + return !!t; + } + function mk(e) { + if (Fq.throwIfCancellationRequested(), !(!e || ix(e))) + switch (e.kind) { + case 177: + const t = e; + Tv(t, t.body); + for (const c of t.parameters) + K_(c, t) && u2(c); + break; + case 175: + case 178: + case 179: + case 174: + poe(e) && Tv(e, e.body); + break; + case 173: + poe(e) && aSe(e); + break; + case 172: + poe(e) && u2(e); + break; + case 274: + const n = e; + n.name && u2(n.name); + const { namedBindings: i } = n; + if (i) + if (i.kind === 275) + u2(i); + else + for (const c of i.elements) + u2(c); + break; + case 305: + Tv(e, e.name); + break; + case 306: + const { expression: s } = e; + Me(s) ? u2(e, s) : u2(e); + break; + case 209: + case 304: + case 261: { + const c = e; + ws(c.name) ? mk(c.name) : aSe(c); + break; + } + case 263: + const o = e.name; + o && Me(o) && nSe(o.text), Tv(e, e.body); + break; + case 220: + case 219: + Tv(e, e.body); + break; + case 267: + _2(e); + for (const c of e.members) + Aze(c) || u2(c); + Sv(); + break; + case 264: + case 232: + case 265: + _2(e); + for (const c of e.members) + mk(c); + Sv(); + break; + case 268: + Tv(e, pSe(e).body); + break; + case 278: { + const c = e.expression, _ = _a(c) || Ps(c) ? c : xo(c) || yo(c) ? c.body : void 0; + _ ? (_2(e), mk(_), Sv()) : u2(e); + break; + } + case 282: + case 272: + case 182: + case 180: + case 181: + case 266: + u2(e); + break; + case 214: + case 227: { + const c = Ac(e); + switch (c) { + case 1: + case 2: + Tv(e, e.right); + return; + case 6: + case 3: { + const _ = e, u = _.left, g = c === 3 ? u.expression : u; + let m = 0, h; + Me(g.expression) ? (nSe(g.expression.text), h = g.expression) : [m, h] = sSe(_, g.expression), c === 6 ? _a(_.right) && _.right.properties.length > 0 && (_2(_, h), xs(_.right, mk), Sv()) : yo(_.right) || xo(_.right) ? Tv(e, _.right, h) : (_2(_, h), Tv(e, _.right, u.name), Sv()), iSe(m); + return; + } + case 7: + case 9: { + const _ = e, u = c === 7 ? _.arguments[0] : _.arguments[0].expression, g = _.arguments[1], [m, h] = sSe(e, u); + _2(e, h), _2(e, ct(N.createIdentifier(g.text), g)), mk(e.arguments[2]), Sv(), Sv(), iSe(m); + return; + } + case 5: { + const _ = e, u = _.left, g = u.expression; + if (Me(g) && Sh(u) !== "prototype" && tE && tE.has(g.text)) { + yo(_.right) || xo(_.right) ? Tv(e, _.right, g) : Ib(u) && (_2(_, g), Tv(_.left, _.right, J3(u)), Sv()); + return; + } + break; + } + case 4: + case 0: + case 8: + break; + default: + E.assertNever(c); + } + } + // falls through + default: + kf(e) && lr(e.jsDoc, (c) => { + lr(c.tags, (_) => { + jp(_) && u2(_); + }); + }), xs(e, mk); + } + } + function Lq(e, t) { + const n = /* @__PURE__ */ new Map(); + kR(e, (i, s) => { + const o = i.name || _s(i.node), c = o && rL(o); + if (!c) + return !0; + const _ = n.get(c); + if (!_) + return n.set(c, i), !0; + if (_ instanceof Array) { + for (const u of _) + if (oSe(u, i, s, t)) + return !1; + return _.push(i), !0; + } else { + const u = _; + return oSe(u, i, s, t) ? !1 : (n.set(c, [u, i]), !0); + } + }); + } + var o8 = { + 5: !0, + 3: !0, + 7: !0, + 9: !0, + 0: !1, + 1: !1, + 2: !1, + 8: !1, + 6: !0, + 4: !1 + }; + function Cze(e, t, n, i) { + function s(_) { + return yo(_) || Cc(_) || ei(_); + } + const o = _n(t.node) || Ps(t.node) ? Ac(t.node) : 0, c = _n(e.node) || Ps(e.node) ? Ac(e.node) : 0; + if (o8[o] && o8[c] || s(e.node) && o8[o] || s(t.node) && o8[c] || tl(e.node) && doe(e.node) && o8[o] || tl(t.node) && o8[c] || tl(e.node) && doe(e.node) && s(t.node) || tl(t.node) && s(e.node) && doe(e.node)) { + let _ = e.additionalNodes && Do(e.additionalNodes) || e.node; + if (!tl(e.node) && !tl(t.node) || s(e.node) || s(t.node)) { + const g = s(e.node) ? e.node : s(t.node) ? t.node : void 0; + if (g !== void 0) { + const m = ct( + N.createConstructorDeclaration( + /*modifiers*/ + void 0, + [], + /*body*/ + void 0 + ), + g + ), h = foe(m); + h.indent = e.indent + 1, h.children = e.node === g ? e.children : t.children, e.children = e.node === g ? Bi([h], t.children || [t]) : Bi(e.children || [{ ...e }], [h]); + } else + (e.children || t.children) && (e.children = Bi(e.children || [{ ...e }], t.children || [t]), e.children && (Lq(e.children, e), moe(e.children))); + _ = e.node = ct( + N.createClassDeclaration( + /*modifiers*/ + void 0, + e.name || N.createIdentifier("__class__"), + /*typeParameters*/ + void 0, + /*heritageClauses*/ + void 0, + [] + ), + e.node + ); + } else + e.children = Bi(e.children, t.children), e.children && Lq(e.children, e); + const u = t.node; + return i.children[n - 1].node.end === _.end ? ct(_, { pos: _.pos, end: u.end }) : (e.additionalNodes || (e.additionalNodes = []), e.additionalNodes.push(ct( + N.createClassDeclaration( + /*modifiers*/ + void 0, + e.name || N.createIdentifier("__class__"), + /*typeParameters*/ + void 0, + /*heritageClauses*/ + void 0, + [] + ), + t.node + ))), !0; + } + return o !== 0; + } + function oSe(e, t, n, i) { + return Cze(e, t, n, i) ? !0 : Eze(e.node, t.node, i) ? (Dze(e, t), !0) : !1; + } + function Eze(e, t, n) { + if (e.kind !== t.kind || e.parent !== t.parent && !(cSe(e, n) && cSe(t, n))) + return !1; + switch (e.kind) { + case 173: + case 175: + case 178: + case 179: + return Js(e) === Js(t); + case 268: + return lSe(e, t) && yoe(e) === yoe(t); + default: + return !0; + } + } + function doe(e) { + return !!(e.flags & 16); + } + function cSe(e, t) { + if (e.parent === void 0) return !1; + const n = vm(e.parent) ? e.parent.parent : e.parent; + return n === t.node || ms(t.additionalNodes, n); + } + function lSe(e, t) { + return !e.body || !t.body ? e.body === t.body : e.body.kind === t.body.kind && (e.body.kind !== 268 || lSe(e.body, t.body)); + } + function Dze(e, t) { + e.additionalNodes = e.additionalNodes || [], e.additionalNodes.push(t.node), t.additionalNodes && e.additionalNodes.push(...t.additionalNodes), e.children = Bi(e.children, t.children), e.children && (Lq(e.children, e), moe(e.children)); + } + function moe(e) { + e.sort(wze); + } + function wze(e, t) { + return WP(uSe(e.node), uSe(t.node)) || ho(Oq(e), Oq(t)); + } + function uSe(e) { + if (e.kind === 268) + return fSe(e); + const t = _s(e); + if (t && qc(t)) { + const n = dS(t); + return n && Si(n); + } + switch (e.kind) { + case 219: + case 220: + case 232: + return mSe(e); + default: + return; + } + } + function goe(e, t) { + if (e.kind === 268) + return ww(fSe(e)); + if (t) { + const n = Me(t) ? t.text : uo(t) ? `[${rL(t.argumentExpression)}]` : rL(t); + if (n.length > 0) + return ww(n); + } + switch (e.kind) { + case 308: + const n = e; + return fl(n) ? `"${Ym(Zc(Gu(Hs(n.fileName))))}"` : ""; + case 278: + return Mo(e) && e.isExportEquals ? "export=" : "default"; + case 220: + case 263: + case 219: + case 264: + case 232: + return h0(e) & 2048 ? "default" : mSe(e); + case 177: + return "constructor"; + case 181: + return "new()"; + case 180: + return "()"; + case 182: + return "[]"; + default: + return ""; + } + } + function Pze(e) { + const t = []; + function n(s) { + if (i(s) && (t.push(s), s.children)) + for (const o of s.children) + n(o); + } + return n(e), t; + function i(s) { + if (s.children) + return !0; + switch (Oq(s)) { + case 264: + case 232: + case 267: + case 265: + case 268: + case 308: + case 266: + case 347: + case 339: + return !0; + case 220: + case 263: + case 219: + return o(s); + default: + return !1; + } + function o(c) { + if (!c.node.body) + return !1; + switch (Oq(c.parent)) { + case 269: + case 308: + case 175: + case 177: + return !0; + default: + return !1; + } + } + } + } + function _Se(e) { + return { + text: goe(e.node, e.name), + kind: o2(e.node), + kindModifiers: dSe(e.node), + spans: hoe(e), + nameSpan: e.name && voe(e.name), + childItems: hr(e.children, _Se) + }; + } + function Nze(e) { + return { + text: goe(e.node, e.name), + kind: o2(e.node), + kindModifiers: dSe(e.node), + spans: hoe(e), + childItems: hr(e.children, t) || _oe, + indent: e.indent, + bolded: !1, + grayed: !1 + }; + function t(n) { + return { + text: goe(n.node, n.name), + kind: o2(n.node), + kindModifiers: hw(n.node), + spans: hoe(n), + childItems: _oe, + indent: 0, + bolded: !1, + grayed: !1 + }; + } + } + function hoe(e) { + const t = [voe(e.node)]; + if (e.additionalNodes) + for (const n of e.additionalNodes) + t.push(voe(n)); + return t; + } + function fSe(e) { + return Vu(e) ? Qo(e.name) : yoe(e); + } + function yoe(e) { + const t = [op(e.name)]; + for (; e.body && e.body.kind === 268; ) + e = e.body, t.push(op(e.name)); + return t.join("."); + } + function pSe(e) { + return e.body && jc(e.body) ? pSe(e.body) : e; + } + function Aze(e) { + return !e.name || e.name.kind === 168; + } + function voe(e) { + return e.kind === 308 ? A0(e) : u_(e, a8); + } + function dSe(e) { + return e.parent && e.parent.kind === 261 && (e = e.parent), hw(e); + } + function mSe(e) { + const { parent: t } = e; + if (e.name && h3(e.name) > 0) + return ww(co(e.name)); + if (ei(t)) + return ww(co(t.name)); + if (_n(t) && t.operatorToken.kind === 64) + return rL(t.left).replace(kze, ""); + if (rl(t)) + return rL(t.name); + if (h0(e) & 2048) + return "default"; + if ($n(e)) + return ""; + if (Ps(t)) { + let n = gSe(t.expression); + if (n !== void 0) { + if (n = ww(n), n.length > uoe) + return `${n} callback`; + const i = ww(Fi(t.arguments, (s) => ja(s) || ox(s) ? s.getText(a8) : void 0).join(", ")); + return `${n}(${i}) callback`; + } + } + return ""; + } + function gSe(e) { + if (Me(e)) + return e.text; + if (wn(e)) { + const t = gSe(e.expression), n = e.name.text; + return t === void 0 ? n : `${t}.${n}`; + } else + return; + } + function Ize(e) { + switch (e.kind) { + case 220: + case 219: + case 232: + return !0; + default: + return !1; + } + } + function ww(e) { + return e = e.length > uoe ? e.substring(0, uoe) + "..." : e, e.replace(/\\?(?:\r?\n|[\r\u2028\u2029])/g, ""); + } + var gk = {}; + Na(gk, { + addExportsInOldFile: () => Noe, + addImportsForMovedSymbols: () => Aoe, + addNewFileToTsconfig: () => Poe, + addOrRemoveBracesToArrowFunction: () => DWe, + addTargetFileImports: () => Joe, + containsJsx: () => Ooe, + convertArrowFunctionOrFunctionExpression: () => IWe, + convertParamsToDestructuredObject: () => UWe, + convertStringOrTemplateLiteral: () => oUe, + convertToOptionalChainExpression: () => hUe, + createNewFileName: () => Foe, + doChangeNamedToNamespaceOrDefault: () => TSe, + extractSymbol: () => dTe, + generateGetAccessorAndSetAccessor: () => eVe, + getApplicableRefactors: () => Fze, + getEditsForRefactor: () => Oze, + getExistingLocals: () => joe, + getIdentifierForNode: () => Boe, + getNewStatementsAndRemoveFromOldFile: () => woe, + getStatementsToMove: () => c8, + getUsageInfo: () => nL, + inferFunctionReturnType: () => tVe, + isInImport: () => Vq, + isRefactorErrorInfo: () => Oh, + refactorKindBeginsWith: () => xv, + registerRefactor: () => Hg + }); + var boe = /* @__PURE__ */ new Map(); + function Hg(e, t) { + boe.set(e, t); + } + function Fze(e, t) { + return is(CR(boe.values(), (n) => { + var i; + return e.cancellationToken && e.cancellationToken.isCancellationRequested() || !((i = n.kinds) != null && i.some((s) => xv(s, e.kind))) ? void 0 : n.getAvailableActions(e, t); + })); + } + function Oze(e, t, n, i) { + const s = boe.get(t); + return s && s.getEditsForAction(e, n, i); + } + var Soe = "Convert export", Mq = { + name: "Convert default export to named export", + description: Ss(p.Convert_default_export_to_named_export), + kind: "refactor.rewrite.export.named" + }, Rq = { + name: "Convert named export to default export", + description: Ss(p.Convert_named_export_to_default_export), + kind: "refactor.rewrite.export.default" + }; + Hg(Soe, { + kinds: [ + Mq.kind, + Rq.kind + ], + getAvailableActions: function(t) { + const n = hSe(t, t.triggerReason === "invoked"); + if (!n) return Ge; + if (!Oh(n)) { + const i = n.wasDefault ? Mq : Rq; + return [{ name: Soe, description: i.description, actions: [i] }]; + } + return t.preferences.provideRefactorNotApplicableReason ? [ + { + name: Soe, + description: Ss(p.Convert_default_export_to_named_export), + actions: [ + { ...Mq, notApplicableReason: n.error }, + { ...Rq, notApplicableReason: n.error } + ] + } + ] : Ge; + }, + getEditsForAction: function(t, n) { + E.assert(n === Mq.name || n === Rq.name, "Unexpected action name"); + const i = hSe(t); + return E.assert(i && !Oh(i), "Expected applicable refactor info"), { edits: cn.ChangeTracker.with(t, (o) => Lze(t.file, t.program, i, o, t.cancellationToken)), renameFilename: void 0, renameLocation: void 0 }; + } + }); + function hSe(e, t = !0) { + const { file: n, program: i } = e, s = pk(e), o = vi(n, s.start), c = o.parent && h0(o.parent) & 32 && t ? o.parent : XA(o, n, s); + if (!c || !Di(c.parent) && !(vm(c.parent) && Vu(c.parent.parent))) + return { error: Ss(p.Could_not_find_export_statement) }; + const _ = i.getTypeChecker(), u = Jze(c.parent, _), g = h0(c) || (Mo(c) && !c.isExportEquals ? 2080 : 0), m = !!(g & 2048); + if (!(g & 32) || !m && u.exports.has( + "default" + /* Default */ + )) + return { error: Ss(p.This_file_already_has_a_default_export) }; + const h = (S) => Me(S) && _.getSymbolAtLocation(S) ? void 0 : { error: Ss(p.Can_only_convert_named_export) }; + switch (c.kind) { + case 263: + case 264: + case 265: + case 267: + case 266: + case 268: { + const S = c; + return S.name ? h(S.name) || { exportNode: S, exportName: S.name, wasDefault: m, exportingModuleSymbol: u } : void 0; + } + case 244: { + const S = c; + if (!(S.declarationList.flags & 2) || S.declarationList.declarations.length !== 1) + return; + const T = Ca(S.declarationList.declarations); + return T.initializer ? (E.assert(!m, "Can't have a default flag here"), h(T.name) || { exportNode: S, exportName: T.name, wasDefault: m, exportingModuleSymbol: u }) : void 0; + } + case 278: { + const S = c; + return S.isExportEquals ? void 0 : h(S.expression) || { exportNode: S, exportName: S.expression, wasDefault: m, exportingModuleSymbol: u }; + } + default: + return; + } + } + function Lze(e, t, n, i, s) { + Mze(e, n, i, t.getTypeChecker()), Rze(t, n, i, s); + } + function Mze(e, { wasDefault: t, exportNode: n, exportName: i }, s, o) { + if (t) + if (Mo(n) && !n.isExportEquals) { + const c = n.expression, _ = ySe(c.text, c.text); + s.replaceNode(e, n, N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createNamedExports([_]) + )); + } else + s.delete(e, E.checkDefined($6( + n, + 90 + /* DefaultKeyword */ + ), "Should find a default keyword in modifier list")); + else { + const c = E.checkDefined($6( + n, + 95 + /* ExportKeyword */ + ), "Should find an export keyword in modifier list"); + switch (n.kind) { + case 263: + case 264: + case 265: + s.insertNodeAfter(e, c, N.createToken( + 90 + /* DefaultKeyword */ + )); + break; + case 244: + const _ = Ca(n.declarationList.declarations); + if (!ko.Core.isSymbolReferencedInFile(i, o, e) && !_.type) { + s.replaceNode(e, n, N.createExportDefault(E.checkDefined(_.initializer, "Initializer was previously known to be present"))); + break; + } + // falls through + case 267: + case 266: + case 268: + s.deleteModifier(e, c), s.insertNodeAfter(e, n, N.createExportDefault(N.createIdentifier(i.text))); + break; + default: + E.fail(`Unexpected exportNode kind ${n.kind}`); + } + } + } + function Rze(e, { wasDefault: t, exportName: n, exportingModuleSymbol: i }, s, o) { + const c = e.getTypeChecker(), _ = E.checkDefined(c.getSymbolAtLocation(n), "Export name should resolve to a symbol"); + ko.Core.eachExportReference(e.getSourceFiles(), c, o, _, i, n.text, t, (u) => { + if (n === u) return; + const g = u.getSourceFile(); + t ? jze(g, u, s, n.text) : Bze(g, u, s); + }); + } + function jze(e, t, n, i) { + const { parent: s } = t; + switch (s.kind) { + case 212: + n.replaceNode(e, t, N.createIdentifier(i)); + break; + case 277: + case 282: { + const c = s; + n.replaceNode(e, c, Toe(i, c.name.text)); + break; + } + case 274: { + const c = s; + E.assert(c.name === t, "Import clause name should match provided ref"); + const _ = Toe(i, t.text), { namedBindings: u } = c; + if (!u) + n.replaceNode(e, t, N.createNamedImports([_])); + else if (u.kind === 275) { + n.deleteRange(e, { pos: t.getStart(e), end: u.getStart(e) }); + const g = ca(c.parent.moduleSpecifier) ? VV(c.parent.moduleSpecifier, e) : 1, m = r1( + /*defaultImport*/ + void 0, + [Toe(i, t.text)], + c.parent.moduleSpecifier, + g + ); + n.insertNodeAfter(e, c.parent, m); + } else + n.delete(e, t), n.insertNodeAtEndOfList(e, u.elements, _); + break; + } + case 206: + const o = s; + n.replaceNode(e, s, N.createImportTypeNode(o.argument, o.attributes, N.createIdentifier(i), o.typeArguments, o.isTypeOf)); + break; + default: + E.failBadSyntaxKind(s); + } + } + function Bze(e, t, n) { + const i = t.parent; + switch (i.kind) { + case 212: + n.replaceNode(e, t, N.createIdentifier("default")); + break; + case 277: { + const s = N.createIdentifier(i.name.text); + i.parent.elements.length === 1 ? n.replaceNode(e, i.parent, s) : (n.delete(e, i), n.insertNodeBefore(e, i.parent, s)); + break; + } + case 282: { + n.replaceNode(e, i, ySe("default", i.name.text)); + break; + } + default: + E.assertNever(i, `Unexpected parent kind ${i.kind}`); + } + } + function Toe(e, t) { + return N.createImportSpecifier( + /*isTypeOnly*/ + !1, + e === t ? void 0 : N.createIdentifier(e), + N.createIdentifier(t) + ); + } + function ySe(e, t) { + return N.createExportSpecifier( + /*isTypeOnly*/ + !1, + e === t ? void 0 : N.createIdentifier(e), + N.createIdentifier(t) + ); + } + function Jze(e, t) { + if (Di(e)) + return e.symbol; + const n = e.parent.symbol; + return n.valueDeclaration && Pb(n.valueDeclaration) ? t.getMergedSymbol(n) : n; + } + var xoe = "Convert import", jq = { + 0: { + name: "Convert namespace import to named imports", + description: Ss(p.Convert_namespace_import_to_named_imports), + kind: "refactor.rewrite.import.named" + }, + 2: { + name: "Convert named imports to namespace import", + description: Ss(p.Convert_named_imports_to_namespace_import), + kind: "refactor.rewrite.import.namespace" + }, + 1: { + name: "Convert named imports to default import", + description: Ss(p.Convert_named_imports_to_default_import), + kind: "refactor.rewrite.import.default" + } + }; + Hg(xoe, { + kinds: XT(jq).map((e) => e.kind), + getAvailableActions: function(t) { + const n = vSe(t, t.triggerReason === "invoked"); + if (!n) return Ge; + if (!Oh(n)) { + const i = jq[n.convertTo]; + return [{ name: xoe, description: i.description, actions: [i] }]; + } + return t.preferences.provideRefactorNotApplicableReason ? XT(jq).map((i) => ({ + name: xoe, + description: i.description, + actions: [{ ...i, notApplicableReason: n.error }] + })) : Ge; + }, + getEditsForAction: function(t, n) { + E.assert(ot(XT(jq), (o) => o.name === n), "Unexpected action name"); + const i = vSe(t); + return E.assert(i && !Oh(i), "Expected applicable refactor info"), { edits: cn.ChangeTracker.with(t, (o) => zze(t.file, t.program, o, i)), renameFilename: void 0, renameLocation: void 0 }; + } + }); + function vSe(e, t = !0) { + const { file: n } = e, i = pk(e), s = vi(n, i.start), o = t ? dr(s, Q_(qo, xm)) : XA(s, n, i); + if (o === void 0 || !(qo(o) || xm(o))) return { error: "Selection is not an import declaration." }; + const c = i.start + i.length, _ = c2(o, o.parent, n); + if (_ && c > _.getStart()) return; + const { importClause: u } = o; + return u ? u.namedBindings ? u.namedBindings.kind === 275 ? { convertTo: 0, import: u.namedBindings } : bSe(e.program, u) ? { convertTo: 1, import: u.namedBindings } : { convertTo: 2, import: u.namedBindings } : { error: Ss(p.Could_not_find_namespace_import_or_named_imports) } : { error: Ss(p.Could_not_find_import_clause) }; + } + function bSe(e, t) { + return Ax(e.getCompilerOptions()) && Vze(t.parent.moduleSpecifier, e.getTypeChecker()); + } + function zze(e, t, n, i) { + const s = t.getTypeChecker(); + i.convertTo === 0 ? Wze(e, s, n, i.import, Ax(t.getCompilerOptions())) : TSe( + e, + t, + n, + i.import, + i.convertTo === 1 + /* Default */ + ); + } + function Wze(e, t, n, i, s) { + let o = !1; + const c = [], _ = /* @__PURE__ */ new Map(); + ko.Core.eachSymbolReferenceInFile(i.name, t, e, (h) => { + if (!f3(h.parent)) + o = !0; + else { + const S = SSe(h.parent).text; + t.resolveName( + S, + h, + -1, + /*excludeGlobals*/ + !0 + ) && _.set(S, !0), E.assert(Uze(h.parent) === h, "Parent expression should match id"), c.push(h.parent); + } + }); + const u = /* @__PURE__ */ new Map(); + for (const h of c) { + const S = SSe(h).text; + let T = u.get(S); + T === void 0 && u.set(S, T = _.has(S) ? qS(S, e) : S), n.replaceNode(e, h, N.createIdentifier(T)); + } + const g = []; + u.forEach((h, S) => { + g.push(N.createImportSpecifier( + /*isTypeOnly*/ + !1, + h === S ? void 0 : N.createIdentifier(S), + N.createIdentifier(h) + )); + }); + const m = i.parent.parent; + if (o && !s && qo(m)) + n.insertNodeAfter(e, m, xSe( + m, + /*defaultImportName*/ + void 0, + g + )); + else { + const h = o ? N.createIdentifier(i.name.text) : void 0; + n.replaceNode(e, i.parent, kSe(h, g)); + } + } + function SSe(e) { + return wn(e) ? e.name : e.right; + } + function Uze(e) { + return wn(e) ? e.expression : e.left; + } + function TSe(e, t, n, i, s = bSe(t, i.parent)) { + const o = t.getTypeChecker(), c = i.parent.parent, { moduleSpecifier: _ } = c, u = /* @__PURE__ */ new Set(); + i.elements.forEach((k) => { + const D = o.getSymbolAtLocation(k.name); + D && u.add(D); + }); + const g = _ && ca(_) ? r8( + _.text, + 99 + /* ESNext */ + ) : "module"; + function m(k) { + return !!ko.Core.eachSymbolReferenceInFile(k.name, o, e, (D) => { + const P = o.resolveName( + g, + D, + -1, + /*excludeGlobals*/ + !0 + ); + return P ? u.has(P) ? Nu(D.parent) : !0 : !1; + }); + } + const S = i.elements.some(m) ? qS(g, e) : g, T = /* @__PURE__ */ new Set(); + for (const k of i.elements) { + const D = k.propertyName || k.name; + ko.Core.eachSymbolReferenceInFile(k.name, o, e, (P) => { + const A = D.kind === 11 ? N.createElementAccessExpression(N.createIdentifier(S), N.cloneNode(D)) : N.createPropertyAccessExpression(N.createIdentifier(S), N.cloneNode(D)); + gu(P.parent) ? n.replaceNode(e, P.parent, N.createPropertyAssignment(P.text, A)) : Nu(P.parent) ? T.add(k) : n.replaceNode(e, P, A); + }); + } + if (n.replaceNode( + e, + i, + s ? N.createIdentifier(S) : N.createNamespaceImport(N.createIdentifier(S)) + ), T.size && qo(c)) { + const k = is(T.values(), (D) => N.createImportSpecifier(D.isTypeOnly, D.propertyName && N.cloneNode(D.propertyName), N.cloneNode(D.name))); + n.insertNodeAfter(e, i.parent.parent, xSe( + c, + /*defaultImportName*/ + void 0, + k + )); + } + } + function Vze(e, t) { + const n = t.resolveExternalModuleName(e); + if (!n) return !1; + const i = t.resolveExternalModuleSymbol(n); + return n !== i; + } + function xSe(e, t, n) { + return N.createImportDeclaration( + /*modifiers*/ + void 0, + kSe(t, n), + e.moduleSpecifier, + /*attributes*/ + void 0 + ); + } + function kSe(e, t) { + return N.createImportClause( + /*phaseModifier*/ + void 0, + e, + t && t.length ? N.createNamedImports(t) : void 0 + ); + } + var koe = "Extract type", Bq = { + name: "Extract to type alias", + description: Ss(p.Extract_to_type_alias), + kind: "refactor.extract.type" + }, Jq = { + name: "Extract to interface", + description: Ss(p.Extract_to_interface), + kind: "refactor.extract.interface" + }, zq = { + name: "Extract to typedef", + description: Ss(p.Extract_to_typedef), + kind: "refactor.extract.typedef" + }; + Hg(koe, { + kinds: [ + Bq.kind, + Jq.kind, + zq.kind + ], + getAvailableActions: function(t) { + const { info: n, affectedTextRange: i } = CSe(t, t.triggerReason === "invoked"); + return n ? Oh(n) ? t.preferences.provideRefactorNotApplicableReason ? [{ + name: koe, + description: Ss(p.Extract_type), + actions: [ + { ...zq, notApplicableReason: n.error }, + { ...Bq, notApplicableReason: n.error }, + { ...Jq, notApplicableReason: n.error } + ] + }] : Ge : [{ + name: koe, + description: Ss(p.Extract_type), + actions: n.isJS ? [zq] : Er([Bq], n.typeElements && Jq) + }].map((o) => ({ + ...o, + actions: o.actions.map((c) => ({ + ...c, + range: i ? { + start: { line: js(t.file, i.pos).line, offset: js(t.file, i.pos).character }, + end: { line: js(t.file, i.end).line, offset: js(t.file, i.end).character } + } : void 0 + })) + })) : Ge; + }, + getEditsForAction: function(t, n) { + const { file: i } = t, { info: s } = CSe(t); + E.assert(s && !Oh(s), "Expected to find a range to extract"); + const o = qS("NewType", i), c = cn.ChangeTracker.with(t, (g) => { + switch (n) { + case Bq.name: + return E.assert(!s.isJS, "Invalid actionName/JS combo"), Gze(g, i, o, s); + case zq.name: + return E.assert(s.isJS, "Invalid actionName/JS combo"), Xze(g, t, i, o, s); + case Jq.name: + return E.assert(!s.isJS && !!s.typeElements, "Invalid actionName/JS combo"), $ze(g, i, o, s); + default: + E.fail("Unexpected action name"); + } + }), _ = i.fileName, u = YA( + c, + _, + o, + /*preferLastLocation*/ + !1 + ); + return { edits: c, renameFilename: _, renameLocation: u }; + } + }); + function CSe(e, t = !0) { + const { file: n, startPosition: i } = e, s = n_(n), o = D9(pk(e)), c = o.pos === o.end && t, _ = qze(n, i, o, c); + if (!_ || !li(_)) return { info: { error: Ss(p.Selection_is_not_a_valid_type_node) }, affectedTextRange: void 0 }; + const u = e.program.getTypeChecker(), g = Qze(_, s); + if (g === void 0) return { info: { error: Ss(p.No_type_could_be_extracted_from_this_type_node) }, affectedTextRange: void 0 }; + const m = Yze(_, g); + if (!li(m)) return { info: { error: Ss(p.Selection_is_not_a_valid_type_node) }, affectedTextRange: void 0 }; + const h = []; + (C0(m.parent) || Hx(m.parent)) && o.end > _.end && In( + h, + m.parent.types.filter((P) => y9(P, n, o.pos, o.end)) + ); + const S = h.length > 1 ? h : m, { typeParameters: T, affectedTextRange: k } = Hze(u, S, g, n); + if (!T) return { info: { error: Ss(p.No_type_could_be_extracted_from_this_type_node) }, affectedTextRange: void 0 }; + const D = Wq(u, S); + return { info: { isJS: s, selection: S, enclosingNode: g, typeParameters: T, typeElements: D }, affectedTextRange: k }; + } + function qze(e, t, n, i) { + const s = [ + () => vi(e, t), + () => H6(e, t, () => !0) + ]; + for (const o of s) { + const c = o(), _ = y9(c, e, n.pos, n.end), u = dr(c, (g) => g.parent && li(g) && !f2(n, g.parent, e) && (i || _)); + if (u) + return u; + } + } + function Wq(e, t) { + if (t) { + if (as(t)) { + const n = []; + for (const i of t) { + const s = Wq(e, i); + if (!s) return; + In(n, s); + } + return n; + } + if (Hx(t)) { + const n = [], i = /* @__PURE__ */ new Set(); + for (const s of t.types) { + const o = Wq(e, s); + if (!o || !o.every((c) => c.name && Jp(i, GA(c.name)))) + return; + In(n, o); + } + return n; + } else { + if (kS(t)) + return Wq(e, t.type); + if (a_(t)) + return t.members; + } + } + } + function f2(e, t, n) { + return WA(e, oa(n.text, t.pos), t.end); + } + function Hze(e, t, n, i) { + const s = [], o = QT(t), c = { pos: o[0].getStart(i), end: o[o.length - 1].end }; + for (const u of o) + if (_(u)) return { typeParameters: void 0, affectedTextRange: void 0 }; + return { typeParameters: s, affectedTextRange: c }; + function _(u) { + if (of(u)) { + if (Me(u.typeName)) { + const g = u.typeName, m = e.resolveName( + g.text, + g, + 262144, + /*excludeGlobals*/ + !0 + ); + for (const h of m?.declarations || Ge) + if (Lo(h) && h.getSourceFile() === i) { + if (h.name.escapedText === g.escapedText && f2(h, c, i)) + return !0; + if (f2(n, h, i) && !f2(c, h, i)) { + tp(s, h); + break; + } + } + } + } else if (xS(u)) { + const g = dr(u, (m) => Gb(m) && f2(m.extendsType, u, i)); + if (!g || !f2(c, g, i)) + return !0; + } else if (Vx(u) || A4(u)) { + const g = dr(u.parent, Es); + if (g && g.type && f2(g.type, u, i) && !f2(c, g, i)) + return !0; + } else if (Hb(u)) { + if (Me(u.exprName)) { + const g = e.resolveName( + u.exprName.text, + u.exprName, + 111551, + /*excludeGlobals*/ + !1 + ); + if (g?.valueDeclaration && f2(n, g.valueDeclaration, i) && !f2(c, g.valueDeclaration, i)) + return !0; + } else if (Ry(u.exprName.left) && !f2(c, u.parent, i)) + return !0; + } + return i && qx(u) && js(i, u.pos).line === js(i, u.end).line && un( + u, + 1 + /* SingleLine */ + ), xs(u, _); + } + } + function Gze(e, t, n, i) { + const { enclosingNode: s, typeParameters: o } = i, { firstTypeNode: c, lastTypeNode: _, newTypeNode: u } = Coe(i), g = N.createTypeAliasDeclaration( + /*modifiers*/ + void 0, + n, + o.map((m) => N.updateTypeParameterDeclaration( + m, + m.modifiers, + m.name, + m.constraint, + /*defaultType*/ + void 0 + )), + u + ); + e.insertNodeBefore( + t, + s, + cz(g), + /*blankLineBetween*/ + !0 + ), e.replaceNodeRange(t, c, _, N.createTypeReferenceNode(n, o.map((m) => N.createTypeReferenceNode( + m.name, + /*typeArguments*/ + void 0 + ))), { leadingTriviaOption: cn.LeadingTriviaOption.Exclude, trailingTriviaOption: cn.TrailingTriviaOption.ExcludeWhitespace }); + } + function $ze(e, t, n, i) { + var s; + const { enclosingNode: o, typeParameters: c, typeElements: _ } = i, u = N.createInterfaceDeclaration( + /*modifiers*/ + void 0, + n, + c, + /*heritageClauses*/ + void 0, + _ + ); + ct(u, (s = _[0]) == null ? void 0 : s.parent), e.insertNodeBefore( + t, + o, + cz(u), + /*blankLineBetween*/ + !0 + ); + const { firstTypeNode: g, lastTypeNode: m } = Coe(i); + e.replaceNodeRange(t, g, m, N.createTypeReferenceNode(n, c.map((h) => N.createTypeReferenceNode( + h.name, + /*typeArguments*/ + void 0 + ))), { leadingTriviaOption: cn.LeadingTriviaOption.Exclude, trailingTriviaOption: cn.TrailingTriviaOption.ExcludeWhitespace }); + } + function Xze(e, t, n, i, s) { + var o; + QT(s.selection).forEach((k) => { + un( + k, + 7168 + /* NoNestedComments */ + ); + }); + const { enclosingNode: c, typeParameters: _ } = s, { firstTypeNode: u, lastTypeNode: g, newTypeNode: m } = Coe(s), h = N.createJSDocTypedefTag( + N.createIdentifier("typedef"), + N.createJSDocTypeExpression(m), + N.createIdentifier(i) + ), S = []; + lr(_, (k) => { + const D = PC(k), P = N.createTypeParameterDeclaration( + /*modifiers*/ + void 0, + k.name + ), A = N.createJSDocTemplateTag( + N.createIdentifier("template"), + D && Us(D, lv), + [P] + ); + S.push(A); + }); + const T = N.createJSDocComment( + /*comment*/ + void 0, + N.createNodeArray(Bi(S, [h])) + ); + if (Od(c)) { + const k = c.getStart(n), D = Fh(t.host, (o = t.formatContext) == null ? void 0 : o.options); + e.insertNodeAt(n, c.getStart(n), T, { + suffix: D + D + n.text.slice(L9(n.text, k - 1), k) + }); + } else + e.insertNodeBefore( + n, + c, + T, + /*blankLineBetween*/ + !0 + ); + e.replaceNodeRange(n, u, g, N.createTypeReferenceNode(i, _.map((k) => N.createTypeReferenceNode( + k.name, + /*typeArguments*/ + void 0 + )))); + } + function Coe(e) { + return as(e.selection) ? { + firstTypeNode: e.selection[0], + lastTypeNode: e.selection[e.selection.length - 1], + newTypeNode: C0(e.selection[0].parent) ? N.createUnionTypeNode(e.selection) : N.createIntersectionTypeNode(e.selection) + } : { + firstTypeNode: e.selection, + lastTypeNode: e.selection, + newTypeNode: e.selection + }; + } + function Qze(e, t) { + return dr(e, Ti) || (t ? dr(e, Od) : void 0); + } + function Yze(e, t) { + return dr(e, (n) => n === t ? "quit" : !!(C0(n.parent) || Hx(n.parent))) ?? e; + } + var Uq = "Move to file", Eoe = Ss(p.Move_to_file), Doe = { + name: "Move to file", + description: Eoe, + kind: "refactor.move.file" + }; + Hg(Uq, { + kinds: [Doe.kind], + getAvailableActions: function(t, n) { + const i = t.file, s = c8(t); + if (!n) + return Ge; + if (t.triggerReason === "implicit" && t.endPosition !== void 0) { + const o = dr(vi(i, t.startPosition), dk), c = dr(vi(i, t.endPosition), dk); + if (o && !Di(o) && c && !Di(c)) + return Ge; + } + if (t.preferences.allowTextChangesInNewFiles && s) { + const o = { + start: { line: js(i, s.all[0].getStart(i)).line, offset: js(i, s.all[0].getStart(i)).character }, + end: { line: js(i, pa(s.all).end).line, offset: js(i, pa(s.all).end).character } + }; + return [{ name: Uq, description: Eoe, actions: [{ ...Doe, range: o }] }]; + } + return t.preferences.provideRefactorNotApplicableReason ? [{ name: Uq, description: Eoe, actions: [{ ...Doe, notApplicableReason: Ss(p.Selection_is_not_a_valid_statement_or_statements) }] }] : Ge; + }, + getEditsForAction: function(t, n, i) { + E.assert(n === Uq, "Wrong refactor invoked"); + const s = E.checkDefined(c8(t)), { host: o, program: c } = t; + E.assert(i, "No interactive refactor arguments available"); + const _ = i.targetFile; + return Bg(_) || yS(_) ? o.fileExists(_) && c.getSourceFile(_) === void 0 ? ESe(Ss(p.Cannot_move_statements_to_the_selected_file)) : { edits: cn.ChangeTracker.with(t, (g) => Zze(t, t.file, i.targetFile, t.program, s, g, t.host, t.preferences)), renameFilename: void 0, renameLocation: void 0 } : ESe(Ss(p.Cannot_move_to_file_selected_file_is_invalid)); + } + }); + function ESe(e) { + return { edits: [], renameFilename: void 0, renameLocation: void 0, notApplicableReason: e }; + } + function Zze(e, t, n, i, s, o, c, _) { + const u = i.getTypeChecker(), g = !c.fileExists(n), m = g ? X9(n, t.externalModuleIndicator ? 99 : t.commonJsModuleIndicator ? 1 : void 0, i, c) : E.checkDefined(i.getSourceFile(n)), h = Ou.createImportAdder(t, e.program, e.preferences, e.host), S = Ou.createImportAdder(m, e.program, e.preferences, e.host); + woe(t, m, nL(t, s.all, u, g ? void 0 : joe(m, s.all, u)), o, s, i, c, _, S, h), g && Poe(i, o, t.fileName, n, xh(c)); + } + function woe(e, t, n, i, s, o, c, _, u, g) { + const m = o.getTypeChecker(), h = HR(e.statements, cm), S = !gq(t.fileName, o, c, !!e.commonJsModuleIndicator), T = _f(e, _); + Aoe(n.oldFileImportsFromTargetFile, t.fileName, g, o), eWe(e, s.all, n.unusedImportsFromOldFile, g), g.writeFixes(i, T), Kze(e, s.ranges, i), tWe(i, o, c, e, n.movedSymbols, t.fileName, T), Noe(e, n.targetFileImportsFromOldFile, i, S), Joe(e, n.oldImportsNeededByTargetFile, n.targetFileImportsFromOldFile, m, o, u), !Og(t) && h.length && i.insertStatementsInNewFile(t.fileName, h, e), u.writeFixes(i, T); + const k = oWe(e, s.all, is(n.oldFileImportsFromTargetFile.keys()), S); + Og(t) && t.statements.length > 0 ? xWe(i, o, k, t, s) : Og(t) ? i.insertNodesAtEndOfFile( + t, + k, + /*blankLineBetween*/ + !1 + ) : i.insertStatementsInNewFile(t.fileName, u.hasFixes() ? [4, ...k] : k, e); + } + function Poe(e, t, n, i, s) { + const o = e.getCompilerOptions().configFile; + if (!o) return; + const c = Hs(On(n, "..", i)), _ = kC(o.fileName, c, s), u = o.statements[0] && Bn(o.statements[0].expression, _a), g = u && Nn(u.properties, (m) => rl(m) && ca(m.name) && m.name.text === "files"); + g && nu(g.initializer) && t.insertNodeInListAfter(o, pa(g.initializer.elements), N.createStringLiteral(_), g.initializer.elements); + } + function Kze(e, t, n) { + for (const { first: i, afterLast: s } of t) + n.deleteNodeRangeExcludingEnd(e, i, s); + } + function eWe(e, t, n, i) { + for (const s of e.statements) + ms(t, s) || wSe(s, (o) => { + PSe(o, (c) => { + n.has(c.symbol) && i.removeExistingImport(c); + }); + }); + } + function Noe(e, t, n, i) { + const s = G6(); + t.forEach((o, c) => { + if (c.declarations) + for (const _ of c.declarations) { + if (!Roe(_)) continue; + const u = mWe(_); + if (!u) continue; + const g = FSe(_); + s(g) && gWe(e, g, u, n, i); + } + }); + } + function tWe(e, t, n, i, s, o, c) { + const _ = t.getTypeChecker(); + for (const u of t.getSourceFiles()) + if (u !== i) + for (const g of u.statements) + wSe(g, (m) => { + if (_.getSymbolAtLocation(sWe(m)) !== i.symbol) return; + const h = (P) => { + const A = ya(P.parent) ? F9(_, P.parent) : eu(_.getSymbolAtLocation(P), _); + return !!A && s.has(A); + }; + cWe(u, m, e, h); + const S = by(Hn(Qi(i.fileName, t.getCurrentDirectory())), o); + if (vC(!t.useCaseSensitiveFileNames())(S, u.fileName) === 0) return; + const T = Ih.getModuleSpecifier(t.getCompilerOptions(), u, u.fileName, S, bv(t, n)), k = fWe(m, vw(T, c), h); + k && e.insertNodeAfter(u, g, k); + const D = rWe(m); + D && nWe(e, u, _, s, T, D, m, c); + }); + } + function rWe(e) { + switch (e.kind) { + case 273: + return e.importClause && e.importClause.namedBindings && e.importClause.namedBindings.kind === 275 ? e.importClause.namedBindings.name : void 0; + case 272: + return e.name; + case 261: + return Bn(e.name, Me); + default: + return E.assertNever(e, `Unexpected node kind ${e.kind}`); + } + } + function nWe(e, t, n, i, s, o, c, _) { + const u = r8( + s, + 99 + /* ESNext */ + ); + let g = !1; + const m = []; + if (ko.Core.eachSymbolReferenceInFile(o, n, t, (h) => { + wn(h.parent) && (g = g || !!n.resolveName( + u, + h, + -1, + /*excludeGlobals*/ + !0 + ), i.has(n.getSymbolAtLocation(h.parent.name)) && m.push(h)); + }), m.length) { + const h = g ? qS(u, t) : u; + for (const S of m) + e.replaceNode(t, S, N.createIdentifier(h)); + e.insertNodeAfter(t, c, iWe(c, u, s, _)); + } + } + function iWe(e, t, n, i) { + const s = N.createIdentifier(t), o = vw(n, i); + switch (e.kind) { + case 273: + return N.createImportDeclaration( + /*modifiers*/ + void 0, + N.createImportClause( + /*phaseModifier*/ + void 0, + /*name*/ + void 0, + N.createNamespaceImport(s) + ), + o, + /*attributes*/ + void 0 + ); + case 272: + return N.createImportEqualsDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + s, + N.createExternalModuleReference(o) + ); + case 261: + return N.createVariableDeclaration( + s, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + DSe(o) + ); + default: + return E.assertNever(e, `Unexpected node kind ${e.kind}`); + } + } + function DSe(e) { + return N.createCallExpression( + N.createIdentifier("require"), + /*typeArguments*/ + void 0, + [e] + ); + } + function sWe(e) { + return e.kind === 273 ? e.moduleSpecifier : e.kind === 272 ? e.moduleReference.expression : e.initializer.arguments[0]; + } + function wSe(e, t) { + if (qo(e)) + ca(e.moduleSpecifier) && t(e); + else if (_l(e)) + wh(e.moduleReference) && ja(e.moduleReference.expression) && t(e); + else if (Ic(e)) + for (const n of e.declarationList.declarations) + n.initializer && x_( + n.initializer, + /*requireStringLiteralLikeArgument*/ + !0 + ) && t(n); + } + function PSe(e, t) { + var n, i, s, o, c; + if (e.kind === 273) { + if ((n = e.importClause) != null && n.name && t(e.importClause), ((s = (i = e.importClause) == null ? void 0 : i.namedBindings) == null ? void 0 : s.kind) === 275 && t(e.importClause.namedBindings), ((c = (o = e.importClause) == null ? void 0 : o.namedBindings) == null ? void 0 : c.kind) === 276) + for (const _ of e.importClause.namedBindings.elements) + t(_); + } else if (e.kind === 272) + t(e); + else if (e.kind === 261) { + if (e.name.kind === 80) + t(e); + else if (e.name.kind === 207) + for (const _ of e.name.elements) + Me(_.name) && t(_); + } + } + function Aoe(e, t, n, i) { + for (const [s, o] of e) { + const c = V9(s, da(i.getCompilerOptions())), _ = s.name === "default" && s.parent ? 1 : 0; + n.addImportForNonExistentExport(c, t, _, s.flags, o); + } + } + function aWe(e, t, n, i = 2) { + return N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList([N.createVariableDeclaration( + e, + /*exclamationToken*/ + void 0, + t, + n + )], i) + ); + } + function oWe(e, t, n, i) { + return ka(t, (s) => { + if (ASe(s) && !NSe(e, s, i) && Moe(s, (o) => { + var c; + return n.includes(E.checkDefined((c = Bn(o, Ed)) == null ? void 0 : c.symbol)); + })) { + const o = lWe(qa(s), i); + if (o) return o; + } + return qa(s); + }); + } + function NSe(e, t, n, i) { + var s; + return n ? !Al(t) && Gn( + t, + 32 + /* Export */ + ) || !!(i && e.symbol && ((s = e.symbol.exports) != null && s.has(i.escapedText))) : !!e.symbol && !!e.symbol.exports && Ioe(t).some((o) => e.symbol.exports.has(tc(o))); + } + function cWe(e, t, n, i) { + if (t.kind === 273 && t.importClause) { + const { name: s, namedBindings: o } = t.importClause; + if ((!s || i(s)) && (!o || o.kind === 276 && o.elements.length !== 0 && o.elements.every((c) => i(c.name)))) + return n.delete(e, t); + } + PSe(t, (s) => { + s.name && Me(s.name) && i(s.name) && n.delete(e, s); + }); + } + function ASe(e) { + return E.assert(Di(e.parent), "Node parent should be a SourceFile"), MSe(e) || Ic(e); + } + function lWe(e, t) { + return t ? [uWe(e)] : _We(e); + } + function uWe(e) { + const t = Vp(e) ? Bi([N.createModifier( + 95 + /* ExportKeyword */ + )], Tb(e)) : void 0; + switch (e.kind) { + case 263: + return N.updateFunctionDeclaration(e, t, e.asteriskToken, e.name, e.typeParameters, e.parameters, e.type, e.body); + case 264: + const n = e2(e) ? Ty(e) : void 0; + return N.updateClassDeclaration(e, Bi(n, t), e.name, e.typeParameters, e.heritageClauses, e.members); + case 244: + return N.updateVariableStatement(e, t, e.declarationList); + case 268: + return N.updateModuleDeclaration(e, t, e.name, e.body); + case 267: + return N.updateEnumDeclaration(e, t, e.name, e.members); + case 266: + return N.updateTypeAliasDeclaration(e, t, e.name, e.typeParameters, e.type); + case 265: + return N.updateInterfaceDeclaration(e, t, e.name, e.typeParameters, e.heritageClauses, e.members); + case 272: + return N.updateImportEqualsDeclaration(e, t, e.isTypeOnly, e.name, e.moduleReference); + case 245: + return E.fail(); + default: + return E.assertNever(e, `Unexpected declaration kind ${e.kind}`); + } + } + function _We(e) { + return [e, ...Ioe(e).map(ISe)]; + } + function ISe(e) { + return N.createExpressionStatement( + N.createBinaryExpression( + N.createPropertyAccessExpression(N.createIdentifier("exports"), N.createIdentifier(e)), + 64, + N.createIdentifier(e) + ) + ); + } + function Ioe(e) { + switch (e.kind) { + case 263: + case 264: + return [e.name.text]; + // TODO: GH#18217 + case 244: + return Fi(e.declarationList.declarations, (t) => Me(t.name) ? t.name.text : void 0); + case 268: + case 267: + case 266: + case 265: + case 272: + return Ge; + case 245: + return E.fail("Can't export an ExpressionStatement"); + default: + return E.assertNever(e, `Unexpected decl kind ${e.kind}`); + } + } + function fWe(e, t, n) { + switch (e.kind) { + case 273: { + const i = e.importClause; + if (!i) return; + const s = i.name && n(i.name) ? i.name : void 0, o = i.namedBindings && pWe(i.namedBindings, n); + return s || o ? N.createImportDeclaration( + /*modifiers*/ + void 0, + N.createImportClause(i.phaseModifier, s, o), + qa(t), + /*attributes*/ + void 0 + ) : void 0; + } + case 272: + return n(e.name) ? e : void 0; + case 261: { + const i = dWe(e.name, n); + return i ? aWe(i, e.type, DSe(t), e.parent.flags) : void 0; + } + default: + return E.assertNever(e, `Unexpected import kind ${e.kind}`); + } + } + function pWe(e, t) { + if (e.kind === 275) + return t(e.name) ? e : void 0; + { + const n = e.elements.filter((i) => t(i.name)); + return n.length ? N.createNamedImports(n) : void 0; + } + } + function dWe(e, t) { + switch (e.kind) { + case 80: + return t(e) ? e : void 0; + case 208: + return e; + case 207: { + const n = e.elements.filter((i) => i.propertyName || !Me(i.name) || t(i.name)); + return n.length ? N.createObjectBindingPattern(n) : void 0; + } + } + } + function mWe(e) { + return Al(e) ? Bn(e.expression.left.name, Me) : Bn(e.name, Me); + } + function FSe(e) { + switch (e.kind) { + case 261: + return e.parent.parent; + case 209: + return FSe( + Us(e.parent.parent, (t) => ei(t) || ya(t)) + ); + default: + return e; + } + } + function gWe(e, t, n, i, s) { + if (!NSe(e, t, s, n)) + if (s) + Al(t) || i.insertExportModifier(e, t); + else { + const o = Ioe(t); + o.length !== 0 && i.insertNodesAfter(e, t, o.map(ISe)); + } + } + function Foe(e, t, n, i) { + const s = t.getTypeChecker(); + if (i) { + const o = nL(e, i.all, s), c = Hn(e.fileName), _ = p4(e.fileName); + return On( + // new file is always placed in the same directory as the old file + c, + // ensures the filename computed below isn't already taken + bWe( + // infers a name for the new file from the symbols being moved + SWe(o.oldFileImportsFromTargetFile, o.movedSymbols), + _, + c, + n + ) + ) + _; + } + return ""; + } + function hWe(e) { + const { file: t } = e, n = D9(pk(e)), { statements: i } = t; + let s = oc(i, (g) => g.end > n.pos); + if (s === -1) return; + const o = i[s], c = RSe(t, o); + c && (s = c.start); + let _ = oc(i, (g) => g.end >= n.end, s); + _ !== -1 && n.end <= i[_].getStart() && _--; + const u = RSe(t, i[_]); + return u && (_ = u.end), { + toMove: i.slice(s, _ === -1 ? i.length : _ + 1), + afterLast: _ === -1 ? void 0 : i[_ + 1] + }; + } + function c8(e) { + const t = hWe(e); + if (t === void 0) return; + const n = [], i = [], { toMove: s, afterLast: o } = t; + return wR(s, yWe, (c, _) => { + for (let u = c; u < _; u++) n.push(s[u]); + i.push({ first: s[c], afterLast: o }); + }), n.length === 0 ? void 0 : { all: n, ranges: i }; + } + function Ooe(e) { + return Nn(e, (t) => !!(t.transformFlags & 2)); + } + function yWe(e) { + return !vWe(e) && !cm(e); + } + function vWe(e) { + switch (e.kind) { + case 273: + return !0; + case 272: + return !Gn( + e, + 32 + /* Export */ + ); + case 244: + return e.declarationList.declarations.every((t) => !!t.initializer && x_( + t.initializer, + /*requireStringLiteralLikeArgument*/ + !0 + )); + default: + return !1; + } + } + function nL(e, t, n, i = /* @__PURE__ */ new Set(), s) { + var o; + const c = /* @__PURE__ */ new Set(), _ = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), g = S(Ooe(t)); + g && _.set(g, [!1, Bn((o = g.declarations) == null ? void 0 : o[0], (T) => Xu(T) || ld(T) || Ug(T) || _l(T) || ya(T) || ei(T))]); + for (const T of t) + Moe(T, (k) => { + c.add(E.checkDefined(Al(k) ? n.getSymbolAtLocation(k.expression.left) : k.symbol, "Need a symbol here")); + }); + const m = /* @__PURE__ */ new Set(); + for (const T of t) + Loe(T, n, s, (k, D) => { + if (!ot(k.declarations)) + return; + if (i.has(eu(k, n))) { + m.add(k); + return; + } + const P = Nn(k.declarations, Vq); + if (P) { + const A = _.get(k); + _.set(k, [ + (A === void 0 || A) && D, + Bn(P, (O) => Xu(O) || ld(O) || Ug(O) || _l(O) || ya(O) || ei(O)) + ]); + } else !c.has(k) && Ni(k.declarations, (A) => Roe(A) && TWe(A) === e) && u.set(k, D); + }); + for (const T of _.keys()) + m.add(T); + const h = /* @__PURE__ */ new Map(); + for (const T of e.statements) + ms(t, T) || (g && T.transformFlags & 2 && m.delete(g), Loe(T, n, s, (k, D) => { + c.has(k) && h.set(k, D), m.delete(k); + })); + return { movedSymbols: c, targetFileImportsFromOldFile: u, oldFileImportsFromTargetFile: h, oldImportsNeededByTargetFile: _, unusedImportsFromOldFile: m }; + function S(T) { + if (T === void 0) + return; + const k = n.getJsxNamespace(T), D = n.resolveName( + k, + T, + 1920, + /*excludeGlobals*/ + !0 + ); + return D && ot(D.declarations, Vq) ? D : void 0; + } + } + function bWe(e, t, n, i) { + let s = e; + for (let o = 1; ; o++) { + const c = On(n, s + t); + if (!i.fileExists(c)) return s; + s = `${e}.${o}`; + } + } + function SWe(e, t) { + return Ag(e, HV) || Ag(t, HV) || "newFile"; + } + function Loe(e, t, n, i) { + e.forEachChild(function s(o) { + if (Me(o) && !Qm(o)) { + if (n && !C_(n, o)) + return; + const c = t.getSymbolAtLocation(o); + c && i(c, K1(o)); + } else + o.forEachChild(s); + }); + } + function Moe(e, t) { + switch (e.kind) { + case 263: + case 264: + case 268: + case 267: + case 266: + case 265: + case 272: + return t(e); + case 244: + return Lc(e.declarationList.declarations, (n) => LSe(n.name, t)); + case 245: { + const { expression: n } = e; + return _n(n) && Ac(n) === 1 ? t(e) : void 0; + } + } + } + function Vq(e) { + switch (e.kind) { + case 272: + case 277: + case 274: + case 275: + return !0; + case 261: + return OSe(e); + case 209: + return ei(e.parent.parent) && OSe(e.parent.parent); + default: + return !1; + } + } + function OSe(e) { + return Di(e.parent.parent.parent) && !!e.initializer && x_( + e.initializer, + /*requireStringLiteralLikeArgument*/ + !0 + ); + } + function Roe(e) { + return MSe(e) && Di(e.parent) || ei(e) && Di(e.parent.parent.parent); + } + function TWe(e) { + return ei(e) ? e.parent.parent.parent : e.parent; + } + function LSe(e, t) { + switch (e.kind) { + case 80: + return t(Us(e.parent, (n) => ei(n) || ya(n))); + case 208: + case 207: + return Lc(e.elements, (n) => vl(n) ? void 0 : LSe(n.name, t)); + default: + return E.assertNever(e, `Unexpected name kind ${e.kind}`); + } + } + function MSe(e) { + switch (e.kind) { + case 263: + case 264: + case 268: + case 267: + case 266: + case 265: + case 272: + return !0; + default: + return !1; + } + } + function xWe(e, t, n, i, s) { + var o; + const c = /* @__PURE__ */ new Set(), _ = (o = i.symbol) == null ? void 0 : o.exports; + if (_) { + const g = t.getTypeChecker(), m = /* @__PURE__ */ new Map(); + for (const h of s.all) + ASe(h) && Gn( + h, + 32 + /* Export */ + ) && Moe(h, (S) => { + var T; + const k = Ed(S) ? (T = _.get(S.symbol.escapedName)) == null ? void 0 : T.declarations : void 0, D = Lc(k, (P) => Bc(P) ? P : Nu(P) ? Bn(P.parent.parent, Bc) : void 0); + D && D.moduleSpecifier && m.set(D, (m.get(D) || /* @__PURE__ */ new Set()).add(S)); + }); + for (const [h, S] of is(m)) + if (h.exportClause && mp(h.exportClause) && wr(h.exportClause.elements)) { + const T = h.exportClause.elements, k = kn(T, (D) => Nn(eu(D.symbol, g).declarations, (P) => Roe(P) && S.has(P)) === void 0); + if (wr(k) === 0) { + e.deleteNode(i, h), c.add(h); + continue; + } + wr(k) < wr(T) && e.replaceNode(i, h, N.updateExportDeclaration(h, h.modifiers, h.isTypeOnly, N.updateNamedExports(h.exportClause, N.createNodeArray(k, T.hasTrailingComma)), h.moduleSpecifier, h.attributes)); + } + } + const u = gb(i.statements, (g) => Bc(g) && !!g.moduleSpecifier && !c.has(g)); + u ? e.insertNodesBefore( + i, + u, + n, + /*blankLineBetween*/ + !0 + ) : e.insertNodesAfter(i, i.statements[i.statements.length - 1], n); + } + function RSe(e, t) { + if (io(t)) { + const n = t.symbol.declarations; + if (n === void 0 || wr(n) <= 1 || !ms(n, t)) + return; + const i = n[0], s = n[wr(n) - 1], o = Fi(n, (u) => xr(u) === e && Ti(u) ? u : void 0), c = oc(e.statements, (u) => u.end >= s.end), _ = oc(e.statements, (u) => u.end >= i.end); + return { toMove: o, start: _, end: c }; + } + } + function joe(e, t, n) { + const i = /* @__PURE__ */ new Set(); + for (const s of e.imports) { + const o = UD(s); + if (qo(o) && o.importClause && o.importClause.namedBindings && bm(o.importClause.namedBindings)) + for (const c of o.importClause.namedBindings.elements) { + const _ = n.getSymbolAtLocation(c.propertyName || c.name); + _ && i.add(eu(_, n)); + } + if (L3(o.parent) && Of(o.parent.name)) + for (const c of o.parent.name.elements) { + const _ = n.getSymbolAtLocation(c.propertyName || c.name); + _ && i.add(eu(_, n)); + } + } + for (const s of t) + Loe( + s, + n, + /*enclosingRange*/ + void 0, + (o) => { + const c = eu(o, n); + c.valueDeclaration && xr(c.valueDeclaration).path === e.path && i.add(c); + } + ); + return i; + } + function Oh(e) { + return e.error !== void 0; + } + function xv(e, t) { + return t ? e.substr(0, t.length) === t : !0; + } + function Boe(e, t, n, i) { + return wn(e) && !$n(t) && !n.resolveName( + e.name.text, + e, + 111551, + /*excludeGlobals*/ + !1 + ) && !Ai(e.name) && !Z2(e.name) ? e.name.text : qS($n(t) ? "newProperty" : "newLocal", i); + } + function Joe(e, t, n, i, s, o) { + t.forEach(([c, _], u) => { + var g; + const m = eu(u, i); + i.isUnknownSymbol(m) ? o.addVerbatimImport(E.checkDefined(_ ?? dr((g = u.declarations) == null ? void 0 : g[0], nK))) : m.parent === void 0 ? (E.assert(_ !== void 0, "expected module symbol to have a declaration"), o.addImportForModuleSymbol(u, c, _)) : o.addImportFromExportedSymbol(m, c, _); + }), Aoe(n, e.fileName, o, s); + } + var iL = "Inline variable", zoe = Ss(p.Inline_variable), Woe = { + name: iL, + description: zoe, + kind: "refactor.inline.variable" + }; + Hg(iL, { + kinds: [Woe.kind], + getAvailableActions(e) { + const { + file: t, + program: n, + preferences: i, + startPosition: s, + triggerReason: o + } = e, c = jSe(t, s, o === "invoked", n); + return c ? gk.isRefactorErrorInfo(c) ? i.provideRefactorNotApplicableReason ? [{ + name: iL, + description: zoe, + actions: [{ + ...Woe, + notApplicableReason: c.error + }] + }] : Ge : [{ + name: iL, + description: zoe, + actions: [Woe] + }] : Ge; + }, + getEditsForAction(e, t) { + E.assert(t === iL, "Unexpected refactor invoked"); + const { file: n, program: i, startPosition: s } = e, o = jSe( + n, + s, + /*tryWithReferenceToken*/ + !0, + i + ); + if (!o || gk.isRefactorErrorInfo(o)) + return; + const { references: c, declaration: _, replacement: u } = o; + return { edits: cn.ChangeTracker.with(e, (m) => { + for (const h of c) { + const S = ca(u) && Me(h) && ad(h.parent); + S && g6(S) && !nv(S.parent.parent) ? CWe(m, n, S, u) : m.replaceNode(n, h, kWe(h, u)); + } + m.delete(n, _); + }) }; + } + }); + function jSe(e, t, n, i) { + var s, o; + const c = i.getTypeChecker(), _ = w_(e, t), u = _.parent; + if (Me(_)) { + if (_N(u) && LD(u) && Me(u.name)) { + if (((s = c.getMergedSymbol(u.symbol).declarations) == null ? void 0 : s.length) !== 1) + return { error: Ss(p.Variables_with_multiple_declarations_cannot_be_inlined) }; + if (BSe(u)) + return; + const g = JSe(u, c, e); + return g && { references: g, declaration: u, replacement: u.initializer }; + } + if (n) { + let g = c.resolveName( + _.text, + _, + 111551, + /*excludeGlobals*/ + !1 + ); + if (g = g && c.getMergedSymbol(g), ((o = g?.declarations) == null ? void 0 : o.length) !== 1) + return { error: Ss(p.Variables_with_multiple_declarations_cannot_be_inlined) }; + const m = g.declarations[0]; + if (!_N(m) || !LD(m) || !Me(m.name) || BSe(m)) + return; + const h = JSe(m, c, e); + return h && { references: h, declaration: m, replacement: m.initializer }; + } + return { error: Ss(p.Could_not_find_variable_to_inline) }; + } + } + function BSe(e) { + const t = Us(e.parent.parent, Ic); + return ot(t.modifiers, zx); + } + function JSe(e, t, n) { + const i = [], s = ko.Core.eachSymbolReferenceInFile(e.name, t, n, (o) => { + if (ko.isWriteAccessForReference(o) && !gu(o.parent) || Nu(o.parent) || Mo(o.parent) || Hb(o.parent) || KP(e, o.pos)) + return !0; + i.push(o); + }); + return i.length === 0 || s ? void 0 : i; + } + function kWe(e, t) { + t = qa(t); + const { parent: n } = e; + return ut(n) && (YD(t) < YD(n) || M9(n)) || Es(t) && (Cb(n) || wn(n)) || wn(n) && (E_(t) || _a(t)) ? N.createParenthesizedExpression(t) : Me(e) && gu(n) ? N.createPropertyAssignment(e, t) : t; + } + function CWe(e, t, n, i) { + const s = n.parent, o = s.templateSpans.indexOf(n), c = o === 0 ? s.head : s.templateSpans[o - 1]; + e.replaceRangeWithText( + t, + { + pos: c.getEnd() - 2, + end: n.literal.getStart() + 1 + }, + i.text.replace(/\\/g, "\\\\").replace(/`/g, "\\`") + ); + } + var sL = "Move to a new file", Uoe = Ss(p.Move_to_a_new_file), Voe = { + name: sL, + description: Uoe, + kind: "refactor.move.newFile" + }; + Hg(sL, { + kinds: [Voe.kind], + getAvailableActions: function(t) { + const n = c8(t), i = t.file; + if (t.triggerReason === "implicit" && t.endPosition !== void 0) { + const s = dr(vi(i, t.startPosition), dk), o = dr(vi(i, t.endPosition), dk); + if (s && !Di(s) && o && !Di(o)) + return Ge; + } + if (t.preferences.allowTextChangesInNewFiles && n) { + const s = t.file, o = { + start: { line: js(s, n.all[0].getStart(s)).line, offset: js(s, n.all[0].getStart(s)).character }, + end: { line: js(s, pa(n.all).end).line, offset: js(s, pa(n.all).end).character } + }; + return [{ name: sL, description: Uoe, actions: [{ ...Voe, range: o }] }]; + } + return t.preferences.provideRefactorNotApplicableReason ? [{ name: sL, description: Uoe, actions: [{ ...Voe, notApplicableReason: Ss(p.Selection_is_not_a_valid_statement_or_statements) }] }] : Ge; + }, + getEditsForAction: function(t, n) { + E.assert(n === sL, "Wrong refactor invoked"); + const i = E.checkDefined(c8(t)); + return { edits: cn.ChangeTracker.with(t, (o) => EWe(t.file, t.program, i, o, t.host, t, t.preferences)), renameFilename: void 0, renameLocation: void 0 }; + } + }); + function EWe(e, t, n, i, s, o, c) { + const _ = t.getTypeChecker(), u = nL(e, n.all, _), g = Foe(e, t, s, n), m = X9(g, e.externalModuleIndicator ? 99 : e.commonJsModuleIndicator ? 1 : void 0, t, s), h = Ou.createImportAdder(e, o.program, o.preferences, o.host), S = Ou.createImportAdder(m, o.program, o.preferences, o.host); + woe(e, m, u, i, n, t, s, c, S, h), Poe(t, i, e.fileName, g, xh(s)); + } + var DWe = {}, qoe = "Convert overload list to single signature", zSe = Ss(p.Convert_overload_list_to_single_signature), WSe = { + name: qoe, + description: zSe, + kind: "refactor.rewrite.function.overloadList" + }; + Hg(qoe, { + kinds: [WSe.kind], + getEditsForAction: PWe, + getAvailableActions: wWe + }); + function wWe(e) { + const { file: t, startPosition: n, program: i } = e; + return VSe(t, n, i) ? [{ + name: qoe, + description: zSe, + actions: [WSe] + }] : Ge; + } + function PWe(e) { + const { file: t, startPosition: n, program: i } = e, s = VSe(t, n, i); + if (!s) return; + const o = i.getTypeChecker(), c = s[s.length - 1]; + let _ = c; + switch (c.kind) { + case 174: { + _ = N.updateMethodSignature( + c, + c.modifiers, + c.name, + c.questionToken, + c.typeParameters, + g(s), + c.type + ); + break; + } + case 175: { + _ = N.updateMethodDeclaration( + c, + c.modifiers, + c.asteriskToken, + c.name, + c.questionToken, + c.typeParameters, + g(s), + c.type, + c.body + ); + break; + } + case 180: { + _ = N.updateCallSignature( + c, + c.typeParameters, + g(s), + c.type + ); + break; + } + case 177: { + _ = N.updateConstructorDeclaration( + c, + c.modifiers, + g(s), + c.body + ); + break; + } + case 181: { + _ = N.updateConstructSignature( + c, + c.typeParameters, + g(s), + c.type + ); + break; + } + case 263: { + _ = N.updateFunctionDeclaration( + c, + c.modifiers, + c.asteriskToken, + c.name, + c.typeParameters, + g(s), + c.type, + c.body + ); + break; + } + default: + return E.failBadSyntaxKind(c, "Unhandled signature kind in overload list conversion refactoring"); + } + if (_ === c) + return; + return { renameFilename: void 0, renameLocation: void 0, edits: cn.ChangeTracker.with(e, (S) => { + S.replaceNodeRange(t, s[0], s[s.length - 1], _); + }) }; + function g(S) { + const T = S[S.length - 1]; + return io(T) && T.body && (S = S.slice(0, S.length - 1)), N.createNodeArray([ + N.createParameterDeclaration( + /*modifiers*/ + void 0, + N.createToken( + 26 + /* DotDotDotToken */ + ), + "args", + /*questionToken*/ + void 0, + N.createUnionTypeNode(hr(S, m)) + ) + ]); + } + function m(S) { + const T = hr(S.parameters, h); + return un( + N.createTupleTypeNode(T), + ot(T, (k) => !!wr(l6(k))) ? 0 : 1 + /* SingleLine */ + ); + } + function h(S) { + E.assert(Me(S.name)); + const T = ct( + N.createNamedTupleMember( + S.dotDotDotToken, + S.name, + S.questionToken, + S.type || N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ) + ), + S + ), k = S.symbol && S.symbol.getDocumentationComment(o); + if (k) { + const D = _8(k); + D.length && tv(T, [{ + text: `* +${D.split(` +`).map((P) => ` * ${P}`).join(` +`)} + `, + kind: 3, + pos: -1, + end: -1, + hasTrailingNewLine: !0, + hasLeadingNewline: !0 + }]); + } + return T; + } + } + function USe(e) { + switch (e.kind) { + case 174: + case 175: + case 180: + case 177: + case 181: + case 263: + return !0; + } + return !1; + } + function VSe(e, t, n) { + const i = vi(e, t), s = dr(i, USe); + if (!s || io(s) && s.body && q6(s.body, t)) + return; + const o = n.getTypeChecker(), c = s.symbol; + if (!c) + return; + const _ = c.declarations; + if (wr(_) <= 1 || !Ni(_, (S) => xr(S) === e) || !USe(_[0])) + return; + const u = _[0].kind; + if (!Ni(_, (S) => S.kind === u)) + return; + const g = _; + if (ot(g, (S) => !!S.typeParameters || ot(S.parameters, (T) => !!T.modifiers || !Me(T.name)))) + return; + const m = Fi(g, (S) => o.getSignatureFromDeclaration(S)); + if (wr(m) !== wr(_)) + return; + const h = o.getReturnTypeOfSignature(m[0]); + if (Ni(m, (S) => o.getReturnTypeOfSignature(S) === h)) + return g; + } + var Hoe = "Add or remove braces in an arrow function", qSe = Ss(p.Add_or_remove_braces_in_an_arrow_function), qq = { + name: "Add braces to arrow function", + description: Ss(p.Add_braces_to_arrow_function), + kind: "refactor.rewrite.arrow.braces.add" + }, aL = { + name: "Remove braces from arrow function", + description: Ss(p.Remove_braces_from_arrow_function), + kind: "refactor.rewrite.arrow.braces.remove" + }; + Hg(Hoe, { + kinds: [aL.kind], + getEditsForAction: AWe, + getAvailableActions: NWe + }); + function NWe(e) { + const { file: t, startPosition: n, triggerReason: i } = e, s = HSe(t, n, i === "invoked"); + return s ? Oh(s) ? e.preferences.provideRefactorNotApplicableReason ? [{ + name: Hoe, + description: qSe, + actions: [ + { ...qq, notApplicableReason: s.error }, + { ...aL, notApplicableReason: s.error } + ] + }] : Ge : [{ + name: Hoe, + description: qSe, + actions: [ + s.addBraces ? qq : aL + ] + }] : Ge; + } + function AWe(e, t) { + const { file: n, startPosition: i } = e, s = HSe(n, i); + E.assert(s && !Oh(s), "Expected applicable refactor info"); + const { expression: o, returnStatement: c, func: _ } = s; + let u; + if (t === qq.name) { + const m = N.createReturnStatement(o); + u = N.createBlock( + [m], + /*multiLine*/ + !0 + ), Y6( + o, + m, + n, + 3, + /*hasTrailingNewLine*/ + !0 + ); + } else if (t === aL.name && c) { + const m = o || N.createVoidZero(); + u = M9(m) ? N.createParenthesizedExpression(m) : m, ZA( + c, + u, + n, + 3, + /*hasTrailingNewLine*/ + !1 + ), Y6( + c, + u, + n, + 3, + /*hasTrailingNewLine*/ + !1 + ), xw( + c, + u, + n, + 3, + /*hasTrailingNewLine*/ + !1 + ); + } else + E.fail("invalid action"); + return { renameFilename: void 0, renameLocation: void 0, edits: cn.ChangeTracker.with(e, (m) => { + m.replaceNode(n, _.body, u); + }) }; + } + function HSe(e, t, n = !0, i) { + const s = vi(e, t), o = Af(s); + if (!o) + return { + error: Ss(p.Could_not_find_a_containing_arrow_function) + }; + if (!xo(o)) + return { + error: Ss(p.Containing_function_is_not_an_arrow_function) + }; + if (!(!C_(o, s) || C_(o.body, s) && !n)) { + if (xv(qq.kind, i) && ut(o.body)) + return { func: o, addBraces: !0, expression: o.body }; + if (xv(aL.kind, i) && Ns(o.body) && o.body.statements.length === 1) { + const c = Ca(o.body.statements); + if (Cf(c)) { + const _ = c.expression && _a(n6( + c.expression, + /*stopAtCallExpressions*/ + !1 + )) ? N.createParenthesizedExpression(c.expression) : c.expression; + return { func: o, addBraces: !1, expression: _, returnStatement: c }; + } + } + } + } + var IWe = {}, GSe = "Convert arrow function or function expression", FWe = Ss(p.Convert_arrow_function_or_function_expression), oL = { + name: "Convert to anonymous function", + description: Ss(p.Convert_to_anonymous_function), + kind: "refactor.rewrite.function.anonymous" + }, cL = { + name: "Convert to named function", + description: Ss(p.Convert_to_named_function), + kind: "refactor.rewrite.function.named" + }, lL = { + name: "Convert to arrow function", + description: Ss(p.Convert_to_arrow_function), + kind: "refactor.rewrite.function.arrow" + }; + Hg(GSe, { + kinds: [ + oL.kind, + cL.kind, + lL.kind + ], + getEditsForAction: LWe, + getAvailableActions: OWe + }); + function OWe(e) { + const { file: t, startPosition: n, program: i, kind: s } = e, o = XSe(t, n, i); + if (!o) return Ge; + const { selectedVariableDeclaration: c, func: _ } = o, u = [], g = []; + if (xv(cL.kind, s)) { + const m = c || xo(_) && ei(_.parent) ? void 0 : Ss(p.Could_not_convert_to_named_function); + m ? g.push({ ...cL, notApplicableReason: m }) : u.push(cL); + } + if (xv(oL.kind, s)) { + const m = !c && xo(_) ? void 0 : Ss(p.Could_not_convert_to_anonymous_function); + m ? g.push({ ...oL, notApplicableReason: m }) : u.push(oL); + } + if (xv(lL.kind, s)) { + const m = yo(_) ? void 0 : Ss(p.Could_not_convert_to_arrow_function); + m ? g.push({ ...lL, notApplicableReason: m }) : u.push(lL); + } + return [{ + name: GSe, + description: FWe, + actions: u.length === 0 && e.preferences.provideRefactorNotApplicableReason ? g : u + }]; + } + function LWe(e, t) { + const { file: n, startPosition: i, program: s } = e, o = XSe(n, i, s); + if (!o) return; + const { func: c } = o, _ = []; + switch (t) { + case oL.name: + _.push(...BWe(e, c)); + break; + case cL.name: + const u = jWe(c); + if (!u) return; + _.push(...JWe(e, c, u)); + break; + case lL.name: + if (!yo(c)) return; + _.push(...zWe(e, c)); + break; + default: + return E.fail("invalid action"); + } + return { renameFilename: void 0, renameLocation: void 0, edits: _ }; + } + function $Se(e) { + let t = !1; + return e.forEachChild(function n(i) { + if (V6(i)) { + t = !0; + return; + } + !$n(i) && !Cc(i) && !yo(i) && xs(i, n); + }), t; + } + function XSe(e, t, n) { + const i = vi(e, t), s = n.getTypeChecker(), o = RWe(e, s, i.parent); + if (o && !$Se(o.body) && !s.containsArgumentsReference(o)) + return { selectedVariableDeclaration: !0, func: o }; + const c = Af(i); + if (c && (yo(c) || xo(c)) && !C_(c.body, i) && !$Se(c.body) && !s.containsArgumentsReference(c)) + return yo(c) && YSe(e, s, c) ? void 0 : { selectedVariableDeclaration: !1, func: c }; + } + function MWe(e) { + return ei(e) || Ul(e) && e.declarations.length === 1; + } + function RWe(e, t, n) { + if (!MWe(n)) + return; + const s = (ei(n) ? n : Ca(n.declarations)).initializer; + if (s && (xo(s) || yo(s) && !YSe(e, t, s))) + return s; + } + function QSe(e) { + if (ut(e)) { + const t = N.createReturnStatement(e), n = e.getSourceFile(); + return ct(t, e), af(t), ZA( + e, + t, + n, + /*commentKind*/ + void 0, + /*hasTrailingNewLine*/ + !0 + ), N.createBlock( + [t], + /*multiLine*/ + !0 + ); + } else + return e; + } + function jWe(e) { + const t = e.parent; + if (!ei(t) || !LD(t)) return; + const n = t.parent, i = n.parent; + if (!(!Ul(n) || !Ic(i) || !Me(t.name))) + return { variableDeclaration: t, variableDeclarationList: n, statement: i, name: t.name }; + } + function BWe(e, t) { + const { file: n } = e, i = QSe(t.body), s = N.createFunctionExpression( + t.modifiers, + t.asteriskToken, + /*name*/ + void 0, + t.typeParameters, + t.parameters, + t.type, + i + ); + return cn.ChangeTracker.with(e, (o) => o.replaceNode(n, t, s)); + } + function JWe(e, t, n) { + const { file: i } = e, s = QSe(t.body), { variableDeclaration: o, variableDeclarationList: c, statement: _, name: u } = n; + tz(_); + const g = J1(o) & 32 | pu(t), m = N.createModifiersFromModifierFlags(g), h = N.createFunctionDeclaration(wr(m) ? m : void 0, t.asteriskToken, u, t.typeParameters, t.parameters, t.type, s); + return c.declarations.length === 1 ? cn.ChangeTracker.with(e, (S) => S.replaceNode(i, _, h)) : cn.ChangeTracker.with(e, (S) => { + S.delete(i, o), S.insertNodeAfter(i, _, h); + }); + } + function zWe(e, t) { + const { file: n } = e, s = t.body.statements[0]; + let o; + WWe(t.body, s) ? (o = s.expression, af(o), VS(s, o)) : o = t.body; + const c = N.createArrowFunction(t.modifiers, t.typeParameters, t.parameters, t.type, N.createToken( + 39 + /* EqualsGreaterThanToken */ + ), o); + return cn.ChangeTracker.with(e, (_) => _.replaceNode(n, t, c)); + } + function WWe(e, t) { + return e.statements.length === 1 && Cf(t) && !!t.expression; + } + function YSe(e, t, n) { + return !!n.name && ko.Core.isSymbolReferencedInFile(n.name, t, e); + } + var UWe = {}, Hq = "Convert parameters to destructured object", VWe = 1, ZSe = Ss(p.Convert_parameters_to_destructured_object), KSe = { + name: Hq, + description: ZSe, + kind: "refactor.rewrite.parameters.toDestructured" + }; + Hg(Hq, { + kinds: [KSe.kind], + getEditsForAction: HWe, + getAvailableActions: qWe + }); + function qWe(e) { + const { file: t, startPosition: n } = e; + return n_(t) || !rTe(t, n, e.program.getTypeChecker()) ? Ge : [{ + name: Hq, + description: ZSe, + actions: [KSe] + }]; + } + function HWe(e, t) { + E.assert(t === Hq, "Unexpected action name"); + const { file: n, startPosition: i, program: s, cancellationToken: o, host: c } = e, _ = rTe(n, i, s.getTypeChecker()); + if (!_ || !o) return; + const u = $We(_, s, o); + return u.valid ? { renameFilename: void 0, renameLocation: void 0, edits: cn.ChangeTracker.with(e, (m) => GWe(n, s, c, m, _, u)) } : { edits: [] }; + } + function GWe(e, t, n, i, s, o) { + const c = o.signature, _ = hr(aTe(s, t, n), (m) => qa(m)); + if (c) { + const m = hr(aTe(c, t, n), (h) => qa(h)); + g(c, m); + } + g(s, _); + const u = tD( + o.functionCalls, + /*comparer*/ + (m, h) => ho(m.pos, h.pos) + ); + for (const m of u) + if (m.arguments && m.arguments.length) { + const h = qa( + iUe(s, m.arguments), + /*includeTrivia*/ + !0 + ); + i.replaceNodeRange( + xr(m), + Ca(m.arguments), + pa(m.arguments), + h, + { leadingTriviaOption: cn.LeadingTriviaOption.IncludeAll, trailingTriviaOption: cn.TrailingTriviaOption.Include } + ); + } + function g(m, h) { + i.replaceNodeRangeWithNodes( + e, + Ca(m.parameters), + pa(m.parameters), + h, + { + joiner: ", ", + // indentation is set to 0 because otherwise the object parameter will be indented if there is a `this` parameter + indentation: 0, + leadingTriviaOption: cn.LeadingTriviaOption.IncludeAll, + trailingTriviaOption: cn.TrailingTriviaOption.Include + } + ); + } + } + function $We(e, t, n) { + const i = aUe(e), s = nc(e) ? sUe(e) : [], o = hb([...i, ...s], gy), c = t.getTypeChecker(), _ = ka( + o, + /*mapfn*/ + (h) => ko.getReferenceEntriesForNode(-1, h, t, t.getSourceFiles(), n) + ), u = g(_); + return Ni( + u.declarations, + /*callback*/ + (h) => ms(o, h) + ) || (u.valid = !1), u; + function g(h) { + const S = { accessExpressions: [], typeUsages: [] }, T = { functionCalls: [], declarations: [], classReferences: S, valid: !0 }, k = hr(i, m), D = hr(s, m), P = nc(e), A = hr(i, (O) => Goe(O, c)); + for (const O of h) { + if (O.kind === ko.EntryKind.Span) { + T.valid = !1; + continue; + } + if (ms(A, m(O.node))) { + if (ZWe(O.node.parent)) { + T.signature = O.node.parent; + continue; + } + const R = tTe(O); + if (R) { + T.functionCalls.push(R); + continue; + } + } + const F = Goe(O.node, c); + if (F && ms(A, F)) { + const R = $oe(O); + if (R) { + T.declarations.push(R); + continue; + } + } + if (ms(k, m(O.node)) || dw(O.node)) { + if (eTe(O)) + continue; + const B = $oe(O); + if (B) { + T.declarations.push(B); + continue; + } + const U = tTe(O); + if (U) { + T.functionCalls.push(U); + continue; + } + } + if (P && ms(D, m(O.node))) { + if (eTe(O)) + continue; + const B = $oe(O); + if (B) { + T.declarations.push(B); + continue; + } + const U = XWe(O); + if (U) { + S.accessExpressions.push(U); + continue; + } + if (tl(e.parent)) { + const $ = QWe(O); + if ($) { + S.typeUsages.push($); + continue; + } + } + } + T.valid = !1; + } + return T; + } + function m(h) { + const S = c.getSymbolAtLocation(h); + return S && nq(S, c); + } + } + function Goe(e, t) { + const n = f8(e); + if (n) { + const i = t.getContextualTypeForObjectLiteralElement(n), s = i?.getSymbol(); + if (s && !(uc(s) & 6)) + return s; + } + } + function eTe(e) { + const t = e.node; + if (Xu(t.parent) || ld(t.parent) || _l(t.parent) || Ug(t.parent) || Nu(t.parent) || Mo(t.parent)) + return t; + } + function $oe(e) { + if (Pl(e.node.parent)) + return e.node; + } + function tTe(e) { + if (e.node.parent) { + const t = e.node, n = t.parent; + switch (n.kind) { + // foo(...) or super(...) or new Foo(...) + case 214: + case 215: + const i = Bn(n, sm); + if (i && i.expression === t) + return i; + break; + // x.foo(...) + case 212: + const s = Bn(n, wn); + if (s && s.parent && s.name === t) { + const c = Bn(s.parent, sm); + if (c && c.expression === s) + return c; + } + break; + // x["foo"](...) + case 213: + const o = Bn(n, uo); + if (o && o.parent && o.argumentExpression === t) { + const c = Bn(o.parent, sm); + if (c && c.expression === o) + return c; + } + break; + } + } + } + function XWe(e) { + if (e.node.parent) { + const t = e.node, n = t.parent; + switch (n.kind) { + // `C.foo` + case 212: + const i = Bn(n, wn); + if (i && i.expression === t) + return i; + break; + // `C["foo"]` + case 213: + const s = Bn(n, uo); + if (s && s.expression === t) + return s; + break; + } + } + } + function QWe(e) { + const t = e.node; + if (WS(t) === 2 || I5(t.parent)) + return t; + } + function rTe(e, t, n) { + const i = H6(e, t), s = bK(i); + if (!YWe(i) && s && KWe(s, n) && C_(s, i) && !(s.body && C_(s.body, i))) + return s; + } + function YWe(e) { + const t = dr(e, FC); + if (t) { + const n = dr(t, (i) => !FC(i)); + return !!n && io(n); + } + return !1; + } + function ZWe(e) { + return cd(e) && (Vl(e.parent) || a_(e.parent)); + } + function KWe(e, t) { + var n; + if (!eUe(e.parameters, t)) return !1; + switch (e.kind) { + case 263: + return nTe(e) && uL(e, t); + case 175: + if (_a(e.parent)) { + const i = Goe(e.name, t); + return ((n = i?.declarations) == null ? void 0 : n.length) === 1 && uL(e, t); + } + return uL(e, t); + case 177: + return tl(e.parent) ? nTe(e.parent) && uL(e, t) : iTe(e.parent.parent) && uL(e, t); + case 219: + case 220: + return iTe(e.parent); + } + return !1; + } + function uL(e, t) { + return !!e.body && !t.isImplementationOfOverload(e); + } + function nTe(e) { + return e.name ? !0 : !!$6( + e, + 90 + /* DefaultKeyword */ + ); + } + function eUe(e, t) { + return rUe(e) >= VWe && Ni( + e, + /*callback*/ + (n) => tUe(n, t) + ); + } + function tUe(e, t) { + if (Hm(e)) { + const n = t.getTypeAtLocation(e); + if (!t.isArrayType(n) && !t.isTupleType(n)) return !1; + } + return !e.modifiers && Me(e.name); + } + function iTe(e) { + return ei(e) && BC(e) && Me(e.name) && !e.type; + } + function Xoe(e) { + return e.length > 0 && V6(e[0].name); + } + function rUe(e) { + return Xoe(e) ? e.length - 1 : e.length; + } + function sTe(e) { + return Xoe(e) && (e = N.createNodeArray(e.slice(1), e.hasTrailingComma)), e; + } + function nUe(e, t) { + return Me(t) && op(t) === e ? N.createShorthandPropertyAssignment(e) : N.createPropertyAssignment(e, t); + } + function iUe(e, t) { + const n = sTe(e.parameters), i = Hm(pa(n)), s = i ? t.slice(0, n.length - 1) : t, o = hr(s, (_, u) => { + const g = Gq(n[u]), m = nUe(g, _); + return af(m.name), rl(m) && af(m.initializer), VS(_, m), m; + }); + if (i && t.length >= n.length) { + const _ = t.slice(n.length - 1), u = N.createPropertyAssignment(Gq(pa(n)), N.createArrayLiteralExpression(_)); + o.push(u); + } + return N.createObjectLiteralExpression( + o, + /*multiLine*/ + !1 + ); + } + function aTe(e, t, n) { + const i = t.getTypeChecker(), s = sTe(e.parameters), o = hr(s, m), c = N.createObjectBindingPattern(o), _ = h(s); + let u; + Ni(s, k) && (u = N.createObjectLiteralExpression()); + const g = N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + c, + /*questionToken*/ + void 0, + _, + u + ); + if (Xoe(e.parameters)) { + const D = e.parameters[0], P = N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + D.name, + /*questionToken*/ + void 0, + D.type + ); + return af(P.name), VS(D.name, P.name), D.type && (af(P.type), VS(D.type, P.type)), N.createNodeArray([P, g]); + } + return N.createNodeArray([g]); + function m(D) { + const P = N.createBindingElement( + /*dotDotDotToken*/ + void 0, + /*propertyName*/ + void 0, + Gq(D), + Hm(D) && k(D) ? N.createArrayLiteralExpression() : D.initializer + ); + return af(P), D.initializer && P.initializer && VS(D.initializer, P.initializer), P; + } + function h(D) { + const P = hr(D, S); + return gm( + N.createTypeLiteralNode(P), + 1 + /* SingleLine */ + ); + } + function S(D) { + let P = D.type; + !P && (D.initializer || Hm(D)) && (P = T(D)); + const A = N.createPropertySignature( + /*modifiers*/ + void 0, + Gq(D), + k(D) ? N.createToken( + 58 + /* QuestionToken */ + ) : D.questionToken, + P + ); + return af(A), VS(D.name, A.name), D.type && A.type && VS(D.type, A.type), A; + } + function T(D) { + const P = i.getTypeAtLocation(D); + return Cw(P, D, t, n); + } + function k(D) { + if (Hm(D)) { + const P = i.getTypeAtLocation(D); + return !i.isTupleType(P); + } + return i.isOptionalParameter(D); + } + } + function Gq(e) { + return op(e.name); + } + function sUe(e) { + switch (e.parent.kind) { + case 264: + const t = e.parent; + return t.name ? [t.name] : [E.checkDefined( + $6( + t, + 90 + /* DefaultKeyword */ + ), + "Nameless class declaration should be a default export" + )]; + case 232: + const i = e.parent, s = e.parent.parent, o = i.name; + return o ? [o, s.name] : [s.name]; + } + } + function aUe(e) { + switch (e.kind) { + case 263: + return e.name ? [e.name] : [E.checkDefined( + $6( + e, + 90 + /* DefaultKeyword */ + ), + "Nameless function declaration should be a default export" + )]; + case 175: + return [e.name]; + case 177: + const n = E.checkDefined( + Ya(e, 137, e.getSourceFile()), + "Constructor declaration should have constructor keyword" + ); + return e.parent.kind === 232 ? [e.parent.parent.name, n] : [n]; + case 220: + return [e.parent.name]; + case 219: + return e.name ? [e.name, e.parent.name] : [e.parent.name]; + default: + return E.assertNever(e, `Unexpected function declaration kind ${e.kind}`); + } + } + var oUe = {}, Qoe = "Convert to template string", Yoe = Ss(p.Convert_to_template_string), Zoe = { + name: Qoe, + description: Yoe, + kind: "refactor.rewrite.string" + }; + Hg(Qoe, { + kinds: [Zoe.kind], + getEditsForAction: lUe, + getAvailableActions: cUe + }); + function cUe(e) { + const { file: t, startPosition: n } = e, i = oTe(t, n), s = Koe(i), o = ca(s), c = { name: Qoe, description: Yoe, actions: [] }; + return o && e.triggerReason !== "invoked" ? Ge : Xm(s) && (o || _n(s) && ece(s).isValidConcatenation) ? (c.actions.push(Zoe), [c]) : e.preferences.provideRefactorNotApplicableReason ? (c.actions.push({ ...Zoe, notApplicableReason: Ss(p.Can_only_convert_string_concatenations_and_string_literals) }), [c]) : Ge; + } + function oTe(e, t) { + const n = vi(e, t), i = Koe(n); + return !ece(i).isValidConcatenation && o_(i.parent) && _n(i.parent.parent) ? i.parent.parent : n; + } + function lUe(e, t) { + const { file: n, startPosition: i } = e, s = oTe(n, i); + switch (t) { + case Yoe: + return { edits: uUe(e, s) }; + default: + return E.fail("invalid action"); + } + } + function uUe(e, t) { + const n = Koe(t), i = e.file, s = mUe(ece(n), i), o = Sy(i.text, n.end); + if (o) { + const c = o[o.length - 1], _ = { pos: o[0].pos, end: c.end }; + return cn.ChangeTracker.with(e, (u) => { + u.deleteRange(i, _), u.replaceNode(i, n, s); + }); + } else + return cn.ChangeTracker.with(e, (c) => c.replaceNode(i, n, s)); + } + function _Ue(e) { + return !(e.operatorToken.kind === 64 || e.operatorToken.kind === 65); + } + function Koe(e) { + return dr(e.parent, (n) => { + switch (n.kind) { + case 212: + case 213: + return !1; + case 229: + case 227: + return !(_n(n.parent) && _Ue(n.parent)); + default: + return "quit"; + } + }) || e; + } + function ece(e) { + const t = (c) => { + if (!_n(c)) + return { nodes: [c], operators: [], validOperators: !0, hasString: ca(c) || TS(c) }; + const { nodes: _, operators: u, hasString: g, validOperators: m } = t(c.left); + if (!(g || ca(c.right) || wF(c.right))) + return { nodes: [c], operators: [], hasString: !1, validOperators: !0 }; + const h = c.operatorToken.kind === 40, S = m && h; + return _.push(c.right), u.push(c.operatorToken), { nodes: _, operators: u, hasString: !0, validOperators: S }; + }, { nodes: n, operators: i, validOperators: s, hasString: o } = t(e); + return { nodes: n, operators: i, isValidConcatenation: s && o }; + } + var fUe = (e, t) => (n, i) => { + n < e.length && xw( + e[n], + i, + t, + 3, + /*hasTrailingNewLine*/ + !1 + ); + }, pUe = (e, t, n) => (i, s) => { + for (; i.length > 0; ) { + const o = i.shift(); + xw( + e[o], + s, + t, + 3, + /*hasTrailingNewLine*/ + !1 + ), n(o, s); + } + }; + function dUe(e) { + return e.replace(/\\.|[$`]/g, (t) => t[0] === "\\" ? t : "\\" + t); + } + function cTe(e) { + const t = Jx(e) || uz(e) ? -2 : -1; + return Qo(e).slice(1, t); + } + function lTe(e, t) { + const n = []; + let i = "", s = ""; + for (; e < t.length; ) { + const o = t[e]; + if (ja(o)) + i += o.text, s += dUe(Qo(o).slice(1, -1)), n.push(e), e++; + else if (wF(o)) { + i += o.head.text, s += cTe(o.head); + break; + } else + break; + } + return [e, i, s, n]; + } + function mUe({ nodes: e, operators: t }, n) { + const i = fUe(t, n), s = pUe(e, n, i), [o, c, _, u] = lTe(0, e); + if (o === e.length) { + const h = N.createNoSubstitutionTemplateLiteral(c, _); + return s(u, h), h; + } + const g = [], m = N.createTemplateHead(c, _); + s(u, m); + for (let h = o; h < e.length; h++) { + const S = gUe(e[h]); + i(h, S); + const [T, k, D, P] = lTe(h + 1, e); + h = T - 1; + const A = h === e.length - 1; + if (wF(S)) { + const O = hr(S.templateSpans, (F, R) => { + uTe(F); + const B = R === S.templateSpans.length - 1, U = F.literal.text + (B ? k : ""), $ = cTe(F.literal) + (B ? D : ""); + return N.createTemplateSpan( + F.expression, + A && B ? N.createTemplateTail(U, $) : N.createTemplateMiddle(U, $) + ); + }); + g.push(...O); + } else { + const O = A ? N.createTemplateTail(k, D) : N.createTemplateMiddle(k, D); + s(P, O), g.push(N.createTemplateSpan(S, O)); + } + } + return N.createTemplateExpression(m, g); + } + function uTe(e) { + const t = e.getSourceFile(); + xw( + e, + e.expression, + t, + 3, + /*hasTrailingNewLine*/ + !1 + ), ZA( + e.expression, + e.expression, + t, + 3, + /*hasTrailingNewLine*/ + !1 + ); + } + function gUe(e) { + return o_(e) && (uTe(e), e = e.expression), e; + } + var hUe = {}, $q = "Convert to optional chain expression", tce = Ss(p.Convert_to_optional_chain_expression), rce = { + name: $q, + description: tce, + kind: "refactor.rewrite.expression.optionalChain" + }; + Hg($q, { + kinds: [rce.kind], + getEditsForAction: vUe, + getAvailableActions: yUe + }); + function yUe(e) { + const t = _Te(e, e.triggerReason === "invoked"); + return t ? Oh(t) ? e.preferences.provideRefactorNotApplicableReason ? [{ + name: $q, + description: tce, + actions: [{ ...rce, notApplicableReason: t.error }] + }] : Ge : [{ + name: $q, + description: tce, + actions: [rce] + }] : Ge; + } + function vUe(e, t) { + const n = _Te(e); + return E.assert(n && !Oh(n), "Expected applicable refactor info"), { edits: cn.ChangeTracker.with(e, (s) => DUe(e.file, e.program.getTypeChecker(), s, n)), renameFilename: void 0, renameLocation: void 0 }; + } + function Xq(e) { + return _n(e) || ES(e); + } + function bUe(e) { + return Al(e) || Cf(e) || Ic(e); + } + function Qq(e) { + return Xq(e) || bUe(e); + } + function _Te(e, t = !0) { + const { file: n, program: i } = e, s = pk(e), o = s.length === 0; + if (o && !t) return; + const c = vi(n, s.start), _ = gw(n, s.start + s.length), u = Nc(c.pos, _ && _.end >= c.pos ? _.getEnd() : c.getEnd()), g = o ? CUe(c) : kUe(c, u), m = g && Qq(g) ? EUe(g) : void 0; + if (!m) return { error: Ss(p.Could_not_find_convertible_access_expression) }; + const h = i.getTypeChecker(); + return ES(m) ? SUe(m, h) : TUe(m); + } + function SUe(e, t) { + const n = e.condition, i = ice(e.whenTrue); + if (!i || t.isNullableType(t.getTypeAtLocation(i))) + return { error: Ss(p.Could_not_find_convertible_access_expression) }; + if ((wn(n) || Me(n)) && nce(n, i.expression)) + return { finalExpression: i, occurrences: [n], expression: e }; + if (_n(n)) { + const s = fTe(i.expression, n); + return s ? { finalExpression: i, occurrences: s, expression: e } : { error: Ss(p.Could_not_find_matching_access_expressions) }; + } + } + function TUe(e) { + if (e.operatorToken.kind !== 56) + return { error: Ss(p.Can_only_convert_logical_AND_access_chains) }; + const t = ice(e.right); + if (!t) return { error: Ss(p.Could_not_find_convertible_access_expression) }; + const n = fTe(t.expression, e.left); + return n ? { finalExpression: t, occurrences: n, expression: e } : { error: Ss(p.Could_not_find_matching_access_expressions) }; + } + function fTe(e, t) { + const n = []; + for (; _n(t) && t.operatorToken.kind === 56; ) { + const s = nce(Ba(e), Ba(t.right)); + if (!s) + break; + n.push(s), e = s, t = t.left; + } + const i = nce(e, t); + return i && n.push(i), n.length > 0 ? n : void 0; + } + function nce(e, t) { + if (!(!Me(t) && !wn(t) && !uo(t))) + return xUe(e, t) ? t : void 0; + } + function xUe(e, t) { + for (; (Ps(e) || wn(e) || uo(e)) && l8(e) !== l8(t); ) + e = e.expression; + for (; wn(e) && wn(t) || uo(e) && uo(t); ) { + if (l8(e) !== l8(t)) return !1; + e = e.expression, t = t.expression; + } + return Me(e) && Me(t) && e.getText() === t.getText(); + } + function l8(e) { + if (Me(e) || If(e)) + return e.getText(); + if (wn(e)) + return l8(e.name); + if (uo(e)) + return l8(e.argumentExpression); + } + function kUe(e, t) { + for (; e.parent; ) { + if (Qq(e) && t.length !== 0 && e.end >= t.start + t.length) + return e; + e = e.parent; + } + } + function CUe(e) { + for (; e.parent; ) { + if (Qq(e) && !Qq(e.parent)) + return e; + e = e.parent; + } + } + function EUe(e) { + if (Xq(e)) + return e; + if (Ic(e)) { + const t = bx(e), n = t?.initializer; + return n && Xq(n) ? n : void 0; + } + return e.expression && Xq(e.expression) ? e.expression : void 0; + } + function ice(e) { + if (e = Ba(e), _n(e)) + return ice(e.left); + if ((wn(e) || uo(e) || Ps(e)) && !Eu(e)) + return e; + } + function pTe(e, t, n) { + if (wn(t) || uo(t) || Ps(t)) { + const i = pTe(e, t.expression, n), s = n.length > 0 ? n[n.length - 1] : void 0, o = s?.getText() === t.expression.getText(); + if (o && n.pop(), Ps(t)) + return o ? N.createCallChain(i, N.createToken( + 29 + /* QuestionDotToken */ + ), t.typeArguments, t.arguments) : N.createCallChain(i, t.questionDotToken, t.typeArguments, t.arguments); + if (wn(t)) + return o ? N.createPropertyAccessChain(i, N.createToken( + 29 + /* QuestionDotToken */ + ), t.name) : N.createPropertyAccessChain(i, t.questionDotToken, t.name); + if (uo(t)) + return o ? N.createElementAccessChain(i, N.createToken( + 29 + /* QuestionDotToken */ + ), t.argumentExpression) : N.createElementAccessChain(i, t.questionDotToken, t.argumentExpression); + } + return t; + } + function DUe(e, t, n, i, s) { + const { finalExpression: o, occurrences: c, expression: _ } = i, u = c[c.length - 1], g = pTe(t, o, c); + g && (wn(g) || uo(g) || Ps(g)) && (_n(_) ? n.replaceNodeRange(e, u, o, g) : ES(_) && n.replaceNode(e, _, N.createBinaryExpression(g, N.createToken( + 61 + /* QuestionQuestionToken */ + ), _.whenFalse))); + } + var dTe = {}; + Na(dTe, { + Messages: () => su, + RangeFacts: () => hTe, + getRangeToExtract: () => sce, + getRefactorActionsToExtractSymbol: () => mTe, + getRefactorEditsToExtractSymbol: () => gTe + }); + var Pw = "Extract Symbol", Nw = { + name: "Extract Constant", + description: Ss(p.Extract_constant), + kind: "refactor.extract.constant" + }, Aw = { + name: "Extract Function", + description: Ss(p.Extract_function), + kind: "refactor.extract.function" + }; + Hg(Pw, { + kinds: [ + Nw.kind, + Aw.kind + ], + getEditsForAction: gTe, + getAvailableActions: mTe + }); + function mTe(e) { + const t = e.kind, n = sce(e.file, pk(e), e.triggerReason === "invoked"), i = n.targetRange; + if (i === void 0) { + if (!n.errors || n.errors.length === 0 || !e.preferences.provideRefactorNotApplicableReason) + return Ge; + const D = []; + return xv(Aw.kind, t) && D.push({ + name: Pw, + description: Aw.description, + actions: [{ ...Aw, notApplicableReason: k(n.errors) }] + }), xv(Nw.kind, t) && D.push({ + name: Pw, + description: Nw.description, + actions: [{ ...Nw, notApplicableReason: k(n.errors) }] + }), D; + } + const { affectedTextRange: s, extractions: o } = FUe(i, e); + if (o === void 0) + return Ge; + const c = [], _ = /* @__PURE__ */ new Map(); + let u; + const g = [], m = /* @__PURE__ */ new Map(); + let h, S = 0; + for (const { functionExtraction: D, constantExtraction: P } of o) { + if (xv(Aw.kind, t)) { + const A = D.description; + D.errors.length === 0 ? _.has(A) || (_.set(A, !0), c.push({ + description: A, + name: `function_scope_${S}`, + kind: Aw.kind, + range: { + start: { line: js(e.file, s.pos).line, offset: js(e.file, s.pos).character }, + end: { line: js(e.file, s.end).line, offset: js(e.file, s.end).character } + } + })) : u || (u = { + description: A, + name: `function_scope_${S}`, + notApplicableReason: k(D.errors), + kind: Aw.kind + }); + } + if (xv(Nw.kind, t)) { + const A = P.description; + P.errors.length === 0 ? m.has(A) || (m.set(A, !0), g.push({ + description: A, + name: `constant_scope_${S}`, + kind: Nw.kind, + range: { + start: { line: js(e.file, s.pos).line, offset: js(e.file, s.pos).character }, + end: { line: js(e.file, s.end).line, offset: js(e.file, s.end).character } + } + })) : h || (h = { + description: A, + name: `constant_scope_${S}`, + notApplicableReason: k(P.errors), + kind: Nw.kind + }); + } + S++; + } + const T = []; + return c.length ? T.push({ + name: Pw, + description: Ss(p.Extract_function), + actions: c + }) : e.preferences.provideRefactorNotApplicableReason && u && T.push({ + name: Pw, + description: Ss(p.Extract_function), + actions: [u] + }), g.length ? T.push({ + name: Pw, + description: Ss(p.Extract_constant), + actions: g + }) : e.preferences.provideRefactorNotApplicableReason && h && T.push({ + name: Pw, + description: Ss(p.Extract_constant), + actions: [h] + }), T.length ? T : Ge; + function k(D) { + let P = D[0].messageText; + return typeof P != "string" && (P = P.messageText), P; + } + } + function gTe(e, t) { + const i = sce(e.file, pk(e)).targetRange, s = /^function_scope_(\d+)$/.exec(t); + if (s) { + const c = +s[1]; + return E.assert(isFinite(c), "Expected to parse a finite number from the function scope index"), AUe(i, e, c); + } + const o = /^constant_scope_(\d+)$/.exec(t); + if (o) { + const c = +o[1]; + return E.assert(isFinite(c), "Expected to parse a finite number from the constant scope index"), IUe(i, e, c); + } + E.fail("Unrecognized action name"); + } + var su; + ((e) => { + function t(n) { + return { message: n, code: 0, category: 3, key: n }; + } + e.cannotExtractRange = t("Cannot extract range."), e.cannotExtractImport = t("Cannot extract import statement."), e.cannotExtractSuper = t("Cannot extract super call."), e.cannotExtractJSDoc = t("Cannot extract JSDoc."), e.cannotExtractEmpty = t("Cannot extract empty range."), e.expressionExpected = t("expression expected."), e.uselessConstantType = t("No reason to extract constant of type."), e.statementOrExpressionExpected = t("Statement or expression expected."), e.cannotExtractRangeContainingConditionalBreakOrContinueStatements = t("Cannot extract range containing conditional break or continue statements."), e.cannotExtractRangeContainingConditionalReturnStatement = t("Cannot extract range containing conditional return statement."), e.cannotExtractRangeContainingLabeledBreakOrContinueStatementWithTargetOutsideOfTheRange = t("Cannot extract range containing labeled break or continue with target outside of the range."), e.cannotExtractRangeThatContainsWritesToReferencesLocatedOutsideOfTheTargetRangeInGenerators = t("Cannot extract range containing writes to references located outside of the target range in generators."), e.typeWillNotBeVisibleInTheNewScope = t("Type will not visible in the new scope."), e.functionWillNotBeVisibleInTheNewScope = t("Function will not visible in the new scope."), e.cannotExtractIdentifier = t("Select more than a single identifier."), e.cannotExtractExportedEntity = t("Cannot extract exported declaration"), e.cannotWriteInExpression = t("Cannot write back side-effects when extracting an expression"), e.cannotExtractReadonlyPropertyInitializerOutsideConstructor = t("Cannot move initialization of read-only class property outside of the constructor"), e.cannotExtractAmbientBlock = t("Cannot extract code from ambient contexts"), e.cannotAccessVariablesFromNestedScopes = t("Cannot access variables from nested scopes"), e.cannotExtractToJSClass = t("Cannot extract constant to a class scope in JS"), e.cannotExtractToExpressionArrowFunction = t("Cannot extract constant to an arrow function without a block"), e.cannotExtractFunctionsContainingThisToMethod = t("Cannot extract functions containing this to method"); + })(su || (su = {})); + var hTe = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.HasReturn = 1] = "HasReturn", e[e.IsGenerator = 2] = "IsGenerator", e[e.IsAsyncFunction = 4] = "IsAsyncFunction", e[e.UsesThis = 8] = "UsesThis", e[e.UsesThisInFunction = 16] = "UsesThisInFunction", e[e.InStaticRegion = 32] = "InStaticRegion", e))(hTe || {}); + function sce(e, t, n = !0) { + const { length: i } = t; + if (i === 0 && !n) + return { errors: [ll(e, t.start, i, su.cannotExtractEmpty)] }; + const s = i === 0 && n, o = rae(e, t.start), c = gw(e, ec(t)), _ = o && c && n ? wUe(o, c, e) : t, u = s ? KUe(o) : XA(o, e, _), g = s ? u : XA(c, e, _); + let m = 0, h; + if (!u || !g) + return { errors: [ll(e, t.start, i, su.cannotExtractRange)] }; + if (u.flags & 16777216) + return { errors: [ll(e, t.start, i, su.cannotExtractJSDoc)] }; + if (u.parent !== g.parent) + return { errors: [ll(e, t.start, i, su.cannotExtractRange)] }; + if (u !== g) { + if (!dk(u.parent)) + return { errors: [ll(e, t.start, i, su.cannotExtractRange)] }; + const O = []; + for (const F of u.parent.statements) { + if (F === u || O.length) { + const R = A(F); + if (R) + return { errors: R }; + O.push(F); + } + if (F === g) + break; + } + return O.length ? { targetRange: { range: O, facts: m, thisNode: h } } : { errors: [ll(e, t.start, i, su.cannotExtractRange)] }; + } + if (Cf(u) && !u.expression) + return { errors: [ll(e, t.start, i, su.cannotExtractRange)] }; + const S = k(u), T = D(S) || A(S); + if (T) + return { errors: T }; + return { targetRange: { range: PUe(S), facts: m, thisNode: h } }; + function k(O) { + if (Cf(O)) { + if (O.expression) + return O.expression; + } else if (Ic(O) || Ul(O)) { + const F = Ic(O) ? O.declarationList.declarations : O.declarations; + let R = 0, B; + for (const U of F) + U.initializer && (R++, B = U.initializer); + if (R === 1) + return B; + } else if (ei(O) && O.initializer) + return O.initializer; + return O; + } + function D(O) { + if (Me(Al(O) ? O.expression : O)) + return [sn(O, su.cannotExtractIdentifier)]; + } + function P(O, F) { + let R = O; + for (; R !== F; ) { + if (R.kind === 173) { + Js(R) && (m |= 32); + break; + } else if (R.kind === 170) { + Af(R).kind === 177 && (m |= 32); + break; + } else R.kind === 175 && Js(R) && (m |= 32); + R = R.parent; + } + } + function A(O) { + let F; + if (((_e) => { + _e[_e.None = 0] = "None", _e[_e.Break = 1] = "Break", _e[_e.Continue = 2] = "Continue", _e[_e.Return = 4] = "Return"; + })(F || (F = {})), E.assert(O.pos <= O.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809 (1)"), E.assert(!Nd(O.pos), "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809 (2)"), !Ti(O) && !(Xm(O) && yTe(O)) && !uce(O)) + return [sn(O, su.statementOrExpressionExpected)]; + if (O.flags & 33554432) + return [sn(O, su.cannotExtractAmbientBlock)]; + const R = Wl(O); + R && P(O, R); + let B, U = 4, $; + if (W(O), m & 8) { + const _e = qu( + O, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + (_e.kind === 263 || _e.kind === 175 && _e.parent.kind === 211 || _e.kind === 219) && (m |= 16); + } + return B; + function W(_e) { + if (B) + return !0; + if (Pl(_e)) { + const V = _e.kind === 261 ? _e.parent.parent : _e; + if (Gn( + V, + 32 + /* Export */ + )) + return (B || (B = [])).push(sn(_e, su.cannotExtractExportedEntity)), !0; + } + switch (_e.kind) { + case 273: + return (B || (B = [])).push(sn(_e, su.cannotExtractImport)), !0; + case 278: + return (B || (B = [])).push(sn(_e, su.cannotExtractExportedEntity)), !0; + case 108: + if (_e.parent.kind === 214) { + const V = Wl(_e); + if (V === void 0 || V.pos < t.start || V.end >= t.start + t.length) + return (B || (B = [])).push(sn(_e, su.cannotExtractSuper)), !0; + } else + m |= 8, h = _e; + break; + case 220: + xs(_e, function V(ae) { + if (V6(ae)) + m |= 8, h = _e; + else { + if ($n(ae) || Es(ae) && !xo(ae)) + return !1; + xs(ae, V); + } + }); + // falls through + case 264: + case 263: + Di(_e.parent) && _e.parent.externalModuleIndicator === void 0 && (B || (B = [])).push(sn(_e, su.functionWillNotBeVisibleInTheNewScope)); + // falls through + case 232: + case 219: + case 175: + case 177: + case 178: + case 179: + return !1; + } + const K = U; + switch (_e.kind) { + case 246: + U &= -5; + break; + case 259: + U = 0; + break; + case 242: + _e.parent && _e.parent.kind === 259 && _e.parent.finallyBlock === _e && (U = 4); + break; + case 298: + case 297: + U |= 1; + break; + default: + wy( + _e, + /*lookInLabeledStatements*/ + !1 + ) && (U |= 3); + break; + } + switch (_e.kind) { + case 198: + case 110: + m |= 8, h = _e; + break; + case 257: { + const V = _e.label; + ($ || ($ = [])).push(V.escapedText), xs(_e, W), $.pop(); + break; + } + case 253: + case 252: { + const V = _e.label; + V ? ms($, V.escapedText) || (B || (B = [])).push(sn(_e, su.cannotExtractRangeContainingLabeledBreakOrContinueStatementWithTargetOutsideOfTheRange)) : U & (_e.kind === 253 ? 1 : 2) || (B || (B = [])).push(sn(_e, su.cannotExtractRangeContainingConditionalBreakOrContinueStatements)); + break; + } + case 224: + m |= 4; + break; + case 230: + m |= 2; + break; + case 254: + U & 4 ? m |= 1 : (B || (B = [])).push(sn(_e, su.cannotExtractRangeContainingConditionalReturnStatement)); + break; + default: + xs(_e, W); + break; + } + U = K; + } + } + } + function wUe(e, t, n) { + const i = e.getStart(n); + let s = t.getEnd(); + return n.text.charCodeAt(s) === 59 && s++, { start: i, length: s - i }; + } + function PUe(e) { + if (Ti(e)) + return [e]; + if (Xm(e)) + return Al(e.parent) ? [e.parent] : e; + if (uce(e)) + return e; + } + function ace(e) { + return xo(e) ? Xj(e.body) : io(e) || Di(e) || vm(e) || $n(e); + } + function NUe(e) { + let t = F0(e.range) ? Ca(e.range) : e.range; + if (e.facts & 8 && !(e.facts & 16)) { + const i = Wl(t); + if (i) { + const s = dr(t, io); + return s ? [s, i] : [i]; + } + } + const n = []; + for (; ; ) + if (t = t.parent, t.kind === 170 && (t = dr(t, (i) => io(i)).parent), ace(t) && (n.push(t), t.kind === 308)) + return n; + } + function AUe(e, t, n) { + const { scopes: i, readsAndWrites: { target: s, usagesPerScope: o, functionErrorsPerScope: c, exposedVariableDeclarations: _ } } = oce(e, t); + return E.assert(!c[n].length, "The extraction went missing? How?"), t.cancellationToken.throwIfCancellationRequested(), BUe(s, i[n], o[n], _, e, t); + } + function IUe(e, t, n) { + const { scopes: i, readsAndWrites: { target: s, usagesPerScope: o, constantErrorsPerScope: c, exposedVariableDeclarations: _ } } = oce(e, t); + E.assert(!c[n].length, "The extraction went missing? How?"), E.assert(_.length === 0, "Extract constant accepted a range containing a variable declaration?"), t.cancellationToken.throwIfCancellationRequested(); + const u = ut(s) ? s : s.statements[0].expression; + return JUe(u, i[n], o[n], e.facts, t); + } + function FUe(e, t) { + const { scopes: n, affectedTextRange: i, readsAndWrites: { functionErrorsPerScope: s, constantErrorsPerScope: o } } = oce(e, t), c = n.map((_, u) => { + const g = OUe(_), m = LUe(_), h = io(_) ? MUe(_) : $n(_) ? RUe(_) : jUe(_); + let S, T; + return h === 1 ? (S = jg(Ss(p.Extract_to_0_in_1_scope), [g, "global"]), T = jg(Ss(p.Extract_to_0_in_1_scope), [m, "global"])) : h === 0 ? (S = jg(Ss(p.Extract_to_0_in_1_scope), [g, "module"]), T = jg(Ss(p.Extract_to_0_in_1_scope), [m, "module"])) : (S = jg(Ss(p.Extract_to_0_in_1), [g, h]), T = jg(Ss(p.Extract_to_0_in_1), [m, h])), u === 0 && !$n(_) && (T = jg(Ss(p.Extract_to_0_in_enclosing_scope), [m])), { + functionExtraction: { + description: S, + errors: s[u] + }, + constantExtraction: { + description: T, + errors: o[u] + } + }; + }); + return { affectedTextRange: i, extractions: c }; + } + function oce(e, t) { + const { file: n } = t, i = NUe(e), s = YUe(e, n), o = ZUe( + e, + i, + s, + n, + t.program.getTypeChecker(), + t.cancellationToken + ); + return { scopes: i, affectedTextRange: s, readsAndWrites: o }; + } + function OUe(e) { + return io(e) ? "inner function" : $n(e) ? "method" : "function"; + } + function LUe(e) { + return $n(e) ? "readonly field" : "constant"; + } + function MUe(e) { + switch (e.kind) { + case 177: + return "constructor"; + case 219: + case 263: + return e.name ? `function '${e.name.text}'` : aq; + case 220: + return "arrow function"; + case 175: + return `method '${e.name.getText()}'`; + case 178: + return `'get ${e.name.getText()}'`; + case 179: + return `'set ${e.name.getText()}'`; + default: + E.assertNever(e, `Unexpected scope kind ${e.kind}`); + } + } + function RUe(e) { + return e.kind === 264 ? e.name ? `class '${e.name.text}'` : "anonymous class declaration" : e.name ? `class expression '${e.name.text}'` : "anonymous class expression"; + } + function jUe(e) { + return e.kind === 269 ? `namespace '${e.parent.name.getText()}'` : e.externalModuleIndicator ? 0 : 1; + } + function BUe(e, t, { usages: n, typeParameterUsages: i, substitutions: s }, o, c, _) { + const u = _.program.getTypeChecker(), g = da(_.program.getCompilerOptions()), m = Ou.createImportAdder(_.file, _.program, _.preferences, _.host), h = t.getSourceFile(), S = qS($n(t) ? "newMethod" : "newFunction", h), T = an(t), k = N.createIdentifier(S); + let D; + const P = [], A = []; + let O; + n.forEach((Z, pe) => { + let Te; + if (!T) { + let Ye = u.getTypeOfSymbolAtLocation(Z.symbol, Z.node); + Ye = u.getBaseTypeOfLiteralType(Ye), Te = Ou.typeToAutoImportableTypeNode( + u, + m, + Ye, + t, + g, + 1, + 8 + /* AllowUnresolvedNames */ + ); + } + const Fe = N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + /*name*/ + pe, + /*questionToken*/ + void 0, + Te + ); + P.push(Fe), Z.usage === 2 && (O || (O = [])).push(Z), A.push(N.createIdentifier(pe)); + }); + const F = is(i.values(), (Z) => ({ type: Z, declaration: WUe(Z, _.startPosition) })); + F.sort(UUe); + const R = F.length === 0 ? void 0 : Fi(F, ({ declaration: Z }) => Z), B = R !== void 0 ? R.map((Z) => N.createTypeReferenceNode( + Z.name, + /*typeArguments*/ + void 0 + )) : void 0; + if (ut(e) && !T) { + const Z = u.getContextualType(e); + D = u.typeToTypeNode( + Z, + t, + 1, + 8 + /* AllowUnresolvedNames */ + ); + } + const { body: U, returnValueProperty: $ } = qUe(e, o, O, s, !!(c.facts & 1)); + af(U); + let W; + const _e = !!(c.facts & 16); + if ($n(t)) { + const Z = T ? [] : [N.createModifier( + 123 + /* PrivateKeyword */ + )]; + c.facts & 32 && Z.push(N.createModifier( + 126 + /* StaticKeyword */ + )), c.facts & 4 && Z.push(N.createModifier( + 134 + /* AsyncKeyword */ + )), W = N.createMethodDeclaration( + Z.length ? Z : void 0, + c.facts & 2 ? N.createToken( + 42 + /* AsteriskToken */ + ) : void 0, + k, + /*questionToken*/ + void 0, + R, + P, + D, + U + ); + } else + _e && P.unshift( + N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + /*name*/ + "this", + /*questionToken*/ + void 0, + u.typeToTypeNode( + u.getTypeAtLocation(c.thisNode), + t, + 1, + 8 + /* AllowUnresolvedNames */ + ), + /*initializer*/ + void 0 + ) + ), W = N.createFunctionDeclaration( + c.facts & 4 ? [N.createToken( + 134 + /* AsyncKeyword */ + )] : void 0, + c.facts & 2 ? N.createToken( + 42 + /* AsteriskToken */ + ) : void 0, + k, + R, + P, + D, + U + ); + const K = cn.ChangeTracker.fromContext(_), V = (F0(c.range) ? pa(c.range) : c.range).end, ae = $Ue(V, t); + ae ? K.insertNodeBefore( + _.file, + ae, + W, + /*blankLineBetween*/ + !0 + ) : K.insertNodeAtEndOfScope(_.file, t, W), m.writeFixes(K); + const se = [], ce = VUe(t, c, S); + _e && A.unshift(N.createIdentifier("this")); + let fe = N.createCallExpression( + _e ? N.createPropertyAccessExpression( + ce, + "call" + ) : ce, + B, + // Note that no attempt is made to take advantage of type argument inference + A + ); + if (c.facts & 2 && (fe = N.createYieldExpression(N.createToken( + 42 + /* AsteriskToken */ + ), fe)), c.facts & 4 && (fe = N.createAwaitExpression(fe)), lce(e) && (fe = N.createJsxExpression( + /*dotDotDotToken*/ + void 0, + fe + )), o.length && !O) + if (E.assert(!$, "Expected no returnValueProperty"), E.assert(!(c.facts & 1), "Expected RangeFacts.HasReturn flag to be unset"), o.length === 1) { + const Z = o[0]; + se.push(N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [N.createVariableDeclaration( + qa(Z.name), + /*exclamationToken*/ + void 0, + /*type*/ + qa(Z.type), + /*initializer*/ + fe + )], + Z.parent.flags + ) + )); + } else { + const Z = [], pe = []; + let Te = o[0].parent.flags, Fe = !1; + for (const ne of o) { + Z.push(N.createBindingElement( + /*dotDotDotToken*/ + void 0, + /*propertyName*/ + void 0, + /*name*/ + qa(ne.name) + )); + const Se = u.typeToTypeNode( + u.getBaseTypeOfLiteralType(u.getTypeAtLocation(ne)), + t, + 1, + 8 + /* AllowUnresolvedNames */ + ); + pe.push(N.createPropertySignature( + /*modifiers*/ + void 0, + /*name*/ + ne.symbol.name, + /*questionToken*/ + void 0, + /*type*/ + Se + )), Fe = Fe || ne.type !== void 0, Te = Te & ne.parent.flags; + } + const Ye = Fe ? N.createTypeLiteralNode(pe) : void 0; + Ye && un( + Ye, + 1 + /* SingleLine */ + ), se.push(N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [N.createVariableDeclaration( + N.createObjectBindingPattern(Z), + /*exclamationToken*/ + void 0, + /*type*/ + Ye, + /*initializer*/ + fe + )], + Te + ) + )); + } + else if (o.length || O) { + if (o.length) + for (const pe of o) { + let Te = pe.parent.flags; + Te & 2 && (Te = Te & -3 | 1), se.push(N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [N.createVariableDeclaration( + pe.symbol.name, + /*exclamationToken*/ + void 0, + me(pe.type) + )], + Te + ) + )); + } + $ && se.push(N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [N.createVariableDeclaration( + $, + /*exclamationToken*/ + void 0, + me(D) + )], + 1 + /* Let */ + ) + )); + const Z = cce(o, O); + $ && Z.unshift(N.createShorthandPropertyAssignment($)), Z.length === 1 ? (E.assert(!$, "Shouldn't have returnValueProperty here"), se.push(N.createExpressionStatement(N.createAssignment(Z[0].name, fe))), c.facts & 1 && se.push(N.createReturnStatement())) : (se.push(N.createExpressionStatement(N.createAssignment(N.createObjectLiteralExpression(Z), fe))), $ && se.push(N.createReturnStatement(N.createIdentifier($)))); + } else + c.facts & 1 ? se.push(N.createReturnStatement(fe)) : F0(c.range) ? se.push(N.createExpressionStatement(fe)) : se.push(fe); + F0(c.range) ? K.replaceNodeRangeWithNodes(_.file, Ca(c.range), pa(c.range), se) : K.replaceNodeWithNodes(_.file, c.range, se); + const he = K.getChanges(), be = (F0(c.range) ? Ca(c.range) : c.range).getSourceFile().fileName, je = YA( + he, + be, + S, + /*preferLastLocation*/ + !1 + ); + return { renameFilename: be, renameLocation: je, edits: he }; + function me(Z) { + if (Z === void 0) + return; + const pe = qa(Z); + let Te = pe; + for (; kS(Te); ) + Te = Te.type; + return C0(Te) && Nn( + Te.types, + (Fe) => Fe.kind === 157 + /* UndefinedKeyword */ + ) ? pe : N.createUnionTypeNode([pe, N.createKeywordTypeNode( + 157 + /* UndefinedKeyword */ + )]); + } + } + function JUe(e, t, { substitutions: n }, i, s) { + const o = s.program.getTypeChecker(), c = t.getSourceFile(), _ = Boe(e, t, o, c), u = an(t); + let g = u || !o.isContextSensitive(e) ? void 0 : o.typeToTypeNode( + o.getContextualType(e), + t, + 1, + 8 + /* AllowUnresolvedNames */ + ), m = HUe(Ba(e), n); + ({ variableType: g, initializer: m } = D(g, m)), af(m); + const h = cn.ChangeTracker.fromContext(s); + if ($n(t)) { + E.assert(!u, "Cannot extract to a JS class"); + const P = []; + P.push(N.createModifier( + 123 + /* PrivateKeyword */ + )), i & 32 && P.push(N.createModifier( + 126 + /* StaticKeyword */ + )), P.push(N.createModifier( + 148 + /* ReadonlyKeyword */ + )); + const A = N.createPropertyDeclaration( + P, + _, + /*questionOrExclamationToken*/ + void 0, + g, + m + ); + let O = N.createPropertyAccessExpression( + i & 32 ? N.createIdentifier(t.name.getText()) : N.createThis(), + N.createIdentifier(_) + ); + lce(e) && (O = N.createJsxExpression( + /*dotDotDotToken*/ + void 0, + O + )); + const F = e.pos, R = XUe(F, t); + h.insertNodeBefore( + s.file, + R, + A, + /*blankLineBetween*/ + !0 + ), h.replaceNode(s.file, e, O); + } else { + const P = N.createVariableDeclaration( + _, + /*exclamationToken*/ + void 0, + g, + m + ), A = zUe(e, t); + if (A) { + h.insertNodeBefore(s.file, A, P); + const O = N.createIdentifier(_); + h.replaceNode(s.file, e, O); + } else if (e.parent.kind === 245 && t === dr(e, ace)) { + const O = N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [P], + 2 + /* Const */ + ) + ); + h.replaceNode(s.file, e.parent, O); + } else { + const O = N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [P], + 2 + /* Const */ + ) + ), F = QUe(e, t); + if (F.pos === 0 ? h.insertNodeAtTopOfFile( + s.file, + O, + /*blankLineBetween*/ + !1 + ) : h.insertNodeBefore( + s.file, + F, + O, + /*blankLineBetween*/ + !1 + ), e.parent.kind === 245) + h.delete(s.file, e.parent); + else { + let R = N.createIdentifier(_); + lce(e) && (R = N.createJsxExpression( + /*dotDotDotToken*/ + void 0, + R + )), h.replaceNode(s.file, e, R); + } + } + } + const S = h.getChanges(), T = e.getSourceFile().fileName, k = YA( + S, + T, + _, + /*preferLastLocation*/ + !0 + ); + return { renameFilename: T, renameLocation: k, edits: S }; + function D(P, A) { + if (P === void 0) return { variableType: P, initializer: A }; + if (!yo(A) && !xo(A) || A.typeParameters) return { variableType: P, initializer: A }; + const O = o.getTypeAtLocation(e), F = xg(o.getSignaturesOfType( + O, + 0 + /* Call */ + )); + if (!F) return { variableType: P, initializer: A }; + if (F.getTypeParameters()) return { variableType: P, initializer: A }; + const R = []; + let B = !1; + for (const U of A.parameters) + if (U.type) + R.push(U); + else { + const $ = o.getTypeAtLocation(U); + $ === o.getAnyType() && (B = !0), R.push(N.updateParameterDeclaration(U, U.modifiers, U.dotDotDotToken, U.name, U.questionToken, U.type || o.typeToTypeNode( + $, + t, + 1, + 8 + /* AllowUnresolvedNames */ + ), U.initializer)); + } + if (B) return { variableType: P, initializer: A }; + if (P = void 0, xo(A)) + A = N.updateArrowFunction(A, Vp(e) ? Tb(e) : void 0, A.typeParameters, R, A.type || o.typeToTypeNode( + F.getReturnType(), + t, + 1, + 8 + /* AllowUnresolvedNames */ + ), A.equalsGreaterThanToken, A.body); + else { + if (F && F.thisParameter) { + const U = Yc(R); + if (!U || Me(U.name) && U.name.escapedText !== "this") { + const $ = o.getTypeOfSymbolAtLocation(F.thisParameter, e); + R.splice( + 0, + 0, + N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "this", + /*questionToken*/ + void 0, + o.typeToTypeNode( + $, + t, + 1, + 8 + /* AllowUnresolvedNames */ + ) + ) + ); + } + } + A = N.updateFunctionExpression(A, Vp(e) ? Tb(e) : void 0, A.asteriskToken, A.name, A.typeParameters, R, A.type || o.typeToTypeNode( + F.getReturnType(), + t, + 1 + /* NoTruncation */ + ), A.body); + } + return { variableType: P, initializer: A }; + } + } + function zUe(e, t) { + let n; + for (; e !== void 0 && e !== t; ) { + if (ei(e) && e.initializer === n && Ul(e.parent) && e.parent.declarations.length > 1) + return e; + n = e, e = e.parent; + } + } + function WUe(e, t) { + let n; + const i = e.symbol; + if (i && i.declarations) + for (const s of i.declarations) + (n === void 0 || s.pos < n.pos) && s.pos < t && (n = s); + return n; + } + function UUe({ type: e, declaration: t }, { type: n, declaration: i }) { + return pQ(t, i, "pos", ho) || _u( + e.symbol ? e.symbol.getName() : "", + n.symbol ? n.symbol.getName() : "" + ) || ho(e.id, n.id); + } + function VUe(e, t, n) { + const i = N.createIdentifier(n); + if ($n(e)) { + const s = t.facts & 32 ? N.createIdentifier(e.name.text) : N.createThis(); + return N.createPropertyAccessExpression(s, i); + } else + return i; + } + function qUe(e, t, n, i, s) { + const o = n !== void 0 || t.length > 0; + if (Ns(e) && !o && i.size === 0) + return { body: N.createBlock( + e.statements, + /*multiLine*/ + !0 + ), returnValueProperty: void 0 }; + let c, _ = !1; + const u = N.createNodeArray(Ns(e) ? e.statements.slice(0) : [Ti(e) ? e : N.createReturnStatement(Ba(e))]); + if (o || i.size) { + const m = Ar(u, g, Ti).slice(); + if (o && !s && Ti(e)) { + const h = cce(t, n); + h.length === 1 ? m.push(N.createReturnStatement(h[0].name)) : m.push(N.createReturnStatement(N.createObjectLiteralExpression(h))); + } + return { body: N.createBlock( + m, + /*multiLine*/ + !0 + ), returnValueProperty: c }; + } else + return { body: N.createBlock( + u, + /*multiLine*/ + !0 + ), returnValueProperty: void 0 }; + function g(m) { + if (!_ && Cf(m) && o) { + const h = cce(t, n); + return m.expression && (c || (c = "__return"), h.unshift(N.createPropertyAssignment(c, Qe(m.expression, g, ut)))), h.length === 1 ? N.createReturnStatement(h[0].name) : N.createReturnStatement(N.createObjectLiteralExpression(h)); + } else { + const h = _; + _ = _ || io(m) || $n(m); + const S = i.get(Ma(m).toString()), T = S ? qa(S) : br( + m, + g, + /*context*/ + void 0 + ); + return _ = h, T; + } + } + } + function HUe(e, t) { + return t.size ? n(e) : e; + function n(i) { + const s = t.get(Ma(i).toString()); + return s ? qa(s) : br( + i, + n, + /*context*/ + void 0 + ); + } + } + function GUe(e) { + if (io(e)) { + const t = e.body; + if (Ns(t)) + return t.statements; + } else { + if (vm(e) || Di(e)) + return e.statements; + if ($n(e)) + return e.members; + } + return Ge; + } + function $Ue(e, t) { + return Nn(GUe(t), (n) => n.pos >= e && io(n) && !nc(n)); + } + function XUe(e, t) { + const n = t.members; + E.assert(n.length > 0, "Found no members"); + let i, s = !0; + for (const o of n) { + if (o.pos > e) + return i || n[0]; + if (s && !os(o)) { + if (i !== void 0) + return o; + s = !1; + } + i = o; + } + return i === void 0 ? E.fail() : i; + } + function QUe(e, t) { + E.assert(!$n(t)); + let n; + for (let i = e; i !== t; i = i.parent) + ace(i) && (n = i); + for (let i = (n || e).parent; ; i = i.parent) { + if (dk(i)) { + let s; + for (const o of i.statements) { + if (o.pos > e.pos) + break; + s = o; + } + return !s && y6(i) ? (E.assert(F4(i.parent.parent), "Grandparent isn't a switch statement"), i.parent.parent) : E.checkDefined(s, "prevStatement failed to get set"); + } + E.assert(i !== t, "Didn't encounter a block-like before encountering scope"); + } + } + function cce(e, t) { + const n = hr(e, (s) => N.createShorthandPropertyAssignment(s.symbol.name)), i = hr(t, (s) => N.createShorthandPropertyAssignment(s.symbol.name)); + return n === void 0 ? i : i === void 0 ? n : n.concat(i); + } + function F0(e) { + return as(e); + } + function YUe(e, t) { + return F0(e.range) ? { pos: Ca(e.range).getStart(t), end: pa(e.range).getEnd() } : e.range; + } + function ZUe(e, t, n, i, s, o) { + const c = /* @__PURE__ */ new Map(), _ = [], u = [], g = [], m = [], h = [], S = /* @__PURE__ */ new Map(), T = []; + let k; + const D = F0(e.range) ? e.range.length === 1 && Al(e.range[0]) ? e.range[0].expression : void 0 : e.range; + let P; + if (D === void 0) { + const se = e.range, ce = Ca(se).getStart(), fe = pa(se).end; + P = ll(i, ce, fe - ce, su.expressionExpected); + } else s.getTypeAtLocation(D).flags & 147456 && (P = sn(D, su.uselessConstantType)); + for (const se of t) { + _.push({ usages: /* @__PURE__ */ new Map(), typeParameterUsages: /* @__PURE__ */ new Map(), substitutions: /* @__PURE__ */ new Map() }), u.push(/* @__PURE__ */ new Map()), g.push([]); + const ce = []; + P && ce.push(P), $n(se) && an(se) && ce.push(sn(se, su.cannotExtractToJSClass)), xo(se) && !Ns(se.body) && ce.push(sn(se, su.cannotExtractToExpressionArrowFunction)), m.push(ce); + } + const A = /* @__PURE__ */ new Map(), O = F0(e.range) ? N.createBlock(e.range) : e.range, F = F0(e.range) ? Ca(e.range) : e.range, R = B(F); + if ($(O), R && !F0(e.range) && !Tm(e.range)) { + const se = s.getContextualType(e.range); + U(se); + } + if (c.size > 0) { + const se = /* @__PURE__ */ new Map(); + let ce = 0; + for (let fe = F; fe !== void 0 && ce < t.length; fe = fe.parent) + if (fe === t[ce] && (se.forEach((he, q) => { + _[ce].typeParameterUsages.set(q, he); + }), ce++), gB(fe)) + for (const he of xy(fe)) { + const q = s.getTypeAtLocation(he); + c.has(q.id.toString()) && se.set(q.id.toString(), q); + } + E.assert(ce === t.length, "Should have iterated all scopes"); + } + if (h.length) { + const se = mB(t[0], t[0].parent) ? t[0] : Dd(t[0]); + xs(se, K); + } + for (let se = 0; se < t.length; se++) { + const ce = _[se]; + if (se > 0 && (ce.usages.size > 0 || ce.typeParameterUsages.size > 0)) { + const q = F0(e.range) ? e.range[0] : e.range; + m[se].push(sn(q, su.cannotAccessVariablesFromNestedScopes)); + } + e.facts & 16 && $n(t[se]) && g[se].push(sn(e.thisNode, su.cannotExtractFunctionsContainingThisToMethod)); + let fe = !1, he; + if (_[se].usages.forEach((q) => { + q.usage === 2 && (fe = !0, q.symbol.flags & 106500 && q.symbol.valueDeclaration && sf( + q.symbol.valueDeclaration, + 8 + /* Readonly */ + ) && (he = q.symbol.valueDeclaration)); + }), E.assert(F0(e.range) || T.length === 0, "No variable declarations expected if something was extracted"), fe && !F0(e.range)) { + const q = sn(e.range, su.cannotWriteInExpression); + g[se].push(q), m[se].push(q); + } else if (he && se > 0) { + const q = sn(he, su.cannotExtractReadonlyPropertyInitializerOutsideConstructor); + g[se].push(q), m[se].push(q); + } else if (k) { + const q = sn(k, su.cannotExtractExportedEntity); + g[se].push(q), m[se].push(q); + } + } + return { target: O, usagesPerScope: _, functionErrorsPerScope: g, constantErrorsPerScope: m, exposedVariableDeclarations: T }; + function B(se) { + return !!dr(se, (ce) => gB(ce) && xy(ce).length !== 0); + } + function U(se) { + const ce = s.getSymbolWalker(() => (o.throwIfCancellationRequested(), !0)), { visitedTypes: fe } = ce.walkType(se); + for (const he of fe) + he.isTypeParameter() && c.set(he.id.toString(), he); + } + function $(se, ce = 1) { + if (R) { + const fe = s.getTypeAtLocation(se); + U(fe); + } + if (Pl(se) && se.symbol && h.push(se), Nl(se)) + $( + se.left, + 2 + /* Write */ + ), $(se.right); + else if (wZ(se)) + $( + se.operand, + 2 + /* Write */ + ); + else if (wn(se) || uo(se)) + xs(se, $); + else if (Me(se)) { + if (!se.parent || s_(se.parent) && se !== se.parent.left || wn(se.parent) && se !== se.parent.expression) + return; + W( + se, + ce, + /*isTypeNode*/ + lm(se) + ); + } else + xs(se, $); + } + function W(se, ce, fe) { + const he = _e(se, ce, fe); + if (he) + for (let q = 0; q < t.length; q++) { + const be = u[q].get(he); + be && _[q].substitutions.set(Ma(se).toString(), be); + } + } + function _e(se, ce, fe) { + const he = V(se); + if (!he) + return; + const q = Xs(he).toString(), be = A.get(q); + if (be && be >= ce) + return q; + if (A.set(q, ce), be) { + for (const Z of _) + Z.usages.get(se.text) && Z.usages.set(se.text, { usage: ce, symbol: he, node: se }); + return q; + } + const je = he.getDeclarations(), me = je && Nn(je, (Z) => Z.getSourceFile() === i); + if (me && !WA(n, me.getStart(), me.end)) { + if (e.facts & 2 && ce === 2) { + const Z = sn(se, su.cannotExtractRangeThatContainsWritesToReferencesLocatedOutsideOfTheTargetRangeInGenerators); + for (const pe of g) + pe.push(Z); + for (const pe of m) + pe.push(Z); + } + for (let Z = 0; Z < t.length; Z++) { + const pe = t[Z]; + if (s.resolveName( + he.name, + pe, + he.flags, + /*excludeGlobals*/ + !1 + ) !== he && !u[Z].has(q)) { + const Fe = ae(he.exportSymbol || he, pe, fe); + if (Fe) + u[Z].set(q, Fe); + else if (fe) { + if (!(he.flags & 262144)) { + const Ye = sn(se, su.typeWillNotBeVisibleInTheNewScope); + g[Z].push(Ye), m[Z].push(Ye); + } + } else + _[Z].usages.set(se.text, { usage: ce, symbol: he, node: se }); + } + } + return q; + } + } + function K(se) { + if (se === e.range || F0(e.range) && e.range.includes(se)) + return; + const ce = Me(se) ? V(se) : s.getSymbolAtLocation(se); + if (ce) { + const fe = Nn(h, (he) => he.symbol === ce); + if (fe) + if (ei(fe)) { + const he = fe.symbol.id.toString(); + S.has(he) || (T.push(fe), S.set(he, !0)); + } else + k = k || fe; + } + xs(se, K); + } + function V(se) { + return se.parent && gu(se.parent) && se.parent.name === se ? s.getShorthandAssignmentValueSymbol(se.parent) : s.getSymbolAtLocation(se); + } + function ae(se, ce, fe) { + if (!se) + return; + const he = se.getDeclarations(); + if (he && he.some((be) => be.parent === ce)) + return N.createIdentifier(se.name); + const q = ae(se.parent, ce, fe); + if (q !== void 0) + return fe ? N.createQualifiedName(q, N.createIdentifier(se.name)) : N.createPropertyAccessExpression(q, se.name); + } + } + function KUe(e) { + return dr(e, (t) => t.parent && yTe(t) && !_n(t.parent)); + } + function yTe(e) { + const { parent: t } = e; + switch (t.kind) { + case 307: + return !1; + } + switch (e.kind) { + case 11: + return t.kind !== 273 && t.kind !== 277; + case 231: + case 207: + case 209: + return !1; + case 80: + return t.kind !== 209 && t.kind !== 277 && t.kind !== 282; + } + return !0; + } + function lce(e) { + return uce(e) || (Sm(e) || NS(e) || cv(e)) && (Sm(e.parent) || cv(e.parent)); + } + function uce(e) { + return ca(e) && e.parent && Tm(e.parent); + } + var eVe = {}, Yq = "Generate 'get' and 'set' accessors", _ce = Ss(p.Generate_get_and_set_accessors), fce = { + name: Yq, + description: _ce, + kind: "refactor.rewrite.property.generateAccessors" + }; + Hg(Yq, { + kinds: [fce.kind], + getEditsForAction: function(t, n) { + if (!t.endPosition) return; + const i = Ou.getAccessorConvertiblePropertyAtPosition(t.file, t.program, t.startPosition, t.endPosition); + E.assert(i && !Oh(i), "Expected applicable refactor info"); + const s = Ou.generateAccessorFromProperty(t.file, t.program, t.startPosition, t.endPosition, t, n); + if (!s) return; + const o = t.file.fileName, c = i.renameAccessor ? i.accessorName : i.fieldName, u = (Me(c) ? 0 : -1) + YA( + s, + o, + c.text, + /*preferLastLocation*/ + Ii(i.declaration) + ); + return { renameFilename: o, renameLocation: u, edits: s }; + }, + getAvailableActions(e) { + if (!e.endPosition) return Ge; + const t = Ou.getAccessorConvertiblePropertyAtPosition(e.file, e.program, e.startPosition, e.endPosition, e.triggerReason === "invoked"); + return t ? Oh(t) ? e.preferences.provideRefactorNotApplicableReason ? [{ + name: Yq, + description: _ce, + actions: [{ ...fce, notApplicableReason: t.error }] + }] : Ge : [{ + name: Yq, + description: _ce, + actions: [fce] + }] : Ge; + } + }); + var tVe = {}, Zq = "Infer function return type", pce = Ss(p.Infer_function_return_type), Kq = { + name: Zq, + description: pce, + kind: "refactor.rewrite.function.returnType" + }; + Hg(Zq, { + kinds: [Kq.kind], + getEditsForAction: rVe, + getAvailableActions: nVe + }); + function rVe(e) { + const t = vTe(e); + if (t && !Oh(t)) + return { renameFilename: void 0, renameLocation: void 0, edits: cn.ChangeTracker.with(e, (i) => iVe(e.file, i, t.declaration, t.returnTypeNode)) }; + } + function nVe(e) { + const t = vTe(e); + return t ? Oh(t) ? e.preferences.provideRefactorNotApplicableReason ? [{ + name: Zq, + description: pce, + actions: [{ ...Kq, notApplicableReason: t.error }] + }] : Ge : [{ + name: Zq, + description: pce, + actions: [Kq] + }] : Ge; + } + function iVe(e, t, n, i) { + const s = Ya(n, 22, e), o = xo(n) && s === void 0, c = o ? Ca(n.parameters) : s; + c && (o && (t.insertNodeBefore(e, c, N.createToken( + 21 + /* OpenParenToken */ + )), t.insertNodeAfter(e, c, N.createToken( + 22 + /* CloseParenToken */ + ))), t.insertNodeAt(e, c.end, i, { prefix: ": " })); + } + function vTe(e) { + if (an(e.file) || !xv(Kq.kind, e.kind)) return; + const t = w_(e.file, e.startPosition), n = dr(t, (c) => Ns(c) || c.parent && xo(c.parent) && (c.kind === 39 || c.parent.body === c) ? "quit" : sVe(c)); + if (!n || !n.body || n.type) + return { error: Ss(p.Return_type_must_be_inferred_from_a_function) }; + const i = e.program.getTypeChecker(); + let s; + if (i.isImplementationOfOverload(n)) { + const c = i.getTypeAtLocation(n).getCallSignatures(); + c.length > 1 && (s = i.getUnionType(Fi(c, (_) => _.getReturnType()))); + } + if (!s) { + const c = i.getSignatureFromDeclaration(n); + if (c) { + const _ = i.getTypePredicateOfSignature(c); + if (_ && _.type) { + const u = i.typePredicateToTypePredicateNode( + _, + n, + 1, + 8 + /* AllowUnresolvedNames */ + ); + if (u) + return { declaration: n, returnTypeNode: u }; + } else + s = i.getReturnTypeOfSignature(c); + } + } + if (!s) + return { error: Ss(p.Could_not_determine_function_return_type) }; + const o = i.typeToTypeNode( + s, + n, + 1, + 8 + /* AllowUnresolvedNames */ + ); + if (o) + return { declaration: n, returnTypeNode: o }; + } + function sVe(e) { + switch (e.kind) { + case 263: + case 219: + case 220: + case 175: + return !0; + default: + return !1; + } + } + var bTe = /* @__PURE__ */ ((e) => (e[e.typeOffset = 8] = "typeOffset", e[e.modifierMask = 255] = "modifierMask", e))(bTe || {}), STe = /* @__PURE__ */ ((e) => (e[e.class = 0] = "class", e[e.enum = 1] = "enum", e[e.interface = 2] = "interface", e[e.namespace = 3] = "namespace", e[e.typeParameter = 4] = "typeParameter", e[e.type = 5] = "type", e[e.parameter = 6] = "parameter", e[e.variable = 7] = "variable", e[e.enumMember = 8] = "enumMember", e[e.property = 9] = "property", e[e.function = 10] = "function", e[e.member = 11] = "member", e))(STe || {}), TTe = /* @__PURE__ */ ((e) => (e[e.declaration = 0] = "declaration", e[e.static = 1] = "static", e[e.async = 2] = "async", e[e.readonly = 3] = "readonly", e[e.defaultLibrary = 4] = "defaultLibrary", e[e.local = 5] = "local", e))(TTe || {}); + function xTe(e, t, n, i) { + const s = dce(e, t, n, i); + E.assert(s.spans.length % 3 === 0); + const o = s.spans, c = []; + for (let _ = 0; _ < o.length; _ += 3) + c.push({ + textSpan: Kl(o[_], o[_ + 1]), + classificationType: o[_ + 2] + }); + return c; + } + function dce(e, t, n, i) { + return { + spans: aVe(e, n, i, t), + endOfLineState: 0 + /* None */ + }; + } + function aVe(e, t, n, i) { + const s = []; + return e && t && oVe(e, t, n, (c, _, u) => { + s.push(c.getStart(t), c.getWidth(t), (_ + 1 << 8) + u); + }, i), s; + } + function oVe(e, t, n, i, s) { + const o = e.getTypeChecker(); + let c = !1; + function _(u) { + switch (u.kind) { + case 268: + case 264: + case 265: + case 263: + case 232: + case 219: + case 220: + s.throwIfCancellationRequested(); + } + if (!u || !e3(n, u.pos, u.getFullWidth()) || u.getFullWidth() === 0) + return; + const g = c; + if ((Sm(u) || NS(u)) && (c = !0), h6(u) && (c = !1), Me(u) && !c && !_Ve(u) && !v4(u.escapedText)) { + let m = o.getSymbolAtLocation(u); + if (m) { + m.flags & 2097152 && (m = o.getAliasedSymbol(m)); + let h = cVe(m, WS(u)); + if (h !== void 0) { + let S = 0; + u.parent && (ya(u.parent) || ETe.get(u.parent.kind) === h) && u.parent.name === u && (S = 1), h === 6 && CTe(u) && (h = 9), h = lVe(o, u, h); + const T = m.valueDeclaration; + if (T) { + const k = J1(T), D = yh(T); + k & 256 && (S |= 2), k & 1024 && (S |= 4), h !== 0 && h !== 2 && (k & 8 || D & 2 || m.getFlags() & 8) && (S |= 8), (h === 7 || h === 10) && uVe(T, t) && (S |= 32), e.isSourceFileDefaultLibrary(T.getSourceFile()) && (S |= 16); + } else m.declarations && m.declarations.some((k) => e.isSourceFileDefaultLibrary(k.getSourceFile())) && (S |= 16); + i(u, h, S); + } + } + } + xs(u, _), c = g; + } + _(t); + } + function cVe(e, t) { + const n = e.getFlags(); + if (n & 32) + return 0; + if (n & 384) + return 1; + if (n & 524288) + return 5; + if (n & 64) { + if (t & 2) + return 2; + } else if (n & 262144) + return 4; + let i = e.valueDeclaration || e.declarations && e.declarations[0]; + return i && ya(i) && (i = kTe(i)), i && ETe.get(i.kind); + } + function lVe(e, t, n) { + if (n === 7 || n === 9 || n === 6) { + const i = e.getTypeAtLocation(t); + if (i) { + const s = (o) => o(i) || i.isUnion() && i.types.some(o); + if (n !== 6 && s((o) => o.getConstructSignatures().length > 0)) + return 0; + if (s((o) => o.getCallSignatures().length > 0) && !s((o) => o.getProperties().length > 0) || fVe(t)) + return n === 9 ? 11 : 10; + } + } + return n; + } + function uVe(e, t) { + return ya(e) && (e = kTe(e)), ei(e) ? (!Di(e.parent.parent.parent) || Zb(e.parent)) && e.getSourceFile() === t : Cc(e) ? !Di(e.parent) && e.getSourceFile() === t : !1; + } + function kTe(e) { + for (; ; ) + if (ya(e.parent.parent)) + e = e.parent.parent; + else + return e.parent.parent; + } + function _Ve(e) { + const t = e.parent; + return t && (ld(t) || Xu(t) || Ug(t)); + } + function fVe(e) { + for (; CTe(e); ) + e = e.parent; + return Ps(e.parent) && e.parent.expression === e; + } + function CTe(e) { + return s_(e.parent) && e.parent.right === e || wn(e.parent) && e.parent.name === e; + } + var ETe = /* @__PURE__ */ new Map([ + [ + 261, + 7 + /* variable */ + ], + [ + 170, + 6 + /* parameter */ + ], + [ + 173, + 9 + /* property */ + ], + [ + 268, + 3 + /* namespace */ + ], + [ + 267, + 1 + /* enum */ + ], + [ + 307, + 8 + /* enumMember */ + ], + [ + 264, + 0 + /* class */ + ], + [ + 175, + 11 + /* member */ + ], + [ + 263, + 10 + /* function */ + ], + [ + 219, + 10 + /* function */ + ], + [ + 174, + 11 + /* member */ + ], + [ + 178, + 9 + /* property */ + ], + [ + 179, + 9 + /* property */ + ], + [ + 172, + 9 + /* property */ + ], + [ + 265, + 2 + /* interface */ + ], + [ + 266, + 5 + /* type */ + ], + [ + 169, + 4 + /* typeParameter */ + ], + [ + 304, + 9 + /* property */ + ], + [ + 305, + 9 + /* property */ + ] + ]), DTe = "0.8"; + function wTe(e, t, n, i) { + const s = C7(e) ? new mce(e, t, n) : e === 80 ? new NTe(80, t, n) : e === 81 ? new ATe(81, t, n) : new PTe(e, t, n); + return s.parent = i, s.flags = i.flags & 101441536, s; + } + var mce = class { + constructor(e, t, n) { + this.pos = t, this.end = n, this.kind = e, this.id = 0, this.flags = 0, this.modifierFlagsCache = 0, this.transformFlags = 0, this.parent = void 0, this.original = void 0, this.emitNode = void 0; + } + assertHasRealPosition(e) { + E.assert(!Nd(this.pos) && !Nd(this.end), e || "Node must have a real position for this operation"); + } + getSourceFile() { + return xr(this); + } + getStart(e, t) { + return this.assertHasRealPosition(), Ay(this, e, t); + } + getFullStart() { + return this.assertHasRealPosition(), this.pos; + } + getEnd() { + return this.assertHasRealPosition(), this.end; + } + getWidth(e) { + return this.assertHasRealPosition(), this.getEnd() - this.getStart(e); + } + getFullWidth() { + return this.assertHasRealPosition(), this.end - this.pos; + } + getLeadingTriviaWidth(e) { + return this.assertHasRealPosition(), this.getStart(e) - this.pos; + } + getFullText(e) { + return this.assertHasRealPosition(), (e || this.getSourceFile()).text.substring(this.pos, this.end); + } + getText(e) { + return this.assertHasRealPosition(), e || (e = this.getSourceFile()), e.text.substring(this.getStart(e), this.getEnd()); + } + getChildCount(e) { + return this.getChildren(e).length; + } + getChildAt(e, t) { + return this.getChildren(t)[e]; + } + getChildren(e = xr(this)) { + return this.assertHasRealPosition("Node without a real position cannot be scanned and thus has no token nodes - use forEachChild and collect the result if that's fine"), wz(this, e) ?? Kte(this, e, pVe(this, e)); + } + getFirstToken(e) { + this.assertHasRealPosition(); + const t = this.getChildren(e); + if (!t.length) + return; + const n = Nn( + t, + (i) => i.kind < 310 || i.kind > 352 + /* LastJSDocNode */ + ); + return n.kind < 167 ? n : n.getFirstToken(e); + } + getLastToken(e) { + this.assertHasRealPosition(); + const t = this.getChildren(e), n = Do(t); + if (n) + return n.kind < 167 ? n : n.getLastToken(e); + } + forEachChild(e, t) { + return xs(this, e, t); + } + }; + function pVe(e, t) { + const n = []; + if (F7(e)) + return e.forEachChild((c) => { + n.push(c); + }), n; + ql.setText((t || e.getSourceFile()).text); + let i = e.pos; + const s = (c) => { + _L(n, i, c.pos, e), n.push(c), i = c.end; + }, o = (c) => { + _L(n, i, c.pos, e), n.push(dVe(c, e)), i = c.end; + }; + return lr(e.jsDoc, s), i = e.pos, e.forEachChild(s, o), _L(n, i, e.end, e), ql.setText(void 0), n; + } + function _L(e, t, n, i) { + for (ql.resetTokenState(t); t < n; ) { + const s = ql.scan(), o = ql.getTokenEnd(); + if (o <= n) { + if (s === 80) { + if (Yee(i)) + continue; + E.fail(`Did not expect ${E.formatSyntaxKind(i.kind)} to have an Identifier in its trivia`); + } + e.push(wTe(s, t, o, i)); + } + if (t = o, s === 1) + break; + } + } + function dVe(e, t) { + const n = wTe(353, e.pos, e.end, t), i = []; + let s = e.pos; + for (const o of e) + _L(i, s, o.pos, t), i.push(o), s = o.end; + return _L(i, s, e.end, t), n._children = i, n; + } + var gce = class { + constructor(e, t, n) { + this.pos = t, this.end = n, this.kind = e, this.id = 0, this.flags = 0, this.transformFlags = 0, this.parent = void 0, this.emitNode = void 0; + } + getSourceFile() { + return xr(this); + } + getStart(e, t) { + return Ay(this, e, t); + } + getFullStart() { + return this.pos; + } + getEnd() { + return this.end; + } + getWidth(e) { + return this.getEnd() - this.getStart(e); + } + getFullWidth() { + return this.end - this.pos; + } + getLeadingTriviaWidth(e) { + return this.getStart(e) - this.pos; + } + getFullText(e) { + return (e || this.getSourceFile()).text.substring(this.pos, this.end); + } + getText(e) { + return e || (e = this.getSourceFile()), e.text.substring(this.getStart(e), this.getEnd()); + } + getChildCount() { + return this.getChildren().length; + } + getChildAt(e) { + return this.getChildren()[e]; + } + getChildren() { + return this.kind === 1 && this.jsDoc || Ge; + } + getFirstToken() { + } + getLastToken() { + } + forEachChild() { + } + }, mVe = class { + constructor(e, t) { + this.flags = e, this.escapedName = t, this.declarations = void 0, this.valueDeclaration = void 0, this.id = 0, this.mergeId = 0, this.parent = void 0, this.members = void 0, this.exports = void 0, this.exportSymbol = void 0, this.constEnumOnlyModule = void 0, this.isReferenced = void 0, this.lastAssignmentPos = void 0, this.links = void 0; + } + getFlags() { + return this.flags; + } + get name() { + return cc(this); + } + getEscapedName() { + return this.escapedName; + } + getName() { + return this.name; + } + getDeclarations() { + return this.declarations; + } + getDocumentationComment(e) { + if (!this.documentationComment) + if (this.documentationComment = Ge, !this.declarations && Ng(this) && this.links.target && Ng(this.links.target) && this.links.target.links.tupleLabelDeclaration) { + const t = this.links.target.links.tupleLabelDeclaration; + this.documentationComment = fL([t], e); + } else + this.documentationComment = fL(this.declarations, e); + return this.documentationComment; + } + getContextualDocumentationComment(e, t) { + if (e) { + if (Pg(e) && (this.contextualGetAccessorDocumentationComment || (this.contextualGetAccessorDocumentationComment = Ge, this.contextualGetAccessorDocumentationComment = fL(kn(this.declarations, Pg), t)), wr(this.contextualGetAccessorDocumentationComment))) + return this.contextualGetAccessorDocumentationComment; + if (am(e) && (this.contextualSetAccessorDocumentationComment || (this.contextualSetAccessorDocumentationComment = Ge, this.contextualSetAccessorDocumentationComment = fL(kn(this.declarations, am), t)), wr(this.contextualSetAccessorDocumentationComment))) + return this.contextualSetAccessorDocumentationComment; + } + return this.getDocumentationComment(t); + } + getJsDocTags(e) { + return this.tags === void 0 && (this.tags = Ge, this.tags = eH(this.declarations, e)), this.tags; + } + getContextualJsDocTags(e, t) { + if (e) { + if (Pg(e) && (this.contextualGetAccessorTags || (this.contextualGetAccessorTags = Ge, this.contextualGetAccessorTags = eH(kn(this.declarations, Pg), t)), wr(this.contextualGetAccessorTags))) + return this.contextualGetAccessorTags; + if (am(e) && (this.contextualSetAccessorTags || (this.contextualSetAccessorTags = Ge, this.contextualSetAccessorTags = eH(kn(this.declarations, am), t)), wr(this.contextualSetAccessorTags))) + return this.contextualSetAccessorTags; + } + return this.getJsDocTags(t); + } + }, PTe = class extends gce { + constructor(e, t, n) { + super(e, t, n); + } + }, NTe = class extends gce { + constructor(e, t, n) { + super(e, t, n); + } + get text() { + return An(this); + } + }, ATe = class extends gce { + constructor(e, t, n) { + super(e, t, n); + } + get text() { + return An(this); + } + }, gVe = class { + constructor(e, t) { + this.flags = t, this.checker = e; + } + getFlags() { + return this.flags; + } + getSymbol() { + return this.symbol; + } + getProperties() { + return this.checker.getPropertiesOfType(this); + } + getProperty(e) { + return this.checker.getPropertyOfType(this, e); + } + getApparentProperties() { + return this.checker.getAugmentedPropertiesOfType(this); + } + getCallSignatures() { + return this.checker.getSignaturesOfType( + this, + 0 + /* Call */ + ); + } + getConstructSignatures() { + return this.checker.getSignaturesOfType( + this, + 1 + /* Construct */ + ); + } + getStringIndexType() { + return this.checker.getIndexTypeOfType( + this, + 0 + /* String */ + ); + } + getNumberIndexType() { + return this.checker.getIndexTypeOfType( + this, + 1 + /* Number */ + ); + } + getBaseTypes() { + return this.isClassOrInterface() ? this.checker.getBaseTypes(this) : void 0; + } + isNullableType() { + return this.checker.isNullableType(this); + } + getNonNullableType() { + return this.checker.getNonNullableType(this); + } + getNonOptionalType() { + return this.checker.getNonOptionalType(this); + } + getConstraint() { + return this.checker.getBaseConstraintOfType(this); + } + getDefault() { + return this.checker.getDefaultFromTypeParameter(this); + } + isUnion() { + return !!(this.flags & 1048576); + } + isIntersection() { + return !!(this.flags & 2097152); + } + isUnionOrIntersection() { + return !!(this.flags & 3145728); + } + isLiteral() { + return !!(this.flags & 2432); + } + isStringLiteral() { + return !!(this.flags & 128); + } + isNumberLiteral() { + return !!(this.flags & 256); + } + isTypeParameter() { + return !!(this.flags & 262144); + } + isClassOrInterface() { + return !!(Dn(this) & 3); + } + isClass() { + return !!(Dn(this) & 1); + } + isIndexType() { + return !!(this.flags & 4194304); + } + /** + * This polyfills `referenceType.typeArguments` for API consumers + */ + get typeArguments() { + if (Dn(this) & 4) + return this.checker.getTypeArguments(this); + } + }, hVe = class { + // same + constructor(e, t) { + this.flags = t, this.checker = e; + } + getDeclaration() { + return this.declaration; + } + getTypeParameters() { + return this.typeParameters; + } + getParameters() { + return this.parameters; + } + getReturnType() { + return this.checker.getReturnTypeOfSignature(this); + } + getTypeParameterAtPosition(e) { + const t = this.checker.getParameterType(this, e); + if (t.isIndexType() && b4(t.type)) { + const n = t.type.getConstraint(); + if (n) + return this.checker.getIndexType(n); + } + return t; + } + getDocumentationComment() { + return this.documentationComment || (this.documentationComment = fL(ZT(this.declaration), this.checker)); + } + getJsDocTags() { + return this.jsDocTags || (this.jsDocTags = eH(ZT(this.declaration), this.checker)); + } + }; + function ITe(e) { + return W1(e).some((t) => t.tagName.text === "inheritDoc" || t.tagName.text === "inheritdoc"); + } + function eH(e, t) { + if (!e) return Ge; + let n = Ev.getJsDocTagsFromDeclarations(e, t); + if (t && (n.length === 0 || e.some(ITe))) { + const i = /* @__PURE__ */ new Set(); + for (const s of e) { + const o = FTe(t, s, (c) => { + var _; + if (!i.has(c)) + return i.add(c), s.kind === 178 || s.kind === 179 ? c.getContextualJsDocTags(s, t) : ((_ = c.declarations) == null ? void 0 : _.length) === 1 ? c.getJsDocTags(t) : void 0; + }); + o && (n = [...o, ...n]); + } + } + return n; + } + function fL(e, t) { + if (!e) return Ge; + let n = Ev.getJsDocCommentsFromDeclarations(e, t); + if (t && (n.length === 0 || e.some(ITe))) { + const i = /* @__PURE__ */ new Set(); + for (const s of e) { + const o = FTe(t, s, (c) => { + if (!i.has(c)) + return i.add(c), s.kind === 178 || s.kind === 179 ? c.getContextualDocumentationComment(s, t) : c.getDocumentationComment(t); + }); + o && (n = n.length === 0 ? o.slice() : o.concat(Q6(), n)); + } + } + return n; + } + function FTe(e, t, n) { + var i; + const s = ((i = t.parent) == null ? void 0 : i.kind) === 177 ? t.parent.parent : t.parent; + if (!s) return; + const o = cl(t); + return Lc(HD(s), (c) => { + const _ = e.getTypeAtLocation(c), u = o && _.symbol ? e.getTypeOfSymbol(_.symbol) : _, g = e.getPropertyOfType(u, t.symbol.name); + return g ? n(g) : void 0; + }); + } + var yVe = class extends mce { + constructor(e, t, n) { + super(e, t, n); + } + update(e, t) { + return Uz(this, e, t); + } + getLineAndCharacterOfPosition(e) { + return js(this, e); + } + getLineStarts() { + return kg(this); + } + getPositionOfLineAndCharacter(e, t, n) { + return d7(kg(this), e, t, this.text, n); + } + getLineEndOfPosition(e) { + const { line: t } = this.getLineAndCharacterOfPosition(e), n = this.getLineStarts(); + let i; + t + 1 >= n.length && (i = this.getEnd()), i || (i = n[t + 1] - 1); + const s = this.getFullText(); + return s[i] === ` +` && s[i - 1] === "\r" ? i - 1 : i; + } + getNamedDeclarations() { + return this.namedDeclarations || (this.namedDeclarations = this.computeNamedDeclarations()), this.namedDeclarations; + } + computeNamedDeclarations() { + const e = Fp(); + return this.forEachChild(s), e; + function t(o) { + const c = i(o); + c && e.add(c, o); + } + function n(o) { + let c = e.get(o); + return c || e.set(o, c = []), c; + } + function i(o) { + const c = h7(o); + return c && (Gs(c) && wn(c.expression) ? c.expression.name.text : qc(c) ? GA(c) : void 0); + } + function s(o) { + switch (o.kind) { + case 263: + case 219: + case 175: + case 174: + const c = o, _ = i(c); + if (_) { + const m = n(_), h = Do(m); + h && c.parent === h.parent && c.symbol === h.symbol ? c.body && !h.body && (m[m.length - 1] = c) : m.push(c); + } + xs(o, s); + break; + case 264: + case 232: + case 265: + case 266: + case 267: + case 268: + case 272: + case 282: + case 277: + case 274: + case 275: + case 178: + case 179: + case 188: + t(o), xs(o, s); + break; + case 170: + if (!Gn( + o, + 31 + /* ParameterPropertyModifier */ + )) + break; + // falls through + case 261: + case 209: { + const m = o; + if (ws(m.name)) { + xs(m.name, s); + break; + } + m.initializer && s(m.initializer); + } + // falls through + case 307: + case 173: + case 172: + t(o); + break; + case 279: + const u = o; + u.exportClause && (mp(u.exportClause) ? lr(u.exportClause.elements, s) : s(u.exportClause.name)); + break; + case 273: + const g = o.importClause; + g && (g.name && t(g.name), g.namedBindings && (g.namedBindings.kind === 275 ? t(g.namedBindings) : lr(g.namedBindings.elements, s))); + break; + case 227: + Ac(o) !== 0 && t(o); + // falls through + default: + xs(o, s); + } + } + } + }, vVe = class { + constructor(e, t, n) { + this.fileName = e, this.text = t, this.skipTrivia = n || ((i) => i); + } + getLineAndCharacterOfPosition(e) { + return js(this, e); + } + }; + function bVe() { + return { + getNodeConstructor: () => mce, + getTokenConstructor: () => PTe, + getIdentifierConstructor: () => NTe, + getPrivateIdentifierConstructor: () => ATe, + getSourceFileConstructor: () => yVe, + getSymbolConstructor: () => mVe, + getTypeConstructor: () => gVe, + getSignatureConstructor: () => hVe, + getSourceMapSourceConstructor: () => vVe + }; + } + function u8(e) { + let t = !0; + for (const i in e) + if (eo(e, i) && !OTe(i)) { + t = !1; + break; + } + if (t) + return e; + const n = {}; + for (const i in e) + if (eo(e, i)) { + const s = OTe(i) ? i : i.charAt(0).toLowerCase() + i.substr(1); + n[s] = e[i]; + } + return n; + } + function OTe(e) { + return !e.length || e.charAt(0) === e.charAt(0).toLowerCase(); + } + function _8(e) { + return e ? hr(e, (t) => t.text).join("") : ""; + } + function pL() { + return { + target: 1, + jsx: 1 + /* Preserve */ + }; + } + function tH() { + return Ou.getSupportedErrorCodes(); + } + var SVe = class { + constructor(e) { + this.host = e; + } + getCurrentSourceFile(e) { + var t, n, i, s, o, c, _, u; + const g = this.host.getScriptSnapshot(e); + if (!g) + throw new Error("Could not find file: '" + e + "'."); + const m = rq(e, this.host), h = this.host.getScriptVersion(e); + let S; + if (this.currentFileName !== e) { + const T = { + languageVersion: 99, + impliedNodeFormat: DA( + oo(e, this.host.getCurrentDirectory(), ((i = (n = (t = this.host).getCompilerHost) == null ? void 0 : n.call(t)) == null ? void 0 : i.getCanonicalFileName) || xh(this.host)), + (u = (_ = (c = (o = (s = this.host).getCompilerHost) == null ? void 0 : o.call(s)) == null ? void 0 : c.getModuleResolutionCache) == null ? void 0 : _.call(c)) == null ? void 0 : u.getPackageJsonInfoCache(), + this.host, + this.host.getCompilationSettings() + ), + setExternalModuleIndicator: pN(this.host.getCompilationSettings()), + // These files are used to produce syntax-based highlighting, which reads JSDoc, so we must use ParseAll. + jsDocParsingMode: 0 + /* ParseAll */ + }; + S = dL( + e, + g, + T, + h, + /*setNodeParents*/ + !0, + m + ); + } else if (this.currentFileVersion !== h) { + const T = g.getChangeRange(this.currentFileScriptSnapshot); + S = rH(this.currentSourceFile, g, h, T); + } + return S && (this.currentFileVersion = h, this.currentFileName = e, this.currentFileScriptSnapshot = g, this.currentSourceFile = S), this.currentSourceFile; + } + }; + function LTe(e, t, n) { + e.version = n, e.scriptSnapshot = t; + } + function dL(e, t, n, i, s, o) { + const c = ek(e, fk(t), n, s, o); + return LTe(c, t, i), c; + } + function rH(e, t, n, i, s) { + if (i && n !== e.version) { + let c; + const _ = i.span.start !== 0 ? e.text.substr(0, i.span.start) : "", u = ec(i.span) !== e.text.length ? e.text.substr(ec(i.span)) : ""; + if (i.newLength === 0) + c = _ && u ? _ + u : _ || u; + else { + const m = t.getText(i.span.start, i.span.start + i.newLength); + c = _ && u ? _ + m + u : _ ? _ + m : m + u; + } + const g = Uz(e, c, i, s); + return LTe(g, t, n), g.nameTable = void 0, e !== g && e.scriptSnapshot && (e.scriptSnapshot.dispose && e.scriptSnapshot.dispose(), e.scriptSnapshot = void 0), g; + } + const o = { + languageVersion: e.languageVersion, + impliedNodeFormat: e.impliedNodeFormat, + setExternalModuleIndicator: e.setExternalModuleIndicator, + jsDocParsingMode: e.jsDocParsingMode + }; + return dL( + e.fileName, + t, + o, + n, + /*setNodeParents*/ + !0, + e.scriptKind + ); + } + var TVe = { + isCancellationRequested: mh, + throwIfCancellationRequested: Ha + }, xVe = class { + constructor(e) { + this.cancellationToken = e; + } + isCancellationRequested() { + return this.cancellationToken.isCancellationRequested(); + } + throwIfCancellationRequested() { + var e; + if (this.isCancellationRequested()) + throw (e = on) == null || e.instant(on.Phase.Session, "cancellationThrown", { kind: "CancellationTokenObject" }), new lD(); + } + }, hce = class { + constructor(e, t = 20) { + this.hostCancellationToken = e, this.throttleWaitMilliseconds = t, this.lastCancellationCheckTime = 0; + } + isCancellationRequested() { + const e = ao(); + return Math.abs(e - this.lastCancellationCheckTime) >= this.throttleWaitMilliseconds ? (this.lastCancellationCheckTime = e, this.hostCancellationToken.isCancellationRequested()) : !1; + } + throwIfCancellationRequested() { + var e; + if (this.isCancellationRequested()) + throw (e = on) == null || e.instant(on.Phase.Session, "cancellationThrown", { kind: "ThrottledCancellationToken" }), new lD(); + } + }, MTe = [ + "getSemanticDiagnostics", + "getSuggestionDiagnostics", + "getCompilerOptionsDiagnostics", + "getSemanticClassifications", + "getEncodedSemanticClassifications", + "getCodeFixesAtPosition", + "getCombinedCodeFix", + "applyCodeActionCommand", + "organizeImports", + "getEditsForFileRename", + "getEmitOutput", + "getApplicableRefactors", + "getEditsForRefactor", + "prepareCallHierarchy", + "provideCallHierarchyIncomingCalls", + "provideCallHierarchyOutgoingCalls", + "provideInlayHints", + "getSupportedCodeFixes", + "getPasteEdits" + ], kVe = [ + ...MTe, + "getCompletionsAtPosition", + "getCompletionEntryDetails", + "getCompletionEntrySymbol", + "getSignatureHelpItems", + "getQuickInfoAtPosition", + "getDefinitionAtPosition", + "getDefinitionAndBoundSpan", + "getImplementationAtPosition", + "getTypeDefinitionAtPosition", + "getReferencesAtPosition", + "findReferences", + "getDocumentHighlights", + "getNavigateToItems", + "getRenameInfo", + "findRenameLocations", + "getApplicableRefactors", + "preparePasteEditsForFile" + ]; + function yce(e, t = Wae(e.useCaseSensitiveFileNames && e.useCaseSensitiveFileNames(), e.getCurrentDirectory(), e.jsDocParsingMode), n) { + var i; + let s; + n === void 0 ? s = 0 : typeof n == "boolean" ? s = n ? 2 : 0 : s = n; + const o = new SVe(e); + let c, _, u = 0; + const g = e.getCancellationToken ? new xVe(e.getCancellationToken()) : TVe, m = e.getCurrentDirectory(); + Tee((i = e.getLocalizedDiagnosticMessages) == null ? void 0 : i.bind(e)); + function h(rt) { + e.log && e.log(rt); + } + const S = mS(e), T = Zl(S), k = roe({ + useCaseSensitiveFileNames: () => S, + getCurrentDirectory: () => m, + getProgram: O, + fileExists: Os(e, e.fileExists), + readFile: Os(e, e.readFile), + getDocumentPositionMapper: Os(e, e.getDocumentPositionMapper), + getSourceFileLike: Os(e, e.getSourceFileLike), + log: h + }); + function D(rt) { + const vt = c.getSourceFile(rt); + if (!vt) { + const Nt = new Error(`Could not find source file: '${rt}'.`); + throw Nt.ProgramFiles = c.getSourceFiles().map((Jt) => Jt.fileName), Nt; + } + return vt; + } + function P() { + e.updateFromProject && !e.updateFromProjectInProgress ? e.updateFromProject() : A(); + } + function A() { + var rt, vt, Nt; + if (E.assert( + s !== 2 + /* Syntactic */ + ), e.getProjectVersion) { + const cs = e.getProjectVersion(); + if (cs) { + if (_ === cs && !((rt = e.hasChangedAutomaticTypeDirectiveNames) != null && rt.call(e))) + return; + _ = cs; + } + } + const Jt = e.getTypeRootsVersion ? e.getTypeRootsVersion() : 0; + u !== Jt && (h("TypeRoots version has changed; provide new program"), c = void 0, u = Jt); + const _r = e.getScriptFileNames().slice(), nr = e.getCompilationSettings() || pL(), kt = e.hasInvalidatedResolutions || mh, cr = Os(e, e.hasInvalidatedLibResolutions) || mh, fr = Os(e, e.hasChangedAutomaticTypeDirectiveNames), vr = (vt = e.getProjectReferences) == null ? void 0 : vt.call(e); + let Xt, oi = { + getSourceFile: Ec, + getSourceFileByPath: zf, + getCancellationToken: () => g, + getCanonicalFileName: T, + useCaseSensitiveFileNames: () => S, + getNewLine: () => v0(nr), + getDefaultLibFileName: (cs) => e.getDefaultLibFileName(cs), + writeFile: Ha, + getCurrentDirectory: () => m, + fileExists: (cs) => e.fileExists(cs), + readFile: (cs) => e.readFile && e.readFile(cs), + getSymlinkCache: Os(e, e.getSymlinkCache), + realpath: Os(e, e.realpath), + directoryExists: (cs) => Pd(cs, e), + getDirectories: (cs) => e.getDirectories ? e.getDirectories(cs) : [], + readDirectory: (cs, Ws, Fa, va, zt) => (E.checkDefined(e.readDirectory, "'LanguageServiceHost.readDirectory' must be implemented to correctly process 'projectReferences'"), e.readDirectory(cs, Ws, Fa, va, zt)), + onReleaseOldSourceFile: ta, + onReleaseParsedCommandLine: Gc, + hasInvalidatedResolutions: kt, + hasInvalidatedLibResolutions: cr, + hasChangedAutomaticTypeDirectiveNames: fr, + trace: Os(e, e.trace), + resolveModuleNames: Os(e, e.resolveModuleNames), + getModuleResolutionCache: Os(e, e.getModuleResolutionCache), + createHash: Os(e, e.createHash), + resolveTypeReferenceDirectives: Os(e, e.resolveTypeReferenceDirectives), + resolveModuleNameLiterals: Os(e, e.resolveModuleNameLiterals), + resolveTypeReferenceDirectiveReferences: Os(e, e.resolveTypeReferenceDirectiveReferences), + resolveLibrary: Os(e, e.resolveLibrary), + useSourceOfProjectReferenceRedirect: Os(e, e.useSourceOfProjectReferenceRedirect), + getParsedCommandLine: zi, + jsDocParsingMode: e.jsDocParsingMode, + getGlobalTypingsCacheLocation: Os(e, e.getGlobalTypingsCacheLocation) + }; + const Fs = oi.getSourceFile, { getSourceFileWithCache: Rs } = ow( + oi, + (cs) => oo(cs, m, T), + (...cs) => Fs.call(oi, ...cs) + ); + oi.getSourceFile = Rs, (Nt = e.setCompilerHost) == null || Nt.call(e, oi); + const ds = { + useCaseSensitiveFileNames: S, + fileExists: (cs) => oi.fileExists(cs), + readFile: (cs) => oi.readFile(cs), + directoryExists: (cs) => oi.directoryExists(cs), + getDirectories: (cs) => oi.getDirectories(cs), + realpath: oi.realpath, + readDirectory: (...cs) => oi.readDirectory(...cs), + trace: oi.trace, + getCurrentDirectory: oi.getCurrentDirectory, + onUnRecoverableConfigFileDiagnostic: Ha + }, pc = t.getKeyForCompilationSettings(nr); + let Zo = /* @__PURE__ */ new Set(); + if (vU(c, _r, nr, (cs, Ws) => e.getScriptVersion(Ws), (cs) => oi.fileExists(cs), kt, cr, fr, zi, vr)) { + oi = void 0, Xt = void 0, Zo = void 0; + return; + } + c = wA({ + rootNames: _r, + options: nr, + host: oi, + oldProgram: c, + projectReferences: vr + }), oi = void 0, Xt = void 0, Zo = void 0, k.clearCache(), c.getTypeChecker(); + return; + function zi(cs) { + const Ws = oo(cs, m, T), Fa = Xt?.get(Ws); + if (Fa !== void 0) return Fa || void 0; + const va = e.getParsedCommandLine ? e.getParsedCommandLine(cs) : hs(cs); + return (Xt || (Xt = /* @__PURE__ */ new Map())).set(Ws, va || !1), va; + } + function hs(cs) { + const Ws = Ec( + cs, + 100 + /* JSON */ + ); + if (Ws) + return Ws.path = oo(cs, m, T), Ws.resolvedPath = Ws.path, Ws.originalFileName = Ws.fileName, sA( + Ws, + ds, + Qi(Hn(cs), m), + /*existingOptions*/ + void 0, + Qi(cs, m) + ); + } + function Gc(cs, Ws, Fa) { + var va; + e.getParsedCommandLine ? (va = e.onReleaseParsedCommandLine) == null || va.call(e, cs, Ws, Fa) : Ws && Co(Ws.sourceFile, Fa); + } + function Co(cs, Ws) { + const Fa = t.getKeyForCompilationSettings(Ws); + t.releaseDocumentWithKey(cs.resolvedPath, Fa, cs.scriptKind, cs.impliedNodeFormat); + } + function ta(cs, Ws, Fa, va) { + var zt; + Co(cs, Ws), (zt = e.onReleaseOldSourceFile) == null || zt.call(e, cs, Ws, Fa, va); + } + function Ec(cs, Ws, Fa, va) { + return zf(cs, oo(cs, m, T), Ws, Fa, va); + } + function zf(cs, Ws, Fa, va, zt) { + E.assert(oi, "getOrCreateSourceFileByPath called after typical CompilerHost lifetime, check the callstack something with a reference to an old host."); + const Za = e.getScriptSnapshot(cs); + if (!Za) + return; + const yc = rq(cs, e), Fc = e.getScriptVersion(cs); + if (!zt) { + const Hl = c && c.getSourceFileByPath(Ws); + if (Hl) { + if (yc === Hl.scriptKind || Zo.has(Hl.resolvedPath)) + return t.updateDocumentWithKey(cs, Ws, e, pc, Za, Fc, yc, Fa); + t.releaseDocumentWithKey(Hl.resolvedPath, t.getKeyForCompilationSettings(c.getCompilerOptions()), Hl.scriptKind, Hl.impliedNodeFormat), Zo.add(Hl.resolvedPath); + } + } + return t.acquireDocumentWithKey(cs, Ws, e, pc, Za, Fc, yc, Fa); + } + } + function O() { + if (s === 2) { + E.assert(c === void 0); + return; + } + return P(), c; + } + function F() { + var rt; + return (rt = e.getPackageJsonAutoImportProvider) == null ? void 0 : rt.call(e); + } + function R(rt, vt) { + const Nt = c.getTypeChecker(), Jt = _r(); + if (!Jt) return !1; + for (const kt of rt) + for (const cr of kt.references) { + const fr = nr(cr); + if (E.assertIsDefined(fr), vt.has(cr) || ko.isDeclarationOfSymbol(fr, Jt)) { + vt.add(cr), cr.isDefinition = !0; + const vr = O9(cr, k, Os(e, e.fileExists)); + vr && vt.add(vr); + } else + cr.isDefinition = !1; + } + return !0; + function _r() { + for (const kt of rt) + for (const cr of kt.references) { + if (vt.has(cr)) { + const vr = nr(cr); + return E.assertIsDefined(vr), Nt.getSymbolAtLocation(vr); + } + const fr = O9(cr, k, Os(e, e.fileExists)); + if (fr && vt.has(fr)) { + const vr = nr(fr); + if (vr) + return Nt.getSymbolAtLocation(vr); + } + } + } + function nr(kt) { + const cr = c.getSourceFile(kt.fileName); + if (!cr) return; + const fr = w_(cr, kt.textSpan.start); + return ko.Core.getAdjustedNode(fr, { use: ko.FindReferencesUse.References }); + } + } + function B() { + if (c) { + const rt = t.getKeyForCompilationSettings(c.getCompilerOptions()); + lr(c.getSourceFiles(), (vt) => t.releaseDocumentWithKey(vt.resolvedPath, rt, vt.scriptKind, vt.impliedNodeFormat)), c = void 0; + } + } + function U() { + B(), e = void 0; + } + function $(rt) { + return P(), c.getSyntacticDiagnostics(D(rt), g).slice(); + } + function W(rt) { + P(); + const vt = D(rt), Nt = c.getSemanticDiagnostics(vt, g); + if (!J_(c.getCompilerOptions())) + return Nt.slice(); + const Jt = c.getDeclarationDiagnostics(vt, g); + return [...Nt, ...Jt]; + } + function _e(rt, vt) { + P(); + const Nt = D(rt), Jt = c.getCompilerOptions(); + if (a6(Nt, Jt, c) || !m4(Nt, Jt) || c.getCachedSemanticDiagnostics(Nt)) + return; + const _r = K(Nt, vt); + if (!_r) + return; + const nr = Pj(_r.map((cr) => Nc(cr.getFullStart(), cr.getEnd()))); + return { + diagnostics: c.getSemanticDiagnostics(Nt, g, _r).slice(), + spans: nr + }; + } + function K(rt, vt) { + const Nt = [], Jt = Pj(vt.map((_r) => A0(_r))); + for (const _r of Jt) { + const nr = V(rt, _r); + if (!nr) + return; + Nt.push(...nr); + } + if (Nt.length) + return Nt; + } + function V(rt, vt) { + if (wj(vt, rt)) + return; + const Nt = gw(rt, ec(vt)) || rt, Jt = dr(Nt, (nr) => $Y(nr, vt)), _r = []; + if (ae(vt, Jt, _r), rt.end === vt.start + vt.length && _r.push(rt.endOfFileToken), !ot(_r, Di)) + return _r; + } + function ae(rt, vt, Nt) { + return se(vt, rt) ? wj(rt, vt) ? (ce(vt, Nt), !0) : dk(vt) ? fe(rt, vt, Nt) : $n(vt) ? he(rt, vt, Nt) : (ce(vt, Nt), !0) : !1; + } + function se(rt, vt) { + const Nt = vt.start + vt.length; + return rt.pos < Nt && rt.end > vt.start; + } + function ce(rt, vt) { + for (; rt.parent && !tte(rt); ) + rt = rt.parent; + vt.push(rt); + } + function fe(rt, vt, Nt) { + const Jt = []; + return vt.statements.filter((nr) => ae(rt, nr, Jt)).length === vt.statements.length ? (ce(vt, Nt), !0) : (Nt.push(...Jt), !1); + } + function he(rt, vt, Nt) { + var Jt, _r, nr; + const kt = (vr) => ZY(vr, rt); + if ((Jt = vt.modifiers) != null && Jt.some(kt) || vt.name && kt(vt.name) || (_r = vt.typeParameters) != null && _r.some(kt) || (nr = vt.heritageClauses) != null && nr.some(kt)) + return ce(vt, Nt), !0; + const cr = []; + return vt.members.filter((vr) => ae(rt, vr, cr)).length === vt.members.length ? (ce(vt, Nt), !0) : (Nt.push(...cr), !1); + } + function q(rt) { + return P(), wq(D(rt), c, g); + } + function be() { + return P(), [...c.getOptionsDiagnostics(g), ...c.getGlobalDiagnostics(g)]; + } + function je(rt, vt, Nt = qp, Jt) { + const _r = { + ...Nt, + // avoid excess property check + includeCompletionsForModuleExports: Nt.includeCompletionsForModuleExports || Nt.includeExternalModuleExports, + includeCompletionsWithInsertText: Nt.includeCompletionsWithInsertText || Nt.includeInsertTextCompletions + }; + return P(), Tk.getCompletionsAtPosition( + e, + c, + h, + D(rt), + vt, + _r, + Nt.triggerCharacter, + Nt.triggerKind, + g, + Jt && nl.getFormatContext(Jt, e), + Nt.includeSymbol + ); + } + function me(rt, vt, Nt, Jt, _r, nr = qp, kt) { + return P(), Tk.getCompletionEntryDetails( + c, + h, + D(rt), + vt, + { name: Nt, source: _r, data: kt }, + e, + Jt && nl.getFormatContext(Jt, e), + // TODO: GH#18217 + nr, + g + ); + } + function Z(rt, vt, Nt, Jt, _r = qp) { + return P(), Tk.getCompletionEntrySymbol(c, h, D(rt), vt, { name: Nt, source: Jt }, e, _r); + } + function pe(rt, vt, Nt, Jt) { + P(); + const _r = D(rt), nr = w_(_r, vt); + if (nr === _r) + return; + const kt = c.getTypeChecker(), cr = Ye(nr), fr = wVe(cr, kt); + if (!fr || kt.isUnknownSymbol(fr)) { + const ds = ne(_r, cr, vt) ? kt.getTypeAtLocation(cr) : void 0; + return ds && { + kind: "", + kindModifiers: "", + textSpan: u_(cr, _r), + displayParts: kt.runWithCancellationToken(g, (pc) => QA( + pc, + ds, + US(cr), + /*flags*/ + void 0, + Jt + )), + documentation: ds.symbol ? ds.symbol.getDocumentationComment(kt) : void 0, + tags: ds.symbol ? ds.symbol.getJsDocTags(kt) : void 0 + }; + } + const { symbolKind: vr, displayParts: Xt, documentation: oi, tags: Fs, canIncreaseVerbosityLevel: Rs } = kt.runWithCancellationToken( + g, + (ds) => O0.getSymbolDisplayPartsDocumentationAndSymbolKind( + ds, + fr, + _r, + US(cr), + cr, + /*semanticMeaning*/ + void 0, + /*alias*/ + void 0, + Nt ?? zZ, + Jt + ) + ); + return { + kind: vr, + kindModifiers: O0.getSymbolModifiers(kt, fr), + textSpan: u_(cr, _r), + displayParts: Xt, + documentation: oi, + tags: Fs, + canIncreaseVerbosityLevel: Rs + }; + } + function Te(rt, vt) { + return P(), pG.preparePasteEdits( + D(rt), + vt, + c.getTypeChecker() + ); + } + function Fe(rt, vt) { + return P(), dG.pasteEditsProvider( + D(rt.targetFile), + rt.pastedText, + rt.pasteLocations, + rt.copiedFrom ? { file: D(rt.copiedFrom.file), range: rt.copiedFrom.range } : void 0, + e, + rt.preferences, + nl.getFormatContext(vt, e), + g + ); + } + function Ye(rt) { + return Xb(rt.parent) && rt.pos === rt.parent.pos ? rt.parent.expression : f6(rt.parent) && rt.pos === rt.parent.pos || JC(rt.parent) && rt.parent.name === rt || Fd(rt.parent) ? rt.parent : rt; + } + function ne(rt, vt, Nt) { + switch (vt.kind) { + case 80: + return vt.flags & 16777216 && !an(vt) && (vt.parent.kind === 172 && vt.parent.name === vt || dr( + vt, + (Jt) => Jt.kind === 170 + /* Parameter */ + )) ? !1 : !TV(vt) && !xV(vt) && !nd(vt.parent); + case 212: + case 167: + return !P0(rt, Nt); + case 110: + case 198: + case 108: + case 203: + return !0; + case 237: + return JC(vt); + default: + return !1; + } + } + function Se(rt, vt, Nt, Jt) { + return P(), sE.getDefinitionAtPosition(c, D(rt), vt, Nt, Jt); + } + function ie(rt, vt) { + return P(), sE.getDefinitionAndBoundSpan(c, D(rt), vt); + } + function Ne(rt, vt) { + return P(), sE.getTypeDefinitionAtPosition(c.getTypeChecker(), D(rt), vt); + } + function Ee(rt, vt) { + return P(), ko.getImplementationsAtPosition(c, g, c.getSourceFiles(), D(rt), vt); + } + function Ce(rt, vt, Nt) { + const Jt = Hs(rt); + E.assert(Nt.some((kt) => Hs(kt) === Jt)), P(); + const _r = Fi(Nt, (kt) => c.getSourceFile(kt)), nr = D(rt); + return Z9.getDocumentHighlights(c, g, nr, vt, _r); + } + function Ve(rt, vt, Nt, Jt, _r) { + P(); + const nr = D(rt), kt = T9(w_(nr, vt)); + if (LL.nodeIsEligibleForRename(kt)) + if (Me(kt) && (Id(kt.parent) || Qb(kt.parent)) && YC(kt.escapedText)) { + const { openingElement: cr, closingElement: fr } = kt.parent.parent; + return [cr, fr].map((vr) => { + const Xt = u_(vr.tagName, nr); + return { + fileName: nr.fileName, + textSpan: Xt, + ...ko.toContextSpan(Xt, nr, vr.parent) + }; + }); + } else { + const cr = _f(nr, _r ?? qp), fr = typeof _r == "boolean" ? _r : _r?.providePrefixAndSuffixTextForRename; + return Bt(kt, vt, { findInStrings: Nt, findInComments: Jt, providePrefixAndSuffixTextForRename: fr, use: ko.FindReferencesUse.Rename }, (vr, Xt, oi) => ko.toRenameLocation(vr, Xt, oi, fr || !1, cr)); + } + } + function St(rt, vt) { + return P(), Bt(w_(D(rt), vt), vt, { use: ko.FindReferencesUse.References }, ko.toReferenceEntry); + } + function Bt(rt, vt, Nt, Jt) { + P(); + const _r = Nt && Nt.use === ko.FindReferencesUse.Rename ? c.getSourceFiles().filter((nr) => !c.isSourceFileDefaultLibrary(nr)) : c.getSourceFiles(); + return ko.findReferenceOrRenameEntries(c, g, _r, rt, vt, Nt, Jt); + } + function tr(rt, vt) { + return P(), ko.findReferencedSymbols(c, g, c.getSourceFiles(), D(rt), vt); + } + function Nr(rt) { + return P(), ko.Core.getReferencesForFileName(rt, c, c.getSourceFiles()).map(ko.toReferenceEntry); + } + function st(rt, vt, Nt, Jt = !1, _r = !1) { + P(); + const nr = Nt ? [D(Nt)] : c.getSourceFiles(); + return $2e(nr, c.getTypeChecker(), g, rt, vt, Jt, _r); + } + function Wt(rt, vt, Nt) { + P(); + const Jt = D(rt), _r = e.getCustomTransformers && e.getCustomTransformers(); + return Lie(c, Jt, !!vt, g, _r, Nt); + } + function Jr(rt, vt, { triggerReason: Nt } = qp) { + P(); + const Jt = D(rt); + return D8.getSignatureHelpItems(c, Jt, vt, Nt, g); + } + function ui(rt) { + return o.getCurrentSourceFile(rt); + } + function Ji(rt, vt, Nt) { + const Jt = o.getCurrentSourceFile(rt), _r = w_(Jt, vt); + if (_r === Jt) + return; + switch (_r.kind) { + case 212: + case 167: + case 11: + case 97: + case 112: + case 106: + case 108: + case 110: + case 198: + case 80: + break; + // Cant create the text span + default: + return; + } + let nr = _r; + for (; ; ) + if (U6(nr) || Zse(nr)) + nr = nr.parent; + else if (CV(nr)) + if (nr.parent.parent.kind === 268 && nr.parent.parent.body === nr.parent) + nr = nr.parent.parent.name; + else + break; + else + break; + return Nc(nr.getStart(), _r.getEnd()); + } + function Dt(rt, vt) { + const Nt = o.getCurrentSourceFile(rt); + return iH.spanInSourceFileAtLocation(Nt, vt); + } + function Mn(rt) { + return Z2e(o.getCurrentSourceFile(rt), g); + } + function ai(rt) { + return K2e(o.getCurrentSourceFile(rt), g); + } + function fi(rt, vt, Nt) { + return P(), (Nt || "original") === "2020" ? xTe(c, g, D(rt), vt) : Jae(c.getTypeChecker(), g, D(rt), c.getClassifiableNames(), vt); + } + function pn(rt, vt, Nt) { + return P(), (Nt || "original") === "original" ? bq(c.getTypeChecker(), g, D(rt), c.getClassifiableNames(), vt) : dce(c, g, D(rt), vt); + } + function _i(rt, vt) { + return zae(g, o.getCurrentSourceFile(rt), vt); + } + function Je(rt, vt) { + return Sq(g, o.getCurrentSourceFile(rt), vt); + } + function ft(rt) { + const vt = o.getCurrentSourceFile(rt); + return ZH.collectElements(vt, g); + } + const er = new Map(Object.entries({ + 19: 20, + 21: 22, + 23: 24, + 32: 30 + /* LessThanToken */ + })); + er.forEach((rt, vt) => er.set(rt.toString(), Number(vt))); + function qr(rt, vt) { + const Nt = o.getCurrentSourceFile(rt), Jt = H6(Nt, vt), _r = Jt.getStart(Nt) === vt ? er.get(Jt.kind.toString()) : void 0, nr = _r && Ya(Jt.parent, _r, Nt); + return nr ? [u_(Jt, Nt), u_(nr, Nt)].sort((kt, cr) => kt.start - cr.start) : Ge; + } + function Jn(rt, vt, Nt) { + let Jt = ao(); + const _r = u8(Nt), nr = o.getCurrentSourceFile(rt); + h("getIndentationAtPosition: getCurrentSourceFile: " + (ao() - Jt)), Jt = ao(); + const kt = nl.SmartIndenter.getIndentation(vt, nr, _r); + return h("getIndentationAtPosition: computeIndentation : " + (ao() - Jt)), kt; + } + function Un(rt, vt, Nt, Jt) { + const _r = o.getCurrentSourceFile(rt); + return nl.formatSelection(vt, Nt, _r, nl.getFormatContext(u8(Jt), e)); + } + function ki(rt, vt) { + return nl.formatDocument(o.getCurrentSourceFile(rt), nl.getFormatContext(u8(vt), e)); + } + function Ds(rt, vt, Nt, Jt) { + const _r = o.getCurrentSourceFile(rt), nr = nl.getFormatContext(u8(Jt), e); + if (!P0(_r, vt)) + switch (Nt) { + case "{": + return nl.formatOnOpeningCurly(vt, _r, nr); + case "}": + return nl.formatOnClosingCurly(vt, _r, nr); + case ";": + return nl.formatOnSemicolon(vt, _r, nr); + case ` +`: + return nl.formatOnEnter(vt, _r, nr); + } + return []; + } + function Ks(rt, vt, Nt, Jt, _r, nr = qp) { + P(); + const kt = D(rt), cr = Nc(vt, Nt), fr = nl.getFormatContext(_r, e); + return ka(hb(Jt, gy, ho), (vr) => (g.throwIfCancellationRequested(), Ou.getFixes({ errorCode: vr, sourceFile: kt, span: cr, program: c, host: e, cancellationToken: g, formatContext: fr, preferences: nr }))); + } + function yr(rt, vt, Nt, Jt = qp) { + P(), E.assert(rt.type === "file"); + const _r = D(rt.fileName), nr = nl.getFormatContext(Nt, e); + return Ou.getAllFixes({ fixId: vt, sourceFile: _r, program: c, host: e, cancellationToken: g, formatContext: nr, preferences: Jt }); + } + function bs(rt, vt, Nt = qp) { + P(), E.assert(rt.type === "file"); + const Jt = D(rt.fileName); + if (fx(Jt)) return Ge; + const _r = nl.getFormatContext(vt, e), nr = rt.mode ?? (rt.skipDestructiveCodeActions ? "SortAndCombine" : "All"); + return Dv.organizeImports(Jt, _r, e, c, Nt, nr); + } + function Xe(rt, vt, Nt, Jt = qp) { + return Vae(O(), rt, vt, e, nl.getFormatContext(Nt, e), Jt, k); + } + function Et(rt, vt) { + const Nt = typeof rt == "string" ? vt : rt; + return as(Nt) ? Promise.all(Nt.map((Jt) => re(Jt))) : re(Nt); + } + function re(rt) { + const vt = (Nt) => oo(Nt, m, T); + return E.assertEqual(rt.type, "install package"), e.installPackage ? e.installPackage({ fileName: vt(rt.file), packageName: rt.packageName }) : Promise.reject("Host does not implement `installPackage`"); + } + function it(rt, vt, Nt, Jt) { + const _r = Jt ? nl.getFormatContext(Jt, e).options : void 0; + return Ev.getDocCommentTemplateAtPosition(Fh(e, _r), o.getCurrentSourceFile(rt), vt, Nt); + } + function Y(rt, vt, Nt) { + if (Nt === 60) + return !1; + const Jt = o.getCurrentSourceFile(rt); + if (_k(Jt, vt)) + return !1; + if (sae(Jt, vt)) + return Nt === 123; + if (AV(Jt, vt)) + return !1; + switch (Nt) { + case 39: + case 34: + case 96: + return !P0(Jt, vt); + } + return !0; + } + function Ae(rt, vt) { + const Nt = o.getCurrentSourceFile(rt), Jt = pl(vt, Nt); + if (!Jt) return; + const _r = Jt.kind === 32 && Id(Jt.parent) ? Jt.parent.parent : Bx(Jt) && Sm(Jt.parent) ? Jt.parent : void 0; + if (_r && Ct(_r)) + return { newText: `` }; + const nr = Jt.kind === 32 && ud(Jt.parent) ? Jt.parent.parent : Bx(Jt) && cv(Jt.parent) ? Jt.parent : void 0; + if (nr && qe(nr)) + return { newText: "" }; + } + function $e(rt, vt) { + const Nt = o.getCurrentSourceFile(rt), Jt = pl(vt, Nt); + if (!Jt || Jt.parent.kind === 308) return; + const _r = "[a-zA-Z0-9:\\-\\._$]*"; + if (cv(Jt.parent.parent)) { + const nr = Jt.parent.parent.openingFragment, kt = Jt.parent.parent.closingFragment; + if (fx(nr) || fx(kt)) return; + const cr = nr.getStart(Nt) + 1, fr = kt.getStart(Nt) + 2; + return vt !== cr && vt !== fr ? void 0 : { + ranges: [{ start: cr, length: 0 }, { start: fr, length: 0 }], + wordPattern: _r + }; + } else { + const nr = dr(Jt.parent, (Rs) => !!(Id(Rs) || Qb(Rs))); + if (!nr) return; + E.assert(Id(nr) || Qb(nr), "tag should be opening or closing element"); + const kt = nr.parent.openingElement, cr = nr.parent.closingElement, fr = kt.tagName.getStart(Nt), vr = kt.tagName.end, Xt = cr.tagName.getStart(Nt), oi = cr.tagName.end; + return fr === kt.getStart(Nt) || Xt === cr.getStart(Nt) || vr === kt.getEnd() || oi === cr.getEnd() || !(fr <= vt && vt <= vr || Xt <= vt && vt <= oi) || kt.tagName.getText(Nt) !== cr.tagName.getText(Nt) ? void 0 : { + ranges: [{ start: fr, length: vr - fr }, { start: Xt, length: oi - Xt }], + wordPattern: _r + }; + } + } + function Ke(rt, vt) { + return { + lineStarts: rt.getLineStarts(), + firstLine: rt.getLineAndCharacterOfPosition(vt.pos).line, + lastLine: rt.getLineAndCharacterOfPosition(vt.end).line + }; + } + function Tt(rt, vt, Nt) { + const Jt = o.getCurrentSourceFile(rt), _r = [], { lineStarts: nr, firstLine: kt, lastLine: cr } = Ke(Jt, vt); + let fr = Nt || !1, vr = Number.MAX_VALUE; + const Xt = /* @__PURE__ */ new Map(), oi = new RegExp(/\S/), Fs = k9(Jt, nr[kt]), Rs = Fs ? "{/*" : "//"; + for (let ds = kt; ds <= cr; ds++) { + const pc = Jt.text.substring(nr[ds], Jt.getLineEndOfPosition(nr[ds])), Zo = oi.exec(pc); + Zo && (vr = Math.min(vr, Zo.index), Xt.set(ds.toString(), Zo.index), pc.substr(Zo.index, Rs.length) !== Rs && (fr = Nt === void 0 || Nt)); + } + for (let ds = kt; ds <= cr; ds++) { + if (kt !== cr && nr[ds] === vt.end) + continue; + const pc = Xt.get(ds.toString()); + pc !== void 0 && (Fs ? _r.push(...Le(rt, { pos: nr[ds] + vr, end: Jt.getLineEndOfPosition(nr[ds]) }, fr, Fs)) : fr ? _r.push({ + newText: Rs, + span: { + length: 0, + start: nr[ds] + vr + } + }) : Jt.text.substr(nr[ds] + pc, Rs.length) === Rs && _r.push({ + newText: "", + span: { + length: Rs.length, + start: nr[ds] + pc + } + })); + } + return _r; + } + function Le(rt, vt, Nt, Jt) { + var _r; + const nr = o.getCurrentSourceFile(rt), kt = [], { text: cr } = nr; + let fr = !1, vr = Nt || !1; + const Xt = []; + let { pos: oi } = vt; + const Fs = Jt !== void 0 ? Jt : k9(nr, oi), Rs = Fs ? "{/*" : "/*", ds = Fs ? "*/}" : "*/", pc = Fs ? "\\{\\/\\*" : "\\/\\*", Zo = Fs ? "\\*\\/\\}" : "\\*\\/"; + for (; oi <= vt.end; ) { + const so = cr.substr(oi, Rs.length) === Rs ? Rs.length : 0, zi = P0(nr, oi + so); + if (zi) + Fs && (zi.pos--, zi.end++), Xt.push(zi.pos), zi.kind === 3 && Xt.push(zi.end), fr = !0, oi = zi.end + 1; + else { + const hs = cr.substring(oi, vt.end).search(`(${pc})|(${Zo})`); + vr = Nt !== void 0 ? Nt : vr || !gae(cr, oi, hs === -1 ? vt.end : oi + hs), oi = hs === -1 ? vt.end + 1 : oi + hs + ds.length; + } + } + if (vr || !fr) { + ((_r = P0(nr, vt.pos)) == null ? void 0 : _r.kind) !== 2 && _y(Xt, vt.pos, ho), _y(Xt, vt.end, ho); + const so = Xt[0]; + cr.substr(so, Rs.length) !== Rs && kt.push({ + newText: Rs, + span: { + length: 0, + start: so + } + }); + for (let zi = 1; zi < Xt.length - 1; zi++) + cr.substr(Xt[zi] - ds.length, ds.length) !== ds && kt.push({ + newText: ds, + span: { + length: 0, + start: Xt[zi] + } + }), cr.substr(Xt[zi], Rs.length) !== Rs && kt.push({ + newText: Rs, + span: { + length: 0, + start: Xt[zi] + } + }); + kt.length % 2 !== 0 && kt.push({ + newText: ds, + span: { + length: 0, + start: Xt[Xt.length - 1] + } + }); + } else + for (const so of Xt) { + const zi = so - ds.length > 0 ? so - ds.length : 0, hs = cr.substr(zi, ds.length) === ds ? ds.length : 0; + kt.push({ + newText: "", + span: { + length: Rs.length, + start: so - hs + } + }); + } + return kt; + } + function mt(rt, vt) { + const Nt = o.getCurrentSourceFile(rt), { firstLine: Jt, lastLine: _r } = Ke(Nt, vt); + return Jt === _r && vt.pos !== vt.end ? Le( + rt, + vt, + /*insertComment*/ + !0 + ) : Tt( + rt, + vt, + /*insertComment*/ + !0 + ); + } + function pt(rt, vt) { + const Nt = o.getCurrentSourceFile(rt), Jt = [], { pos: _r } = vt; + let { end: nr } = vt; + _r === nr && (nr += k9(Nt, _r) ? 2 : 1); + for (let kt = _r; kt <= nr; kt++) { + const cr = P0(Nt, kt); + if (cr) { + switch (cr.kind) { + case 2: + Jt.push(...Tt( + rt, + { end: cr.end, pos: cr.pos + 1 }, + /*insertComment*/ + !1 + )); + break; + case 3: + Jt.push(...Le( + rt, + { end: cr.end, pos: cr.pos + 1 }, + /*insertComment*/ + !1 + )); + } + kt = cr.end + 1; + } + } + return Jt; + } + function Ct({ openingElement: rt, closingElement: vt, parent: Nt }) { + return !dv(rt.tagName, vt.tagName) || Sm(Nt) && dv(rt.tagName, Nt.openingElement.tagName) && Ct(Nt); + } + function qe({ closingFragment: rt, parent: vt }) { + return !!(rt.flags & 262144) || cv(vt) && qe(vt); + } + function Lt(rt, vt, Nt) { + const Jt = o.getCurrentSourceFile(rt), _r = nl.getRangeOfEnclosingComment(Jt, vt); + return _r && (!Nt || _r.kind === 3) ? A0(_r) : void 0; + } + function rn(rt, vt) { + P(); + const Nt = D(rt); + g.throwIfCancellationRequested(); + const Jt = Nt.text, _r = []; + if (vt.length > 0 && !fr(Nt.fileName)) { + const vr = kt(); + let Xt; + for (; Xt = vr.exec(Jt); ) { + g.throwIfCancellationRequested(); + const oi = 3; + E.assert(Xt.length === vt.length + oi); + const Fs = Xt[1], Rs = Xt.index + Fs.length; + if (!P0(Nt, Rs)) + continue; + let ds; + for (let Zo = 0; Zo < vt.length; Zo++) + Xt[Zo + oi] && (ds = vt[Zo]); + if (ds === void 0) return E.fail(); + if (cr(Jt.charCodeAt(Rs + ds.text.length))) + continue; + const pc = Xt[2]; + _r.push({ descriptor: ds, message: pc, position: Rs }); + } + } + return _r; + function nr(vr) { + return vr.replace(/[-[\]/{}()*+?.\\^$|]/g, "\\$&"); + } + function kt() { + const vr = /(?:\/{2,}\s*)/.source, Xt = /(?:\/\*+\s*)/.source, Fs = "(" + /(?:^(?:\s|\*)*)/.source + "|" + vr + "|" + Xt + ")", Rs = "(?:" + hr(vt, (zi) => "(" + nr(zi.text) + ")").join("|") + ")", ds = /(?:$|\*\/)/.source, pc = /(?:.*?)/.source, Zo = "(" + Rs + pc + ")", so = Fs + Zo + ds; + return new RegExp(so, "gim"); + } + function cr(vr) { + return vr >= 97 && vr <= 122 || vr >= 65 && vr <= 90 || vr >= 48 && vr <= 57; + } + function fr(vr) { + return vr.includes("/node_modules/"); + } + } + function Pe(rt, vt, Nt) { + return P(), LL.getRenameInfo(c, D(rt), vt, Nt || {}); + } + function yt(rt, vt, Nt, Jt, _r, nr) { + const [kt, cr] = typeof vt == "number" ? [vt, void 0] : [vt.pos, vt.end]; + return { + file: rt, + startPosition: kt, + endPosition: cr, + program: O(), + host: e, + formatContext: nl.getFormatContext(Jt, e), + // TODO: GH#18217 + cancellationToken: g, + preferences: Nt, + triggerReason: _r, + kind: nr + }; + } + function ue(rt, vt, Nt) { + return { + file: rt, + program: O(), + host: e, + span: vt, + preferences: Nt, + cancellationToken: g + }; + } + function M(rt, vt) { + return tG.getSmartSelectionRange(vt, o.getCurrentSourceFile(rt)); + } + function ye(rt, vt, Nt = qp, Jt, _r, nr) { + P(); + const kt = D(rt); + return gk.getApplicableRefactors(yt(kt, vt, Nt, qp, Jt, _r), nr); + } + function Q(rt, vt, Nt = qp) { + P(); + const Jt = D(rt), _r = E.checkDefined(c.getSourceFiles()), nr = p4(rt), kt = c8(yt(Jt, vt, Nt, qp)), cr = Ooe(kt?.all), fr = Fi(_r, (vr) => { + const Xt = p4(vr.fileName); + return !c?.isSourceFileFromExternalLibrary(Jt) && !(Jt === D(vr.fileName) || nr === ".ts" && Xt === ".d.ts" || nr === ".d.ts" && Ui(Zc(vr.fileName), "lib.") && Xt === ".d.ts") && (nr === Xt || (nr === ".tsx" && Xt === ".ts" || nr === ".jsx" && Xt === ".js") && !cr) ? vr.fileName : void 0; + }); + return { newFileName: Foe(Jt, c, e, kt), files: fr }; + } + function dt(rt, vt, Nt, Jt, _r, nr = qp, kt) { + P(); + const cr = D(rt); + return gk.getEditsForRefactor(yt(cr, Nt, nr, vt), Jt, _r, kt); + } + function Mt(rt, vt) { + return vt === 0 ? { line: 0, character: 0 } : k.toLineColumnOffset(rt, vt); + } + function ke(rt, vt) { + P(); + const Nt = hk.resolveCallHierarchyDeclaration(c, w_(D(rt), vt)); + return Nt && _q(Nt, (Jt) => hk.createCallHierarchyItem(c, Jt)); + } + function at(rt, vt) { + P(); + const Nt = D(rt), Jt = fq(hk.resolveCallHierarchyDeclaration(c, vt === 0 ? Nt : w_(Nt, vt))); + return Jt ? hk.getIncomingCalls(c, Jt, g) : []; + } + function wt(rt, vt) { + P(); + const Nt = D(rt), Jt = fq(hk.resolveCallHierarchyDeclaration(c, vt === 0 ? Nt : w_(Nt, vt))); + return Jt ? hk.getOutgoingCalls(c, Jt) : []; + } + function Zr(rt, vt, Nt = qp) { + P(); + const Jt = D(rt); + return XH.provideInlayHints(ue(Jt, vt, Nt)); + } + function Rr(rt, vt, Nt, Jt, _r) { + return QH.mapCode( + o.getCurrentSourceFile(rt), + vt, + Nt, + e, + nl.getFormatContext(Jt, e), + _r + ); + } + const Pr = { + dispose: U, + cleanupSemanticCache: B, + getSyntacticDiagnostics: $, + getSemanticDiagnostics: W, + getRegionSemanticDiagnostics: _e, + getSuggestionDiagnostics: q, + getCompilerOptionsDiagnostics: be, + getSyntacticClassifications: _i, + getSemanticClassifications: fi, + getEncodedSyntacticClassifications: Je, + getEncodedSemanticClassifications: pn, + getCompletionsAtPosition: je, + getCompletionEntryDetails: me, + getCompletionEntrySymbol: Z, + getSignatureHelpItems: Jr, + getQuickInfoAtPosition: pe, + getDefinitionAtPosition: Se, + getDefinitionAndBoundSpan: ie, + getImplementationAtPosition: Ee, + getTypeDefinitionAtPosition: Ne, + getReferencesAtPosition: St, + findReferences: tr, + getFileReferences: Nr, + getDocumentHighlights: Ce, + getNameOrDottedNameSpan: Ji, + getBreakpointStatementAtPosition: Dt, + getNavigateToItems: st, + getRenameInfo: Pe, + getSmartSelectionRange: M, + findRenameLocations: Ve, + getNavigationBarItems: Mn, + getNavigationTree: ai, + getOutliningSpans: ft, + getTodoComments: rn, + getBraceMatchingAtPosition: qr, + getIndentationAtPosition: Jn, + getFormattingEditsForRange: Un, + getFormattingEditsForDocument: ki, + getFormattingEditsAfterKeystroke: Ds, + getDocCommentTemplateAtPosition: it, + isValidBraceCompletionAtPosition: Y, + getJsxClosingTagAtPosition: Ae, + getLinkedEditingRangeAtPosition: $e, + getSpanOfEnclosingComment: Lt, + getCodeFixesAtPosition: Ks, + getCombinedCodeFix: yr, + applyCodeActionCommand: Et, + organizeImports: bs, + getEditsForFileRename: Xe, + getEmitOutput: Wt, + getNonBoundSourceFile: ui, + getProgram: O, + getCurrentProgram: () => c, + getAutoImportProvider: F, + updateIsDefinitionOfReferencedSymbols: R, + getApplicableRefactors: ye, + getEditsForRefactor: dt, + getMoveToRefactoringFileSuggestions: Q, + toLineColumnOffset: Mt, + getSourceMapper: () => k, + clearSourceMapperCache: () => k.clearCache(), + prepareCallHierarchy: ke, + provideCallHierarchyIncomingCalls: at, + provideCallHierarchyOutgoingCalls: wt, + toggleLineComment: Tt, + toggleMultilineComment: Le, + commentSelection: mt, + uncommentSelection: pt, + provideInlayHints: Zr, + getSupportedCodeFixes: tH, + preparePasteEditsForFile: Te, + getPasteEdits: Fe, + mapCode: Rr + }; + switch (s) { + case 0: + break; + case 1: + MTe.forEach( + (rt) => Pr[rt] = () => { + throw new Error(`LanguageService Operation: ${rt} not allowed in LanguageServiceMode.PartialSemantic`); + } + ); + break; + case 2: + kVe.forEach( + (rt) => Pr[rt] = () => { + throw new Error(`LanguageService Operation: ${rt} not allowed in LanguageServiceMode.Syntactic`); + } + ); + break; + default: + E.assertNever(s); + } + return Pr; + } + function nH(e) { + return e.nameTable || CVe(e), e.nameTable; + } + function CVe(e) { + const t = e.nameTable = /* @__PURE__ */ new Map(); + e.forEachChild(function n(i) { + if (Me(i) && !xV(i) && i.escapedText || If(i) && EVe(i)) { + const s = XD(i); + t.set(s, t.get(s) === void 0 ? i.pos : -1); + } else if (Ai(i)) { + const s = i.escapedText; + t.set(s, t.get(s) === void 0 ? i.pos : -1); + } + if (xs(i, n), kf(i)) + for (const s of i.jsDoc) + xs(s, n); + }); + } + function EVe(e) { + return Qm(e) || e.parent.kind === 284 || PVe(e) || X3(e); + } + function f8(e) { + const t = DVe(e); + return t && (_a(t.parent) || Yb(t.parent)) ? t : void 0; + } + function DVe(e) { + switch (e.kind) { + case 11: + case 15: + case 9: + if (e.parent.kind === 168) + return Yj(e.parent.parent) ? e.parent.parent : void 0; + // falls through + case 80: + case 296: + return Yj(e.parent) && (e.parent.parent.kind === 211 || e.parent.parent.kind === 293) && e.parent.name === e ? e.parent : void 0; + } + } + function wVe(e, t) { + const n = f8(e); + if (n) { + const i = t.getContextualType(n.parent), s = i && mL( + n, + t, + i, + /*unionSymbolOk*/ + !1 + ); + if (s && s.length === 1) + return Ca(s); + } + return t.getSymbolAtLocation(e); + } + function mL(e, t, n, i) { + const s = GA(e.name); + if (!s) return Ge; + if (!n.isUnion()) { + const _ = n.getProperty(s); + return _ ? [_] : Ge; + } + const o = _a(e.parent) || Yb(e.parent) ? kn(n.types, (_) => !t.isTypeInvalidDueToUnionDiscriminant(_, e.parent)) : n.types, c = Fi(o, (_) => _.getProperty(s)); + if (i && (c.length === 0 || c.length === n.types.length)) { + const _ = n.getProperty(s); + if (_) return [_]; + } + return !o.length && !c.length ? Fi(n.types, (_) => _.getProperty(s)) : hb(c, gy); + } + function PVe(e) { + return e && e.parent && e.parent.kind === 213 && e.parent.argumentExpression === e; + } + function vce(e) { + if (ml) + return On(Hn(Hs(ml.getExecutingFilePath())), ZP(e)); + throw new Error("getDefaultLibFilePath is only supported when consumed as a node module. "); + } + bee(bVe()); + function RTe(e, t, n) { + const i = []; + n = Iq(n, i); + const s = as(e) ? e : [e], o = bA( + /*resolver*/ + void 0, + /*host*/ + void 0, + N, + n, + s, + t, + /*allowDtsFiles*/ + !0 + ); + return o.diagnostics = Bi(o.diagnostics, i), o; + } + var iH = {}; + Na(iH, { + spanInSourceFileAtLocation: () => NVe + }); + function NVe(e, t) { + if (e.isDeclarationFile) + return; + let n = vi(e, t); + const i = e.getLineAndCharacterOfPosition(t).line; + if (e.getLineAndCharacterOfPosition(n.getStart(e)).line > i) { + const h = pl(n.pos, e); + if (!h || e.getLineAndCharacterOfPosition(h.getEnd()).line !== i) + return; + n = h; + } + if (n.flags & 33554432) + return; + return m(n); + function s(h, S) { + const T = e2(h) ? gb(h.modifiers, ul) : void 0, k = T ? oa(e.text, T.end) : h.getStart(e); + return Nc(k, (S || h).getEnd()); + } + function o(h, S) { + return s(h, c2(S, S.parent, e)); + } + function c(h, S) { + return h && i === e.getLineAndCharacterOfPosition(h.getStart(e)).line ? m(h) : m(S); + } + function _(h, S, T) { + if (h) { + const k = h.indexOf(S); + if (k >= 0) { + let D = k, P = k + 1; + for (; D > 0 && T(h[D - 1]); ) D--; + for (; P < h.length && T(h[P]); ) P++; + return Nc(oa(e.text, h[D].pos), h[P - 1].end); + } + } + return s(S); + } + function u(h) { + return m(pl(h.pos, e)); + } + function g(h) { + return m(c2(h, h.parent, e)); + } + function m(h) { + if (h) { + const { parent: q } = h; + switch (h.kind) { + case 244: + return T(h.declarationList.declarations[0]); + case 261: + case 173: + case 172: + return T(h); + case 170: + return D(h); + case 263: + case 175: + case 174: + case 178: + case 179: + case 177: + case 219: + case 220: + return A(h); + case 242: + if (Nb(h)) + return O(h); + // falls through + case 269: + return F(h); + case 300: + return F(h.block); + case 245: + return s(h.expression); + case 254: + return s(h.getChildAt(0), h.expression); + case 248: + return o(h, h.expression); + case 247: + return m(h.statement); + case 260: + return s(h.getChildAt(0)); + case 246: + return o(h, h.expression); + case 257: + return m(h.statement); + case 253: + case 252: + return s(h.getChildAt(0), h.label); + case 249: + return B(h); + case 250: + return o(h, h.expression); + case 251: + return R(h); + case 256: + return o(h, h.expression); + case 297: + case 298: + return m(h.statements[0]); + case 259: + return F(h.tryBlock); + case 258: + return s(h, h.expression); + case 278: + return s(h, h.expression); + case 272: + return s(h, h.moduleReference); + case 273: + return s(h, h.moduleSpecifier); + case 279: + return s(h, h.moduleSpecifier); + case 268: + if (Ah(h) !== 1) + return; + // falls through + case 264: + case 267: + case 307: + case 209: + return s(h); + case 255: + return m(h.statement); + case 171: + return _(q.modifiers, h, ul); + case 207: + case 208: + return U(h); + // No breakpoint in interface, type alias + case 265: + case 266: + return; + // Tokens: + case 27: + case 1: + return c(pl(h.pos, e)); + case 28: + return u(h); + case 19: + return W(h); + case 20: + return _e(h); + case 24: + return K(h); + case 21: + return V(h); + case 22: + return ae(h); + case 59: + return se(h); + case 32: + case 30: + return ce(h); + // Keywords: + case 117: + return fe(h); + case 93: + case 85: + case 98: + return g(h); + case 165: + return he(h); + default: + if (N0(h)) + return $(h); + if ((h.kind === 80 || h.kind === 231 || h.kind === 304 || h.kind === 305) && N0(q)) + return s(h); + if (h.kind === 227) { + const { left: be, operatorToken: je } = h; + if (N0(be)) + return $( + be + ); + if (je.kind === 64 && N0(h.parent)) + return s(h); + if (je.kind === 28) + return m(be); + } + if (Xm(h)) + switch (q.kind) { + case 247: + return u(h); + case 171: + return m(h.parent); + case 249: + case 251: + return s(h); + case 227: + if (h.parent.operatorToken.kind === 28) + return s(h); + break; + case 220: + if (h.parent.body === h) + return s(h); + break; + } + switch (h.parent.kind) { + case 304: + if (h.parent.name === h && !N0(h.parent.parent)) + return m(h.parent.initializer); + break; + case 217: + if (h.parent.type === h) + return g(h.parent.type); + break; + case 261: + case 170: { + const { initializer: be, type: je } = h.parent; + if (be === h || je === h || kh(h.kind)) + return u(h); + break; + } + case 227: { + const { left: be } = h.parent; + if (N0(be) && h !== be) + return u(h); + break; + } + default: + if (Es(h.parent) && h.parent.type === h) + return u(h); + } + return m(h.parent); + } + } + function S(q) { + return Ul(q.parent) && q.parent.declarations[0] === q ? s(pl(q.pos, e, q.parent), q) : s(q); + } + function T(q) { + if (q.parent.parent.kind === 250) + return m(q.parent.parent); + const be = q.parent; + if (ws(q.name)) + return U(q.name); + if (iS(q) && q.initializer || Gn( + q, + 32 + /* Export */ + ) || be.parent.kind === 251) + return S(q); + if (Ul(q.parent) && q.parent.declarations[0] !== q) + return m(pl(q.pos, e, q.parent)); + } + function k(q) { + return !!q.initializer || q.dotDotDotToken !== void 0 || Gn( + q, + 3 + /* Private */ + ); + } + function D(q) { + if (ws(q.name)) + return U(q.name); + if (k(q)) + return s(q); + { + const be = q.parent, je = be.parameters.indexOf(q); + return E.assert(je !== -1), je !== 0 ? D(be.parameters[je - 1]) : m(be.body); + } + } + function P(q) { + return Gn( + q, + 32 + /* Export */ + ) || q.parent.kind === 264 && q.kind !== 177; + } + function A(q) { + if (q.body) + return P(q) ? s(q) : m(q.body); + } + function O(q) { + const be = q.statements.length ? q.statements[0] : q.getLastToken(); + return P(q.parent) ? c(q.parent, be) : m(be); + } + function F(q) { + switch (q.parent.kind) { + case 268: + if (Ah(q.parent) !== 1) + return; + // Set on parent if on same line otherwise on first statement + // falls through + case 248: + case 246: + case 250: + return c(q.parent, q.statements[0]); + // Set span on previous token if it starts on same line otherwise on the first statement of the block + case 249: + case 251: + return c(pl(q.pos, e, q.parent), q.statements[0]); + } + return m(q.statements[0]); + } + function R(q) { + if (q.initializer.kind === 262) { + const be = q.initializer; + if (be.declarations.length > 0) + return m(be.declarations[0]); + } else + return m(q.initializer); + } + function B(q) { + if (q.initializer) + return R(q); + if (q.condition) + return s(q.condition); + if (q.incrementor) + return s(q.incrementor); + } + function U(q) { + const be = lr(q.elements, (je) => je.kind !== 233 ? je : void 0); + return be ? m(be) : q.parent.kind === 209 ? s(q.parent) : S(q.parent); + } + function $(q) { + E.assert( + q.kind !== 208 && q.kind !== 207 + /* ObjectBindingPattern */ + ); + const be = q.kind === 210 ? q.elements : q.properties, je = lr(be, (me) => me.kind !== 233 ? me : void 0); + return je ? m(je) : s(q.parent.kind === 227 ? q.parent : q); + } + function W(q) { + switch (q.parent.kind) { + case 267: + const be = q.parent; + return c(pl(q.pos, e, q.parent), be.members.length ? be.members[0] : be.getLastToken(e)); + case 264: + const je = q.parent; + return c(pl(q.pos, e, q.parent), je.members.length ? je.members[0] : je.getLastToken(e)); + case 270: + return c(q.parent.parent, q.parent.clauses[0]); + } + return m(q.parent); + } + function _e(q) { + switch (q.parent.kind) { + case 269: + if (Ah(q.parent.parent) !== 1) + return; + // falls through + case 267: + case 264: + return s(q); + case 242: + if (Nb(q.parent)) + return s(q); + // falls through + case 300: + return m(Do(q.parent.statements)); + case 270: + const be = q.parent, je = Do(be.clauses); + return je ? m(Do(je.statements)) : void 0; + case 207: + const me = q.parent; + return m(Do(me.elements) || me); + // Default to parent node + default: + if (N0(q.parent)) { + const Z = q.parent; + return s(Do(Z.properties) || Z); + } + return m(q.parent); + } + } + function K(q) { + switch (q.parent.kind) { + case 208: + const be = q.parent; + return s(Do(be.elements) || be); + default: + if (N0(q.parent)) { + const je = q.parent; + return s(Do(je.elements) || je); + } + return m(q.parent); + } + } + function V(q) { + return q.parent.kind === 247 || // Go to while keyword and do action instead + q.parent.kind === 214 || q.parent.kind === 215 ? u(q) : q.parent.kind === 218 ? g(q) : m(q.parent); + } + function ae(q) { + switch (q.parent.kind) { + case 219: + case 263: + case 220: + case 175: + case 174: + case 178: + case 179: + case 177: + case 248: + case 247: + case 249: + case 251: + case 214: + case 215: + case 218: + return u(q); + // Default to parent node + default: + return m(q.parent); + } + } + function se(q) { + return Es(q.parent) || q.parent.kind === 304 || q.parent.kind === 170 ? u(q) : m(q.parent); + } + function ce(q) { + return q.parent.kind === 217 ? g(q) : m(q.parent); + } + function fe(q) { + return q.parent.kind === 247 ? o(q, q.parent.expression) : m(q.parent); + } + function he(q) { + return q.parent.kind === 251 ? g(q) : m(q.parent); + } + } + } + var hk = {}; + Na(hk, { + createCallHierarchyItem: () => bce, + getIncomingCalls: () => jVe, + getOutgoingCalls: () => $Ve, + resolveCallHierarchyDeclaration: () => qTe + }); + function AVe(e) { + return (yo(e) || Rc(e)) && wl(e); + } + function jTe(e) { + return os(e) || ei(e); + } + function p8(e) { + return (yo(e) || xo(e) || Rc(e)) && jTe(e.parent) && e === e.parent.initializer && Me(e.parent.name) && (!!(yh(e.parent) & 2) || os(e.parent)); + } + function BTe(e) { + return Di(e) || jc(e) || Cc(e) || yo(e) || tl(e) || Rc(e) || kc(e) || rc(e) || cd(e) || pp(e) || z_(e); + } + function rE(e) { + return Di(e) || jc(e) && Me(e.name) || Cc(e) || tl(e) || kc(e) || rc(e) || cd(e) || pp(e) || z_(e) || AVe(e) || p8(e); + } + function JTe(e) { + return Di(e) ? e : wl(e) ? e.name : p8(e) ? e.parent.name : E.checkDefined(e.modifiers && Nn(e.modifiers, zTe)); + } + function zTe(e) { + return e.kind === 90; + } + function WTe(e, t) { + const n = JTe(t); + return n && e.getSymbolAtLocation(n); + } + function IVe(e, t) { + if (Di(t)) + return { text: t.fileName, pos: 0, end: 0 }; + if ((Cc(t) || tl(t)) && !wl(t)) { + const s = t.modifiers && Nn(t.modifiers, zTe); + if (s) + return { text: "default", pos: s.getStart(), end: s.getEnd() }; + } + if (kc(t)) { + const s = t.getSourceFile(), o = oa(s.text, dm(t).pos), c = o + 6, _ = e.getTypeChecker(), u = _.getSymbolAtLocation(t.parent); + return { text: `${u ? `${_.symbolToString(u, t.parent)} ` : ""}static {}`, pos: o, end: c }; + } + const n = p8(t) ? t.parent.name : E.checkDefined(_s(t), "Expected call hierarchy item to have a name"); + let i = Me(n) ? An(n) : If(n) ? n.text : Gs(n) && If(n.expression) ? n.expression.text : void 0; + if (i === void 0) { + const s = e.getTypeChecker(), o = s.getSymbolAtLocation(n); + o && (i = s.symbolToString(o, t)); + } + if (i === void 0) { + const s = sU(); + i = LC((o) => s.writeNode(4, t, t.getSourceFile(), o)); + } + return { text: i, pos: n.getStart(), end: n.getEnd() }; + } + function FVe(e) { + var t, n, i, s; + if (p8(e)) + return os(e.parent) && $n(e.parent.parent) ? Rc(e.parent.parent) ? (t = y7(e.parent.parent)) == null ? void 0 : t.getText() : (n = e.parent.parent.name) == null ? void 0 : n.getText() : vm(e.parent.parent.parent.parent) && Me(e.parent.parent.parent.parent.parent.name) ? e.parent.parent.parent.parent.parent.name.getText() : void 0; + switch (e.kind) { + case 178: + case 179: + case 175: + return e.parent.kind === 211 ? (i = y7(e.parent)) == null ? void 0 : i.getText() : (s = _s(e.parent)) == null ? void 0 : s.getText(); + case 263: + case 264: + case 268: + if (vm(e.parent) && Me(e.parent.parent.name)) + return e.parent.parent.name.getText(); + } + } + function UTe(e, t) { + if (t.body) + return t; + if (nc(t)) + return Mg(t.parent); + if (Cc(t) || rc(t)) { + const n = WTe(e, t); + return n && n.valueDeclaration && io(n.valueDeclaration) && n.valueDeclaration.body ? n.valueDeclaration : void 0; + } + return t; + } + function VTe(e, t) { + const n = WTe(e, t); + let i; + if (n && n.declarations) { + const s = $I(n.declarations), o = hr(n.declarations, (u) => ({ file: u.getSourceFile().fileName, pos: u.pos })); + s.sort((u, g) => _u(o[u].file, o[g].file) || o[u].pos - o[g].pos); + const c = hr(s, (u) => n.declarations[u]); + let _; + for (const u of c) + rE(u) && ((!_ || _.parent !== u.parent || _.end !== u.pos) && (i = Er(i, u)), _ = u); + } + return i; + } + function sH(e, t) { + return kc(t) ? t : io(t) ? UTe(e, t) ?? VTe(e, t) ?? t : VTe(e, t) ?? t; + } + function qTe(e, t) { + const n = e.getTypeChecker(); + let i = !1; + for (; ; ) { + if (rE(t)) + return sH(n, t); + if (BTe(t)) { + const s = dr(t, rE); + return s && sH(n, s); + } + if (Qm(t)) { + if (rE(t.parent)) + return sH(n, t.parent); + if (BTe(t.parent)) { + const s = dr(t.parent, rE); + return s && sH(n, s); + } + return jTe(t.parent) && t.parent.initializer && p8(t.parent.initializer) ? t.parent.initializer : void 0; + } + if (nc(t)) + return rE(t.parent) ? t.parent : void 0; + if (t.kind === 126 && kc(t.parent)) { + t = t.parent; + continue; + } + if (ei(t) && t.initializer && p8(t.initializer)) + return t.initializer; + if (!i) { + let s = n.getSymbolAtLocation(t); + if (s && (s.flags & 2097152 && (s = n.getAliasedSymbol(s)), s.valueDeclaration)) { + i = !0, t = s.valueDeclaration; + continue; + } + } + return; + } + } + function bce(e, t) { + const n = t.getSourceFile(), i = IVe(e, t), s = FVe(t), o = o2(t), c = hw(t), _ = Nc(oa( + n.text, + t.getFullStart(), + /*stopAfterLineBreak*/ + !1, + /*stopAtComments*/ + !0 + ), t.getEnd()), u = Nc(i.pos, i.end); + return { file: n.fileName, kind: o, kindModifiers: c, name: i.text, containerName: s, span: _, selectionSpan: u }; + } + function OVe(e) { + return e !== void 0; + } + function LVe(e) { + if (e.kind === ko.EntryKind.Node) { + const { node: t } = e; + if (vV( + t, + /*includeElementAccess*/ + !0, + /*skipPastOuterExpressions*/ + !0 + ) || Xse( + t, + /*includeElementAccess*/ + !0, + /*skipPastOuterExpressions*/ + !0 + ) || Qse( + t, + /*includeElementAccess*/ + !0, + /*skipPastOuterExpressions*/ + !0 + ) || Yse( + t, + /*includeElementAccess*/ + !0, + /*skipPastOuterExpressions*/ + !0 + ) || U6(t) || kV(t)) { + const n = t.getSourceFile(); + return { declaration: dr(t, rE) || n, range: BV(t, n) }; + } + } + } + function HTe(e) { + return Ma(e.declaration); + } + function MVe(e, t) { + return { from: e, fromSpans: t }; + } + function RVe(e, t) { + return MVe(bce(e, t[0].declaration), hr(t, (n) => A0(n.range))); + } + function jVe(e, t, n) { + if (Di(t) || jc(t) || kc(t)) + return []; + const i = JTe(t), s = kn(ko.findReferenceOrRenameEntries( + e, + n, + e.getSourceFiles(), + i, + /*position*/ + 0, + { use: ko.FindReferencesUse.References }, + LVe + ), OVe); + return s ? yC(s, HTe, (o) => RVe(e, o)) : []; + } + function BVe(e, t) { + function n(s) { + const o = nv(s) ? s.tag : wu(s) ? s.tagName : To(s) || kc(s) ? s : s.expression, c = qTe(e, o); + if (c) { + const _ = BV(o, s.getSourceFile()); + if (as(c)) + for (const u of c) + t.push({ declaration: u, range: _ }); + else + t.push({ declaration: c, range: _ }); + } + } + function i(s) { + if (s && !(s.flags & 33554432)) { + if (rE(s)) { + if ($n(s)) + for (const o of s.members) + o.name && Gs(o.name) && i(o.name.expression); + return; + } + switch (s.kind) { + case 80: + case 272: + case 273: + case 279: + case 265: + case 266: + return; + case 176: + n(s); + return; + case 217: + case 235: + i(s.expression); + return; + case 261: + case 170: + i(s.name), i(s.initializer); + return; + case 214: + n(s), i(s.expression), lr(s.arguments, i); + return; + case 215: + n(s), i(s.expression), lr(s.arguments, i); + return; + case 216: + n(s), i(s.tag), i(s.template); + return; + case 287: + case 286: + n(s), i(s.tagName), i(s.attributes); + return; + case 171: + n(s), i(s.expression); + return; + case 212: + case 213: + n(s), xs(s, i); + break; + case 239: + i(s.expression); + return; + } + lm(s) || xs(s, i); + } + } + return i; + } + function JVe(e, t) { + lr(e.statements, t); + } + function zVe(e, t) { + !Gn( + e, + 128 + /* Ambient */ + ) && e.body && vm(e.body) && lr(e.body.statements, t); + } + function WVe(e, t, n) { + const i = UTe(e, t); + i && (lr(i.parameters, n), n(i.body)); + } + function UVe(e, t) { + t(e.body); + } + function VVe(e, t) { + lr(e.modifiers, t); + const n = Lb(e); + n && t(n.expression); + for (const i of e.members) + Vp(i) && lr(i.modifiers, t), os(i) ? t(i.initializer) : nc(i) && i.body ? (lr(i.parameters, t), t(i.body)) : kc(i) && t(i); + } + function qVe(e, t) { + const n = [], i = BVe(e, n); + switch (t.kind) { + case 308: + JVe(t, i); + break; + case 268: + zVe(t, i); + break; + case 263: + case 219: + case 220: + case 175: + case 178: + case 179: + WVe(e.getTypeChecker(), t, i); + break; + case 264: + case 232: + VVe(t, i); + break; + case 176: + UVe(t, i); + break; + default: + E.assertNever(t); + } + return n; + } + function HVe(e, t) { + return { to: e, fromSpans: t }; + } + function GVe(e, t) { + return HVe(bce(e, t[0].declaration), hr(t, (n) => A0(n.range))); + } + function $Ve(e, t) { + return t.flags & 33554432 || cd(t) ? [] : yC(qVe(e, t), HTe, (n) => GVe(e, n)); + } + var Sce = {}; + Na(Sce, { + v2020: () => GTe + }); + var GTe = {}; + Na(GTe, { + TokenEncodingConsts: () => bTe, + TokenModifier: () => TTe, + TokenType: () => STe, + getEncodedSemanticClassifications: () => dce, + getSemanticClassifications: () => xTe + }); + var Ou = {}; + Na(Ou, { + PreserveOptionalFlags: () => oEe, + addNewNodeForMemberSymbol: () => cEe, + codeFixAll: () => Qa, + createCodeFixAction: () => Ls, + createCodeFixActionMaybeFixAll: () => kce, + createCodeFixActionWithoutFixAll: () => jd, + createCombinedCodeActions: () => yk, + createFileTextChanges: () => $Te, + createImportAdder: () => d2, + createImportSpecifierResolver: () => nHe, + createMissingMemberNodes: () => qle, + createSignatureDeclarationFromCallExpression: () => Hle, + createSignatureDeclarationFromSignature: () => AH, + createStubbedBody: () => TL, + eachDiagnostic: () => vk, + findAncestorMatchingSpan: () => Kle, + generateAccessorFromProperty: () => gEe, + getAccessorConvertiblePropertyAtPosition: () => vEe, + getAllFixes: () => ZVe, + getFixes: () => YVe, + getImportCompletionAction: () => iHe, + getImportKind: () => gH, + getJSDocTypedefNodes: () => tHe, + getNoopSymbolTrackerWithResolver: () => iE, + getPromoteTypeOnlyCompletionAction: () => sHe, + getSupportedErrorCodes: () => XVe, + importFixName: () => gke, + importSymbols: () => HS, + parameterShouldGetTypeFromJSDoc: () => Cxe, + registerCodeFix: () => Qs, + setJsonCompilerOptionValue: () => Yle, + setJsonCompilerOptionValues: () => Qle, + tryGetAutoImportableReferenceFromTypeNode: () => m2, + typeNodeToAutoImportableTypeNode: () => Gle, + typePredicateToAutoImportableTypeNode: () => _Ee, + typeToAutoImportableTypeNode: () => IH, + typeToMinimizedReferenceType: () => uEe + }); + var Tce = Fp(), xce = /* @__PURE__ */ new Map(); + function jd(e, t, n) { + return Cce( + e, + l2(n), + t, + /*fixId*/ + void 0, + /*fixAllDescription*/ + void 0 + ); + } + function Ls(e, t, n, i, s, o) { + return Cce(e, l2(n), t, i, l2(s), o); + } + function kce(e, t, n, i, s, o) { + return Cce(e, l2(n), t, i, s && l2(s), o); + } + function Cce(e, t, n, i, s, o) { + return { fixName: e, description: t, changes: n, fixId: i, fixAllDescription: s, commands: o ? [o] : void 0 }; + } + function Qs(e) { + for (const t of e.errorCodes) + Ece = void 0, Tce.add(String(t), e); + if (e.fixIds) + for (const t of e.fixIds) + E.assert(!xce.has(t)), xce.set(t, e); + } + var Ece; + function XVe() { + return Ece ?? (Ece = is(Tce.keys())); + } + function QVe(e, t) { + const { errorCodes: n } = e; + let i = 0; + for (const o of t) + if (ms(n, o.code) && i++, i > 1) break; + const s = i < 2; + return ({ fixId: o, fixAllDescription: c, ..._ }) => s ? _ : { ..._, fixId: o, fixAllDescription: c }; + } + function YVe(e) { + const t = XTe(e), n = Tce.get(String(e.errorCode)); + return ka(n, (i) => hr(i.getCodeActions(e), QVe(i, t))); + } + function ZVe(e) { + return xce.get(Us(e.fixId, gs)).getAllCodeActions(e); + } + function yk(e, t) { + return { changes: e, commands: t }; + } + function $Te(e, t) { + return { fileName: e, textChanges: t }; + } + function Qa(e, t, n) { + const i = [], s = cn.ChangeTracker.with(e, (o) => vk(e, t, (c) => n(o, c, i))); + return yk(s, i.length === 0 ? void 0 : i); + } + function vk(e, t, n) { + for (const i of XTe(e)) + ms(t, i.code) && n(i); + } + function XTe({ program: e, sourceFile: t, cancellationToken: n }) { + const i = [ + ...e.getSemanticDiagnostics(t, n), + ...e.getSyntacticDiagnostics(t, n), + ...wq(t, e, n) + ]; + return J_(e.getCompilerOptions()) && i.push( + ...e.getDeclarationDiagnostics(t, n) + ), i; + } + var Dce = "addConvertToUnknownForNonOverlappingTypes", QTe = [p.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first.code]; + Qs({ + errorCodes: QTe, + getCodeActions: function(t) { + const n = ZTe(t.sourceFile, t.span.start); + if (n === void 0) return; + const i = cn.ChangeTracker.with(t, (s) => YTe(s, t.sourceFile, n)); + return [Ls(Dce, i, p.Add_unknown_conversion_for_non_overlapping_types, Dce, p.Add_unknown_to_all_conversions_of_non_overlapping_types)]; + }, + fixIds: [Dce], + getAllCodeActions: (e) => Qa(e, QTe, (t, n) => { + const i = ZTe(n.file, n.start); + i && YTe(t, n.file, i); + }) + }); + function YTe(e, t, n) { + const i = d6(n) ? N.createAsExpression(n.expression, N.createKeywordTypeNode( + 159 + /* UnknownKeyword */ + )) : N.createTypeAssertion(N.createKeywordTypeNode( + 159 + /* UnknownKeyword */ + ), n.expression); + e.replaceNode(t, n.expression, i); + } + function ZTe(e, t) { + if (!an(e)) + return dr(vi(e, t), (n) => d6(n) || DF(n)); + } + Qs({ + errorCodes: [ + p.await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module.code, + p.await_using_statements_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module.code, + p.for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module.code + ], + getCodeActions: function(t) { + const { sourceFile: n } = t, i = cn.ChangeTracker.with(t, (s) => { + const o = N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createNamedExports([]), + /*moduleSpecifier*/ + void 0 + ); + s.insertNodeAtEndOfScope(n, n, o); + }); + return [jd("addEmptyExportDeclaration", i, p.Add_export_to_make_this_file_into_a_module)]; + } + }); + var wce = "addMissingAsync", KTe = [ + p.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code, + p.Type_0_is_not_assignable_to_type_1.code, + p.Type_0_is_not_comparable_to_type_1.code + ]; + Qs({ + fixIds: [wce], + errorCodes: KTe, + getCodeActions: function(t) { + const { sourceFile: n, errorCode: i, cancellationToken: s, program: o, span: c } = t, _ = Nn(o.getTypeChecker().getDiagnostics(n, s), eqe(c, i)), u = _ && _.relatedInformation && Nn(_.relatedInformation, (h) => h.code === p.Did_you_mean_to_mark_this_function_as_async.code), g = txe(n, u); + return g ? [exe(t, g, (h) => cn.ChangeTracker.with(t, h))] : void 0; + }, + getAllCodeActions: (e) => { + const { sourceFile: t } = e, n = /* @__PURE__ */ new Set(); + return Qa(e, KTe, (i, s) => { + const o = s.relatedInformation && Nn(s.relatedInformation, (u) => u.code === p.Did_you_mean_to_mark_this_function_as_async.code), c = txe(t, o); + return c ? exe(e, c, (u) => (u(i), []), n) : void 0; + }); + } + }); + function exe(e, t, n, i) { + const s = n((o) => KVe(o, e.sourceFile, t, i)); + return Ls(wce, s, p.Add_async_modifier_to_containing_function, wce, p.Add_all_missing_async_modifiers); + } + function KVe(e, t, n, i) { + if (i && i.has(Ma(n))) + return; + i?.add(Ma(n)); + const s = N.replaceModifiers( + qa( + n, + /*includeTrivia*/ + !0 + ), + N.createNodeArray(N.createModifiersFromModifierFlags( + h0(n) | 1024 + /* Async */ + )) + ); + e.replaceNode( + t, + n, + s + ); + } + function txe(e, t) { + if (!t) return; + const n = vi(e, t.start); + return dr(n, (s) => s.getStart(e) < t.start || s.getEnd() > ec(t) ? "quit" : (xo(s) || rc(s) || yo(s) || Cc(s)) && X6(t, u_(s, e))); + } + function eqe(e, t) { + return ({ start: n, length: i, relatedInformation: s, code: o }) => dy(n) && dy(i) && X6({ start: n, length: i }, e) && o === t && !!s && ot(s, (c) => c.code === p.Did_you_mean_to_mark_this_function_as_async.code); + } + var Pce = "addMissingAwait", rxe = p.Property_0_does_not_exist_on_type_1.code, nxe = [ + p.This_expression_is_not_callable.code, + p.This_expression_is_not_constructable.code + ], Nce = [ + p.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type.code, + p.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type.code, + p.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type.code, + p.Operator_0_cannot_be_applied_to_type_1.code, + p.Operator_0_cannot_be_applied_to_types_1_and_2.code, + p.This_comparison_appears_to_be_unintentional_because_the_types_0_and_1_have_no_overlap.code, + p.This_condition_will_always_return_true_since_this_0_is_always_defined.code, + p.Type_0_is_not_an_array_type.code, + p.Type_0_is_not_an_array_type_or_a_string_type.code, + p.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher.code, + p.Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator.code, + p.Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator.code, + p.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator.code, + p.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator.code, + p.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code, + rxe, + ...nxe + ]; + Qs({ + fixIds: [Pce], + errorCodes: Nce, + getCodeActions: function(t) { + const { sourceFile: n, errorCode: i, span: s, cancellationToken: o, program: c } = t, _ = ixe(n, i, s, o, c); + if (!_) + return; + const u = t.program.getTypeChecker(), g = (m) => cn.ChangeTracker.with(t, m); + return RP([ + sxe(t, _, i, u, g), + axe(t, _, i, u, g) + ]); + }, + getAllCodeActions: (e) => { + const { sourceFile: t, program: n, cancellationToken: i } = e, s = e.program.getTypeChecker(), o = /* @__PURE__ */ new Set(); + return Qa(e, Nce, (c, _) => { + const u = ixe(t, _.code, _, i, n); + if (!u) + return; + const g = (m) => (m(c), []); + return sxe(e, u, _.code, s, g, o) || axe(e, u, _.code, s, g, o); + }); + } + }); + function ixe(e, t, n, i, s) { + const o = uq(e, n); + return o && tqe(e, t, n, i, s) && oxe(o) ? o : void 0; + } + function sxe(e, t, n, i, s, o) { + const { sourceFile: c, program: _, cancellationToken: u } = e, g = rqe(t, c, u, _, i); + if (g) { + const m = s((h) => { + lr(g.initializers, ({ expression: S }) => Ace(h, n, c, i, S, o)), o && g.needsSecondPassForFixAll && Ace(h, n, c, i, t, o); + }); + return jd( + "addMissingAwaitToInitializer", + m, + g.initializers.length === 1 ? [p.Add_await_to_initializer_for_0, g.initializers[0].declarationSymbol.name] : p.Add_await_to_initializers + ); + } + } + function axe(e, t, n, i, s, o) { + const c = s((_) => Ace(_, n, e.sourceFile, i, t, o)); + return Ls(Pce, c, p.Add_await, Pce, p.Fix_all_expressions_possibly_missing_await); + } + function tqe(e, t, n, i, s) { + const c = s.getTypeChecker().getDiagnostics(e, i); + return ot(c, ({ start: _, length: u, relatedInformation: g, code: m }) => dy(_) && dy(u) && X6({ start: _, length: u }, n) && m === t && !!g && ot(g, (h) => h.code === p.Did_you_forget_to_use_await.code)); + } + function rqe(e, t, n, i, s) { + const o = nqe(e, s); + if (!o) + return; + let c = o.isCompleteFix, _; + for (const u of o.identifiers) { + const g = s.getSymbolAtLocation(u); + if (!g) + continue; + const m = Bn(g.valueDeclaration, ei), h = m && Bn(m.name, Me), S = Q1( + m, + 244 + /* VariableStatement */ + ); + if (!m || !S || m.type || !m.initializer || S.getSourceFile() !== t || Gn( + S, + 32 + /* Export */ + ) || !h || !oxe(m.initializer)) { + c = !1; + continue; + } + const T = i.getSemanticDiagnostics(t, n); + if (ko.Core.eachSymbolReferenceInFile(h, s, t, (D) => u !== D && !iqe(D, T, t, s))) { + c = !1; + continue; + } + (_ || (_ = [])).push({ + expression: m.initializer, + declarationSymbol: g + }); + } + return _ && { + initializers: _, + needsSecondPassForFixAll: !c + }; + } + function nqe(e, t) { + if (wn(e.parent) && Me(e.parent.expression)) + return { identifiers: [e.parent.expression], isCompleteFix: !0 }; + if (Me(e)) + return { identifiers: [e], isCompleteFix: !0 }; + if (_n(e)) { + let n, i = !0; + for (const s of [e.left, e.right]) { + const o = t.getTypeAtLocation(s); + if (t.getPromisedTypeOfPromise(o)) { + if (!Me(s)) { + i = !1; + continue; + } + (n || (n = [])).push(s); + } + } + return n && { identifiers: n, isCompleteFix: i }; + } + } + function iqe(e, t, n, i) { + const s = wn(e.parent) ? e.parent.name : _n(e.parent) ? e.parent : e, o = Nn(t, (c) => c.start === s.getStart(n) && c.start + c.length === s.getEnd()); + return o && ms(Nce, o.code) || // A Promise is usually not correct in a binary expression (it's not valid + // in an arithmetic expression and an equality comparison seems unusual), + // but if the other side of the binary expression has an error, the side + // is typed `any` which will squash the error that would identify this + // Promise as an invalid operand. So if the whole binary expression is + // typed `any` as a result, there is a strong likelihood that this Promise + // is accidentally missing `await`. + i.getTypeAtLocation(s).flags & 1; + } + function oxe(e) { + return e.flags & 65536 || !!dr(e, (t) => t.parent && xo(t.parent) && t.parent.body === t || Ns(t) && (t.parent.kind === 263 || t.parent.kind === 219 || t.parent.kind === 220 || t.parent.kind === 175)); + } + function Ace(e, t, n, i, s, o) { + if (JN(s.parent) && !s.parent.awaitModifier) { + const c = i.getTypeAtLocation(s), _ = i.getAnyAsyncIterableType(); + if (_ && i.isTypeAssignableTo(c, _)) { + const u = s.parent; + e.replaceNode(n, u, N.updateForOfStatement(u, N.createToken( + 135 + /* AwaitKeyword */ + ), u.initializer, u.expression, u.statement)); + return; + } + } + if (_n(s)) + for (const c of [s.left, s.right]) { + if (o && Me(c)) { + const g = i.getSymbolAtLocation(c); + if (g && o.has(Xs(g))) + continue; + } + const _ = i.getTypeAtLocation(c), u = i.getPromisedTypeOfPromise(_) ? N.createAwaitExpression(c) : c; + e.replaceNode(n, c, u); + } + else if (t === rxe && wn(s.parent)) { + if (o && Me(s.parent.expression)) { + const c = i.getSymbolAtLocation(s.parent.expression); + if (c && o.has(Xs(c))) + return; + } + e.replaceNode( + n, + s.parent.expression, + N.createParenthesizedExpression(N.createAwaitExpression(s.parent.expression)) + ), cxe(e, s.parent.expression, n); + } else if (ms(nxe, t) && sm(s.parent)) { + if (o && Me(s)) { + const c = i.getSymbolAtLocation(s); + if (c && o.has(Xs(c))) + return; + } + e.replaceNode(n, s, N.createParenthesizedExpression(N.createAwaitExpression(s))), cxe(e, s, n); + } else { + if (o && ei(s.parent) && Me(s.parent.name)) { + const c = i.getSymbolAtLocation(s.parent.name); + if (c && !u0(o, Xs(c))) + return; + } + e.replaceNode(n, s, N.createAwaitExpression(s)); + } + } + function cxe(e, t, n) { + const i = pl(t.pos, n); + i && B9(i.end, i.parent, n) && e.insertText(n, t.getStart(n), ";"); + } + var Ice = "addMissingConst", lxe = [ + p.Cannot_find_name_0.code, + p.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer.code + ]; + Qs({ + errorCodes: lxe, + getCodeActions: function(t) { + const n = cn.ChangeTracker.with(t, (i) => uxe(i, t.sourceFile, t.span.start, t.program)); + if (n.length > 0) + return [Ls(Ice, n, p.Add_const_to_unresolved_variable, Ice, p.Add_const_to_all_unresolved_variables)]; + }, + fixIds: [Ice], + getAllCodeActions: (e) => { + const t = /* @__PURE__ */ new Set(); + return Qa(e, lxe, (n, i) => uxe(n, i.file, i.start, e.program, t)); + } + }); + function uxe(e, t, n, i, s) { + const o = vi(t, n), c = dr(o, (g) => nS(g.parent) ? g.parent.initializer === g : sqe(g) ? !1 : "quit"); + if (c) return aH(e, c, t, s); + const _ = o.parent; + if (_n(_) && _.operatorToken.kind === 64 && Al(_.parent)) + return aH(e, o, t, s); + if (nu(_)) { + const g = i.getTypeChecker(); + return Ni(_.elements, (m) => aqe(m, g)) ? aH(e, _, t, s) : void 0; + } + const u = dr(o, (g) => Al(g.parent) ? !0 : oqe(g) ? !1 : "quit"); + if (u) { + const g = i.getTypeChecker(); + return _xe(u, g) ? aH(e, u, t, s) : void 0; + } + } + function aH(e, t, n, i) { + (!i || u0(i, t)) && e.insertModifierBefore(n, 87, t); + } + function sqe(e) { + switch (e.kind) { + case 80: + case 210: + case 211: + case 304: + case 305: + return !0; + default: + return !1; + } + } + function aqe(e, t) { + const n = Me(e) ? e : Nl( + e, + /*excludeCompoundAssignment*/ + !0 + ) && Me(e.left) ? e.left : void 0; + return !!n && !t.getSymbolAtLocation(n); + } + function oqe(e) { + switch (e.kind) { + case 80: + case 227: + case 28: + return !0; + default: + return !1; + } + } + function _xe(e, t) { + return _n(e) ? e.operatorToken.kind === 28 ? Ni([e.left, e.right], (n) => _xe(n, t)) : e.operatorToken.kind === 64 && Me(e.left) && !t.getSymbolAtLocation(e.left) : !1; + } + var Fce = "addMissingDeclareProperty", fxe = [ + p.Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration.code + ]; + Qs({ + errorCodes: fxe, + getCodeActions: function(t) { + const n = cn.ChangeTracker.with(t, (i) => pxe(i, t.sourceFile, t.span.start)); + if (n.length > 0) + return [Ls(Fce, n, p.Prefix_with_declare, Fce, p.Prefix_all_incorrect_property_declarations_with_declare)]; + }, + fixIds: [Fce], + getAllCodeActions: (e) => { + const t = /* @__PURE__ */ new Set(); + return Qa(e, fxe, (n, i) => pxe(n, i.file, i.start, t)); + } + }); + function pxe(e, t, n, i) { + const s = vi(t, n); + if (!Me(s)) + return; + const o = s.parent; + o.kind === 173 && (!i || u0(i, o)) && e.insertModifierBefore(t, 138, o); + } + var Oce = "addMissingInvocationForDecorator", dxe = [p._0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0.code]; + Qs({ + errorCodes: dxe, + getCodeActions: function(t) { + const n = cn.ChangeTracker.with(t, (i) => mxe(i, t.sourceFile, t.span.start)); + return [Ls(Oce, n, p.Call_decorator_expression, Oce, p.Add_to_all_uncalled_decorators)]; + }, + fixIds: [Oce], + getAllCodeActions: (e) => Qa(e, dxe, (t, n) => mxe(t, n.file, n.start)) + }); + function mxe(e, t, n) { + const i = vi(t, n), s = dr(i, ul); + E.assert(!!s, "Expected position to be owned by a decorator."); + const o = N.createCallExpression( + s.expression, + /*typeArguments*/ + void 0, + /*argumentsArray*/ + void 0 + ); + e.replaceNode(t, s.expression, o); + } + var Lce = "addMissingResolutionModeImportAttribute", gxe = [ + p.Type_only_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute.code, + p.Type_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute.code + ]; + Qs({ + errorCodes: gxe, + getCodeActions: function(t) { + const n = cn.ChangeTracker.with(t, (i) => hxe(i, t.sourceFile, t.span.start, t.program, t.host, t.preferences)); + return [Ls(Lce, n, p.Add_resolution_mode_import_attribute, Lce, p.Add_resolution_mode_import_attribute_to_all_type_only_imports_that_need_it)]; + }, + fixIds: [Lce], + getAllCodeActions: (e) => Qa(e, gxe, (t, n) => hxe(t, n.file, n.start, e.program, e.host, e.preferences)) + }); + function hxe(e, t, n, i, s, o) { + var c, _, u; + const g = vi(t, n), m = dr(g, Q_(qo, ym)); + E.assert(!!m, "Expected position to be owned by an ImportDeclaration or ImportType."); + const h = _f(t, o) === 0, S = gx(m), T = !S || ((c = MS( + S.text, + t.fileName, + i.getCompilerOptions(), + s, + i.getModuleResolutionCache(), + /*redirectedReference*/ + void 0, + 99 + /* ESNext */ + ).resolvedModule) == null ? void 0 : c.resolvedFileName) === ((u = (_ = i.getResolvedModuleFromModuleSpecifier( + S, + t + )) == null ? void 0 : _.resolvedModule) == null ? void 0 : u.resolvedFileName), k = m.attributes ? N.updateImportAttributes( + m.attributes, + N.createNodeArray([ + ...m.attributes.elements, + N.createImportAttribute( + N.createStringLiteral("resolution-mode", h), + N.createStringLiteral(T ? "import" : "require", h) + ) + ], m.attributes.elements.hasTrailingComma), + m.attributes.multiLine + ) : N.createImportAttributes( + N.createNodeArray([ + N.createImportAttribute( + N.createStringLiteral("resolution-mode", h), + N.createStringLiteral(T ? "import" : "require", h) + ) + ]) + ); + m.kind === 273 ? e.replaceNode( + t, + m, + N.updateImportDeclaration( + m, + m.modifiers, + m.importClause, + m.moduleSpecifier, + k + ) + ) : e.replaceNode( + t, + m, + N.updateImportTypeNode( + m, + m.argument, + k, + m.qualifier, + m.typeArguments + ) + ); + } + var Mce = "addNameToNamelessParameter", yxe = [p.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1.code]; + Qs({ + errorCodes: yxe, + getCodeActions: function(t) { + const n = cn.ChangeTracker.with(t, (i) => vxe(i, t.sourceFile, t.span.start)); + return [Ls(Mce, n, p.Add_parameter_name, Mce, p.Add_names_to_all_parameters_without_names)]; + }, + fixIds: [Mce], + getAllCodeActions: (e) => Qa(e, yxe, (t, n) => vxe(t, n.file, n.start)) + }); + function vxe(e, t, n) { + const i = vi(t, n), s = i.parent; + if (!Ii(s)) + return E.fail("Tried to add a parameter name to a non-parameter: " + E.formatSyntaxKind(i.kind)); + const o = s.parent.parameters.indexOf(s); + E.assert(!s.type, "Tried to add a parameter name to a parameter that already had one."), E.assert(o > -1, "Parameter not found in parent parameter list."); + let c = s.name.getEnd(), _ = N.createTypeReferenceNode( + s.name, + /*typeArguments*/ + void 0 + ), u = bxe(t, s); + for (; u; ) + _ = N.createArrayTypeNode(_), c = u.getEnd(), u = bxe(t, u); + const g = N.createParameterDeclaration( + s.modifiers, + s.dotDotDotToken, + "arg" + o, + s.questionToken, + s.dotDotDotToken && !jN(_) ? N.createArrayTypeNode(_) : _, + s.initializer + ); + e.replaceRange(t, cp(s.getStart(t), c), g); + } + function bxe(e, t) { + const n = c2(t.name, t.parent, e); + if (n && n.kind === 23 && D0(n.parent) && Ii(n.parent.parent)) + return n.parent.parent; + } + var Sxe = "addOptionalPropertyUndefined", cqe = [ + p.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target.code, + p.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code, + p.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code + ]; + Qs({ + errorCodes: cqe, + getCodeActions(e) { + const t = e.program.getTypeChecker(), n = lqe(e.sourceFile, e.span, t); + if (!n.length) + return; + const i = cn.ChangeTracker.with(e, (s) => _qe(s, n)); + return [jd(Sxe, i, p.Add_undefined_to_optional_property_type)]; + }, + fixIds: [Sxe] + }); + function lqe(e, t, n) { + var i, s; + const o = Txe(uq(e, t), n); + if (!o) + return Ge; + const { source: c, target: _ } = o, u = uqe(c, _, n) ? n.getTypeAtLocation(_.expression) : n.getTypeAtLocation(_); + return (s = (i = u.symbol) == null ? void 0 : i.declarations) != null && s.some((g) => xr(g).fileName.match(/\.d\.ts$/)) ? Ge : n.getExactOptionalProperties(u); + } + function uqe(e, t, n) { + return wn(t) && !!n.getExactOptionalProperties(n.getTypeAtLocation(t.expression)).length && n.getTypeAtLocation(e) === n.getUndefinedType(); + } + function Txe(e, t) { + var n; + if (e) { + if (_n(e.parent) && e.parent.operatorToken.kind === 64) + return { source: e.parent.right, target: e.parent.left }; + if (ei(e.parent) && e.parent.initializer) + return { source: e.parent.initializer, target: e.parent.name }; + if (Ps(e.parent)) { + const i = t.getSymbolAtLocation(e.parent.expression); + if (!i?.valueDeclaration || !sx(i.valueDeclaration.kind) || !ut(e)) return; + const s = e.parent.arguments.indexOf(e); + if (s === -1) return; + const o = i.valueDeclaration.parameters[s].name; + if (Me(o)) return { source: e, target: o }; + } else if (rl(e.parent) && Me(e.parent.name) || gu(e.parent)) { + const i = Txe(e.parent.parent, t); + if (!i) return; + const s = t.getPropertyOfType(t.getTypeAtLocation(i.target), e.parent.name.text), o = (n = s?.declarations) == null ? void 0 : n[0]; + return o ? { + source: rl(e.parent) ? e.parent.initializer : e.parent.name, + target: o + } : void 0; + } + } else return; + } + function _qe(e, t) { + for (const n of t) { + const i = n.valueDeclaration; + if (i && ($u(i) || os(i)) && i.type) { + const s = N.createUnionTypeNode([ + ...i.type.kind === 193 ? i.type.types : [i.type], + N.createTypeReferenceNode("undefined") + ]); + e.replaceNode(i.getSourceFile(), i.type, s); + } + } + } + var Rce = "annotateWithTypeFromJSDoc", xxe = [p.JSDoc_types_may_be_moved_to_TypeScript_types.code]; + Qs({ + errorCodes: xxe, + getCodeActions(e) { + const t = kxe(e.sourceFile, e.span.start); + if (!t) return; + const n = cn.ChangeTracker.with(e, (i) => Dxe(i, e.sourceFile, t)); + return [Ls(Rce, n, p.Annotate_with_type_from_JSDoc, Rce, p.Annotate_everything_with_types_from_JSDoc)]; + }, + fixIds: [Rce], + getAllCodeActions: (e) => Qa(e, xxe, (t, n) => { + const i = kxe(n.file, n.start); + i && Dxe(t, n.file, i); + }) + }); + function kxe(e, t) { + const n = vi(e, t); + return Bn(Ii(n.parent) ? n.parent.parent : n.parent, Cxe); + } + function Cxe(e) { + return fqe(e) && Exe(e); + } + function Exe(e) { + return io(e) ? e.parameters.some(Exe) || !e.type && !!i3(e) : !e.type && !!f0(e); + } + function Dxe(e, t, n) { + if (io(n) && (i3(n) || n.parameters.some((i) => !!f0(i)))) { + if (!n.typeParameters) { + const s = P5(n); + s.length && e.insertTypeParameters(t, n, s); + } + const i = xo(n) && !Ya(n, 21, t); + i && e.insertNodeBefore(t, Ca(n.parameters), N.createToken( + 21 + /* OpenParenToken */ + )); + for (const s of n.parameters) + if (!s.type) { + const o = f0(s); + o && e.tryInsertTypeAnnotation(t, s, Qe(o, p2, li)); + } + if (i && e.insertNodeAfter(t, pa(n.parameters), N.createToken( + 22 + /* CloseParenToken */ + )), !n.type) { + const s = i3(n); + s && e.tryInsertTypeAnnotation(t, n, Qe(s, p2, li)); + } + } else { + const i = E.checkDefined(f0(n), "A JSDocType for this declaration should exist"); + E.assert(!n.type, "The JSDocType decl should have a type"), e.tryInsertTypeAnnotation(t, n, Qe(i, p2, li)); + } + } + function fqe(e) { + return io(e) || e.kind === 261 || e.kind === 172 || e.kind === 173; + } + function p2(e) { + switch (e.kind) { + case 313: + case 314: + return N.createTypeReferenceNode("any", Ge); + case 317: + return dqe(e); + case 316: + return p2(e.type); + case 315: + return mqe(e); + case 319: + return gqe(e); + case 318: + return hqe(e); + case 184: + return vqe(e); + case 323: + return pqe(e); + default: + const t = br( + e, + p2, + /*context*/ + void 0 + ); + return un( + t, + 1 + /* SingleLine */ + ), t; + } + } + function pqe(e) { + const t = N.createTypeLiteralNode(hr(e.jsDocPropertyTags, (n) => N.createPropertySignature( + /*modifiers*/ + void 0, + Me(n.name) ? n.name : n.name.right, + EN(n) ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, + n.typeExpression && Qe(n.typeExpression.type, p2, li) || N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ) + ))); + return un( + t, + 1 + /* SingleLine */ + ), t; + } + function dqe(e) { + return N.createUnionTypeNode([Qe(e.type, p2, li), N.createTypeReferenceNode("undefined", Ge)]); + } + function mqe(e) { + return N.createUnionTypeNode([Qe(e.type, p2, li), N.createTypeReferenceNode("null", Ge)]); + } + function gqe(e) { + return N.createArrayTypeNode(Qe(e.type, p2, li)); + } + function hqe(e) { + return N.createFunctionTypeNode(Ge, e.parameters.map(yqe), e.type ?? N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + )); + } + function yqe(e) { + const t = e.parent.parameters.indexOf(e), n = e.type.kind === 319 && t === e.parent.parameters.length - 1, i = e.name || (n ? "rest" : "arg" + t), s = n ? N.createToken( + 26 + /* DotDotDotToken */ + ) : e.dotDotDotToken; + return N.createParameterDeclaration(e.modifiers, s, i, e.questionToken, Qe(e.type, p2, li), e.initializer); + } + function vqe(e) { + let t = e.typeName, n = e.typeArguments; + if (Me(e.typeName)) { + if (u5(e)) + return bqe(e); + let i = e.typeName.text; + switch (e.typeName.text) { + case "String": + case "Boolean": + case "Object": + case "Number": + i = i.toLowerCase(); + break; + case "array": + case "date": + case "promise": + i = i[0].toUpperCase() + i.slice(1); + break; + } + t = N.createIdentifier(i), (i === "Array" || i === "Promise") && !e.typeArguments ? n = N.createNodeArray([N.createTypeReferenceNode("any", Ge)]) : n = Ar(e.typeArguments, p2, li); + } + return N.createTypeReferenceNode(t, n); + } + function bqe(e) { + const t = N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + e.typeArguments[0].kind === 150 ? "n" : "s", + /*questionToken*/ + void 0, + N.createTypeReferenceNode(e.typeArguments[0].kind === 150 ? "number" : "string", []), + /*initializer*/ + void 0 + ), n = N.createTypeLiteralNode([N.createIndexSignature( + /*modifiers*/ + void 0, + [t], + e.typeArguments[1] + )]); + return un( + n, + 1 + /* SingleLine */ + ), n; + } + var jce = "convertFunctionToEs6Class", wxe = [p.This_constructor_function_may_be_converted_to_a_class_declaration.code]; + Qs({ + errorCodes: wxe, + getCodeActions(e) { + const t = cn.ChangeTracker.with(e, (n) => Pxe(n, e.sourceFile, e.span.start, e.program.getTypeChecker(), e.preferences, e.program.getCompilerOptions())); + return [Ls(jce, t, p.Convert_function_to_an_ES2015_class, jce, p.Convert_all_constructor_functions_to_classes)]; + }, + fixIds: [jce], + getAllCodeActions: (e) => Qa(e, wxe, (t, n) => Pxe(t, n.file, n.start, e.program.getTypeChecker(), e.preferences, e.program.getCompilerOptions())) + }); + function Pxe(e, t, n, i, s, o) { + const c = i.getSymbolAtLocation(vi(t, n)); + if (!c || !c.valueDeclaration || !(c.flags & 19)) + return; + const _ = c.valueDeclaration; + if (Cc(_) || yo(_)) + e.replaceNode(t, _, m(_)); + else if (ei(_)) { + const h = g(_); + if (!h) + return; + const S = _.parent.parent; + Ul(_.parent) && _.parent.declarations.length > 1 ? (e.delete(t, _), e.insertNodeAfter(t, S, h)) : e.replaceNode(t, S, h); + } + function u(h) { + const S = []; + return h.exports && h.exports.forEach((D) => { + if (D.name === "prototype" && D.declarations) { + const P = D.declarations[0]; + if (D.declarations.length === 1 && wn(P) && _n(P.parent) && P.parent.operatorToken.kind === 64 && _a(P.parent.right)) { + const A = P.parent.right; + k( + A.symbol, + /*modifiers*/ + void 0, + S + ); + } + } else + k(D, [N.createToken( + 126 + /* StaticKeyword */ + )], S); + }), h.members && h.members.forEach((D, P) => { + var A, O, F, R; + if (P === "constructor" && D.valueDeclaration) { + const B = (R = (F = (O = (A = h.exports) == null ? void 0 : A.get("prototype")) == null ? void 0 : O.declarations) == null ? void 0 : F[0]) == null ? void 0 : R.parent; + B && _n(B) && _a(B.right) && ot(B.right.properties, cH) || e.delete(t, D.valueDeclaration.parent); + return; + } + k( + D, + /*modifiers*/ + void 0, + S + ); + }), S; + function T(D, P) { + return To(D) ? wn(D) && cH(D) ? !0 : Es(P) : Ni(D.properties, (A) => !!(rc(A) || a3(A) || rl(A) && yo(A.initializer) && A.name || cH(A))); + } + function k(D, P, A) { + if (!(D.flags & 8192) && !(D.flags & 4096)) + return; + const O = D.valueDeclaration, F = O.parent, R = F.right; + if (!T(O, R) || ot(A, (_e) => { + const K = _s(_e); + return !!(K && Me(K) && An(K) === cc(D)); + })) + return; + const B = F.parent && F.parent.kind === 245 ? F.parent : F; + if (e.delete(t, B), !R) { + A.push(N.createPropertyDeclaration( + P, + D.name, + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + )); + return; + } + if (To(O) && (yo(R) || xo(R))) { + const _e = _f(t, s), K = Sqe(O, o, _e); + K && U(A, R, K); + return; + } else if (_a(R)) { + lr( + R.properties, + (_e) => { + (rc(_e) || a3(_e)) && A.push(_e), rl(_e) && yo(_e.initializer) && U(A, _e.initializer, _e.name), cH(_e); + } + ); + return; + } else { + if (n_(t) || !wn(O)) return; + const _e = N.createPropertyDeclaration( + P, + O.name, + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + R + ); + Y6(F.parent, _e, t), A.push(_e); + return; + } + function U(_e, K, V) { + return yo(K) ? $(_e, K, V) : W(_e, K, V); + } + function $(_e, K, V) { + const ae = Bi(P, oH( + K, + 134 + /* AsyncKeyword */ + )), se = N.createMethodDeclaration( + ae, + /*asteriskToken*/ + void 0, + V, + /*questionToken*/ + void 0, + /*typeParameters*/ + void 0, + K.parameters, + /*type*/ + void 0, + K.body + ); + Y6(F, se, t), _e.push(se); + } + function W(_e, K, V) { + const ae = K.body; + let se; + ae.kind === 242 ? se = ae : se = N.createBlock([N.createReturnStatement(ae)]); + const ce = Bi(P, oH( + K, + 134 + /* AsyncKeyword */ + )), fe = N.createMethodDeclaration( + ce, + /*asteriskToken*/ + void 0, + V, + /*questionToken*/ + void 0, + /*typeParameters*/ + void 0, + K.parameters, + /*type*/ + void 0, + se + ); + Y6(F, fe, t), _e.push(fe); + } + } + } + function g(h) { + const S = h.initializer; + if (!S || !yo(S) || !Me(h.name)) + return; + const T = u(h.symbol); + S.body && T.unshift(N.createConstructorDeclaration( + /*modifiers*/ + void 0, + S.parameters, + S.body + )); + const k = oH( + h.parent.parent, + 95 + /* ExportKeyword */ + ); + return N.createClassDeclaration( + k, + h.name, + /*typeParameters*/ + void 0, + /*heritageClauses*/ + void 0, + T + ); + } + function m(h) { + const S = u(c); + h.body && S.unshift(N.createConstructorDeclaration( + /*modifiers*/ + void 0, + h.parameters, + h.body + )); + const T = oH( + h, + 95 + /* ExportKeyword */ + ); + return N.createClassDeclaration( + T, + h.name, + /*typeParameters*/ + void 0, + /*heritageClauses*/ + void 0, + S + ); + } + } + function oH(e, t) { + return Vp(e) ? kn(e.modifiers, (n) => n.kind === t) : void 0; + } + function cH(e) { + return e.name ? !!(Me(e.name) && e.name.text === "constructor") : !1; + } + function Sqe(e, t, n) { + if (wn(e)) + return e.name; + const i = e.argumentExpression; + if (E_(i)) + return i; + if (ja(i)) + return R_(i.text, da(t)) ? N.createIdentifier(i.text) : TS(i) ? N.createStringLiteral( + i.text, + n === 0 + /* Single */ + ) : i; + } + var Bce = "convertToAsyncFunction", Nxe = [p.This_may_be_converted_to_an_async_function.code], lH = !0; + Qs({ + errorCodes: Nxe, + getCodeActions(e) { + lH = !0; + const t = cn.ChangeTracker.with(e, (n) => Axe(n, e.sourceFile, e.span.start, e.program.getTypeChecker())); + return lH ? [Ls(Bce, t, p.Convert_to_async_function, Bce, p.Convert_all_to_async_functions)] : []; + }, + fixIds: [Bce], + getAllCodeActions: (e) => Qa(e, Nxe, (t, n) => Axe(t, n.file, n.start, e.program.getTypeChecker())) + }); + function Axe(e, t, n, i) { + const s = vi(t, n); + let o; + if (Me(s) && ei(s.parent) && s.parent.initializer && io(s.parent.initializer) ? o = s.parent.initializer : o = Bn(Af(vi(t, n)), Aq), !o) + return; + const c = /* @__PURE__ */ new Map(), _ = an(o), u = xqe(o, i), g = kqe(o, i, c); + if (!Pq(g, i)) + return; + const m = g.body && Ns(g.body) ? Tqe(g.body, i) : Ge, h = { checker: i, synthNamesMap: c, setOfExpressionsToReturn: u, isInJSFile: _ }; + if (!m.length) + return; + const S = oa(t.text, dm(o).pos); + e.insertModifierAt(t, S, 134, { suffix: " " }); + for (const T of m) + if (xs(T, function k(D) { + if (Ps(D)) { + const P = nE( + D, + D, + h, + /*hasContinuation*/ + !1 + ); + if (bk()) + return !0; + e.replaceNodeWithNodes(t, T, P); + } else if (!Es(D) && (xs(D, k), bk())) + return !0; + }), bk()) + return; + } + function Tqe(e, t) { + const n = []; + return Fy(e, (i) => { + K9(i, t) && n.push(i); + }), n; + } + function xqe(e, t) { + if (!e.body) + return /* @__PURE__ */ new Set(); + const n = /* @__PURE__ */ new Set(); + return xs(e.body, function i(s) { + d8(s, t, "then") ? (n.add(Ma(s)), lr(s.arguments, i)) : d8(s, t, "catch") || d8(s, t, "finally") ? (n.add(Ma(s)), xs(s, i)) : Fxe(s, t) ? n.add(Ma(s)) : xs(s, i); + }), n; + } + function d8(e, t, n) { + if (!Ps(e)) return !1; + const s = BA(e, n) && t.getTypeAtLocation(e); + return !!(s && t.getPromisedTypeOfPromise(s)); + } + function Ixe(e, t) { + return (Dn(e) & 4) !== 0 && e.target === t; + } + function uH(e, t, n) { + if (e.expression.name.escapedText === "finally") + return; + const i = n.getTypeAtLocation(e.expression.expression); + if (Ixe(i, n.getPromiseType()) || Ixe(i, n.getPromiseLikeType())) + if (e.expression.name.escapedText === "then") { + if (t === fy(e.arguments, 0)) + return fy(e.typeArguments, 0); + if (t === fy(e.arguments, 1)) + return fy(e.typeArguments, 1); + } else + return fy(e.typeArguments, 0); + } + function Fxe(e, t) { + return ut(e) ? !!t.getPromisedTypeOfPromise(t.getTypeAtLocation(e)) : !1; + } + function kqe(e, t, n) { + const i = /* @__PURE__ */ new Map(), s = Fp(); + return xs(e, function o(c) { + if (!Me(c)) { + xs(c, o); + return; + } + const _ = t.getSymbolAtLocation(c); + if (_) { + const u = t.getTypeAtLocation(c), g = Bxe(u, t), m = Xs(_).toString(); + if (g && !Ii(c.parent) && !io(c.parent) && !n.has(m)) { + const h = Yc(g.parameters), S = h?.valueDeclaration && Ii(h.valueDeclaration) && Bn(h.valueDeclaration.name, Me) || N.createUniqueName( + "result", + 16 + /* Optimistic */ + ), T = Oxe(S, s); + n.set(m, T), s.add(S.text, _); + } else if (c.parent && (Ii(c.parent) || ei(c.parent) || ya(c.parent))) { + const h = c.text, S = s.get(h); + if (S && S.some((T) => T !== _)) { + const T = Oxe(c, s); + i.set(m, T.identifier), n.set(m, T), s.add(h, _); + } else { + const T = qa(c); + n.set(m, Iw(T)), s.add(h, _); + } + } + } + }), PN( + e, + /*includeTrivia*/ + !0, + (o) => { + if (ya(o) && Me(o.name) && Of(o.parent)) { + const c = t.getSymbolAtLocation(o.name), _ = c && i.get(String(Xs(c))); + if (_ && _.text !== (o.name || o.propertyName).getText()) + return N.createBindingElement( + o.dotDotDotToken, + o.propertyName || o.name, + _, + o.initializer + ); + } else if (Me(o)) { + const c = t.getSymbolAtLocation(o), _ = c && i.get(String(Xs(c))); + if (_) + return N.createIdentifier(_.text); + } + } + ); + } + function Oxe(e, t) { + const n = (t.get(e.text) || Ge).length, i = n === 0 ? e : N.createIdentifier(e.text + "_" + n); + return Iw(i); + } + function bk() { + return !lH; + } + function kv() { + return lH = !1, Ge; + } + function nE(e, t, n, i, s) { + if (d8(t, n.checker, "then")) + return Dqe(t, fy(t.arguments, 0), fy(t.arguments, 1), n, i, s); + if (d8(t, n.checker, "catch")) + return Rxe(t, fy(t.arguments, 0), n, i, s); + if (d8(t, n.checker, "finally")) + return Eqe(t, fy(t.arguments, 0), n, i, s); + if (wn(t)) + return nE(e, t.expression, n, i, s); + const o = n.checker.getTypeAtLocation(t); + return o && n.checker.getPromisedTypeOfPromise(o) ? (E.assertNode(Vo(t).parent, wn), wqe(e, t, n, i, s)) : kv(); + } + function _H({ checker: e }, t) { + if (t.kind === 106) return !0; + if (Me(t) && !Bo(t) && An(t) === "undefined") { + const n = e.getSymbolAtLocation(t); + return !n || e.isUndefinedSymbol(n); + } + return !1; + } + function Cqe(e) { + const t = N.createUniqueName( + e.identifier.text, + 16 + /* Optimistic */ + ); + return Iw(t); + } + function Lxe(e, t, n) { + let i; + return n && !g8(e, t) && (m8(n) ? (i = n, t.synthNamesMap.forEach((s, o) => { + if (s.identifier.text === n.identifier.text) { + const c = Cqe(n); + t.synthNamesMap.set(o, c); + } + })) : i = Iw(N.createUniqueName( + "result", + 16 + /* Optimistic */ + ), n.types), Uce(i)), i; + } + function Mxe(e, t, n, i, s) { + const o = []; + let c; + if (i && !g8(e, t)) { + c = qa(Uce(i)); + const _ = i.types, u = t.checker.getUnionType( + _, + 2 + /* Subtype */ + ), g = t.isInJSFile ? void 0 : t.checker.typeToTypeNode( + u, + /*enclosingDeclaration*/ + void 0, + /*flags*/ + void 0 + ), m = [N.createVariableDeclaration( + c, + /*exclamationToken*/ + void 0, + g + )], h = N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + m, + 1 + /* Let */ + ) + ); + o.push(h); + } + return o.push(n), s && c && Aqe(s) && o.push(N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [ + N.createVariableDeclaration( + qa(Uxe(s)), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + c + ) + ], + 2 + /* Const */ + ) + )), o; + } + function Eqe(e, t, n, i, s) { + if (!t || _H(n, t)) + return nE( + /* returnContextNode */ + e, + e.expression.expression, + n, + i, + s + ); + const o = Lxe(e, n, s), c = nE( + /*returnContextNode*/ + e, + e.expression.expression, + n, + /*hasContinuation*/ + !0, + o + ); + if (bk()) return kv(); + const _ = zce( + t, + i, + /*continuationArgName*/ + void 0, + /*inputArgName*/ + void 0, + e, + n + ); + if (bk()) return kv(); + const u = N.createBlock(c), g = N.createBlock(_), m = N.createTryStatement( + u, + /*catchClause*/ + void 0, + g + ); + return Mxe(e, n, m, o, s); + } + function Rxe(e, t, n, i, s) { + if (!t || _H(n, t)) + return nE( + /* returnContextNode */ + e, + e.expression.expression, + n, + i, + s + ); + const o = zxe(t, n), c = Lxe(e, n, s), _ = nE( + /*returnContextNode*/ + e, + e.expression.expression, + n, + /*hasContinuation*/ + !0, + c + ); + if (bk()) return kv(); + const u = zce(t, i, c, o, e, n); + if (bk()) return kv(); + const g = N.createBlock(_), m = N.createCatchClause(o && qa(gL(o)), N.createBlock(u)), h = N.createTryStatement( + g, + m, + /*finallyBlock*/ + void 0 + ); + return Mxe(e, n, h, c, s); + } + function Dqe(e, t, n, i, s, o) { + if (!t || _H(i, t)) + return Rxe(e, n, i, s, o); + if (n && !_H(i, n)) + return kv(); + const c = zxe(t, i), _ = nE( + e.expression.expression, + e.expression.expression, + i, + /*hasContinuation*/ + !0, + c + ); + if (bk()) return kv(); + const u = zce(t, s, o, c, e, i); + return bk() ? kv() : Bi(_, u); + } + function wqe(e, t, n, i, s) { + if (g8(e, n)) { + let o = qa(t); + return i && (o = N.createAwaitExpression(o)), [N.createReturnStatement(o)]; + } + return fH( + s, + N.createAwaitExpression(t), + /*typeAnnotation*/ + void 0 + ); + } + function fH(e, t, n) { + return !e || Wxe(e) ? [N.createExpressionStatement(t)] : m8(e) && e.hasBeenDeclared ? [N.createExpressionStatement(N.createAssignment(qa(Wce(e)), t))] : [ + N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [ + N.createVariableDeclaration( + qa(gL(e)), + /*exclamationToken*/ + void 0, + n, + t + ) + ], + 2 + /* Const */ + ) + ) + ]; + } + function Jce(e, t) { + if (t && e) { + const n = N.createUniqueName( + "result", + 16 + /* Optimistic */ + ); + return [ + ...fH(Iw(n), e, t), + N.createReturnStatement(n) + ]; + } + return [N.createReturnStatement(e)]; + } + function zce(e, t, n, i, s, o) { + var c; + switch (e.kind) { + case 106: + break; + case 212: + case 80: + if (!i) + break; + const _ = N.createCallExpression( + qa(e), + /*typeArguments*/ + void 0, + m8(i) ? [Wce(i)] : [] + ); + if (g8(s, o)) + return Jce(_, uH(s, e, o.checker)); + const u = o.checker.getTypeAtLocation(e), g = o.checker.getSignaturesOfType( + u, + 0 + /* Call */ + ); + if (!g.length) + return kv(); + const m = g[0].getReturnType(), h = fH(n, N.createAwaitExpression(_), uH(s, e, o.checker)); + return n && n.types.push(o.checker.getAwaitedType(m) || m), h; + case 219: + case 220: { + const S = e.body, T = (c = Bxe(o.checker.getTypeAtLocation(e), o.checker)) == null ? void 0 : c.getReturnType(); + if (Ns(S)) { + let k = [], D = !1; + for (const P of S.statements) + if (Cf(P)) + if (D = !0, K9(P, o.checker)) + k = k.concat(Jxe(o, P, t, n)); + else { + const A = T && P.expression ? jxe(o.checker, T, P.expression) : P.expression; + k.push(...Jce(A, uH(s, e, o.checker))); + } + else { + if (t && Fy(P, yb)) + return kv(); + k.push(P); + } + return g8(s, o) ? k.map((P) => qa(P)) : Pqe( + k, + n, + o, + D + ); + } else { + const k = Nq(S, o.checker) ? Jxe(o, N.createReturnStatement(S), t, n) : Ge; + if (k.length > 0) + return k; + if (T) { + const D = jxe(o.checker, T, S); + if (g8(s, o)) + return Jce(D, uH(s, e, o.checker)); + { + const P = fH( + n, + D, + /*typeAnnotation*/ + void 0 + ); + return n && n.types.push(o.checker.getAwaitedType(T) || T), P; + } + } else + return kv(); + } + } + default: + return kv(); + } + return Ge; + } + function jxe(e, t, n) { + const i = qa(n); + return e.getPromisedTypeOfPromise(t) ? N.createAwaitExpression(i) : i; + } + function Bxe(e, t) { + const n = t.getSignaturesOfType( + e, + 0 + /* Call */ + ); + return Do(n); + } + function Pqe(e, t, n, i) { + const s = []; + for (const o of e) + if (Cf(o)) { + if (o.expression) { + const c = Fxe(o.expression, n.checker) ? N.createAwaitExpression(o.expression) : o.expression; + t === void 0 ? s.push(N.createExpressionStatement(c)) : m8(t) && t.hasBeenDeclared ? s.push(N.createExpressionStatement(N.createAssignment(Wce(t), c))) : s.push(N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [N.createVariableDeclaration( + gL(t), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + c + )], + 2 + /* Const */ + ) + )); + } + } else + s.push(qa(o)); + return !i && t !== void 0 && s.push(N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [N.createVariableDeclaration( + gL(t), + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + N.createIdentifier("undefined") + )], + 2 + /* Const */ + ) + )), s; + } + function Jxe(e, t, n, i) { + let s = []; + return xs(t, function o(c) { + if (Ps(c)) { + const _ = nE(c, c, e, n, i); + if (s = s.concat(_), s.length > 0) + return; + } else Es(c) || xs(c, o); + }), s; + } + function zxe(e, t) { + const n = []; + let i; + if (io(e)) { + if (e.parameters.length > 0) { + const u = e.parameters[0].name; + i = s(u); + } + } else Me(e) ? i = o(e) : wn(e) && Me(e.name) && (i = o(e.name)); + if (!i || "identifier" in i && i.identifier.text === "undefined") + return; + return i; + function s(u) { + if (Me(u)) return o(u); + const g = ka(u.elements, (m) => vl(m) ? [] : [s(m.name)]); + return Nqe(u, g); + } + function o(u) { + const g = _(u), m = c(g); + return m && t.synthNamesMap.get(Xs(m).toString()) || Iw(u, n); + } + function c(u) { + var g; + return ((g = Bn(u, Ed)) == null ? void 0 : g.symbol) ?? t.checker.getSymbolAtLocation(u); + } + function _(u) { + return u.original ? u.original : u; + } + } + function Wxe(e) { + return e ? m8(e) ? !e.identifier.text : Ni(e.elements, Wxe) : !0; + } + function Iw(e, t = []) { + return { kind: 0, identifier: e, types: t, hasBeenDeclared: !1, hasBeenReferenced: !1 }; + } + function Nqe(e, t = Ge, n = []) { + return { kind: 1, bindingPattern: e, elements: t, types: n }; + } + function Wce(e) { + return e.hasBeenReferenced = !0, e.identifier; + } + function gL(e) { + return m8(e) ? Uce(e) : Uxe(e); + } + function Uxe(e) { + for (const t of e.elements) + gL(t); + return e.bindingPattern; + } + function Uce(e) { + return e.hasBeenDeclared = !0, e.identifier; + } + function m8(e) { + return e.kind === 0; + } + function Aqe(e) { + return e.kind === 1; + } + function g8(e, t) { + return !!e.original && t.setOfExpressionsToReturn.has(Ma(e.original)); + } + Qs({ + errorCodes: [p.File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module.code], + getCodeActions(e) { + const { sourceFile: t, program: n, preferences: i } = e, s = cn.ChangeTracker.with(e, (o) => { + if (Fqe(t, n.getTypeChecker(), o, da(n.getCompilerOptions()), _f(t, i))) + for (const _ of n.getSourceFiles()) + Iqe(_, t, n, o, _f(_, i)); + }); + return [jd("convertToEsModule", s, p.Convert_to_ES_module)]; + } + }); + function Iqe(e, t, n, i, s) { + var o; + for (const c of e.imports) { + const _ = (o = n.getResolvedModuleFromModuleSpecifier(c, e)) == null ? void 0 : o.resolvedModule; + if (!_ || _.resolvedFileName !== t.fileName) + continue; + const u = UD(c); + switch (u.kind) { + case 272: + i.replaceNode(e, u, r1( + u.name, + /*namedImports*/ + void 0, + c, + s + )); + break; + case 214: + x_( + u, + /*requireStringLiteralLikeArgument*/ + !1 + ) && i.replaceNode(e, u, N.createPropertyAccessExpression(qa(u), "default")); + break; + } + } + } + function Fqe(e, t, n, i, s) { + const o = { original: Hqe(e), additional: /* @__PURE__ */ new Set() }, c = Oqe(e, t, o); + Lqe(e, c, n); + let _ = !1, u; + for (const g of kn(e.statements, Ic)) { + const m = qxe(e, g, n, t, o, i, s); + m && j7(m, u ?? (u = /* @__PURE__ */ new Map())); + } + for (const g of kn(e.statements, (m) => !Ic(m))) { + const m = Mqe(e, g, t, n, o, i, c, u, s); + _ = _ || m; + } + return u?.forEach((g, m) => { + n.replaceNode(e, m, g); + }), _; + } + function Oqe(e, t, n) { + const i = /* @__PURE__ */ new Map(); + return Vxe(e, (s) => { + const { text: o } = s.name; + !i.has(o) && (BB(s.name) || t.resolveName( + o, + s, + 111551, + /*excludeGlobals*/ + !0 + )) && i.set(o, pH(`_${o}`, n)); + }), i; + } + function Lqe(e, t, n) { + Vxe(e, (i, s) => { + if (s) + return; + const { text: o } = i.name; + n.replaceNode(e, i, N.createIdentifier(t.get(o) || o)); + }); + } + function Vxe(e, t) { + e.forEachChild(function n(i) { + if (wn(i) && t2(e, i.expression) && Me(i.name)) { + const { parent: s } = i; + t( + i, + _n(s) && s.left === i && s.operatorToken.kind === 64 + /* EqualsToken */ + ); + } + i.forEachChild(n); + }); + } + function Mqe(e, t, n, i, s, o, c, _, u) { + switch (t.kind) { + case 244: + return qxe(e, t, i, n, s, o, u), !1; + case 245: { + const { expression: g } = t; + switch (g.kind) { + case 214: + return x_( + g, + /*requireStringLiteralLikeArgument*/ + !0 + ) && i.replaceNode(e, t, r1( + /*defaultImport*/ + void 0, + /*namedImports*/ + void 0, + g.arguments[0], + u + )), !1; + case 227: { + const { operatorToken: m } = g; + return m.kind === 64 && jqe(e, n, g, i, c, _); + } + } + } + // falls through + default: + return !1; + } + } + function qxe(e, t, n, i, s, o, c) { + const { declarationList: _ } = t; + let u = !1; + const g = hr(_.declarations, (m) => { + const { name: h, initializer: S } = m; + if (S) { + if (t2(e, S)) + return u = !0, Fw([]); + if (x_( + S, + /*requireStringLiteralLikeArgument*/ + !0 + )) + return u = !0, Vqe(h, S.arguments[0], i, s, o, c); + if (wn(S) && x_( + S.expression, + /*requireStringLiteralLikeArgument*/ + !0 + )) + return u = !0, Rqe(h, S.name.text, S.expression.arguments[0], s, c); + } + return Fw([N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList([m], _.flags) + )]); + }); + if (u) { + n.replaceNodeWithNodes(e, t, ka(g, (h) => h.newImports)); + let m; + return lr(g, (h) => { + h.useSitesToUnqualify && j7(h.useSitesToUnqualify, m ?? (m = /* @__PURE__ */ new Map())); + }), m; + } + } + function Rqe(e, t, n, i, s) { + switch (e.kind) { + case 207: + case 208: { + const o = pH(t, i); + return Fw([ + Xxe(o, t, n, s), + dH( + /*modifiers*/ + void 0, + e, + N.createIdentifier(o) + ) + ]); + } + case 80: + return Fw([Xxe(e.text, t, n, s)]); + default: + return E.assertNever(e, `Convert to ES module got invalid syntax form ${e.kind}`); + } + } + function jqe(e, t, n, i, s, o) { + const { left: c, right: _ } = n; + if (!wn(c)) + return !1; + if (t2(e, c)) + if (t2(e, _)) + i.delete(e, n.parent); + else { + const u = _a(_) ? Bqe(_, o) : x_( + _, + /*requireStringLiteralLikeArgument*/ + !0 + ) ? zqe(_.arguments[0], t) : void 0; + return u ? (i.replaceNodeWithNodes(e, n.parent, u[0]), u[1]) : (i.replaceRangeWithText(e, cp(c.getStart(e), _.pos), "export default"), !0); + } + else t2(e, c.expression) && Jqe(e, n, i, s); + return !1; + } + function Bqe(e, t) { + const n = ER(e.properties, (i) => { + switch (i.kind) { + case 178: + case 179: + // TODO: Maybe we should handle this? See fourslash test `refactorConvertToEs6Module_export_object_shorthand.ts`. + // falls through + case 305: + case 306: + return; + case 304: + return Me(i.name) ? Uqe(i.name.text, i.initializer, t) : void 0; + case 175: + return Me(i.name) ? $xe(i.name.text, [N.createToken( + 95 + /* ExportKeyword */ + )], i, t) : void 0; + default: + E.assertNever(i, `Convert to ES6 got invalid prop kind ${i.kind}`); + } + }); + return n && [n, !1]; + } + function Jqe(e, t, n, i) { + const { text: s } = t.left.name, o = i.get(s); + if (o !== void 0) { + const c = [ + dH( + /*modifiers*/ + void 0, + o, + t.right + ), + Hce([N.createExportSpecifier( + /*isTypeOnly*/ + !1, + o, + s + )]) + ]; + n.replaceNodeWithNodes(e, t.parent, c); + } else + Wqe(t, e, n); + } + function zqe(e, t) { + const n = e.text, i = t.getSymbolAtLocation(e), s = i ? i.exports : SR; + return s.has( + "export=" + /* ExportEquals */ + ) ? [[Vce(n)], !0] : s.has( + "default" + /* Default */ + ) ? ( + // If there's some non-default export, must include both `export *` and `export default`. + s.size > 1 ? [[Hxe(n), Vce(n)], !0] : [[Vce(n)], !0] + ) : [[Hxe(n)], !1]; + } + function Hxe(e) { + return Hce( + /*exportSpecifiers*/ + void 0, + e + ); + } + function Vce(e) { + return Hce([N.createExportSpecifier( + /*isTypeOnly*/ + !1, + /*propertyName*/ + void 0, + "default" + )], e); + } + function Wqe({ left: e, right: t, parent: n }, i, s) { + const o = e.name.text; + if ((yo(t) || xo(t) || Rc(t)) && (!t.name || t.name.text === o)) { + s.replaceRange(i, { pos: e.getStart(i), end: t.getStart(i) }, N.createToken( + 95 + /* ExportKeyword */ + ), { suffix: " " }), t.name || s.insertName(i, t, o); + const c = Ya(n, 27, i); + c && s.delete(i, c); + } else + s.replaceNodeRangeWithNodes(i, e.expression, Ya(e, 25, i), [N.createToken( + 95 + /* ExportKeyword */ + ), N.createToken( + 87 + /* ConstKeyword */ + )], { joiner: " ", suffix: " " }); + } + function Uqe(e, t, n) { + const i = [N.createToken( + 95 + /* ExportKeyword */ + )]; + switch (t.kind) { + case 219: { + const { name: o } = t; + if (o && o.text !== e) + return s(); + } + // falls through + case 220: + return $xe(e, i, t, n); + case 232: + return $qe(e, i, t, n); + default: + return s(); + } + function s() { + return dH(i, N.createIdentifier(e), qce(t, n)); + } + } + function qce(e, t) { + if (!t || !ot(is(t.keys()), (i) => C_(e, i))) + return e; + return as(e) ? ez( + e, + /*includeTrivia*/ + !0, + n + ) : PN( + e, + /*includeTrivia*/ + !0, + n + ); + function n(i) { + if (i.kind === 212) { + const s = t.get(i); + return t.delete(i), s; + } + } + } + function Vqe(e, t, n, i, s, o) { + switch (e.kind) { + case 207: { + const c = ER(e.elements, (_) => _.dotDotDotToken || _.initializer || _.propertyName && !Me(_.propertyName) || !Me(_.name) ? void 0 : Qxe(_.propertyName && _.propertyName.text, _.name.text)); + if (c) + return Fw([r1( + /*defaultImport*/ + void 0, + c, + t, + o + )]); + } + // falls through -- object destructuring has an interesting pattern and must be a variable declaration + case 208: { + const c = pH(r8(t.text, s), i); + return Fw([ + r1( + N.createIdentifier(c), + /*namedImports*/ + void 0, + t, + o + ), + dH( + /*modifiers*/ + void 0, + qa(e), + N.createIdentifier(c) + ) + ]); + } + case 80: + return qqe(e, t, n, i, o); + default: + return E.assertNever(e, `Convert to ES module got invalid name kind ${e.kind}`); + } + } + function qqe(e, t, n, i, s) { + const o = n.getSymbolAtLocation(e), c = /* @__PURE__ */ new Map(); + let _ = !1, u; + for (const m of i.original.get(e.text)) { + if (n.getSymbolAtLocation(m) !== o || m === e) + continue; + const { parent: h } = m; + if (wn(h)) { + const { name: { text: S } } = h; + if (S === "default") { + _ = !0; + const T = m.getText(); + (u ?? (u = /* @__PURE__ */ new Map())).set(h, N.createIdentifier(T)); + } else { + E.assert(h.expression === m, "Didn't expect expression === use"); + let T = c.get(S); + T === void 0 && (T = pH(S, i), c.set(S, T)), (u ?? (u = /* @__PURE__ */ new Map())).set(h, N.createIdentifier(T)); + } + } else + _ = !0; + } + const g = c.size === 0 ? void 0 : is(ZE(c.entries(), ([m, h]) => N.createImportSpecifier( + /*isTypeOnly*/ + !1, + m === h ? void 0 : N.createIdentifier(m), + N.createIdentifier(h) + ))); + return g || (_ = !0), Fw( + [r1(_ ? qa(e) : void 0, g, t, s)], + u + ); + } + function pH(e, t) { + for (; t.original.has(e) || t.additional.has(e); ) + e = `_${e}`; + return t.additional.add(e), e; + } + function Hqe(e) { + const t = Fp(); + return Gxe(e, (n) => t.add(n.text, n)), t; + } + function Gxe(e, t) { + Me(e) && Gqe(e) && t(e), e.forEachChild((n) => Gxe(n, t)); + } + function Gqe(e) { + const { parent: t } = e; + switch (t.kind) { + case 212: + return t.name !== e; + case 209: + return t.propertyName !== e; + case 277: + return t.propertyName !== e; + default: + return !0; + } + } + function $xe(e, t, n, i) { + return N.createFunctionDeclaration( + Bi(t, qb(n.modifiers)), + qa(n.asteriskToken), + e, + qb(n.typeParameters), + qb(n.parameters), + qa(n.type), + N.converters.convertToFunctionBlock(qce(n.body, i)) + ); + } + function $qe(e, t, n, i) { + return N.createClassDeclaration( + Bi(t, qb(n.modifiers)), + e, + qb(n.typeParameters), + qb(n.heritageClauses), + qce(n.members, i) + ); + } + function Xxe(e, t, n, i) { + return t === "default" ? r1( + N.createIdentifier(e), + /*namedImports*/ + void 0, + n, + i + ) : r1( + /*defaultImport*/ + void 0, + [Qxe(t, e)], + n, + i + ); + } + function Qxe(e, t) { + return N.createImportSpecifier( + /*isTypeOnly*/ + !1, + e !== void 0 && e !== t ? N.createIdentifier(e) : void 0, + N.createIdentifier(t) + ); + } + function dH(e, t, n) { + return N.createVariableStatement( + e, + N.createVariableDeclarationList( + [N.createVariableDeclaration( + t, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + n + )], + 2 + /* Const */ + ) + ); + } + function Hce(e, t) { + return N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + e && N.createNamedExports(e), + t === void 0 ? void 0 : N.createStringLiteral(t) + ); + } + function Fw(e, t) { + return { + newImports: e, + useSitesToUnqualify: t + }; + } + var Gce = "correctQualifiedNameToIndexedAccessType", Yxe = [p.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1.code]; + Qs({ + errorCodes: Yxe, + getCodeActions(e) { + const t = Zxe(e.sourceFile, e.span.start); + if (!t) return; + const n = cn.ChangeTracker.with(e, (s) => Kxe(s, e.sourceFile, t)), i = `${t.left.text}["${t.right.text}"]`; + return [Ls(Gce, n, [p.Rewrite_as_the_indexed_access_type_0, i], Gce, p.Rewrite_all_as_indexed_access_types)]; + }, + fixIds: [Gce], + getAllCodeActions: (e) => Qa(e, Yxe, (t, n) => { + const i = Zxe(n.file, n.start); + i && Kxe(t, n.file, i); + }) + }); + function Zxe(e, t) { + const n = dr(vi(e, t), s_); + return E.assert(!!n, "Expected position to be owned by a qualified name."), Me(n.left) ? n : void 0; + } + function Kxe(e, t, n) { + const i = n.right.text, s = N.createIndexedAccessTypeNode( + N.createTypeReferenceNode( + n.left, + /*typeArguments*/ + void 0 + ), + N.createLiteralTypeNode(N.createStringLiteral(i)) + ); + e.replaceNode(t, n, s); + } + var $ce = [p.Re_exporting_a_type_when_0_is_enabled_requires_using_export_type.code], Xce = "convertToTypeOnlyExport"; + Qs({ + errorCodes: $ce, + getCodeActions: function(t) { + const n = cn.ChangeTracker.with(t, (i) => tke(i, eke(t.span, t.sourceFile), t)); + if (n.length) + return [Ls(Xce, n, p.Convert_to_type_only_export, Xce, p.Convert_all_re_exported_types_to_type_only_exports)]; + }, + fixIds: [Xce], + getAllCodeActions: function(t) { + const n = /* @__PURE__ */ new Set(); + return Qa(t, $ce, (i, s) => { + const o = eke(s, t.sourceFile); + o && Jp(n, Ma(o.parent.parent)) && tke(i, o, t); + }); + } + }); + function eke(e, t) { + return Bn(vi(t, e.start).parent, Nu); + } + function tke(e, t, n) { + if (!t) + return; + const i = t.parent, s = i.parent, o = Xqe(t, n); + if (o.length === i.elements.length) + e.insertModifierBefore(n.sourceFile, 156, i); + else { + const c = N.updateExportDeclaration( + s, + s.modifiers, + /*isTypeOnly*/ + !1, + N.updateNamedExports(i, kn(i.elements, (u) => !ms(o, u))), + s.moduleSpecifier, + /*attributes*/ + void 0 + ), _ = N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !0, + N.createNamedExports(o), + s.moduleSpecifier, + /*attributes*/ + void 0 + ); + e.replaceNode(n.sourceFile, s, c, { + leadingTriviaOption: cn.LeadingTriviaOption.IncludeAll, + trailingTriviaOption: cn.TrailingTriviaOption.Exclude + }), e.insertNodeAfter(n.sourceFile, s, _); + } + } + function Xqe(e, t) { + const n = e.parent; + if (n.elements.length === 1) + return n.elements; + const i = Oae( + u_(n), + t.program.getSemanticDiagnostics(t.sourceFile, t.cancellationToken) + ); + return kn(n.elements, (s) => { + var o; + return s === e || ((o = Fae(s, i)) == null ? void 0 : o.code) === $ce[0]; + }); + } + var rke = [ + p._0_is_a_type_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled.code, + p._0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled.code + ], mH = "convertToTypeOnlyImport"; + Qs({ + errorCodes: rke, + getCodeActions: function(t) { + var n; + const i = nke(t.sourceFile, t.span.start); + if (i) { + const s = cn.ChangeTracker.with(t, (_) => hL(_, t.sourceFile, i)), o = i.kind === 277 && qo(i.parent.parent.parent) && ike(i, t.sourceFile, t.program) ? cn.ChangeTracker.with(t, (_) => hL(_, t.sourceFile, i.parent.parent.parent)) : void 0, c = Ls( + mH, + s, + i.kind === 277 ? [p.Use_type_0, ((n = i.propertyName) == null ? void 0 : n.text) ?? i.name.text] : p.Use_import_type, + mH, + p.Fix_all_with_type_only_imports + ); + return ot(o) ? [ + jd(mH, o, p.Use_import_type), + c + ] : [c]; + } + }, + fixIds: [mH], + getAllCodeActions: function(t) { + const n = /* @__PURE__ */ new Set(); + return Qa(t, rke, (i, s) => { + const o = nke(s.file, s.start); + o?.kind === 273 && !n.has(o) ? (hL(i, s.file, o), n.add(o)) : o?.kind === 277 && qo(o.parent.parent.parent) && !n.has(o.parent.parent.parent) && ike(o, s.file, t.program) ? (hL(i, s.file, o.parent.parent.parent), n.add(o.parent.parent.parent)) : o?.kind === 277 && hL(i, s.file, o); + }); + } + }); + function nke(e, t) { + const { parent: n } = vi(e, t); + return Xu(n) || qo(n) && n.importClause ? n : void 0; + } + function ike(e, t, n) { + if (e.parent.parent.name) + return !1; + const i = e.parent.elements.filter((o) => !o.isTypeOnly); + if (i.length === 1) + return !0; + const s = n.getTypeChecker(); + for (const o of i) + if (ko.Core.eachSymbolReferenceInFile(o.name, s, t, (_) => { + const u = s.getSymbolAtLocation(_); + return !!u && s.symbolIsValue(u) || !K1(_); + })) + return !1; + return !0; + } + function hL(e, t, n) { + var i; + if (Xu(n)) + e.replaceNode(t, n, N.updateImportSpecifier( + n, + /*isTypeOnly*/ + !0, + n.propertyName, + n.name + )); + else { + const s = n.importClause; + if (s.name && s.namedBindings) + e.replaceNodeWithNodes(t, n, [ + N.createImportDeclaration( + qb( + n.modifiers, + /*includeTrivia*/ + !0 + ), + N.createImportClause( + 156, + qa( + s.name, + /*includeTrivia*/ + !0 + ), + /*namedBindings*/ + void 0 + ), + qa( + n.moduleSpecifier, + /*includeTrivia*/ + !0 + ), + qa( + n.attributes, + /*includeTrivia*/ + !0 + ) + ), + N.createImportDeclaration( + qb( + n.modifiers, + /*includeTrivia*/ + !0 + ), + N.createImportClause( + 156, + /*name*/ + void 0, + qa( + s.namedBindings, + /*includeTrivia*/ + !0 + ) + ), + qa( + n.moduleSpecifier, + /*includeTrivia*/ + !0 + ), + qa( + n.attributes, + /*includeTrivia*/ + !0 + ) + ) + ]); + else { + const o = ((i = s.namedBindings) == null ? void 0 : i.kind) === 276 ? N.updateNamedImports( + s.namedBindings, + Qc(s.namedBindings.elements, (_) => N.updateImportSpecifier( + _, + /*isTypeOnly*/ + !1, + _.propertyName, + _.name + )) + ) : s.namedBindings, c = N.updateImportDeclaration(n, n.modifiers, N.updateImportClause(s, 156, s.name, o), n.moduleSpecifier, n.attributes); + e.replaceNode(t, n, c); + } + } + } + var Qce = "convertTypedefToType", ske = [p.JSDoc_typedef_may_be_converted_to_TypeScript_type.code]; + Qs({ + fixIds: [Qce], + errorCodes: ske, + getCodeActions(e) { + const t = Fh(e.host, e.formatContext.options), n = vi( + e.sourceFile, + e.span.start + ); + if (!n) return; + const i = cn.ChangeTracker.with(e, (s) => ake(s, n, e.sourceFile, t)); + if (i.length > 0) + return [ + Ls( + Qce, + i, + p.Convert_typedef_to_TypeScript_type, + Qce, + p.Convert_all_typedef_to_TypeScript_types + ) + ]; + }, + getAllCodeActions: (e) => Qa( + e, + ske, + (t, n) => { + const i = Fh(e.host, e.formatContext.options), s = vi(n.file, n.start); + s && ake(t, s, n.file, i, !0); + } + ) + }); + function ake(e, t, n, i, s = !1) { + if (!IS(t)) return; + const o = Yqe(t); + if (!o) return; + const c = t.parent, { leftSibling: _, rightSibling: u } = Qqe(t); + let g = c.getStart(), m = ""; + !_ && c.comment && (g = oke(c, c.getStart(), t.getStart()), m = `${i} */${i}`), _ && (s && IS(_) ? (g = t.getStart(), m = "") : (g = oke(c, _.getStart(), t.getStart()), m = `${i} */${i}`)); + let h = c.getEnd(), S = ""; + u && (s && IS(u) ? (h = u.getStart(), S = `${i}${i}`) : (h = u.getStart(), S = `${i}/**${i} * `)), e.replaceRange(n, { pos: g, end: h }, o, { prefix: m, suffix: S }); + } + function Qqe(e) { + const t = e.parent, n = t.getChildCount() - 1, i = t.getChildren().findIndex( + (c) => c.getStart() === e.getStart() && c.getEnd() === e.getEnd() + ), s = i > 0 ? t.getChildAt(i - 1) : void 0, o = i < n ? t.getChildAt(i + 1) : void 0; + return { leftSibling: s, rightSibling: o }; + } + function oke(e, t, n) { + const i = e.getText().substring(t - e.getStart(), n - e.getStart()); + for (let s = i.length; s > 0; s--) + if (!/[*/\s]/.test(i.substring(s - 1, s))) + return t + s; + return n; + } + function Yqe(e) { + var t; + const { typeExpression: n } = e; + if (!n) return; + const i = (t = e.name) == null ? void 0 : t.getText(); + if (i) { + if (n.kind === 323) + return Zqe(i, n); + if (n.kind === 310) + return Kqe(i, n); + } + } + function Zqe(e, t) { + const n = cke(t); + if (ot(n)) + return N.createInterfaceDeclaration( + /*modifiers*/ + void 0, + e, + /*typeParameters*/ + void 0, + /*heritageClauses*/ + void 0, + n + ); + } + function Kqe(e, t) { + const n = qa(t.type); + if (n) + return N.createTypeAliasDeclaration( + /*modifiers*/ + void 0, + N.createIdentifier(e), + /*typeParameters*/ + void 0, + n + ); + } + function cke(e) { + const t = e.jsDocPropertyTags; + return ot(t) ? Fi(t, (i) => { + var s; + const o = eHe(i), c = (s = i.typeExpression) == null ? void 0 : s.type, _ = i.isBracketed; + let u; + if (c && AS(c)) { + const g = cke(c); + u = N.createTypeLiteralNode(g); + } else c && (u = qa(c)); + if (u && o) { + const g = _ ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0; + return N.createPropertySignature( + /*modifiers*/ + void 0, + o, + g, + u + ); + } + }) : void 0; + } + function eHe(e) { + return e.name.kind === 80 ? e.name.text : e.name.right.text; + } + function tHe(e) { + return kf(e) ? ka(e.jsDoc, (t) => { + var n; + return (n = t.tags) == null ? void 0 : n.filter((i) => IS(i)); + }) : []; + } + var Yce = "convertLiteralTypeToMappedType", lke = [p._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0.code]; + Qs({ + errorCodes: lke, + getCodeActions: function(t) { + const { sourceFile: n, span: i } = t, s = uke(n, i.start); + if (!s) + return; + const { name: o, constraint: c } = s, _ = cn.ChangeTracker.with(t, (u) => _ke(u, n, s)); + return [Ls(Yce, _, [p.Convert_0_to_1_in_0, c, o], Yce, p.Convert_all_type_literals_to_mapped_type)]; + }, + fixIds: [Yce], + getAllCodeActions: (e) => Qa(e, lke, (t, n) => { + const i = uke(n.file, n.start); + i && _ke(t, n.file, i); + }) + }); + function uke(e, t) { + const n = vi(e, t); + if (Me(n)) { + const i = Us(n.parent.parent, $u), s = n.getText(e); + return { + container: Us(i.parent, a_), + typeNode: i.type, + constraint: s, + name: s === "K" ? "P" : "K" + }; + } + } + function _ke(e, t, { container: n, typeNode: i, constraint: s, name: o }) { + e.replaceNode( + t, + n, + N.createMappedTypeNode( + /*readonlyToken*/ + void 0, + N.createTypeParameterDeclaration( + /*modifiers*/ + void 0, + o, + N.createTypeReferenceNode(s) + ), + /*nameType*/ + void 0, + /*questionToken*/ + void 0, + i, + /*members*/ + void 0 + ) + ); + } + var fke = [ + p.Class_0_incorrectly_implements_interface_1.code, + p.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass.code + ], Zce = "fixClassIncorrectlyImplementsInterface"; + Qs({ + errorCodes: fke, + getCodeActions(e) { + const { sourceFile: t, span: n } = e, i = pke(t, n.start); + return Fi($C(i), (s) => { + const o = cn.ChangeTracker.with(e, (c) => mke(e, s, t, i, c, e.preferences)); + return o.length === 0 ? void 0 : Ls(Zce, o, [p.Implement_interface_0, s.getText(t)], Zce, p.Implement_all_unimplemented_interfaces); + }); + }, + fixIds: [Zce], + getAllCodeActions(e) { + const t = /* @__PURE__ */ new Set(); + return Qa(e, fke, (n, i) => { + const s = pke(i.file, i.start); + if (Jp(t, Ma(s))) + for (const o of $C(s)) + mke(e, o, i.file, s, n, e.preferences); + }); + } + }); + function pke(e, t) { + return E.checkDefined(Wl(vi(e, t)), "There should be a containing class"); + } + function dke(e) { + return !e.valueDeclaration || !(pu(e.valueDeclaration) & 2); + } + function mke(e, t, n, i, s, o) { + const c = e.program.getTypeChecker(), _ = rHe(i, c), u = c.getTypeAtLocation(t), m = c.getPropertiesOfType(u).filter(ZI(dke, (P) => !_.has(P.escapedName))), h = c.getTypeAtLocation(i), S = Nn(i.members, (P) => nc(P)); + h.getNumberIndexType() || k( + u, + 1 + /* Number */ + ), h.getStringIndexType() || k( + u, + 0 + /* String */ + ); + const T = d2(n, e.program, o, e.host); + qle(i, m, n, e, o, T, (P) => D(n, i, P)), T.writeFixes(s); + function k(P, A) { + const O = c.getIndexInfoOfType(P, A); + O && D(n, i, c.indexInfoToIndexSignatureDeclaration( + O, + i, + /*flags*/ + void 0, + /*internalFlags*/ + void 0, + iE(e) + )); + } + function D(P, A, O) { + S ? s.insertNodeAfter(P, S, O) : s.insertMemberAtStart(P, A, O); + } + } + function rHe(e, t) { + const n = wd(e); + if (!n) return Bs(); + const i = t.getTypeAtLocation(n), s = t.getPropertiesOfType(i); + return Bs(s.filter(dke)); + } + var gke = "import", hke = "fixMissingImport", yke = [ + p.Cannot_find_name_0.code, + p.Cannot_find_name_0_Did_you_mean_1.code, + p.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code, + p.Cannot_find_name_0_Did_you_mean_the_static_member_1_0.code, + p.Cannot_find_namespace_0.code, + p._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code, + p._0_only_refers_to_a_type_but_is_being_used_as_a_value_here.code, + p.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer.code, + p._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code, + p.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery.code, + p.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_1_or_later.code, + p.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom.code, + p.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig.code, + p.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function.code, + p.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig.code, + p.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha.code, + p.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode.code, + p.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig.code, + p.Cannot_find_namespace_0_Did_you_mean_1.code, + p.Cannot_extend_an_interface_0_Did_you_mean_implements.code, + p.This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found.code + ]; + Qs({ + errorCodes: yke, + getCodeActions(e) { + const { errorCode: t, preferences: n, sourceFile: i, span: s, program: o } = e, c = kke( + e, + t, + s.start, + /*useAutoImportProvider*/ + !0 + ); + if (c) + return c.map( + ({ fix: _, symbolName: u, errorIdentifierText: g }) => tle( + e, + i, + u, + _, + /*includeSymbolNameInDescription*/ + u !== g, + o, + n + ) + ); + }, + fixIds: [hke], + getAllCodeActions: (e) => { + const { sourceFile: t, program: n, preferences: i, host: s, cancellationToken: o } = e, c = vke( + t, + n, + /*useAutoImportProvider*/ + !0, + i, + s, + o + ); + return vk(e, yke, (_) => c.addImportFromDiagnostic(_, e)), yk(cn.ChangeTracker.with(e, c.writeFixes)); + } + }); + function d2(e, t, n, i, s) { + return vke( + e, + t, + /*useAutoImportProvider*/ + !1, + n, + i, + s + ); + } + function vke(e, t, n, i, s, o) { + const c = t.getCompilerOptions(), _ = [], u = [], g = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Set(), S = /* @__PURE__ */ new Map(); + return { addImportFromDiagnostic: D, addImportFromExportedSymbol: P, addImportForModuleSymbol: A, writeFixes: B, hasFixes: $, addImportForUnresolvedIdentifier: k, addImportForNonExistentExport: O, removeExistingImport: F, addVerbatimImport: T }; + function T(W) { + h.add(W); + } + function k(W, _e, K) { + const V = pHe(W, _e, K); + !V || !V.length || R(Ca(V)); + } + function D(W, _e) { + const K = kke(_e, W.code, W.start, n); + !K || !K.length || R(Ca(K)); + } + function P(W, _e, K) { + var V, ae; + const se = E.checkDefined(W.parent, "Expected exported symbol to have module symbol as parent"), ce = V9(W, da(c)), fe = t.getTypeChecker(), he = fe.getMergedSymbol(eu(W, fe)), q = Ske( + e, + he, + ce, + se, + /*preferCapitalized*/ + !1, + t, + s, + i, + o + ); + if (!q) { + E.assert((V = i.autoImportFileExcludePatterns) == null ? void 0 : V.length); + return; + } + const be = h8(e, t); + let je = Kce( + e, + q, + t, + /*position*/ + void 0, + !!_e, + be, + s, + i + ); + if (je) { + const me = ((ae = Bn(K?.name, Me)) == null ? void 0 : ae.text) ?? ce; + let Z, pe; + K && NC(K) && (je.kind === 3 || je.kind === 2) && je.addAsTypeOnly === 1 && (Z = 2), W.name !== me && (pe = W.name), je = { + ...je, + ...Z === void 0 ? {} : { addAsTypeOnly: Z }, + ...pe === void 0 ? {} : { propertyName: pe } + }, R({ fix: je, symbolName: me ?? ce }); + } + } + function A(W, _e, K) { + var V, ae, se; + const ce = t.getTypeChecker(), fe = ce.getAliasedSymbol(W); + E.assert(fe.flags & 1536, "Expected symbol to be a module"); + const he = bv(t, s), q = Ih.getModuleSpecifiersWithCacheInfo( + fe, + ce, + c, + e, + he, + i, + /*options*/ + void 0, + /*forAutoImport*/ + !0 + ), be = h8(e, t); + let je = vL( + _e, + /*isForNewImportDeclaration*/ + !0, + /*symbol*/ + void 0, + W.flags, + t.getTypeChecker(), + c + ); + je = je === 1 && NC(K) ? 2 : 1; + const me = qo(K) ? fS(K) ? 1 : 2 : Xu(K) ? 0 : ld(K) && K.name ? 1 : 2, Z = [{ + symbol: W, + moduleSymbol: fe, + moduleFileName: (se = (ae = (V = fe.declarations) == null ? void 0 : V[0]) == null ? void 0 : ae.getSourceFile()) == null ? void 0 : se.fileName, + exportKind: 4, + targetFlags: W.flags, + isFromPackageJson: !1 + }], pe = Kce( + e, + Z, + t, + /*position*/ + void 0, + !!_e, + be, + s, + i + ); + let Te; + pe && me !== 2 && pe.kind !== 0 && pe.kind !== 1 ? Te = { + ...pe, + addAsTypeOnly: je, + importKind: me + } : Te = { + kind: 3, + moduleSpecifierKind: pe !== void 0 ? pe.moduleSpecifierKind : q.kind, + moduleSpecifier: pe !== void 0 ? pe.moduleSpecifier : Ca(q.moduleSpecifiers), + importKind: me, + addAsTypeOnly: je, + useRequire: be + }, R({ fix: Te, symbolName: W.name }); + } + function O(W, _e, K, V, ae) { + const se = t.getSourceFile(_e), ce = h8(e, t); + if (se && se.symbol) { + const { fixes: fe } = yL( + [{ + exportKind: K, + isFromPackageJson: !1, + moduleFileName: _e, + moduleSymbol: se.symbol, + targetFlags: V + }], + /*usagePosition*/ + void 0, + ae, + ce, + t, + e, + s, + i + ); + fe.length && R({ fix: fe[0], symbolName: W }); + } else { + const fe = X9(_e, 99, t, s), he = Ih.getLocalModuleSpecifierBetweenFileNames( + e, + _e, + c, + bv(t, s), + i + ), q = gH(fe, K, t), be = vL( + ae, + /*isForNewImportDeclaration*/ + !0, + /*symbol*/ + void 0, + V, + t.getTypeChecker(), + c + ); + R({ fix: { + kind: 3, + moduleSpecifierKind: "relative", + moduleSpecifier: he, + importKind: q, + addAsTypeOnly: be, + useRequire: ce + }, symbolName: W }); + } + } + function F(W) { + W.kind === 274 && E.assertIsDefined(W.name, "ImportClause should have a name if it's being removed"), m.add(W); + } + function R(W) { + var _e, K, V; + const { fix: ae, symbolName: se } = W; + switch (ae.kind) { + case 0: + _.push(ae); + break; + case 1: + u.push(ae); + break; + case 2: { + const { importClauseOrBindingPattern: q, importKind: be, addAsTypeOnly: je, propertyName: me } = ae; + let Z = g.get(q); + if (Z || g.set(q, Z = { importClauseOrBindingPattern: q, defaultImport: void 0, namedImports: /* @__PURE__ */ new Map() }), be === 0) { + const pe = (_e = Z?.namedImports.get(se)) == null ? void 0 : _e.addAsTypeOnly; + Z.namedImports.set(se, { addAsTypeOnly: ce(pe, je), propertyName: me }); + } else + E.assert(Z.defaultImport === void 0 || Z.defaultImport.name === se, "(Add to Existing) Default import should be missing or match symbolName"), Z.defaultImport = { + name: se, + addAsTypeOnly: ce((K = Z.defaultImport) == null ? void 0 : K.addAsTypeOnly, je) + }; + break; + } + case 3: { + const { moduleSpecifier: q, importKind: be, useRequire: je, addAsTypeOnly: me, propertyName: Z } = ae, pe = fe(q, be, je, me); + switch (E.assert(pe.useRequire === je, "(Add new) Tried to add an `import` and a `require` for the same module"), be) { + case 1: + E.assert(pe.defaultImport === void 0 || pe.defaultImport.name === se, "(Add new) Default import should be missing or match symbolName"), pe.defaultImport = { name: se, addAsTypeOnly: ce((V = pe.defaultImport) == null ? void 0 : V.addAsTypeOnly, me) }; + break; + case 0: + const Te = (pe.namedImports || (pe.namedImports = /* @__PURE__ */ new Map())).get(se); + pe.namedImports.set(se, [ce(Te, me), Z]); + break; + case 3: + if (c.verbatimModuleSyntax) { + const Fe = (pe.namedImports || (pe.namedImports = /* @__PURE__ */ new Map())).get(se); + pe.namedImports.set(se, [ce(Fe, me), Z]); + } else + E.assert(pe.namespaceLikeImport === void 0 || pe.namespaceLikeImport.name === se, "Namespacelike import shoudl be missing or match symbolName"), pe.namespaceLikeImport = { importKind: be, name: se, addAsTypeOnly: me }; + break; + case 2: + E.assert(pe.namespaceLikeImport === void 0 || pe.namespaceLikeImport.name === se, "Namespacelike import shoudl be missing or match symbolName"), pe.namespaceLikeImport = { importKind: be, name: se, addAsTypeOnly: me }; + break; + } + break; + } + case 4: + break; + default: + E.assertNever(ae, `fix wasn't never - got kind ${ae.kind}`); + } + function ce(q, be) { + return Math.max(q ?? 0, be); + } + function fe(q, be, je, me) { + const Z = he( + q, + /*topLevelTypeOnly*/ + !0 + ), pe = he( + q, + /*topLevelTypeOnly*/ + !1 + ), Te = S.get(Z), Fe = S.get(pe), Ye = { + defaultImport: void 0, + namedImports: void 0, + namespaceLikeImport: void 0, + useRequire: je + }; + return be === 1 && me === 2 ? Te || (S.set(Z, Ye), Ye) : me === 1 && (Te || Fe) ? Te || Fe : Fe || (S.set(pe, Ye), Ye); + } + function he(q, be) { + return `${be ? 1 : 0}|${q}`; + } + } + function B(W, _e) { + var K, V; + let ae; + e.imports !== void 0 && e.imports.length === 0 && _e !== void 0 ? ae = _e : ae = _f(e, i); + for (const fe of _) + rle(W, e, fe); + for (const fe of u) + Fke(W, e, fe, ae); + let se; + if (m.size) { + E.assert(Og(e), "Cannot remove imports from a future source file"); + const fe = new Set(Fi([...m], (me) => dr(me, qo))), he = new Set(Fi([...m], (me) => dr(me, L3))), q = [...fe].filter( + (me) => { + var Z, pe, Te; + return ( + // nothing added to the import declaration + !g.has(me.importClause) && // no default, or default is being removed + (!((Z = me.importClause) != null && Z.name) || m.has(me.importClause)) && // no namespace import, or namespace import is being removed + (!Bn((pe = me.importClause) == null ? void 0 : pe.namedBindings, Ug) || m.has(me.importClause.namedBindings)) && // no named imports, or all named imports are being removed + (!Bn((Te = me.importClause) == null ? void 0 : Te.namedBindings, bm) || Ni(me.importClause.namedBindings.elements, (Fe) => m.has(Fe))) + ); + } + ), be = [...he].filter( + (me) => ( + // no binding elements being added to the variable declaration + (me.name.kind !== 207 || !g.has(me.name)) && // no binding elements, or all binding elements are being removed + (me.name.kind !== 207 || Ni(me.name.elements, (Z) => m.has(Z))) + ) + ), je = [...fe].filter( + (me) => { + var Z, pe; + return ( + // has named bindings + ((Z = me.importClause) == null ? void 0 : Z.namedBindings) && // is not being fully removed + q.indexOf(me) === -1 && // is not gaining named imports + !((pe = g.get(me.importClause)) != null && pe.namedImports) && // all named imports are being removed + (me.importClause.namedBindings.kind === 275 || Ni(me.importClause.namedBindings.elements, (Te) => m.has(Te))) + ); + } + ); + for (const me of [...q, ...be]) + W.delete(e, me); + for (const me of je) + W.replaceNode( + e, + me.importClause, + N.updateImportClause( + me.importClause, + me.importClause.phaseModifier, + me.importClause.name, + /*namedBindings*/ + void 0 + ) + ); + for (const me of m) { + const Z = dr(me, qo); + Z && q.indexOf(Z) === -1 && je.indexOf(Z) === -1 ? me.kind === 274 ? W.delete(e, me.name) : (E.assert(me.kind === 277, "NamespaceImport should have been handled earlier"), (K = g.get(Z.importClause)) != null && K.namedImports ? (se ?? (se = /* @__PURE__ */ new Set())).add(me) : W.delete(e, me)) : me.kind === 209 ? (V = g.get(me.parent)) != null && V.namedImports ? (se ?? (se = /* @__PURE__ */ new Set())).add(me) : W.delete(e, me) : me.kind === 272 && W.delete(e, me); + } + } + g.forEach(({ importClauseOrBindingPattern: fe, defaultImport: he, namedImports: q }) => { + Ike( + W, + e, + fe, + he, + is(q.entries(), ([be, { addAsTypeOnly: je, propertyName: me }]) => ({ addAsTypeOnly: je, propertyName: me, name: be })), + se, + i + ); + }); + let ce; + S.forEach(({ useRequire: fe, defaultImport: he, namedImports: q, namespaceLikeImport: be }, je) => { + const me = je.slice(2), pe = (fe ? Mke : Lke)( + me, + ae, + he, + q && is(q.entries(), ([Te, [Fe, Ye]]) => ({ addAsTypeOnly: Fe, propertyName: Ye, name: Te })), + be, + c, + i + ); + ce = GT(ce, pe); + }), ce = GT(ce, U()), ce && GV( + W, + e, + ce, + /*blankLineBetween*/ + !0, + i + ); + } + function U() { + if (!h.size) return; + const W = new Set(Fi([...h], (K) => dr(K, qo))), _e = new Set(Fi([...h], (K) => dr(K, M3))); + return [ + ...Fi([...h], (K) => K.kind === 272 ? qa( + K, + /*includeTrivia*/ + !0 + ) : void 0), + ...[...W].map((K) => { + var V; + return h.has(K) ? qa( + K, + /*includeTrivia*/ + !0 + ) : qa( + N.updateImportDeclaration( + K, + K.modifiers, + K.importClause && N.updateImportClause( + K.importClause, + K.importClause.phaseModifier, + h.has(K.importClause) ? K.importClause.name : void 0, + h.has(K.importClause.namedBindings) ? K.importClause.namedBindings : (V = Bn(K.importClause.namedBindings, bm)) != null && V.elements.some((ae) => h.has(ae)) ? N.updateNamedImports( + K.importClause.namedBindings, + K.importClause.namedBindings.elements.filter((ae) => h.has(ae)) + ) : void 0 + ), + K.moduleSpecifier, + K.attributes + ), + /*includeTrivia*/ + !0 + ); + }), + ...[..._e].map((K) => h.has(K) ? qa( + K, + /*includeTrivia*/ + !0 + ) : qa( + N.updateVariableStatement( + K, + K.modifiers, + N.updateVariableDeclarationList( + K.declarationList, + Fi(K.declarationList.declarations, (V) => h.has(V) ? V : N.updateVariableDeclaration( + V, + V.name.kind === 207 ? N.updateObjectBindingPattern( + V.name, + V.name.elements.filter((ae) => h.has(ae)) + ) : V.name, + V.exclamationToken, + V.type, + V.initializer + )) + ) + ), + /*includeTrivia*/ + !0 + )) + ]; + } + function $() { + return _.length > 0 || u.length > 0 || g.size > 0 || S.size > 0 || h.size > 0 || m.size > 0; + } + } + function nHe(e, t, n, i) { + const s = Z6(e, i, n), o = Tke(e, t); + return { getModuleSpecifierForBestExportInfo: c }; + function c(_, u, g, m) { + const { fixes: h, computedWithoutCacheCount: S } = yL( + _, + u, + g, + /*useRequire*/ + !1, + t, + e, + n, + i, + o, + m + ), T = Eke(h, e, t, s, n, i); + return T && { ...T, computedWithoutCacheCount: S }; + } + } + function iHe(e, t, n, i, s, o, c, _, u, g, m, h) { + let S; + n ? (S = i8(i, c, _, m, h).get(i.path, n), E.assertIsDefined(S, "Some exportInfo should match the specified exportMapKey")) : (S = vj(Bp(t.name)) ? [aHe(e, s, t, _, c)] : Ske(i, e, s, t, o, _, c, m, h), E.assertIsDefined(S, "Some exportInfo should match the specified symbol / moduleSymbol")); + const T = h8(i, _), k = K1(vi(i, g)), D = E.checkDefined(Kce(i, S, _, g, k, T, c, m)); + return { + moduleSpecifier: D.moduleSpecifier, + codeAction: bke(tle( + { host: c, formatContext: u, preferences: m }, + i, + s, + D, + /*includeSymbolNameInDescription*/ + !1, + _, + m + )) + }; + } + function sHe(e, t, n, i, s, o) { + const c = n.getCompilerOptions(), _ = FR(ele(e, n.getTypeChecker(), t, c)), u = Nke(e, t, _, n), g = _ !== t.text; + return u && bke(tle( + { host: i, formatContext: s, preferences: o }, + e, + _, + u, + g, + n, + o + )); + } + function Kce(e, t, n, i, s, o, c, _) { + const u = Z6(e, _, c); + return Eke(yL(t, i, s, o, n, e, c, _).fixes, e, n, u, c, _); + } + function bke({ description: e, changes: t, commands: n }) { + return { description: e, changes: t, commands: n }; + } + function Ske(e, t, n, i, s, o, c, _, u) { + const g = xke(o, c), m = _.autoImportFileExcludePatterns && Bae(c, _), h = o.getTypeChecker().getMergedSymbol(i), S = m && h.declarations && Oo( + h, + 308 + /* SourceFile */ + ), T = S && m(S); + return i8(e, c, o, _, u).search(e.path, s, (k) => k === n, (k) => { + const D = g(k[0].isFromPackageJson); + if (D.getMergedSymbol(eu(k[0].symbol, D)) === t && (T || k.some((P) => D.getMergedSymbol(P.moduleSymbol) === i || P.symbol.parent === i))) + return k; + }); + } + function aHe(e, t, n, i, s) { + var o, c; + const _ = g( + i.getTypeChecker(), + /*isFromPackageJson*/ + !1 + ); + if (_) + return _; + const u = (c = (o = s.getPackageJsonAutoImportProvider) == null ? void 0 : o.call(s)) == null ? void 0 : c.getTypeChecker(); + return E.checkDefined(u && g( + u, + /*isFromPackageJson*/ + !0 + ), "Could not find symbol in specified module for code actions"); + function g(m, h) { + const S = Q9(n, m); + if (S && eu(S.symbol, m) === e) + return { symbol: S.symbol, moduleSymbol: n, moduleFileName: void 0, exportKind: S.exportKind, targetFlags: eu(e, m).flags, isFromPackageJson: h }; + const T = m.tryGetMemberInModuleExportsAndProperties(t, n); + if (T && eu(T, m) === e) + return { symbol: T, moduleSymbol: n, moduleFileName: void 0, exportKind: 0, targetFlags: eu(e, m).flags, isFromPackageJson: h }; + } + } + function yL(e, t, n, i, s, o, c, _, u = Og(o) ? Tke(o, s) : void 0, g) { + const m = s.getTypeChecker(), h = u ? ka(e, u.getImportsForExportInfo) : Ge, S = t !== void 0 && oHe(h, t), T = lHe(h, n, m, s.getCompilerOptions()); + if (T) + return { + computedWithoutCacheCount: 0, + fixes: [...S ? [S] : Ge, T] + }; + const { fixes: k, computedWithoutCacheCount: D = 0 } = _He( + e, + h, + s, + o, + t, + n, + i, + c, + _, + g + ); + return { + computedWithoutCacheCount: D, + fixes: [...S ? [S] : Ge, ...k] + }; + } + function oHe(e, t) { + return Lc(e, ({ declaration: n, importKind: i }) => { + var s; + if (i !== 0) return; + const o = cHe(n), c = o && ((s = gx(n)) == null ? void 0 : s.text); + if (c) + return { kind: 0, namespacePrefix: o, usagePosition: t, moduleSpecifierKind: void 0, moduleSpecifier: c }; + }); + } + function cHe(e) { + var t, n, i; + switch (e.kind) { + case 261: + return (t = Bn(e.name, Me)) == null ? void 0 : t.text; + case 272: + return e.name.text; + case 352: + case 273: + return (i = Bn((n = e.importClause) == null ? void 0 : n.namedBindings, Ug)) == null ? void 0 : i.name.text; + default: + return E.assertNever(e); + } + } + function vL(e, t, n, i, s, o) { + return e ? n && o.verbatimModuleSyntax && (!(i & 111551) || s.getTypeOnlyAliasDeclaration(n)) ? 2 : 1 : 4; + } + function lHe(e, t, n, i) { + let s; + for (const c of e) { + const _ = o(c); + if (!_) continue; + const u = NC(_.importClauseOrBindingPattern); + if (_.addAsTypeOnly !== 4 && u || _.addAsTypeOnly === 4 && !u) + return _; + s ?? (s = _); + } + return s; + function o({ declaration: c, importKind: _, symbol: u, targetFlags: g }) { + if (_ === 3 || _ === 2 || c.kind === 272) + return; + if (c.kind === 261) + return (_ === 0 || _ === 1) && c.name.kind === 207 ? { + kind: 2, + importClauseOrBindingPattern: c.name, + importKind: _, + moduleSpecifierKind: void 0, + moduleSpecifier: c.initializer.arguments[0].text, + addAsTypeOnly: 4 + /* NotAllowed */ + } : void 0; + const { importClause: m } = c; + if (!m || !ja(c.moduleSpecifier)) + return; + const { name: h, namedBindings: S } = m; + if (m.isTypeOnly && !(_ === 0 && S)) + return; + const T = vL( + t, + /*isForNewImportDeclaration*/ + !1, + u, + g, + n, + i + ); + if (!(_ === 1 && (h || // Cannot add a default import to a declaration that already has one + T === 2 && S)) && !(_ === 0 && S?.kind === 275)) + return { + kind: 2, + importClauseOrBindingPattern: m, + importKind: _, + moduleSpecifierKind: void 0, + moduleSpecifier: c.moduleSpecifier.text, + addAsTypeOnly: T + }; + } + } + function Tke(e, t) { + const n = t.getTypeChecker(); + let i; + for (const s of e.imports) { + const o = UD(s); + if (L3(o.parent)) { + const c = n.resolveExternalModuleName(s); + c && (i || (i = Fp())).add(Xs(c), o.parent); + } else if (o.kind === 273 || o.kind === 272 || o.kind === 352) { + const c = n.getSymbolAtLocation(s); + c && (i || (i = Fp())).add(Xs(c), o); + } + } + return { + getImportsForExportInfo: ({ moduleSymbol: s, exportKind: o, targetFlags: c, symbol: _ }) => { + const u = i?.get(Xs(s)); + if (!u || n_(e) && !(c & 111551) && !Ni(u, xm)) return Ge; + const g = gH(e, o, t); + return u.map((m) => ({ declaration: m, importKind: g, symbol: _, targetFlags: c })); + } + }; + } + function h8(e, t) { + if (!Bg(e.fileName)) + return !1; + if (e.commonJsModuleIndicator && !e.externalModuleIndicator) return !0; + if (e.externalModuleIndicator && !e.commonJsModuleIndicator) return !1; + const n = t.getCompilerOptions(); + if (n.configFile) + return Hu(n) < 5; + if (ile(e, t) === 1) return !0; + if (ile(e, t) === 99) return !1; + for (const i of t.getSourceFiles()) + if (!(i === e || !n_(i) || t.isSourceFileFromExternalLibrary(i))) { + if (i.commonJsModuleIndicator && !i.externalModuleIndicator) return !0; + if (i.externalModuleIndicator && !i.commonJsModuleIndicator) return !1; + } + return !0; + } + function xke(e, t) { + return nm((n) => n ? t.getPackageJsonAutoImportProvider().getTypeChecker() : e.getTypeChecker()); + } + function uHe(e, t, n, i, s, o, c, _, u) { + const g = Bg(t.fileName), m = e.getCompilerOptions(), h = bv(e, c), S = xke(e, c), T = Pu(m), k = N9(T), D = u ? (O) => Ih.tryGetModuleSpecifiersFromCache(O.moduleSymbol, t, h, _) : (O, F) => Ih.getModuleSpecifiersWithCacheInfo( + O.moduleSymbol, + F, + m, + t, + h, + _, + /*options*/ + void 0, + /*forAutoImport*/ + !0 + ); + let P = 0; + const A = ka(o, (O, F) => { + const R = S(O.isFromPackageJson), { computedWithoutCache: B, moduleSpecifiers: U, kind: $ } = D(O, R) ?? {}, W = !!(O.targetFlags & 111551), _e = vL( + i, + /*isForNewImportDeclaration*/ + !0, + O.symbol, + O.targetFlags, + R, + m + ); + return P += B ? 1 : 0, Fi(U, (K) => { + if (k && Yy(K)) + return; + if (!W && g && n !== void 0) + return { kind: 1, moduleSpecifierKind: $, moduleSpecifier: K, usagePosition: n, exportInfo: O, isReExport: F > 0 }; + const V = gH(t, O.exportKind, e); + let ae; + if (n !== void 0 && V === 3 && O.exportKind === 0) { + const se = R.resolveExternalModuleSymbol(O.moduleSymbol); + let ce; + se !== O.moduleSymbol && (ce = Y9(se, R, da(m), go)), ce || (ce = t8( + O.moduleSymbol, + da(m), + /*forceCapitalize*/ + !1 + )), ae = { namespacePrefix: ce, usagePosition: n }; + } + return { + kind: 3, + moduleSpecifierKind: $, + moduleSpecifier: K, + importKind: V, + useRequire: s, + addAsTypeOnly: _e, + exportInfo: O, + isReExport: F > 0, + qualification: ae + }; + }); + }); + return { computedWithoutCacheCount: P, fixes: A }; + } + function _He(e, t, n, i, s, o, c, _, u, g) { + const m = Lc(t, (h) => fHe(h, o, c, n.getTypeChecker(), n.getCompilerOptions())); + return m ? { fixes: [m] } : uHe(n, i, s, o, c, e, _, u, g); + } + function fHe({ declaration: e, importKind: t, symbol: n, targetFlags: i }, s, o, c, _) { + var u; + const g = (u = gx(e)) == null ? void 0 : u.text; + if (g) { + const m = o ? 4 : vL( + s, + /*isForNewImportDeclaration*/ + !0, + n, + i, + c, + _ + ); + return { kind: 3, moduleSpecifierKind: void 0, moduleSpecifier: g, importKind: t, addAsTypeOnly: m, useRequire: o }; + } + } + function kke(e, t, n, i) { + const s = vi(e.sourceFile, n); + let o; + if (t === p._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code) + o = hHe(e, s); + else if (Me(s)) + if (t === p._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code) { + const _ = FR(ele(e.sourceFile, e.program.getTypeChecker(), s, e.program.getCompilerOptions())), u = Nke(e.sourceFile, s, _, e.program); + return u && [{ fix: u, symbolName: _, errorIdentifierText: s.text }]; + } else + o = Pke(e, s, i); + else return; + const c = Z6(e.sourceFile, e.preferences, e.host); + return o && Cke(o, e.sourceFile, e.program, c, e.host, e.preferences); + } + function Cke(e, t, n, i, s, o) { + const c = (_) => oo(_, s.getCurrentDirectory(), xh(s)); + return X_(e, (_, u) => j1(!!_.isJsxNamespaceFix, !!u.isJsxNamespaceFix) || ho(_.fix.kind, u.fix.kind) || Dke(_.fix, u.fix, t, n, o, i.allowsImportingSpecifier, c)); + } + function pHe(e, t, n) { + const i = Pke(e, t, n), s = Z6(e.sourceFile, e.preferences, e.host); + return i && Cke(i, e.sourceFile, e.program, s, e.host, e.preferences); + } + function Eke(e, t, n, i, s, o) { + if (ot(e)) + return e[0].kind === 0 || e[0].kind === 2 ? e[0] : e.reduce( + (c, _) => ( + // Takes true branch of conditional if `fix` is better than `best` + Dke( + _, + c, + t, + n, + o, + i.allowsImportingSpecifier, + (u) => oo(u, s.getCurrentDirectory(), xh(s)) + ) === -1 ? _ : c + ) + ); + } + function Dke(e, t, n, i, s, o, c) { + return e.kind !== 0 && t.kind !== 0 ? j1( + t.moduleSpecifierKind !== "node_modules" || o(t.moduleSpecifier), + e.moduleSpecifierKind !== "node_modules" || o(e.moduleSpecifier) + ) || dHe(e, t, s) || gHe(e.moduleSpecifier, t.moduleSpecifier, n, i) || j1( + wke(e, n.path, c), + wke(t, n.path, c) + ) || SN(e.moduleSpecifier, t.moduleSpecifier) : 0; + } + function dHe(e, t, n) { + return n.importModuleSpecifierPreference === "non-relative" || n.importModuleSpecifierPreference === "project-relative" ? j1(e.moduleSpecifierKind === "relative", t.moduleSpecifierKind === "relative") : 0; + } + function wke(e, t, n) { + var i; + if (e.isReExport && ((i = e.exportInfo) != null && i.moduleFileName) && mHe(e.exportInfo.moduleFileName)) { + const s = n(Hn(e.exportInfo.moduleFileName)); + return Ui(t, s); + } + return !1; + } + function mHe(e) { + return Zc( + e, + [".js", ".jsx", ".d.ts", ".ts", ".tsx"], + /*ignoreCase*/ + !0 + ) === "index"; + } + function gHe(e, t, n, i) { + return Ui(e, "node:") && !Ui(t, "node:") ? H9(n, i) ? -1 : 1 : Ui(t, "node:") && !Ui(e, "node:") ? H9(n, i) ? 1 : -1 : 0; + } + function hHe({ sourceFile: e, program: t, host: n, preferences: i }, s) { + const o = t.getTypeChecker(), c = yHe(s, o); + if (!c) return; + const _ = o.getAliasedSymbol(c), u = c.name, g = [{ symbol: c, moduleSymbol: _, moduleFileName: void 0, exportKind: 3, targetFlags: _.flags, isFromPackageJson: !1 }], m = h8(e, t); + return yL( + g, + /*usagePosition*/ + void 0, + /*isValidTypeOnlyUseSite*/ + !1, + m, + t, + e, + n, + i + ).fixes.map((S) => { + var T; + return { fix: S, symbolName: u, errorIdentifierText: (T = Bn(s, Me)) == null ? void 0 : T.text }; + }); + } + function yHe(e, t) { + const n = Me(e) ? t.getSymbolAtLocation(e) : void 0; + if (j5(n)) return n; + const { parent: i } = e; + if (wu(i) && i.tagName === e || ud(i)) { + const s = t.resolveName( + t.getJsxNamespace(i), + wu(i) ? e : i, + 111551, + /*excludeGlobals*/ + !1 + ); + if (j5(s)) + return s; + } + } + function gH(e, t, n, i) { + if (n.getCompilerOptions().verbatimModuleSyntax && CHe(e, n) === 1) + return 3; + switch (t) { + case 0: + return 0; + case 1: + return 1; + case 2: + return THe(e, n.getCompilerOptions(), !!i); + case 3: + return vHe(e, n, !!i); + case 4: + return 2; + default: + return E.assertNever(t); + } + } + function vHe(e, t, n) { + if (Ax(t.getCompilerOptions())) + return 1; + const i = Hu(t.getCompilerOptions()); + switch (i) { + case 2: + case 1: + case 3: + return Bg(e.fileName) && (e.externalModuleIndicator || n) ? 2 : 3; + case 4: + case 5: + case 6: + case 7: + case 99: + case 0: + case 200: + return 2; + case 100: + case 101: + case 102: + case 199: + return ile(e, t) === 99 ? 2 : 3; + default: + return E.assertNever(i, `Unexpected moduleKind ${i}`); + } + } + function Pke({ sourceFile: e, program: t, cancellationToken: n, host: i, preferences: s }, o, c) { + const _ = t.getTypeChecker(), u = t.getCompilerOptions(); + return ka(ele(e, _, o, u), (g) => { + if (g === "default") + return; + const m = K1(o), h = h8(e, t), S = SHe(g, UC(o), WS(o), n, e, t, c, i, s); + return is( + CR(S.values(), (T) => yL(T, o.getStart(e), m, h, t, e, i, s).fixes), + (T) => ({ fix: T, symbolName: g, errorIdentifierText: o.text, isJsxNamespaceFix: g !== o.text }) + ); + }); + } + function Nke(e, t, n, i) { + const s = i.getTypeChecker(), o = s.resolveName( + n, + t, + 111551, + /*excludeGlobals*/ + !0 + ); + if (!o) return; + const c = s.getTypeOnlyAliasDeclaration(o); + if (!(!c || xr(c) !== e)) + return { kind: 4, typeOnlyAliasDeclaration: c }; + } + function ele(e, t, n, i) { + const s = n.parent; + if ((wu(s) || Qb(s)) && s.tagName === n && mq(i.jsx)) { + const o = t.getJsxNamespace(e); + if (bHe(o, n, t)) + return !YC(n.text) && !t.resolveName( + n.text, + n, + 111551, + /*excludeGlobals*/ + !1 + ) ? [n.text, o] : [o]; + } + return [n.text]; + } + function bHe(e, t, n) { + if (YC(t.text)) return !0; + const i = n.resolveName( + e, + t, + 111551, + /*excludeGlobals*/ + !0 + ); + return !i || ot(i.declarations, p0) && !(i.flags & 111551); + } + function SHe(e, t, n, i, s, o, c, _, u) { + var g; + const m = Fp(), h = Z6(s, u, _), S = (g = _.getModuleSpecifierCache) == null ? void 0 : g.call(_), T = nm((D) => bv(D ? _.getPackageJsonAutoImportProvider() : o, _)); + function k(D, P, A, O, F, R) { + const B = T(R); + if (yq(F, s, P, D, u, h, B, S)) { + const U = F.getTypeChecker(); + m.add(Cae(A, U).toString(), { symbol: A, moduleSymbol: D, moduleFileName: P?.fileName, exportKind: O, targetFlags: eu(A, U).flags, isFromPackageJson: R }); + } + } + return vq(o, _, u, c, (D, P, A, O) => { + const F = A.getTypeChecker(); + i.throwIfCancellationRequested(); + const R = A.getCompilerOptions(), B = Q9(D, F); + B && jke(F.getSymbolFlags(B.symbol), n) && Y9(B.symbol, F, da(R), ($, W) => (t ? W ?? $ : $) === e) && k(D, P, B.symbol, B.exportKind, A, O); + const U = F.tryGetMemberInModuleExportsAndProperties(e, D); + U && jke(F.getSymbolFlags(U), n) && k(D, P, U, 0, A, O); + }), m; + } + function THe(e, t, n) { + const i = Ax(t), s = Bg(e.fileName); + if (!s && Hu(t) >= 5) + return i ? 1 : 2; + if (s) + return e.externalModuleIndicator || n ? i ? 1 : 2 : 3; + for (const o of e.statements ?? Ge) + if (_l(o) && !lc(o.moduleReference)) + return 3; + return i ? 1 : 3; + } + function tle(e, t, n, i, s, o, c) { + let _; + const u = cn.ChangeTracker.with(e, (g) => { + _ = xHe(g, t, n, i, s, o, c); + }); + return Ls(gke, u, _, hke, p.Add_all_missing_imports); + } + function xHe(e, t, n, i, s, o, c) { + const _ = _f(t, c); + switch (i.kind) { + case 0: + return rle(e, t, i), [p.Change_0_to_1, n, `${i.namespacePrefix}.${n}`]; + case 1: + return Fke(e, t, i, _), [p.Change_0_to_1, n, Oke(i.moduleSpecifier, _) + n]; + case 2: { + const { importClauseOrBindingPattern: u, importKind: g, addAsTypeOnly: m, moduleSpecifier: h } = i; + Ike( + e, + t, + u, + g === 1 ? { name: n, addAsTypeOnly: m } : void 0, + g === 0 ? [{ name: n, addAsTypeOnly: m }] : Ge, + /*removeExistingImportSpecifiers*/ + void 0, + c + ); + const S = Bp(h); + return s ? [p.Import_0_from_1, n, S] : [p.Update_import_from_0, S]; + } + case 3: { + const { importKind: u, moduleSpecifier: g, addAsTypeOnly: m, useRequire: h, qualification: S } = i, T = h ? Mke : Lke, k = u === 1 ? { name: n, addAsTypeOnly: m } : void 0, D = u === 0 ? [{ name: n, addAsTypeOnly: m }] : void 0, P = u === 2 || u === 3 ? { importKind: u, name: S?.namespacePrefix || n, addAsTypeOnly: m } : void 0; + return GV( + e, + t, + T( + g, + _, + k, + D, + P, + o.getCompilerOptions(), + c + ), + /*blankLineBetween*/ + !0, + c + ), S && rle(e, t, S), s ? [p.Import_0_from_1, n, g] : [p.Add_import_from_0, g]; + } + case 4: { + const { typeOnlyAliasDeclaration: u } = i, g = kHe(e, u, o, t, c); + return g.kind === 277 ? [p.Remove_type_from_import_of_0_from_1, n, Ake(g.parent.parent)] : [p.Remove_type_from_import_declaration_from_0, Ake(g)]; + } + default: + return E.assertNever(i, `Unexpected fix kind ${i.kind}`); + } + } + function Ake(e) { + var t, n; + return e.kind === 272 ? ((n = Bn((t = Bn(e.moduleReference, wh)) == null ? void 0 : t.expression, ja)) == null ? void 0 : n.text) || e.moduleReference.getText() : Us(e.parent.moduleSpecifier, ca).text; + } + function kHe(e, t, n, i, s) { + const o = n.getCompilerOptions(), c = o.verbatimModuleSyntax; + switch (t.kind) { + case 277: + if (t.isTypeOnly) { + if (t.parent.elements.length > 1) { + const u = N.updateImportSpecifier( + t, + /*isTypeOnly*/ + !1, + t.propertyName, + t.name + ), { specifierComparer: g } = Dv.getNamedImportSpecifierComparerWithDetection(t.parent.parent.parent, s, i), m = Dv.getImportSpecifierInsertionIndex(t.parent.elements, u, g); + if (m !== t.parent.elements.indexOf(t)) + return e.delete(i, t), e.insertImportSpecifierAtIndex(i, u, t.parent, m), t; + } + return e.deleteRange(i, { pos: Ay(t.getFirstToken()), end: Ay(t.propertyName ?? t.name) }), t; + } else + return E.assert(t.parent.parent.isTypeOnly), _(t.parent.parent), t.parent.parent; + case 274: + return _(t), t; + case 275: + return _(t.parent), t.parent; + case 272: + return e.deleteRange(i, t.getChildAt(1)), t; + default: + E.failBadSyntaxKind(t); + } + function _(u) { + var g; + if (e.delete(i, $V(u, i)), !o.allowImportingTsExtensions) { + const m = gx(u.parent), h = m && ((g = n.getResolvedModuleFromModuleSpecifier(m, i)) == null ? void 0 : g.resolvedModule); + if (h?.resolvedUsingTsExtension) { + const S = HP(m.text, TA(m.text, o)); + e.replaceNode(i, m, N.createStringLiteral(S)); + } + } + if (c) { + const m = Bn(u.namedBindings, bm); + if (m && m.elements.length > 1) { + Dv.getNamedImportSpecifierComparerWithDetection(u.parent, s, i).isSorted !== !1 && t.kind === 277 && m.elements.indexOf(t) !== 0 && (e.delete(i, t), e.insertImportSpecifierAtIndex(i, t, m, 0)); + for (const S of m.elements) + S !== t && !S.isTypeOnly && e.insertModifierBefore(i, 156, S); + } + } + } + } + function Ike(e, t, n, i, s, o, c) { + var _; + if (n.kind === 207) { + if (o && n.elements.some((h) => o.has(h))) { + e.replaceNode( + t, + n, + N.createObjectBindingPattern([ + ...n.elements.filter((h) => !o.has(h)), + ...i ? [N.createBindingElement( + /*dotDotDotToken*/ + void 0, + /*propertyName*/ + "default", + i.name + )] : Ge, + ...s.map((h) => N.createBindingElement( + /*dotDotDotToken*/ + void 0, + h.propertyName, + h.name + )) + ]) + ); + return; + } + i && m(n, i.name, "default"); + for (const h of s) + m(n, h.name, h.propertyName); + return; + } + const u = n.isTypeOnly && ot( + [i, ...s], + (h) => h?.addAsTypeOnly === 4 + /* NotAllowed */ + ), g = n.namedBindings && ((_ = Bn(n.namedBindings, bm)) == null ? void 0 : _.elements); + if (i && (E.assert(!n.name, "Cannot add a default import to an import clause that already has one"), e.insertNodeAt(t, n.getStart(t), N.createIdentifier(i.name), { suffix: ", " })), s.length) { + const { specifierComparer: h, isSorted: S } = Dv.getNamedImportSpecifierComparerWithDetection(n.parent, c, t), T = X_( + s.map( + (k) => N.createImportSpecifier( + (!n.isTypeOnly || u) && hH(k, c), + k.propertyName === void 0 ? void 0 : N.createIdentifier(k.propertyName), + N.createIdentifier(k.name) + ) + ), + h + ); + if (o) + e.replaceNode( + t, + n.namedBindings, + N.updateNamedImports( + n.namedBindings, + X_([...g.filter((k) => !o.has(k)), ...T], h) + ) + ); + else if (g?.length && S !== !1) { + const k = u && g ? N.updateNamedImports( + n.namedBindings, + Qc(g, (D) => N.updateImportSpecifier( + D, + /*isTypeOnly*/ + !0, + D.propertyName, + D.name + )) + ).elements : g; + for (const D of T) { + const P = Dv.getImportSpecifierInsertionIndex(k, D, h); + e.insertImportSpecifierAtIndex(t, D, n.namedBindings, P); + } + } else if (g?.length) + for (const k of T) + e.insertNodeInListAfter(t, pa(g), k, g); + else if (T.length) { + const k = N.createNamedImports(T); + n.namedBindings ? e.replaceNode(t, n.namedBindings, k) : e.insertNodeAfter(t, E.checkDefined(n.name, "Import clause must have either named imports or a default import"), k); + } + } + if (u && (e.delete(t, $V(n, t)), g)) + for (const h of g) + e.insertModifierBefore(t, 156, h); + function m(h, S, T) { + const k = N.createBindingElement( + /*dotDotDotToken*/ + void 0, + T, + S + ); + h.elements.length ? e.insertNodeInListAfter(t, pa(h.elements), k) : e.replaceNode(t, h, N.createObjectBindingPattern([k])); + } + } + function rle(e, t, { namespacePrefix: n, usagePosition: i }) { + e.insertText(t, i, n + "."); + } + function Fke(e, t, { moduleSpecifier: n, usagePosition: i }, s) { + e.insertText(t, i, Oke(n, s)); + } + function Oke(e, t) { + const n = qV(t); + return `import(${n}${e}${n}).`; + } + function nle({ addAsTypeOnly: e }) { + return e === 2; + } + function hH(e, t) { + return nle(e) || !!t.preferTypeOnlyAutoImports && e.addAsTypeOnly !== 4; + } + function Lke(e, t, n, i, s, o, c) { + const _ = vw(e, t); + let u; + if (n !== void 0 || i?.length) { + const g = (!n || nle(n)) && Ni(i, nle) || (o.verbatimModuleSyntax || c.preferTypeOnlyAutoImports) && n?.addAsTypeOnly !== 4 && !ot( + i, + (m) => m.addAsTypeOnly === 4 + /* NotAllowed */ + ); + u = GT( + u, + r1( + n && N.createIdentifier(n.name), + i?.map( + (m) => N.createImportSpecifier( + !g && hH(m, c), + m.propertyName === void 0 ? void 0 : N.createIdentifier(m.propertyName), + N.createIdentifier(m.name) + ) + ), + e, + t, + g + ) + ); + } + if (s) { + const g = s.importKind === 3 ? N.createImportEqualsDeclaration( + /*modifiers*/ + void 0, + hH(s, c), + N.createIdentifier(s.name), + N.createExternalModuleReference(_) + ) : N.createImportDeclaration( + /*modifiers*/ + void 0, + N.createImportClause( + hH(s, c) ? 156 : void 0, + /*name*/ + void 0, + N.createNamespaceImport(N.createIdentifier(s.name)) + ), + _, + /*attributes*/ + void 0 + ); + u = GT(u, g); + } + return E.checkDefined(u); + } + function Mke(e, t, n, i, s) { + const o = vw(e, t); + let c; + if (n || i?.length) { + const _ = i?.map(({ name: g, propertyName: m }) => N.createBindingElement( + /*dotDotDotToken*/ + void 0, + m, + g + )) || []; + n && _.unshift(N.createBindingElement( + /*dotDotDotToken*/ + void 0, + "default", + n.name + )); + const u = Rke(N.createObjectBindingPattern(_), o); + c = GT(c, u); + } + if (s) { + const _ = Rke(s.name, o); + c = GT(c, _); + } + return E.checkDefined(c); + } + function Rke(e, t) { + return N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [ + N.createVariableDeclaration( + typeof e == "string" ? N.createIdentifier(e) : e, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + N.createCallExpression( + N.createIdentifier("require"), + /*typeArguments*/ + void 0, + [t] + ) + ) + ], + 2 + /* Const */ + ) + ); + } + function jke(e, t) { + return t === 7 ? !0 : t & 1 ? !!(e & 111551) : t & 2 ? !!(e & 788968) : t & 4 ? !!(e & 1920) : !1; + } + function ile(e, t) { + return Og(e) ? t.getImpliedNodeFormatForEmit(e) : zS(e, t.getCompilerOptions()); + } + function CHe(e, t) { + return Og(e) ? t.getEmitModuleFormatOfFile(e) : uw(e, t.getCompilerOptions()); + } + var sle = "addMissingConstraint", Bke = [ + // We want errors this could be attached to: + // Diagnostics.This_type_parameter_probably_needs_an_extends_0_constraint + p.Type_0_is_not_comparable_to_type_1.code, + p.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated.code, + p.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code, + p.Type_0_is_not_assignable_to_type_1.code, + p.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code, + p.Property_0_is_incompatible_with_index_signature.code, + p.Property_0_in_type_1_is_not_assignable_to_type_2.code, + p.Type_0_does_not_satisfy_the_constraint_1.code + ]; + Qs({ + errorCodes: Bke, + getCodeActions(e) { + const { sourceFile: t, span: n, program: i, preferences: s, host: o } = e, c = Jke(i, t, n); + if (c === void 0) return; + const _ = cn.ChangeTracker.with(e, (u) => zke(u, i, s, o, t, c)); + return [Ls(sle, _, p.Add_extends_constraint, sle, p.Add_extends_constraint_to_all_type_parameters)]; + }, + fixIds: [sle], + getAllCodeActions: (e) => { + const { program: t, preferences: n, host: i } = e, s = /* @__PURE__ */ new Set(); + return yk(cn.ChangeTracker.with(e, (o) => { + vk(e, Bke, (c) => { + const _ = Jke(t, c.file, Kl(c.start, c.length)); + if (_ && Jp(s, Ma(_.declaration))) + return zke(o, t, n, i, c.file, _); + }); + })); + } + }); + function Jke(e, t, n) { + const i = Nn(e.getSemanticDiagnostics(t), (c) => c.start === n.start && c.length === n.length); + if (i === void 0 || i.relatedInformation === void 0) return; + const s = Nn(i.relatedInformation, (c) => c.code === p.This_type_parameter_might_need_an_extends_0_constraint.code); + if (s === void 0 || s.file === void 0 || s.start === void 0 || s.length === void 0) return; + let o = Kle(s.file, Kl(s.start, s.length)); + if (o !== void 0 && (Me(o) && Lo(o.parent) && (o = o.parent), Lo(o))) { + if (CS(o.parent)) return; + const c = vi(t, n.start), _ = e.getTypeChecker(); + return { constraint: DHe(_, c) || EHe(s.messageText), declaration: o, token: c }; + } + } + function zke(e, t, n, i, s, o) { + const { declaration: c, constraint: _ } = o, u = t.getTypeChecker(); + if (gs(_)) + e.insertText(s, c.name.end, ` extends ${_}`); + else { + const g = da(t.getCompilerOptions()), m = iE({ program: t, host: i }), h = d2(s, t, n, i), S = IH( + u, + h, + _, + /*contextNode*/ + void 0, + g, + /*flags*/ + void 0, + /*internalFlags*/ + void 0, + m + ); + S && (e.replaceNode(s, c, N.updateTypeParameterDeclaration( + c, + /*modifiers*/ + void 0, + c.name, + S, + c.default + )), h.writeFixes(e)); + } + } + function EHe(e) { + const [, t] = km(e, ` +`, 0).match(/`extends (.*)`/) || []; + return t; + } + function DHe(e, t) { + return li(t.parent) ? e.getTypeArgumentConstraint(t.parent) : (ut(t) ? e.getContextualType(t) : void 0) || e.getTypeAtLocation(t); + } + var Wke = "fixOverrideModifier", y8 = "fixAddOverrideModifier", bL = "fixRemoveOverrideModifier", Uke = [ + p.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code, + p.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code, + p.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code, + p.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code, + p.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code, + p.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code, + p.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code, + p.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code, + p.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code + ], Vke = { + // case #1: + [p.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code]: { + descriptions: p.Add_override_modifier, + fixId: y8, + fixAllDescriptions: p.Add_all_missing_override_modifiers + }, + [p.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code]: { + descriptions: p.Add_override_modifier, + fixId: y8, + fixAllDescriptions: p.Add_all_missing_override_modifiers + }, + // case #2: + [p.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code]: { + descriptions: p.Remove_override_modifier, + fixId: bL, + fixAllDescriptions: p.Remove_all_unnecessary_override_modifiers + }, + [p.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code]: { + descriptions: p.Remove_override_modifier, + fixId: bL, + fixAllDescriptions: p.Remove_override_modifier + }, + // case #3: + [p.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code]: { + descriptions: p.Add_override_modifier, + fixId: y8, + fixAllDescriptions: p.Add_all_missing_override_modifiers + }, + [p.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code]: { + descriptions: p.Add_override_modifier, + fixId: y8, + fixAllDescriptions: p.Add_all_missing_override_modifiers + }, + // case #4: + [p.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code]: { + descriptions: p.Add_override_modifier, + fixId: y8, + fixAllDescriptions: p.Remove_all_unnecessary_override_modifiers + }, + // case #5: + [p.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code]: { + descriptions: p.Remove_override_modifier, + fixId: bL, + fixAllDescriptions: p.Remove_all_unnecessary_override_modifiers + }, + [p.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code]: { + descriptions: p.Remove_override_modifier, + fixId: bL, + fixAllDescriptions: p.Remove_all_unnecessary_override_modifiers + } + }; + Qs({ + errorCodes: Uke, + getCodeActions: function(t) { + const { errorCode: n, span: i } = t, s = Vke[n]; + if (!s) return Ge; + const { descriptions: o, fixId: c, fixAllDescriptions: _ } = s, u = cn.ChangeTracker.with(t, (g) => qke(g, t, n, i.start)); + return [ + kce(Wke, u, o, c, _) + ]; + }, + fixIds: [Wke, y8, bL], + getAllCodeActions: (e) => Qa(e, Uke, (t, n) => { + const { code: i, start: s } = n, o = Vke[i]; + !o || o.fixId !== e.fixId || qke(t, e, i, s); + }) + }); + function qke(e, t, n, i) { + switch (n) { + case p.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code: + case p.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code: + case p.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code: + case p.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code: + case p.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code: + return wHe(e, t.sourceFile, i); + case p.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code: + case p.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code: + case p.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code: + case p.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code: + return PHe(e, t.sourceFile, i); + default: + E.fail("Unexpected error code: " + n); + } + } + function wHe(e, t, n) { + const i = Gke(t, n); + if (n_(t)) { + e.addJSDocTags(t, i, [N.createJSDocOverrideTag(N.createIdentifier("override"))]); + return; + } + const s = i.modifiers || Ge, o = Nn(s, Wx), c = Nn(s, Ote), _ = Nn(s, (h) => LV(h.kind)), u = gb(s, ul), g = c ? c.end : o ? o.end : _ ? _.end : u ? oa(t.text, u.end) : i.getStart(t), m = _ || o || c ? { prefix: " " } : { suffix: " " }; + e.insertModifierAt(t, g, 164, m); + } + function PHe(e, t, n) { + const i = Gke(t, n); + if (n_(t)) { + e.filterJSDocTags(t, i, KI(FF)); + return; + } + const s = Nn(i.modifiers, Lte); + E.assertIsDefined(s), e.deleteModifier(t, s); + } + function Hke(e) { + switch (e.kind) { + case 177: + case 173: + case 175: + case 178: + case 179: + return !0; + case 170: + return K_(e, e.parent); + default: + return !1; + } + } + function Gke(e, t) { + const n = vi(e, t), i = dr(n, (s) => $n(s) ? "quit" : Hke(s)); + return E.assert(i && Hke(i)), i; + } + var ale = "fixNoPropertyAccessFromIndexSignature", $ke = [ + p.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0.code + ]; + Qs({ + errorCodes: $ke, + fixIds: [ale], + getCodeActions(e) { + const { sourceFile: t, span: n, preferences: i } = e, s = Qke(t, n.start), o = cn.ChangeTracker.with(e, (c) => Xke(c, e.sourceFile, s, i)); + return [Ls(ale, o, [p.Use_element_access_for_0, s.name.text], ale, p.Use_element_access_for_all_undeclared_properties)]; + }, + getAllCodeActions: (e) => Qa(e, $ke, (t, n) => Xke(t, n.file, Qke(n.file, n.start), e.preferences)) + }); + function Xke(e, t, n, i) { + const s = _f(t, i), o = N.createStringLiteral( + n.name.text, + s === 0 + /* Single */ + ); + e.replaceNode( + t, + n, + T7(n) ? N.createElementAccessChain(n.expression, n.questionDotToken, o) : N.createElementAccessExpression(n.expression, o) + ); + } + function Qke(e, t) { + return Us(vi(e, t).parent, wn); + } + var ole = "fixImplicitThis", Yke = [p.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code]; + Qs({ + errorCodes: Yke, + getCodeActions: function(t) { + const { sourceFile: n, program: i, span: s } = t; + let o; + const c = cn.ChangeTracker.with(t, (_) => { + o = Zke(_, n, s.start, i.getTypeChecker()); + }); + return o ? [Ls(ole, c, o, ole, p.Fix_all_implicit_this_errors)] : Ge; + }, + fixIds: [ole], + getAllCodeActions: (e) => Qa(e, Yke, (t, n) => { + Zke(t, n.file, n.start, e.program.getTypeChecker()); + }) + }); + function Zke(e, t, n, i) { + const s = vi(t, n); + if (!V6(s)) return; + const o = qu( + s, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + if (!(!Cc(o) && !yo(o)) && !Di(qu( + o, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ))) { + const c = E.checkDefined(Ya(o, 100, t)), { name: _ } = o, u = E.checkDefined(o.body); + return yo(o) ? _ && ko.Core.isSymbolReferencedInFile(_, i, t, u) ? void 0 : (e.delete(t, c), _ && e.delete(t, _), e.insertText(t, u.pos, " =>"), [p.Convert_function_expression_0_to_arrow_function, _ ? _.text : aq]) : (e.replaceNode(t, c, N.createToken( + 87 + /* ConstKeyword */ + )), e.insertText(t, _.end, " = "), e.insertText(t, u.pos, " =>"), [p.Convert_function_declaration_0_to_arrow_function, _.text]); + } + } + var cle = "fixImportNonExportedMember", Kke = [ + p.Module_0_declares_1_locally_but_it_is_not_exported.code + ]; + Qs({ + errorCodes: Kke, + fixIds: [cle], + getCodeActions(e) { + const { sourceFile: t, span: n, program: i } = e, s = eCe(t, n.start, i); + if (s === void 0) return; + const o = cn.ChangeTracker.with(e, (c) => NHe(c, i, s)); + return [Ls(cle, o, [p.Export_0_from_module_1, s.exportName.node.text, s.moduleSpecifier], cle, p.Export_all_referenced_locals)]; + }, + getAllCodeActions(e) { + const { program: t } = e; + return yk(cn.ChangeTracker.with(e, (n) => { + const i = /* @__PURE__ */ new Map(); + vk(e, Kke, (s) => { + const o = eCe(s.file, s.start, t); + if (o === void 0) return; + const { exportName: c, node: _, moduleSourceFile: u } = o; + if (yH(u, c.isTypeOnly) === void 0 && CN(_)) + n.insertExportModifier(u, _); + else { + const g = i.get(u) || { typeOnlyExports: [], exports: [] }; + c.isTypeOnly ? g.typeOnlyExports.push(c) : g.exports.push(c), i.set(u, g); + } + }), i.forEach((s, o) => { + const c = yH( + o, + /*isTypeOnly*/ + !0 + ); + c && c.isTypeOnly ? (lle(n, t, o, s.typeOnlyExports, c), lle(n, t, o, s.exports, yH( + o, + /*isTypeOnly*/ + !1 + ))) : lle(n, t, o, [...s.exports, ...s.typeOnlyExports], c); + }); + })); + } + }); + function eCe(e, t, n) { + var i, s; + const o = vi(e, t); + if (Me(o)) { + const c = dr(o, qo); + if (c === void 0) return; + const _ = ca(c.moduleSpecifier) ? c.moduleSpecifier : void 0; + if (_ === void 0) return; + const u = (i = n.getResolvedModuleFromModuleSpecifier(_, e)) == null ? void 0 : i.resolvedModule; + if (u === void 0) return; + const g = n.getSourceFile(u.resolvedFileName); + if (g === void 0 || K6(n, g)) return; + const m = g.symbol, h = (s = Bn(m.valueDeclaration, qm)) == null ? void 0 : s.locals; + if (h === void 0) return; + const S = h.get(o.escapedText); + if (S === void 0) return; + const T = AHe(S); + return T === void 0 ? void 0 : { exportName: { node: o, isTypeOnly: Fx(T) }, node: T, moduleSourceFile: g, moduleSpecifier: _.text }; + } + } + function NHe(e, t, { exportName: n, node: i, moduleSourceFile: s }) { + const o = yH(s, n.isTypeOnly); + o ? tCe(e, t, s, o, [n]) : CN(i) ? e.insertExportModifier(s, i) : rCe(e, t, s, [n]); + } + function lle(e, t, n, i, s) { + wr(i) && (s ? tCe(e, t, n, s, i) : rCe(e, t, n, i)); + } + function yH(e, t) { + const n = (i) => Bc(i) && (t && i.isTypeOnly || !i.isTypeOnly); + return gb(e.statements, n); + } + function tCe(e, t, n, i, s) { + const o = i.exportClause && mp(i.exportClause) ? i.exportClause.elements : N.createNodeArray([]), c = !i.isTypeOnly && !!(zp(t.getCompilerOptions()) || Nn(o, (_) => _.isTypeOnly)); + e.replaceNode( + n, + i, + N.updateExportDeclaration( + i, + i.modifiers, + i.isTypeOnly, + N.createNamedExports( + N.createNodeArray( + [...o, ...nCe(s, c)], + /*hasTrailingComma*/ + o.hasTrailingComma + ) + ), + i.moduleSpecifier, + i.attributes + ) + ); + } + function rCe(e, t, n, i) { + e.insertNodeAtEndOfScope(n, n, N.createExportDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + N.createNamedExports(nCe( + i, + /*allowTypeModifier*/ + zp(t.getCompilerOptions()) + )), + /*moduleSpecifier*/ + void 0, + /*attributes*/ + void 0 + )); + } + function nCe(e, t) { + return N.createNodeArray(hr(e, (n) => N.createExportSpecifier( + t && n.isTypeOnly, + /*propertyName*/ + void 0, + n.node + ))); + } + function AHe(e) { + if (e.valueDeclaration === void 0) + return Yc(e.declarations); + const t = e.valueDeclaration, n = ei(t) ? Bn(t.parent.parent, Ic) : void 0; + return n && wr(n.declarationList.declarations) === 1 ? n : t; + } + var ule = "fixIncorrectNamedTupleSyntax", IHe = [ + p.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type.code, + p.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type.code + ]; + Qs({ + errorCodes: IHe, + getCodeActions: function(t) { + const { sourceFile: n, span: i } = t, s = FHe(n, i.start), o = cn.ChangeTracker.with(t, (c) => OHe(c, n, s)); + return [Ls(ule, o, p.Move_labeled_tuple_element_modifiers_to_labels, ule, p.Move_labeled_tuple_element_modifiers_to_labels)]; + }, + fixIds: [ule] + }); + function FHe(e, t) { + const n = vi(e, t); + return dr( + n, + (i) => i.kind === 203 + /* NamedTupleMember */ + ); + } + function OHe(e, t, n) { + if (!n) + return; + let i = n.type, s = !1, o = !1; + for (; i.kind === 191 || i.kind === 192 || i.kind === 197; ) + i.kind === 191 ? s = !0 : i.kind === 192 && (o = !0), i = i.type; + const c = N.updateNamedTupleMember( + n, + n.dotDotDotToken || (o ? N.createToken( + 26 + /* DotDotDotToken */ + ) : void 0), + n.name, + n.questionToken || (s ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0), + i + ); + c !== n && e.replaceNode(t, n, c); + } + var iCe = "fixSpelling", sCe = [ + p.Property_0_does_not_exist_on_type_1_Did_you_mean_2.code, + p.Property_0_may_not_exist_on_type_1_Did_you_mean_2.code, + p.Cannot_find_name_0_Did_you_mean_1.code, + p.Could_not_find_name_0_Did_you_mean_1.code, + p.Cannot_find_namespace_0_Did_you_mean_1.code, + p.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code, + p.Cannot_find_name_0_Did_you_mean_the_static_member_1_0.code, + p._0_has_no_exported_member_named_1_Did_you_mean_2.code, + p.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1.code, + p.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1.code, + // for JSX class components + p.No_overload_matches_this_call.code, + // for JSX FC + p.Type_0_is_not_assignable_to_type_1.code + ]; + Qs({ + errorCodes: sCe, + getCodeActions(e) { + const { sourceFile: t, errorCode: n } = e, i = aCe(t, e.span.start, e, n); + if (!i) return; + const { node: s, suggestedSymbol: o } = i, c = da(e.host.getCompilationSettings()), _ = cn.ChangeTracker.with(e, (u) => oCe(u, t, s, o, c)); + return [Ls("spelling", _, [p.Change_spelling_to_0, cc(o)], iCe, p.Fix_all_detected_spelling_errors)]; + }, + fixIds: [iCe], + getAllCodeActions: (e) => Qa(e, sCe, (t, n) => { + const i = aCe(n.file, n.start, e, n.code), s = da(e.host.getCompilationSettings()); + i && oCe(t, e.sourceFile, i.node, i.suggestedSymbol, s); + }) + }); + function aCe(e, t, n, i) { + const s = vi(e, t), o = s.parent; + if ((i === p.No_overload_matches_this_call.code || i === p.Type_0_is_not_assignable_to_type_1.code) && !Tm(o)) return; + const c = n.program.getTypeChecker(); + let _; + if (wn(o) && o.name === s) { + E.assert(wg(s), "Expected an identifier for spelling (property access)"); + let u = c.getTypeAtLocation(o.expression); + o.flags & 64 && (u = c.getNonNullableType(u)), _ = c.getSuggestedSymbolForNonexistentProperty(s, u); + } else if (_n(o) && o.operatorToken.kind === 103 && o.left === s && Ai(s)) { + const u = c.getTypeAtLocation(o.right); + _ = c.getSuggestedSymbolForNonexistentProperty(s, u); + } else if (s_(o) && o.right === s) { + const u = c.getSymbolAtLocation(o.left); + u && u.flags & 1536 && (_ = c.getSuggestedSymbolForNonexistentModule(o.right, u)); + } else if (Xu(o) && o.name === s) { + E.assertNode(s, Me, "Expected an identifier for spelling (import)"); + const u = dr(s, qo), g = MHe(n, u, e); + g && g.symbol && (_ = c.getSuggestedSymbolForNonexistentModule(s, g.symbol)); + } else if (Tm(o) && o.name === s) { + E.assertNode(s, Me, "Expected an identifier for JSX attribute"); + const u = dr(s, wu), g = c.getContextualTypeForArgumentAtIndex(u, 0); + _ = c.getSuggestedSymbolForNonexistentJSXAttribute(s, g); + } else if (N5(o) && Hc(o) && o.name === s) { + const u = dr(s, $n), g = u ? wd(u) : void 0, m = g ? c.getTypeAtLocation(g) : void 0; + m && (_ = c.getSuggestedSymbolForNonexistentClassMember(Qo(s), m)); + } else { + const u = WS(s), g = Qo(s); + E.assert(g !== void 0, "name should be defined"), _ = c.getSuggestedSymbolForNonexistentSymbol(s, g, LHe(u)); + } + return _ === void 0 ? void 0 : { node: s, suggestedSymbol: _ }; + } + function oCe(e, t, n, i, s) { + const o = cc(i); + if (!R_(o, s) && wn(n.parent)) { + const c = i.valueDeclaration; + c && wl(c) && Ai(c.name) ? e.replaceNode(t, n, N.createIdentifier(o)) : e.replaceNode(t, n.parent, N.createElementAccessExpression(n.parent.expression, N.createStringLiteral(o))); + } else + e.replaceNode(t, n, N.createIdentifier(o)); + } + function LHe(e) { + let t = 0; + return e & 4 && (t |= 1920), e & 2 && (t |= 788968), e & 1 && (t |= 111551), t; + } + function MHe(e, t, n) { + var i; + if (!t || !ja(t.moduleSpecifier)) return; + const s = (i = e.program.getResolvedModuleFromModuleSpecifier(t.moduleSpecifier, n)) == null ? void 0 : i.resolvedModule; + if (s) + return e.program.getSourceFile(s.resolvedFileName); + } + var _le = "returnValueCorrect", fle = "fixAddReturnStatement", ple = "fixRemoveBracesFromArrowFunctionBody", dle = "fixWrapTheBlockWithParen", cCe = [ + p.A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value.code, + p.Type_0_is_not_assignable_to_type_1.code, + p.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code + ]; + Qs({ + errorCodes: cCe, + fixIds: [fle, ple, dle], + getCodeActions: function(t) { + const { program: n, sourceFile: i, span: { start: s }, errorCode: o } = t, c = uCe(n.getTypeChecker(), i, s, o); + if (c) + return c.kind === 0 ? Er( + [jHe(t, c.expression, c.statement)], + xo(c.declaration) ? BHe(t, c.declaration, c.expression, c.commentSource) : void 0 + ) : [JHe(t, c.declaration, c.expression)]; + }, + getAllCodeActions: (e) => Qa(e, cCe, (t, n) => { + const i = uCe(e.program.getTypeChecker(), n.file, n.start, n.code); + if (i) + switch (e.fixId) { + case fle: + _Ce(t, n.file, i.expression, i.statement); + break; + case ple: + if (!xo(i.declaration)) return; + fCe( + t, + n.file, + i.declaration, + i.expression, + i.commentSource + ); + break; + case dle: + if (!xo(i.declaration)) return; + pCe(t, n.file, i.declaration, i.expression); + break; + default: + E.fail(JSON.stringify(e.fixId)); + } + }) + }); + function lCe(e, t, n) { + const i = e.createSymbol(4, t.escapedText); + i.links.type = e.getTypeAtLocation(n); + const s = Bs([i]); + return e.createAnonymousType( + /*symbol*/ + void 0, + s, + [], + [], + [] + ); + } + function mle(e, t, n, i) { + if (!t.body || !Ns(t.body) || wr(t.body.statements) !== 1) return; + const s = Ca(t.body.statements); + if (Al(s) && gle(e, t, e.getTypeAtLocation(s.expression), n, i)) + return { + declaration: t, + kind: 0, + expression: s.expression, + statement: s, + commentSource: s.expression + }; + if (Gy(s) && Al(s.statement)) { + const o = N.createObjectLiteralExpression([N.createPropertyAssignment(s.label, s.statement.expression)]), c = lCe(e, s.label, s.statement.expression); + if (gle(e, t, c, n, i)) + return xo(t) ? { + declaration: t, + kind: 1, + expression: o, + statement: s, + commentSource: s.statement.expression + } : { + declaration: t, + kind: 0, + expression: o, + statement: s, + commentSource: s.statement.expression + }; + } else if (Ns(s) && wr(s.statements) === 1) { + const o = Ca(s.statements); + if (Gy(o) && Al(o.statement)) { + const c = N.createObjectLiteralExpression([N.createPropertyAssignment(o.label, o.statement.expression)]), _ = lCe(e, o.label, o.statement.expression); + if (gle(e, t, _, n, i)) + return { + declaration: t, + kind: 0, + expression: c, + statement: s, + commentSource: o + }; + } + } + } + function gle(e, t, n, i, s) { + if (s) { + const o = e.getSignatureFromDeclaration(t); + if (o) { + Gn( + t, + 1024 + /* Async */ + ) && (n = e.createPromiseType(n)); + const c = e.createSignature( + t, + o.typeParameters, + o.thisParameter, + o.parameters, + n, + /*typePredicate*/ + void 0, + o.minArgumentCount, + o.flags + ); + n = e.createAnonymousType( + /*symbol*/ + void 0, + Bs(), + [c], + [], + [] + ); + } else + n = e.getAnyType(); + } + return e.isTypeAssignableTo(n, i); + } + function uCe(e, t, n, i) { + const s = vi(t, n); + if (!s.parent) return; + const o = dr(s.parent, io); + switch (i) { + case p.A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value.code: + return !o || !o.body || !o.type || !C_(o.type, s) ? void 0 : mle( + e, + o, + e.getTypeFromTypeNode(o.type), + /*isFunctionType*/ + !1 + ); + case p.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code: + if (!o || !Ps(o.parent) || !o.body) return; + const c = o.parent.arguments.indexOf(o); + if (c === -1) return; + const _ = e.getContextualTypeForArgumentAtIndex(o.parent, c); + return _ ? mle( + e, + o, + _, + /*isFunctionType*/ + !0 + ) : void 0; + case p.Type_0_is_not_assignable_to_type_1.code: + if (!Qm(s) || !OD(s.parent) && !Tm(s.parent)) return; + const u = RHe(s.parent); + return !u || !io(u) || !u.body ? void 0 : mle( + e, + u, + e.getTypeAtLocation(s.parent), + /*isFunctionType*/ + !0 + ); + } + } + function RHe(e) { + switch (e.kind) { + case 261: + case 170: + case 209: + case 173: + case 304: + return e.initializer; + case 292: + return e.initializer && (h6(e.initializer) ? e.initializer.expression : void 0); + case 305: + case 172: + case 307: + case 349: + case 342: + return; + } + } + function _Ce(e, t, n, i) { + af(n); + const s = KA(t); + e.replaceNode(t, i, N.createReturnStatement(n), { + leadingTriviaOption: cn.LeadingTriviaOption.Exclude, + trailingTriviaOption: cn.TrailingTriviaOption.Exclude, + suffix: s ? ";" : void 0 + }); + } + function fCe(e, t, n, i, s, o) { + const c = M9(i) ? N.createParenthesizedExpression(i) : i; + af(s), VS(s, c), e.replaceNode(t, n.body, c); + } + function pCe(e, t, n, i) { + e.replaceNode(t, n.body, N.createParenthesizedExpression(i)); + } + function jHe(e, t, n) { + const i = cn.ChangeTracker.with(e, (s) => _Ce(s, e.sourceFile, t, n)); + return Ls(_le, i, p.Add_a_return_statement, fle, p.Add_all_missing_return_statement); + } + function BHe(e, t, n, i) { + const s = cn.ChangeTracker.with(e, (o) => fCe( + o, + e.sourceFile, + t, + n, + i + )); + return Ls(_le, s, p.Remove_braces_from_arrow_function_body, ple, p.Remove_braces_from_all_arrow_function_bodies_with_relevant_issues); + } + function JHe(e, t, n) { + const i = cn.ChangeTracker.with(e, (s) => pCe(s, e.sourceFile, t, n)); + return Ls(_le, i, p.Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal, dle, p.Wrap_all_object_literal_with_parentheses); + } + var Cv = "fixMissingMember", vH = "fixMissingProperties", bH = "fixMissingAttributes", SH = "fixMissingFunctionDeclaration", dCe = [ + p.Property_0_does_not_exist_on_type_1.code, + p.Property_0_does_not_exist_on_type_1_Did_you_mean_2.code, + p.Property_0_is_missing_in_type_1_but_required_in_type_2.code, + p.Type_0_is_missing_the_following_properties_from_type_1_Colon_2.code, + p.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more.code, + p.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code, + p.Cannot_find_name_0.code, + p.Type_0_does_not_satisfy_the_expected_type_1.code + ]; + Qs({ + errorCodes: dCe, + getCodeActions(e) { + const t = e.program.getTypeChecker(), n = mCe(e.sourceFile, e.span.start, e.errorCode, t, e.program); + if (n) { + if (n.kind === 3) { + const i = cn.ChangeTracker.with(e, (s) => CCe(s, e, n)); + return [Ls(vH, i, p.Add_missing_properties, vH, p.Add_all_missing_properties)]; + } + if (n.kind === 4) { + const i = cn.ChangeTracker.with(e, (s) => kCe(s, e, n)); + return [Ls(bH, i, p.Add_missing_attributes, bH, p.Add_all_missing_attributes)]; + } + if (n.kind === 2 || n.kind === 5) { + const i = cn.ChangeTracker.with(e, (s) => xCe(s, e, n)); + return [Ls(SH, i, [p.Add_missing_function_declaration_0, n.token.text], SH, p.Add_all_missing_function_declarations)]; + } + if (n.kind === 1) { + const i = cn.ChangeTracker.with(e, (s) => TCe(s, e.program.getTypeChecker(), n)); + return [Ls(Cv, i, [p.Add_missing_enum_member_0, n.token.text], Cv, p.Add_all_missing_members)]; + } + return Bi(qHe(e, n), zHe(e, n)); + } + }, + fixIds: [Cv, SH, vH, bH], + getAllCodeActions: (e) => { + const { program: t, fixId: n } = e, i = t.getTypeChecker(), s = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Map(); + return yk(cn.ChangeTracker.with(e, (c) => { + vk(e, dCe, (_) => { + const u = mCe(_.file, _.start, _.code, i, e.program); + if (u === void 0) return; + const g = Ma(u.parentDeclaration) + "#" + (u.kind === 3 ? u.identifier || Ma(u.token) : u.token.text); + if (Jp(s, g)) { + if (n === SH && (u.kind === 2 || u.kind === 5)) + xCe(c, e, u); + else if (n === vH && u.kind === 3) + CCe(c, e, u); + else if (n === bH && u.kind === 4) + kCe(c, e, u); + else if (u.kind === 1 && TCe(c, i, u), u.kind === 0) { + const { parentDeclaration: m, token: h } = u, S = eD(o, m, () => []); + S.some((T) => T.token.text === h.text) || S.push(u); + } + } + }), o.forEach((_, u) => { + const g = a_(u) ? void 0 : QHe(u, i); + for (const m of _) { + if (g?.some((A) => { + const O = o.get(A); + return !!O && O.some(({ token: F }) => F.text === m.token.text); + })) continue; + const { parentDeclaration: h, declSourceFile: S, modifierFlags: T, token: k, call: D, isJSFile: P } = m; + if (D && !Ai(k)) + SCe(e, c, D, k, T & 256, h, S); + else if (P && !Vl(h) && !a_(h)) + gCe(c, S, h, k, !!(T & 256)); + else { + const A = yCe(i, h, k); + vCe( + c, + S, + h, + k.text, + A, + T & 256 + /* Static */ + ); + } + } + }); + })); + } + }); + function mCe(e, t, n, i, s) { + var o, c; + const _ = vi(e, t), u = _.parent; + if (n === p.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code) { + if (!(_.kind === 19 && _a(u) && Ps(u.parent))) return; + const k = oc(u.parent.arguments, (O) => O === u); + if (k < 0) return; + const D = i.getResolvedSignature(u.parent); + if (!(D && D.declaration && D.parameters[k])) return; + const P = D.parameters[k].valueDeclaration; + if (!(P && Ii(P) && Me(P.name))) return; + const A = is(i.getUnmatchedProperties( + i.getTypeAtLocation(u), + i.getParameterType(D, k).getNonNullableType(), + /*requireOptionalProperties*/ + !1, + /*matchDiscriminantProperties*/ + !1 + )); + return wr(A) ? { kind: 3, token: P.name, identifier: P.name.text, properties: A, parentDeclaration: u } : void 0; + } + if (_.kind === 19 || m6(u) || Cf(u)) { + const k = (m6(u) || Cf(u)) && u.expression ? u.expression : u; + if (_a(k)) { + const D = m6(u) ? i.getTypeFromTypeNode(u.type) : i.getContextualType(k) || i.getTypeAtLocation(k), P = is(i.getUnmatchedProperties( + i.getTypeAtLocation(u), + D.getNonNullableType(), + /*requireOptionalProperties*/ + !1, + /*matchDiscriminantProperties*/ + !1 + )); + return wr(P) ? { kind: 3, token: u, identifier: void 0, properties: P, parentDeclaration: k, indentation: Cf(k.parent) || BN(k.parent) ? 0 : void 0 } : void 0; + } + } + if (!wg(_)) return; + if (Me(_) && d0(u) && u.initializer && _a(u.initializer)) { + const k = (o = i.getContextualType(_) || i.getTypeAtLocation(_)) == null ? void 0 : o.getNonNullableType(), D = is(i.getUnmatchedProperties( + i.getTypeAtLocation(u.initializer), + k, + /*requireOptionalProperties*/ + !1, + /*matchDiscriminantProperties*/ + !1 + )); + return wr(D) ? { kind: 3, token: _, identifier: _.text, properties: D, parentDeclaration: u.initializer } : void 0; + } + if (Me(_) && wu(_.parent)) { + const k = da(s.getCompilerOptions()), D = GHe(i, k, _.parent); + return wr(D) ? { kind: 4, token: _, attributes: D, parentDeclaration: _.parent } : void 0; + } + if (Me(_)) { + const k = (c = i.getContextualType(_)) == null ? void 0 : c.getNonNullableType(); + if (k && Dn(k) & 16) { + const D = Yc(i.getSignaturesOfType( + k, + 0 + /* Call */ + )); + return D === void 0 ? void 0 : { kind: 5, token: _, signature: D, sourceFile: e, parentDeclaration: ECe(_) }; + } + if (Ps(u) && u.expression === _) + return { kind: 2, token: _, call: u, sourceFile: e, modifierFlags: 0, parentDeclaration: ECe(_) }; + } + if (!wn(u)) return; + const g = zV(i.getTypeAtLocation(u.expression)), m = g.symbol; + if (!m || !m.declarations) return; + if (Me(_) && Ps(u.parent)) { + const k = Nn(m.declarations, jc), D = k?.getSourceFile(); + if (k && D && !K6(s, D)) + return { kind: 2, token: _, call: u.parent, sourceFile: D, modifierFlags: 32, parentDeclaration: k }; + const P = Nn(m.declarations, Di); + if (e.commonJsModuleIndicator) return; + if (P && !K6(s, P)) + return { kind: 2, token: _, call: u.parent, sourceFile: P, modifierFlags: 32, parentDeclaration: P }; + } + const h = Nn(m.declarations, $n); + if (!h && Ai(_)) return; + const S = h || Nn(m.declarations, (k) => Vl(k) || a_(k)); + if (S && !K6(s, S.getSourceFile())) { + const k = !a_(S) && (g.target || g) !== i.getDeclaredTypeOfSymbol(m); + if (k && (Ai(_) || Vl(S))) return; + const D = S.getSourceFile(), P = a_(S) ? 0 : (k ? 256 : 0) | (dq(_.text) ? 2 : 0), A = n_(D), O = Bn(u.parent, Ps); + return { kind: 0, token: _, call: O, modifierFlags: P, parentDeclaration: S, declSourceFile: D, isJSFile: A }; + } + const T = Nn(m.declarations, ov); + if (T && !(g.flags & 1056) && !Ai(_) && !K6(s, T.getSourceFile())) + return { kind: 1, token: _, parentDeclaration: T }; + } + function zHe(e, t) { + return t.isJSFile ? ZT(WHe(e, t)) : UHe(e, t); + } + function WHe(e, { parentDeclaration: t, declSourceFile: n, modifierFlags: i, token: s }) { + if (Vl(t) || a_(t)) + return; + const o = cn.ChangeTracker.with(e, (_) => gCe(_, n, t, s, !!(i & 256))); + if (o.length === 0) + return; + const c = i & 256 ? p.Initialize_static_property_0 : Ai(s) ? p.Declare_a_private_field_named_0 : p.Initialize_property_0_in_the_constructor; + return Ls(Cv, o, [c, s.text], Cv, p.Add_all_missing_members); + } + function gCe(e, t, n, i, s) { + const o = i.text; + if (s) { + if (n.kind === 232) + return; + const c = n.name.getText(), _ = hCe(N.createIdentifier(c), o); + e.insertNodeAfter(t, n, _); + } else if (Ai(i)) { + const c = N.createPropertyDeclaration( + /*modifiers*/ + void 0, + o, + /*questionOrExclamationToken*/ + void 0, + /*type*/ + void 0, + /*initializer*/ + void 0 + ), _ = bCe(n); + _ ? e.insertNodeAfter(t, _, c) : e.insertMemberAtStart(t, n, c); + } else { + const c = Mg(n); + if (!c) + return; + const _ = hCe(N.createThis(), o); + e.insertNodeAtConstructorEnd(t, c, _); + } + } + function hCe(e, t) { + return N.createExpressionStatement(N.createAssignment(N.createPropertyAccessExpression(e, t), Sk())); + } + function UHe(e, { parentDeclaration: t, declSourceFile: n, modifierFlags: i, token: s }) { + const o = s.text, c = i & 256, _ = yCe(e.program.getTypeChecker(), t, s), u = (m) => cn.ChangeTracker.with(e, (h) => vCe(h, n, t, o, _, m)), g = [Ls(Cv, u( + i & 256 + /* Static */ + ), [c ? p.Declare_static_property_0 : p.Declare_property_0, o], Cv, p.Add_all_missing_members)]; + return c || Ai(s) || (i & 2 && g.unshift(jd(Cv, u( + 2 + /* Private */ + ), [p.Declare_private_property_0, o])), g.push(VHe(e, n, t, s.text, _))), g; + } + function yCe(e, t, n) { + let i; + if (n.parent.parent.kind === 227) { + const s = n.parent.parent, o = n.parent === s.left ? s.right : s.left, c = e.getWidenedType(e.getBaseTypeOfLiteralType(e.getTypeAtLocation(o))); + i = e.typeToTypeNode( + c, + t, + 1, + 8 + /* AllowUnresolvedNames */ + ); + } else { + const s = e.getContextualType(n.parent); + i = s ? e.typeToTypeNode( + s, + /*enclosingDeclaration*/ + void 0, + 1, + 8 + /* AllowUnresolvedNames */ + ) : void 0; + } + return i || N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ); + } + function vCe(e, t, n, i, s, o) { + const c = o ? N.createNodeArray(N.createModifiersFromModifierFlags(o)) : void 0, _ = $n(n) ? N.createPropertyDeclaration( + c, + i, + /*questionOrExclamationToken*/ + void 0, + s, + /*initializer*/ + void 0 + ) : N.createPropertySignature( + /*modifiers*/ + void 0, + i, + /*questionToken*/ + void 0, + s + ), u = bCe(n); + u ? e.insertNodeAfter(t, u, _) : e.insertMemberAtStart(t, n, _); + } + function bCe(e) { + let t; + for (const n of e.members) { + if (!os(n)) break; + t = n; + } + return t; + } + function VHe(e, t, n, i, s) { + const o = N.createKeywordTypeNode( + 154 + /* StringKeyword */ + ), c = N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "x", + /*questionToken*/ + void 0, + o, + /*initializer*/ + void 0 + ), _ = N.createIndexSignature( + /*modifiers*/ + void 0, + [c], + s + ), u = cn.ChangeTracker.with(e, (g) => g.insertMemberAtStart(t, n, _)); + return jd(Cv, u, [p.Add_index_signature_for_property_0, i]); + } + function qHe(e, t) { + const { parentDeclaration: n, declSourceFile: i, modifierFlags: s, token: o, call: c } = t; + if (c === void 0) + return; + const _ = o.text, u = (m) => cn.ChangeTracker.with(e, (h) => SCe(e, h, c, o, m, n, i)), g = [Ls(Cv, u( + s & 256 + /* Static */ + ), [s & 256 ? p.Declare_static_method_0 : p.Declare_method_0, _], Cv, p.Add_all_missing_members)]; + return s & 2 && g.unshift(jd(Cv, u( + 2 + /* Private */ + ), [p.Declare_private_method_0, _])), g; + } + function SCe(e, t, n, i, s, o, c) { + const _ = d2(c, e.program, e.preferences, e.host), u = $n(o) ? 175 : 174, g = Hle(u, e, _, n, i, s, o), m = $He(o, n); + m ? t.insertNodeAfter(c, m, g) : t.insertMemberAtStart(c, o, g), _.writeFixes(t); + } + function TCe(e, t, { token: n, parentDeclaration: i }) { + const s = ot(i.members, (u) => { + const g = t.getTypeAtLocation(u); + return !!(g && g.flags & 402653316); + }), o = i.getSourceFile(), c = N.createEnumMember(n, s ? N.createStringLiteral(n.text) : void 0), _ = Do(i.members); + _ ? e.insertNodeInListAfter(o, _, c, i.members) : e.insertMemberAtStart(o, i, c); + } + function xCe(e, t, n) { + const i = _f(t.sourceFile, t.preferences), s = d2(t.sourceFile, t.program, t.preferences, t.host), o = n.kind === 2 ? Hle(263, t, s, n.call, An(n.token), n.modifierFlags, n.parentDeclaration) : AH( + 263, + t, + i, + n.signature, + TL(p.Function_not_implemented.message, i), + n.token, + /*modifiers*/ + void 0, + /*optional*/ + void 0, + /*enclosingDeclaration*/ + void 0, + s + ); + o === void 0 && E.fail("fixMissingFunctionDeclaration codefix got unexpected error."), Cf(n.parentDeclaration) ? e.insertNodeBefore( + n.sourceFile, + n.parentDeclaration, + o, + /*blankLineBetween*/ + !0 + ) : e.insertNodeAtEndOfScope(n.sourceFile, n.parentDeclaration, o), s.writeFixes(e); + } + function kCe(e, t, n) { + const i = d2(t.sourceFile, t.program, t.preferences, t.host), s = _f(t.sourceFile, t.preferences), o = t.program.getTypeChecker(), c = n.parentDeclaration.attributes, _ = ot(c.properties, Qx), u = hr(n.attributes, (h) => { + const S = TH(t, o, i, s, o.getTypeOfSymbol(h), n.parentDeclaration), T = N.createIdentifier(h.name), k = N.createJsxAttribute(T, N.createJsxExpression( + /*dotDotDotToken*/ + void 0, + S + )); + return za(T, k), k; + }), g = N.createJsxAttributes(_ ? [...u, ...c.properties] : [...c.properties, ...u]), m = { prefix: c.pos === c.end ? " " : void 0 }; + e.replaceNode(t.sourceFile, c, g, m), i.writeFixes(e); + } + function CCe(e, t, n) { + const i = d2(t.sourceFile, t.program, t.preferences, t.host), s = _f(t.sourceFile, t.preferences), o = da(t.program.getCompilerOptions()), c = t.program.getTypeChecker(), _ = hr(n.properties, (g) => { + const m = TH(t, c, i, s, c.getTypeOfSymbol(g), n.parentDeclaration); + return N.createPropertyAssignment(XHe(g, o, s, c), m); + }), u = { + leadingTriviaOption: cn.LeadingTriviaOption.Exclude, + trailingTriviaOption: cn.TrailingTriviaOption.Exclude, + indentation: n.indentation + }; + e.replaceNode(t.sourceFile, n.parentDeclaration, N.createObjectLiteralExpression( + [...n.parentDeclaration.properties, ..._], + /*multiLine*/ + !0 + ), u), i.writeFixes(e); + } + function TH(e, t, n, i, s, o) { + if (s.flags & 3) + return Sk(); + if (s.flags & 134217732) + return N.createStringLiteral( + "", + /* isSingleQuote */ + i === 0 + /* Single */ + ); + if (s.flags & 8) + return N.createNumericLiteral(0); + if (s.flags & 64) + return N.createBigIntLiteral("0n"); + if (s.flags & 16) + return N.createFalse(); + if (s.flags & 1056) { + const c = s.symbol.exports ? XI(s.symbol.exports.values()) : s.symbol, _ = s.symbol.parent && s.symbol.parent.flags & 256 ? s.symbol.parent : s.symbol, u = t.symbolToExpression( + _, + 111551, + /*enclosingDeclaration*/ + void 0, + /*flags*/ + 64 + /* UseFullyQualifiedType */ + ); + return c === void 0 || u === void 0 ? N.createNumericLiteral(0) : N.createPropertyAccessExpression(u, t.symbolToString(c)); + } + if (s.flags & 256) + return N.createNumericLiteral(s.value); + if (s.flags & 2048) + return N.createBigIntLiteral(s.value); + if (s.flags & 128) + return N.createStringLiteral( + s.value, + /* isSingleQuote */ + i === 0 + /* Single */ + ); + if (s.flags & 512) + return s === t.getFalseType() || s === t.getFalseType( + /*fresh*/ + !0 + ) ? N.createFalse() : N.createTrue(); + if (s.flags & 65536) + return N.createNull(); + if (s.flags & 1048576) + return Lc(s.types, (_) => TH(e, t, n, i, _, o)) ?? Sk(); + if (t.isArrayLikeType(s)) + return N.createArrayLiteralExpression(); + if (HHe(s)) { + const c = hr(t.getPropertiesOfType(s), (_) => { + const u = TH(e, t, n, i, t.getTypeOfSymbol(_), o); + return N.createPropertyAssignment(_.name, u); + }); + return N.createObjectLiteralExpression( + c, + /*multiLine*/ + !0 + ); + } + if (Dn(s) & 16) { + if (Nn(s.symbol.declarations || Ge, Q_(Zm, cd, rc)) === void 0) return Sk(); + const _ = t.getSignaturesOfType( + s, + 0 + /* Call */ + ); + return _ === void 0 ? Sk() : AH( + 219, + e, + i, + _[0], + TL(p.Function_not_implemented.message, i), + /*name*/ + void 0, + /*modifiers*/ + void 0, + /*optional*/ + void 0, + /*enclosingDeclaration*/ + o, + n + ) ?? Sk(); + } + if (Dn(s) & 1) { + const c = Eh(s.symbol); + if (c === void 0 || Jb(c)) return Sk(); + const _ = Mg(c); + return _ && wr(_.parameters) ? Sk() : N.createNewExpression( + N.createIdentifier(s.symbol.name), + /*typeArguments*/ + void 0, + /*argumentsArray*/ + void 0 + ); + } + return Sk(); + } + function Sk() { + return N.createIdentifier("undefined"); + } + function HHe(e) { + return e.flags & 524288 && (Dn(e) & 128 || e.symbol && Bn(xg(e.symbol.declarations), a_)); + } + function GHe(e, t, n) { + const i = e.getContextualType(n.attributes); + if (i === void 0) return Ge; + const s = i.getProperties(); + if (!wr(s)) return Ge; + const o = /* @__PURE__ */ new Set(); + for (const c of n.attributes.properties) + if (Tm(c) && o.add(S4(c.name)), Qx(c)) { + const _ = e.getTypeAtLocation(c.expression); + for (const u of _.getProperties()) + o.add(u.escapedName); + } + return kn(s, (c) => R_( + c.name, + t, + 1 + /* JSX */ + ) && !(c.flags & 16777216 || uc(c) & 48 || o.has(c.escapedName))); + } + function $He(e, t) { + if (a_(e)) + return; + const n = dr(t, (i) => rc(i) || nc(i)); + return n && n.parent === e ? n : void 0; + } + function XHe(e, t, n, i) { + if (Ng(e)) { + const s = i.symbolToNode( + e, + 111551, + /*enclosingDeclaration*/ + void 0, + /*flags*/ + void 0, + 1 + /* WriteComputedProps */ + ); + if (s && Gs(s)) return s; + } + return kN( + e.name, + t, + n === 0, + /*stringNamed*/ + !1, + /*isMethod*/ + !1 + ); + } + function ECe(e) { + if (dr(e, h6)) { + const t = dr(e.parent, Cf); + if (t) return t; + } + return xr(e); + } + function QHe(e, t) { + const n = []; + for (; e; ) { + const i = Lb(e), s = i && t.getSymbolAtLocation(i.expression); + if (!s) break; + const o = s.flags & 2097152 ? t.getAliasedSymbol(s) : s, c = o.declarations && Nn(o.declarations, $n); + if (!c) break; + n.push(c), e = c; + } + return n; + } + var hle = "addMissingNewOperator", DCe = [p.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new.code]; + Qs({ + errorCodes: DCe, + getCodeActions(e) { + const { sourceFile: t, span: n } = e, i = cn.ChangeTracker.with(e, (s) => wCe(s, t, n)); + return [Ls(hle, i, p.Add_missing_new_operator_to_call, hle, p.Add_missing_new_operator_to_all_calls)]; + }, + fixIds: [hle], + getAllCodeActions: (e) => Qa(e, DCe, (t, n) => wCe(t, e.sourceFile, n)) + }); + function wCe(e, t, n) { + const i = Us(YHe(t, n), Ps), s = N.createNewExpression(i.expression, i.typeArguments, i.arguments); + e.replaceNode(t, i, s); + } + function YHe(e, t) { + let n = vi(e, t.start); + const i = ec(t); + for (; n.end < i; ) + n = n.parent; + return n; + } + var xH = "addMissingParam", kH = "addOptionalParam", PCe = [p.Expected_0_arguments_but_got_1.code]; + Qs({ + errorCodes: PCe, + fixIds: [xH, kH], + getCodeActions(e) { + const t = NCe(e.sourceFile, e.program, e.span.start); + if (t === void 0) return; + const { name: n, declarations: i, newParameters: s, newOptionalParameters: o } = t, c = []; + return wr(s) && Er( + c, + Ls( + xH, + cn.ChangeTracker.with(e, (_) => CH(_, e.program, e.preferences, e.host, i, s)), + [wr(s) > 1 ? p.Add_missing_parameters_to_0 : p.Add_missing_parameter_to_0, n], + xH, + p.Add_all_missing_parameters + ) + ), wr(o) && Er( + c, + Ls( + kH, + cn.ChangeTracker.with(e, (_) => CH(_, e.program, e.preferences, e.host, i, o)), + [wr(o) > 1 ? p.Add_optional_parameters_to_0 : p.Add_optional_parameter_to_0, n], + kH, + p.Add_all_optional_parameters + ) + ), c; + }, + getAllCodeActions: (e) => Qa(e, PCe, (t, n) => { + const i = NCe(e.sourceFile, e.program, n.start); + if (i) { + const { declarations: s, newParameters: o, newOptionalParameters: c } = i; + e.fixId === xH && CH(t, e.program, e.preferences, e.host, s, o), e.fixId === kH && CH(t, e.program, e.preferences, e.host, s, c); + } + }) + }); + function NCe(e, t, n) { + const i = vi(e, n), s = dr(i, Ps); + if (s === void 0 || wr(s.arguments) === 0) + return; + const o = t.getTypeChecker(), c = o.getTypeAtLocation(s.expression), _ = kn(c.symbol.declarations, ACe); + if (_ === void 0) + return; + const u = Do(_); + if (u === void 0 || u.body === void 0 || K6(t, u.getSourceFile())) + return; + const g = ZHe(u); + if (g === void 0) + return; + const m = [], h = [], S = wr(u.parameters), T = wr(s.arguments); + if (S > T) + return; + const k = [u, ...eGe(u, _)]; + for (let D = 0, P = 0, A = 0; D < T; D++) { + const O = s.arguments[D], F = To(O) ? vJ(O) : O, R = o.getWidenedType(o.getBaseTypeOfLiteralType(o.getTypeAtLocation(O))), B = P < S ? u.parameters[P] : void 0; + if (B && o.isTypeAssignableTo(R, o.getTypeAtLocation(B))) { + P++; + continue; + } + const U = F && Me(F) ? F.text : `p${A++}`, $ = KHe(o, R, u); + Er(m, { + pos: D, + declaration: FCe( + U, + $, + /*questionToken*/ + void 0 + ) + }), !rGe(k, P) && Er(h, { + pos: D, + declaration: FCe(U, $, N.createToken( + 58 + /* QuestionToken */ + )) + }); + } + return { + newParameters: m, + newOptionalParameters: h, + name: co(g), + declarations: k + }; + } + function ZHe(e) { + const t = _s(e); + if (t) + return t; + if (ei(e.parent) && Me(e.parent.name) || os(e.parent) || Ii(e.parent)) + return e.parent.name; + } + function KHe(e, t, n) { + return e.typeToTypeNode( + e.getWidenedType(t), + n, + 1, + 8 + /* AllowUnresolvedNames */ + ) ?? N.createKeywordTypeNode( + 159 + /* UnknownKeyword */ + ); + } + function CH(e, t, n, i, s, o) { + const c = da(t.getCompilerOptions()); + lr(s, (_) => { + const u = xr(_), g = d2(u, t, n, i); + wr(_.parameters) ? e.replaceNodeRangeWithNodes( + u, + Ca(_.parameters), + pa(_.parameters), + ICe(g, c, _, o), + { + joiner: ", ", + indentation: 0, + leadingTriviaOption: cn.LeadingTriviaOption.IncludeAll, + trailingTriviaOption: cn.TrailingTriviaOption.Include + } + ) : lr(ICe(g, c, _, o), (m, h) => { + wr(_.parameters) === 0 && h === 0 ? e.insertNodeAt(u, _.parameters.end, m) : e.insertNodeAtEndOfList(u, _.parameters, m); + }), g.writeFixes(e); + }); + } + function ACe(e) { + switch (e.kind) { + case 263: + case 219: + case 175: + case 220: + return !0; + default: + return !1; + } + } + function ICe(e, t, n, i) { + const s = hr(n.parameters, (o) => N.createParameterDeclaration( + o.modifiers, + o.dotDotDotToken, + o.name, + o.questionToken, + o.type, + o.initializer + )); + for (const { pos: o, declaration: c } of i) { + const _ = o > 0 ? s[o - 1] : void 0; + s.splice( + o, + 0, + N.updateParameterDeclaration( + c, + c.modifiers, + c.dotDotDotToken, + c.name, + _ && _.questionToken ? N.createToken( + 58 + /* QuestionToken */ + ) : c.questionToken, + nGe(e, c.type, t), + c.initializer + ) + ); + } + return s; + } + function eGe(e, t) { + const n = []; + for (const i of t) + if (tGe(i)) { + if (wr(i.parameters) === wr(e.parameters)) { + n.push(i); + continue; + } + if (wr(i.parameters) > wr(e.parameters)) + return []; + } + return n; + } + function tGe(e) { + return ACe(e) && e.body === void 0; + } + function FCe(e, t, n) { + return N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + e, + n, + t, + /*initializer*/ + void 0 + ); + } + function rGe(e, t) { + return wr(e) && ot(e, (n) => t < wr(n.parameters) && !!n.parameters[t] && n.parameters[t].questionToken === void 0); + } + function nGe(e, t, n) { + const i = m2(t, n); + return i ? (HS(e, i.symbols), i.typeNode) : t; + } + var iGe = "fixCannotFindModule", yle = "installTypesPackage", OCe = p.Cannot_find_module_0_or_its_corresponding_type_declarations.code, LCe = p.This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed.code, MCe = [ + OCe, + p.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type.code, + LCe + ]; + Qs({ + errorCodes: MCe, + getCodeActions: function(t) { + const { host: n, sourceFile: i, span: { start: s }, errorCode: o } = t, c = o === LCe ? yN(t.program.getCompilerOptions(), i) : jCe(i, s); + if (c === void 0) return; + const _ = BCe(c, n, o); + return _ === void 0 ? [] : [Ls( + iGe, + /*changes*/ + [], + [p.Install_0, _], + yle, + p.Install_all_missing_types_packages, + RCe(i.fileName, _) + )]; + }, + fixIds: [yle], + getAllCodeActions: (e) => Qa(e, MCe, (t, n, i) => { + const s = jCe(n.file, n.start); + if (s !== void 0) + switch (e.fixId) { + case yle: { + const o = BCe(s, e.host, n.code); + o && i.push(RCe(n.file.fileName, o)); + break; + } + default: + E.fail(`Bad fixId: ${e.fixId}`); + } + }) + }); + function RCe(e, t) { + return { type: "install package", file: e, packageName: t }; + } + function jCe(e, t) { + const n = Bn(vi(e, t), ca); + if (!n) return; + const i = n.text, { packageName: s } = pO(i); + return Dl(s) ? void 0 : s; + } + function BCe(e, t, n) { + var i; + return n === OCe ? c6.has(e) ? "@types/node" : void 0 : (i = t.isKnownTypesPackageName) != null && i.call(t, e) ? mO(e) : void 0; + } + var JCe = [ + p.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2.code, + p.Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2.code, + p.Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2_and_3_more.code, + p.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1.code, + p.Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1.code, + p.Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1_and_2_more.code + ], vle = "fixClassDoesntImplementInheritedAbstractMember"; + Qs({ + errorCodes: JCe, + getCodeActions: function(t) { + const { sourceFile: n, span: i } = t, s = cn.ChangeTracker.with(t, (o) => WCe(zCe(n, i.start), n, t, o, t.preferences)); + return s.length === 0 ? void 0 : [Ls(vle, s, p.Implement_inherited_abstract_class, vle, p.Implement_all_inherited_abstract_classes)]; + }, + fixIds: [vle], + getAllCodeActions: function(t) { + const n = /* @__PURE__ */ new Set(); + return Qa(t, JCe, (i, s) => { + const o = zCe(s.file, s.start); + Jp(n, Ma(o)) && WCe(o, t.sourceFile, t, i, t.preferences); + }); + } + }); + function zCe(e, t) { + const n = vi(e, t); + return Us(n.parent, $n); + } + function WCe(e, t, n, i, s) { + const o = wd(e), c = n.program.getTypeChecker(), _ = c.getTypeAtLocation(o), u = c.getPropertiesOfType(_).filter(sGe), g = d2(t, n.program, s, n.host); + qle(e, u, t, n, s, g, (m) => i.insertMemberAtStart(t, e, m)), g.writeFixes(i); + } + function sGe(e) { + const t = h0(Ca(e.getDeclarations())); + return !(t & 2) && !!(t & 64); + } + var ble = "classSuperMustPrecedeThisAccess", UCe = [p.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class.code]; + Qs({ + errorCodes: UCe, + getCodeActions(e) { + const { sourceFile: t, span: n } = e, i = qCe(t, n.start); + if (!i) return; + const { constructor: s, superCall: o } = i, c = cn.ChangeTracker.with(e, (_) => VCe(_, t, s, o)); + return [Ls(ble, c, p.Make_super_call_the_first_statement_in_the_constructor, ble, p.Make_all_super_calls_the_first_statement_in_their_constructor)]; + }, + fixIds: [ble], + getAllCodeActions(e) { + const { sourceFile: t } = e, n = /* @__PURE__ */ new Set(); + return Qa(e, UCe, (i, s) => { + const o = qCe(s.file, s.start); + if (!o) return; + const { constructor: c, superCall: _ } = o; + Jp(n, Ma(c.parent)) && VCe(i, t, c, _); + }); + } + }); + function VCe(e, t, n, i) { + e.insertNodeAtConstructorStart(t, n, i), e.delete(t, i); + } + function qCe(e, t) { + const n = vi(e, t); + if (n.kind !== 110) return; + const i = Af(n), s = HCe(i.body); + return s && !s.expression.arguments.some((o) => wn(o) && o.expression === n) ? { constructor: i, superCall: s } : void 0; + } + function HCe(e) { + return Al(e) && oS(e.expression) ? e : Es(e) ? void 0 : xs(e, HCe); + } + var Sle = "constructorForDerivedNeedSuperCall", GCe = [p.Constructors_for_derived_classes_must_contain_a_super_call.code]; + Qs({ + errorCodes: GCe, + getCodeActions(e) { + const { sourceFile: t, span: n } = e, i = $Ce(t, n.start), s = cn.ChangeTracker.with(e, (o) => XCe(o, t, i)); + return [Ls(Sle, s, p.Add_missing_super_call, Sle, p.Add_all_missing_super_calls)]; + }, + fixIds: [Sle], + getAllCodeActions: (e) => Qa(e, GCe, (t, n) => XCe(t, e.sourceFile, $Ce(n.file, n.start))) + }); + function $Ce(e, t) { + const n = vi(e, t); + return E.assert(nc(n.parent), "token should be at the constructor declaration"), n.parent; + } + function XCe(e, t, n) { + const i = N.createExpressionStatement(N.createCallExpression( + N.createSuper(), + /*typeArguments*/ + void 0, + /*argumentsArray*/ + Ge + )); + e.insertNodeAtConstructorStart(t, n, i); + } + var QCe = "fixEnableJsxFlag", YCe = [p.Cannot_use_JSX_unless_the_jsx_flag_is_provided.code]; + Qs({ + errorCodes: YCe, + getCodeActions: function(t) { + const { configFile: n } = t.program.getCompilerOptions(); + if (n === void 0) + return; + const i = cn.ChangeTracker.with(t, (s) => ZCe(s, n)); + return [ + jd(QCe, i, p.Enable_the_jsx_flag_in_your_configuration_file) + ]; + }, + fixIds: [QCe], + getAllCodeActions: (e) => Qa(e, YCe, (t) => { + const { configFile: n } = e.program.getCompilerOptions(); + n !== void 0 && ZCe(t, n); + }) + }); + function ZCe(e, t) { + Yle(e, t, "jsx", N.createStringLiteral("react")); + } + var Tle = "fixNaNEquality", KCe = [ + p.This_condition_will_always_return_0.code + ]; + Qs({ + errorCodes: KCe, + getCodeActions(e) { + const { sourceFile: t, span: n, program: i } = e, s = e6e(i, t, n); + if (s === void 0) return; + const { suggestion: o, expression: c, arg: _ } = s, u = cn.ChangeTracker.with(e, (g) => t6e(g, t, _, c)); + return [Ls(Tle, u, [p.Use_0, o], Tle, p.Use_Number_isNaN_in_all_conditions)]; + }, + fixIds: [Tle], + getAllCodeActions: (e) => Qa(e, KCe, (t, n) => { + const i = e6e(e.program, n.file, Kl(n.start, n.length)); + i && t6e(t, n.file, i.arg, i.expression); + }) + }); + function e6e(e, t, n) { + const i = Nn(e.getSemanticDiagnostics(t), (c) => c.start === n.start && c.length === n.length); + if (i === void 0 || i.relatedInformation === void 0) return; + const s = Nn(i.relatedInformation, (c) => c.code === p.Did_you_mean_0.code); + if (s === void 0 || s.file === void 0 || s.start === void 0 || s.length === void 0) return; + const o = Kle(s.file, Kl(s.start, s.length)); + if (o !== void 0 && ut(o) && _n(o.parent)) + return { suggestion: aGe(s.messageText), expression: o.parent, arg: o }; + } + function t6e(e, t, n, i) { + const s = N.createCallExpression( + N.createPropertyAccessExpression(N.createIdentifier("Number"), N.createIdentifier("isNaN")), + /*typeArguments*/ + void 0, + [n] + ), o = i.operatorToken.kind; + e.replaceNode( + t, + i, + o === 38 || o === 36 ? N.createPrefixUnaryExpression(54, s) : s + ); + } + function aGe(e) { + const [, t] = km(e, ` +`, 0).match(/'(.*)'/) || []; + return t; + } + Qs({ + errorCodes: [ + p.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher.code, + p.Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher.code, + p.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_node20_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher.code + ], + getCodeActions: function(t) { + const n = t.program.getCompilerOptions(), { configFile: i } = n; + if (i === void 0) + return; + const s = [], o = Hu(n); + if (o >= 5 && o < 99) { + const g = cn.ChangeTracker.with(t, (m) => { + Yle(m, i, "module", N.createStringLiteral("esnext")); + }); + s.push(jd("fixModuleOption", g, [p.Set_the_module_option_in_your_configuration_file_to_0, "esnext"])); + } + const _ = da(n); + if (_ < 4 || _ > 99) { + const g = cn.ChangeTracker.with(t, (m) => { + if (!MD(i)) return; + const S = [["target", N.createStringLiteral("es2017")]]; + o === 1 && S.push(["module", N.createStringLiteral("commonjs")]), Qle(m, i, S); + }); + s.push(jd("fixTargetOption", g, [p.Set_the_target_option_in_your_configuration_file_to_0, "es2017"])); + } + return s.length ? s : void 0; + } + }); + var xle = "fixPropertyAssignment", r6e = [ + p.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern.code + ]; + Qs({ + errorCodes: r6e, + fixIds: [xle], + getCodeActions(e) { + const { sourceFile: t, span: n } = e, i = i6e(t, n.start), s = cn.ChangeTracker.with(e, (o) => n6e(o, e.sourceFile, i)); + return [Ls(xle, s, [p.Change_0_to_1, "=", ":"], xle, [p.Switch_each_misused_0_to_1, "=", ":"])]; + }, + getAllCodeActions: (e) => Qa(e, r6e, (t, n) => n6e(t, n.file, i6e(n.file, n.start))) + }); + function n6e(e, t, n) { + e.replaceNode(t, n, N.createPropertyAssignment(n.name, n.objectAssignmentInitializer)); + } + function i6e(e, t) { + return Us(vi(e, t).parent, gu); + } + var kle = "extendsInterfaceBecomesImplements", s6e = [p.Cannot_extend_an_interface_0_Did_you_mean_implements.code]; + Qs({ + errorCodes: s6e, + getCodeActions(e) { + const { sourceFile: t } = e, n = a6e(t, e.span.start); + if (!n) return; + const { extendsToken: i, heritageClauses: s } = n, o = cn.ChangeTracker.with(e, (c) => o6e(c, t, i, s)); + return [Ls(kle, o, p.Change_extends_to_implements, kle, p.Change_all_extended_interfaces_to_implements)]; + }, + fixIds: [kle], + getAllCodeActions: (e) => Qa(e, s6e, (t, n) => { + const i = a6e(n.file, n.start); + i && o6e(t, n.file, i.extendsToken, i.heritageClauses); + }) + }); + function a6e(e, t) { + const n = vi(e, t), i = Wl(n).heritageClauses, s = i[0].getFirstToken(); + return s.kind === 96 ? { extendsToken: s, heritageClauses: i } : void 0; + } + function o6e(e, t, n, i) { + if (e.replaceNode(t, n, N.createToken( + 119 + /* ImplementsKeyword */ + )), i.length === 2 && i[0].token === 96 && i[1].token === 119) { + const s = i[1].getFirstToken(), o = s.getFullStart(); + e.replaceRange(t, { pos: o, end: o }, N.createToken( + 28 + /* CommaToken */ + )); + const c = t.text; + let _ = s.end; + for (; _ < c.length && im(c.charCodeAt(_)); ) + _++; + e.deleteRange(t, { pos: s.getStart(), end: _ }); + } + } + var Cle = "forgottenThisPropertyAccess", c6e = p.Cannot_find_name_0_Did_you_mean_the_static_member_1_0.code, l6e = [ + p.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code, + p.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression.code, + c6e + ]; + Qs({ + errorCodes: l6e, + getCodeActions(e) { + const { sourceFile: t } = e, n = u6e(t, e.span.start, e.errorCode); + if (!n) + return; + const i = cn.ChangeTracker.with(e, (s) => _6e(s, t, n)); + return [Ls(Cle, i, [p.Add_0_to_unresolved_variable, n.className || "this"], Cle, p.Add_qualifier_to_all_unresolved_variables_matching_a_member_name)]; + }, + fixIds: [Cle], + getAllCodeActions: (e) => Qa(e, l6e, (t, n) => { + const i = u6e(n.file, n.start, n.code); + i && _6e(t, e.sourceFile, i); + }) + }); + function u6e(e, t, n) { + const i = vi(e, t); + if (Me(i) || Ai(i)) + return { node: i, className: n === c6e ? Wl(i).name.text : void 0 }; + } + function _6e(e, t, { node: n, className: i }) { + af(n), e.replaceNode(t, n, N.createPropertyAccessExpression(i ? N.createIdentifier(i) : N.createThis(), n)); + } + var Ele = "fixInvalidJsxCharacters_expression", EH = "fixInvalidJsxCharacters_htmlEntity", f6e = [ + p.Unexpected_token_Did_you_mean_or_gt.code, + p.Unexpected_token_Did_you_mean_or_rbrace.code + ]; + Qs({ + errorCodes: f6e, + fixIds: [Ele, EH], + getCodeActions(e) { + const { sourceFile: t, preferences: n, span: i } = e, s = cn.ChangeTracker.with(e, (c) => Dle( + c, + n, + t, + i.start, + /*useHtmlEntity*/ + !1 + )), o = cn.ChangeTracker.with(e, (c) => Dle( + c, + n, + t, + i.start, + /*useHtmlEntity*/ + !0 + )); + return [ + Ls(Ele, s, p.Wrap_invalid_character_in_an_expression_container, Ele, p.Wrap_all_invalid_characters_in_an_expression_container), + Ls(EH, o, p.Convert_invalid_character_to_its_html_entity_code, EH, p.Convert_all_invalid_characters_to_HTML_entity_code) + ]; + }, + getAllCodeActions(e) { + return Qa(e, f6e, (t, n) => Dle(t, e.preferences, n.file, n.start, e.fixId === EH)); + } + }); + var p6e = { + ">": ">", + "}": "}" + }; + function oGe(e) { + return eo(p6e, e); + } + function Dle(e, t, n, i, s) { + const o = n.getText()[i]; + if (!oGe(o)) + return; + const c = s ? p6e[o] : `{${kw(n, t, o)}}`; + e.replaceRangeWithText(n, { pos: i, end: i + 1 }, c); + } + var DH = "deleteUnmatchedParameter", d6e = "renameUnmatchedParameter", m6e = [ + p.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name.code + ]; + Qs({ + fixIds: [DH, d6e], + errorCodes: m6e, + getCodeActions: function(t) { + const { sourceFile: n, span: i } = t, s = [], o = g6e(n, i.start); + if (o) + return Er(s, cGe(t, o)), Er(s, lGe(t, o)), s; + }, + getAllCodeActions: function(t) { + const n = /* @__PURE__ */ new Map(); + return yk(cn.ChangeTracker.with(t, (i) => { + vk(t, m6e, ({ file: s, start: o }) => { + const c = g6e(s, o); + c && n.set(c.signature, Er(n.get(c.signature), c.jsDocParameterTag)); + }), n.forEach((s, o) => { + if (t.fixId === DH) { + const c = new Set(s); + i.filterJSDocTags(o.getSourceFile(), o, (_) => !c.has(_)); + } + }); + })); + } + }); + function cGe(e, { name: t, jsDocHost: n, jsDocParameterTag: i }) { + const s = cn.ChangeTracker.with(e, (o) => o.filterJSDocTags(e.sourceFile, n, (c) => c !== i)); + return Ls( + DH, + s, + [p.Delete_unused_param_tag_0, t.getText(e.sourceFile)], + DH, + p.Delete_all_unused_param_tags + ); + } + function lGe(e, { name: t, jsDocHost: n, signature: i, jsDocParameterTag: s }) { + if (!wr(i.parameters)) return; + const o = e.sourceFile, c = W1(i), _ = /* @__PURE__ */ new Set(); + for (const h of c) + Lf(h) && Me(h.name) && _.add(h.name.escapedText); + const u = Lc(i.parameters, (h) => Me(h.name) && !_.has(h.name.escapedText) ? h.name.getText(o) : void 0); + if (u === void 0) return; + const g = N.updateJSDocParameterTag( + s, + s.tagName, + N.createIdentifier(u), + s.isBracketed, + s.typeExpression, + s.isNameFirst, + s.comment + ), m = cn.ChangeTracker.with(e, (h) => h.replaceJSDocComment(o, n, hr(c, (S) => S === s ? g : S))); + return jd(d6e, m, [p.Rename_param_tag_name_0_to_1, t.getText(o), u]); + } + function g6e(e, t) { + const n = vi(e, t); + if (n.parent && Lf(n.parent) && Me(n.parent.name)) { + const i = n.parent, s = Fb(i), o = $1(i); + if (s && o) + return { jsDocHost: s, signature: o, name: n.parent.name, jsDocParameterTag: i }; + } + } + var wle = "fixUnreferenceableDecoratorMetadata", uGe = [p.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled.code]; + Qs({ + errorCodes: uGe, + getCodeActions: (e) => { + const t = _Ge(e.sourceFile, e.program, e.span.start); + if (!t) return; + const n = cn.ChangeTracker.with(e, (o) => t.kind === 277 && pGe(o, e.sourceFile, t, e.program)), i = cn.ChangeTracker.with(e, (o) => fGe(o, e.sourceFile, t, e.program)); + let s; + return n.length && (s = Er(s, jd(wle, n, p.Convert_named_imports_to_namespace_import))), i.length && (s = Er(s, jd(wle, i, p.Use_import_type))), s; + }, + fixIds: [wle] + }); + function _Ge(e, t, n) { + const i = Bn(vi(e, n), Me); + if (!i || i.parent.kind !== 184) return; + const o = t.getTypeChecker().getSymbolAtLocation(i); + return Nn(o?.declarations || Ge, Q_(ld, Xu, _l)); + } + function fGe(e, t, n, i) { + if (n.kind === 272) { + e.insertModifierBefore(t, 156, n.name); + return; + } + const s = n.kind === 274 ? n : n.parent.parent; + if (s.name && s.namedBindings) + return; + const o = i.getTypeChecker(); + IK(s, (_) => { + if (eu(_.symbol, o).flags & 111551) return !0; + }) || e.insertModifierBefore(t, 156, s); + } + function pGe(e, t, n, i) { + gk.doChangeNamedToNamespaceOrDefault(t, i, e, n.parent); + } + var SL = "unusedIdentifier", Ple = "unusedIdentifier_prefix", Nle = "unusedIdentifier_delete", wH = "unusedIdentifier_deleteImports", Ale = "unusedIdentifier_infer", h6e = [ + p._0_is_declared_but_its_value_is_never_read.code, + p._0_is_declared_but_never_used.code, + p.Property_0_is_declared_but_its_value_is_never_read.code, + p.All_imports_in_import_declaration_are_unused.code, + p.All_destructured_elements_are_unused.code, + p.All_variables_are_unused.code, + p.All_type_parameters_are_unused.code + ]; + Qs({ + errorCodes: h6e, + getCodeActions(e) { + const { errorCode: t, sourceFile: n, program: i, cancellationToken: s } = e, o = i.getTypeChecker(), c = i.getSourceFiles(), _ = vi(n, e.span.start); + if (Up(_)) + return [Ow(cn.ChangeTracker.with(e, (h) => h.delete(n, _)), p.Remove_template_tag)]; + if (_.kind === 30) { + const h = cn.ChangeTracker.with(e, (S) => v6e(S, n, _)); + return [Ow(h, p.Remove_type_parameters)]; + } + const u = b6e(_); + if (u) { + const h = cn.ChangeTracker.with(e, (S) => S.delete(n, u)); + return [Ls(SL, h, [p.Remove_import_from_0, hee(u)], wH, p.Delete_all_unused_imports)]; + } else if (Ile(_)) { + const h = cn.ChangeTracker.with(e, (S) => PH( + n, + _, + S, + o, + c, + i, + s, + /*isFixAll*/ + !1 + )); + if (h.length) + return [Ls(SL, h, [p.Remove_unused_declaration_for_Colon_0, _.getText(n)], wH, p.Delete_all_unused_imports)]; + } + if (Of(_.parent) || D0(_.parent)) { + if (Ii(_.parent.parent)) { + const h = _.parent.elements, S = [ + h.length > 1 ? p.Remove_unused_declarations_for_Colon_0 : p.Remove_unused_declaration_for_Colon_0, + hr(h, (T) => T.getText(n)).join(", ") + ]; + return [ + Ow(cn.ChangeTracker.with(e, (T) => dGe(T, n, _.parent)), S) + ]; + } + return [ + Ow(cn.ChangeTracker.with(e, (h) => mGe(e, h, n, _.parent)), p.Remove_unused_destructuring_declaration) + ]; + } + if (S6e(n, _)) + return [ + Ow(cn.ChangeTracker.with(e, (h) => T6e(h, n, _.parent)), p.Remove_variable_statement) + ]; + if (Me(_) && Cc(_.parent)) + return [Ow(cn.ChangeTracker.with(e, (h) => E6e(h, n, _.parent)), [p.Remove_unused_declaration_for_Colon_0, _.getText(n)])]; + const g = []; + if (_.kind === 140) { + const h = cn.ChangeTracker.with(e, (T) => y6e(T, n, _)), S = Us(_.parent, xS).typeParameter.name.text; + g.push(Ls(SL, h, [p.Replace_infer_0_with_unknown, S], Ale, p.Replace_all_unused_infer_with_unknown)); + } else { + const h = cn.ChangeTracker.with(e, (S) => PH( + n, + _, + S, + o, + c, + i, + s, + /*isFixAll*/ + !1 + )); + if (h.length) { + const S = Gs(_.parent) ? _.parent : _; + g.push(Ow(h, [p.Remove_unused_declaration_for_Colon_0, S.getText(n)])); + } + } + const m = cn.ChangeTracker.with(e, (h) => x6e(h, t, n, _)); + return m.length && g.push(Ls(SL, m, [p.Prefix_0_with_an_underscore, _.getText(n)], Ple, p.Prefix_all_unused_declarations_with_where_possible)), g; + }, + fixIds: [Ple, Nle, wH, Ale], + getAllCodeActions: (e) => { + const { sourceFile: t, program: n, cancellationToken: i } = e, s = n.getTypeChecker(), o = n.getSourceFiles(); + return Qa(e, h6e, (c, _) => { + const u = vi(t, _.start); + switch (e.fixId) { + case Ple: + x6e(c, _.code, t, u); + break; + case wH: { + const g = b6e(u); + g ? c.delete(t, g) : Ile(u) && PH( + t, + u, + c, + s, + o, + n, + i, + /*isFixAll*/ + !0 + ); + break; + } + case Nle: { + if (u.kind === 140 || Ile(u)) + break; + if (Up(u)) + c.delete(t, u); + else if (u.kind === 30) + v6e(c, t, u); + else if (Of(u.parent)) { + if (u.parent.parent.initializer) + break; + (!Ii(u.parent.parent) || k6e(u.parent.parent, s, o)) && c.delete(t, u.parent.parent); + } else { + if (D0(u.parent.parent) && u.parent.parent.parent.initializer) + break; + S6e(t, u) ? T6e(c, t, u.parent) : Me(u) && Cc(u.parent) ? E6e(c, t, u.parent) : PH( + t, + u, + c, + s, + o, + n, + i, + /*isFixAll*/ + !0 + ); + } + break; + } + case Ale: + u.kind === 140 && y6e(c, t, u); + break; + default: + E.fail(JSON.stringify(e.fixId)); + } + }); + } + }); + function y6e(e, t, n) { + e.replaceNode(t, n.parent, N.createKeywordTypeNode( + 159 + /* UnknownKeyword */ + )); + } + function Ow(e, t) { + return Ls(SL, e, t, Nle, p.Delete_all_unused_declarations); + } + function v6e(e, t, n) { + e.delete(t, E.checkDefined(Us(n.parent, hB).typeParameters, "The type parameter to delete should exist")); + } + function Ile(e) { + return e.kind === 102 || e.kind === 80 && (e.parent.kind === 277 || e.parent.kind === 274); + } + function b6e(e) { + return e.kind === 102 ? Bn(e.parent, qo) : void 0; + } + function S6e(e, t) { + return Ul(t.parent) && Ca(t.parent.getChildren(e)) === t; + } + function T6e(e, t, n) { + e.delete(t, n.parent.kind === 244 ? n.parent : n); + } + function dGe(e, t, n) { + lr(n.elements, (i) => e.delete(t, i)); + } + function mGe(e, t, n, { parent: i }) { + if (ei(i) && i.initializer && Cb(i.initializer)) + if (Ul(i.parent) && wr(i.parent.declarations) > 1) { + const s = i.parent.parent, o = s.getStart(n), c = s.end; + t.delete(n, i), t.insertNodeAt(n, c, i.initializer, { + prefix: Fh(e.host, e.formatContext.options) + n.text.slice(L9(n.text, o - 1), o), + suffix: KA(n) ? ";" : "" + }); + } else + t.replaceNode(n, i.parent, i.initializer); + else + t.delete(n, i); + } + function x6e(e, t, n, i) { + t !== p.Property_0_is_declared_but_its_value_is_never_read.code && (i.kind === 140 && (i = Us(i.parent, xS).typeParameter.name), Me(i) && gGe(i) && (e.replaceNode(n, i, N.createIdentifier(`_${i.text}`)), Ii(i.parent) && wC(i.parent).forEach((s) => { + Me(s.name) && e.replaceNode(n, s.name, N.createIdentifier(`_${s.name.text}`)); + }))); + } + function gGe(e) { + switch (e.parent.kind) { + case 170: + case 169: + return !0; + case 261: + switch (e.parent.parent.parent.kind) { + case 251: + case 250: + return !0; + } + } + return !1; + } + function PH(e, t, n, i, s, o, c, _) { + hGe(t, n, e, i, s, o, c, _), Me(t) && ko.Core.eachSymbolReferenceInFile(t, i, e, (u) => { + wn(u.parent) && u.parent.name === u && (u = u.parent), !_ && SGe(u) && n.delete(e, u.parent.parent); + }); + } + function hGe(e, t, n, i, s, o, c, _) { + const { parent: u } = e; + if (Ii(u)) + yGe(t, n, u, i, s, o, c, _); + else if (!(_ && Me(e) && ko.Core.isSymbolReferencedInFile(e, i, n))) { + const g = ld(u) ? e : Gs(u) ? u.parent : u; + E.assert(g !== n, "should not delete whole source file"), t.delete(n, g); + } + } + function yGe(e, t, n, i, s, o, c, _ = !1) { + if (vGe(i, t, n, s, o, c, _)) + if (n.modifiers && n.modifiers.length > 0 && (!Me(n.name) || ko.Core.isSymbolReferencedInFile(n.name, i, t))) + for (const u of n.modifiers) + Zs(u) && e.deleteModifier(t, u); + else !n.initializer && k6e(n, i, s) && e.delete(t, n); + } + function k6e(e, t, n) { + const i = e.parent.parameters.indexOf(e); + return !ko.Core.someSignatureUsage(e.parent, n, t, (s, o) => !o || o.arguments.length > i); + } + function vGe(e, t, n, i, s, o, c) { + const { parent: _ } = n; + switch (_.kind) { + case 175: + case 177: + const u = _.parameters.indexOf(n), g = rc(_) ? _.name : _, m = ko.Core.getReferencedSymbolsForNode(_.pos, g, s, i, o); + if (m) { + for (const h of m) + for (const S of h.references) + if (S.kind === ko.EntryKind.Node) { + const T = w4(S.node) && Ps(S.node.parent) && S.node.parent.arguments.length > u, k = wn(S.node.parent) && w4(S.node.parent.expression) && Ps(S.node.parent.parent) && S.node.parent.parent.arguments.length > u, D = (rc(S.node.parent) || cd(S.node.parent)) && S.node.parent !== n.parent && S.node.parent.parameters.length > u; + if (T || k || D) return !1; + } + } + return !0; + case 263: + return _.name && bGe(e, t, _.name) ? C6e(_, n, c) : !0; + case 219: + case 220: + return C6e(_, n, c); + case 179: + return !1; + case 178: + return !0; + default: + return E.failBadSyntaxKind(_); + } + } + function bGe(e, t, n) { + return !!ko.Core.eachSymbolReferenceInFile(n, e, t, (i) => Me(i) && Ps(i.parent) && i.parent.arguments.includes(i)); + } + function C6e(e, t, n) { + const i = e.parameters, s = i.indexOf(t); + return E.assert(s !== -1, "The parameter should already be in the list"), n ? i.slice(s + 1).every((o) => Me(o.name) && !o.symbol.isReferenced) : s === i.length - 1; + } + function SGe(e) { + return (_n(e.parent) && e.parent.left === e || (gz(e.parent) || iv(e.parent)) && e.parent.operand === e) && Al(e.parent.parent); + } + function E6e(e, t, n) { + const i = n.symbol.declarations; + if (i) + for (const s of i) + e.delete(t, s); + } + var Fle = "fixUnreachableCode", D6e = [p.Unreachable_code_detected.code]; + Qs({ + errorCodes: D6e, + getCodeActions(e) { + if (e.program.getSyntacticDiagnostics(e.sourceFile, e.cancellationToken).length) return; + const n = cn.ChangeTracker.with(e, (i) => w6e(i, e.sourceFile, e.span.start, e.span.length, e.errorCode)); + return [Ls(Fle, n, p.Remove_unreachable_code, Fle, p.Remove_all_unreachable_code)]; + }, + fixIds: [Fle], + getAllCodeActions: (e) => Qa(e, D6e, (t, n) => w6e(t, n.file, n.start, n.length, n.code)) + }); + function w6e(e, t, n, i, s) { + const o = vi(t, n), c = dr(o, Ti); + if (c.getStart(t) !== o.getStart(t)) { + const u = JSON.stringify({ + statementKind: E.formatSyntaxKind(c.kind), + tokenKind: E.formatSyntaxKind(o.kind), + errorCode: s, + start: n, + length: i + }); + E.fail("Token and statement should start at the same point. " + u); + } + const _ = (Ns(c.parent) ? c.parent : c).parent; + if (!Ns(c.parent) || c === Ca(c.parent.statements)) + switch (_.kind) { + case 246: + if (_.elseStatement) { + if (Ns(c.parent)) + break; + e.replaceNode(t, c, N.createBlock(Ge)); + return; + } + // falls through + case 248: + case 249: + e.delete(t, _); + return; + } + if (Ns(c.parent)) { + const u = n + i, g = E.checkDefined(TGe(MJ(c.parent.statements, c), (m) => m.pos < u), "Some statement should be last"); + e.deleteNodeRange(t, c, g); + } else + e.delete(t, c); + } + function TGe(e, t) { + let n; + for (const i of e) { + if (!t(i)) break; + n = i; + } + return n; + } + var Ole = "fixUnusedLabel", P6e = [p.Unused_label.code]; + Qs({ + errorCodes: P6e, + getCodeActions(e) { + const t = cn.ChangeTracker.with(e, (n) => N6e(n, e.sourceFile, e.span.start)); + return [Ls(Ole, t, p.Remove_unused_label, Ole, p.Remove_all_unused_labels)]; + }, + fixIds: [Ole], + getAllCodeActions: (e) => Qa(e, P6e, (t, n) => N6e(t, n.file, n.start)) + }); + function N6e(e, t, n) { + const i = vi(t, n), s = Us(i.parent, Gy), o = i.getStart(t), c = s.statement.getStart(t), _ = lp(o, c, t) ? c : oa( + t.text, + Ya(s, 59, t).end, + /*stopAfterLineBreak*/ + !0 + ); + e.deleteRange(t, { pos: o, end: _ }); + } + var A6e = "fixJSDocTypes_plain", Lle = "fixJSDocTypes_nullable", I6e = [ + p.JSDoc_types_can_only_be_used_inside_documentation_comments.code, + p._0_at_the_end_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1.code, + p._0_at_the_start_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1.code + ]; + Qs({ + errorCodes: I6e, + getCodeActions(e) { + const { sourceFile: t } = e, n = e.program.getTypeChecker(), i = O6e(t, e.span.start, n); + if (!i) return; + const { typeNode: s, type: o } = i, c = s.getText(t), _ = [u(o, A6e, p.Change_all_jsdoc_style_types_to_TypeScript)]; + return s.kind === 315 && _.push(u(o, Lle, p.Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types)), _; + function u(g, m, h) { + const S = cn.ChangeTracker.with(e, (T) => F6e(T, t, s, g, n)); + return Ls("jdocTypes", S, [p.Change_0_to_1, c, n.typeToString(g)], m, h); + } + }, + fixIds: [A6e, Lle], + getAllCodeActions(e) { + const { fixId: t, program: n, sourceFile: i } = e, s = n.getTypeChecker(); + return Qa(e, I6e, (o, c) => { + const _ = O6e(c.file, c.start, s); + if (!_) return; + const { typeNode: u, type: g } = _, m = u.kind === 315 && t === Lle ? s.getNullableType( + g, + 32768 + /* Undefined */ + ) : g; + F6e(o, i, u, m, s); + }); + } + }); + function F6e(e, t, n, i, s) { + e.replaceNode(t, n, s.typeToTypeNode( + i, + /*enclosingDeclaration*/ + n, + /*flags*/ + void 0 + )); + } + function O6e(e, t, n) { + const i = dr(vi(e, t), xGe), s = i && i.type; + return s && { typeNode: s, type: kGe(n, s) }; + } + function xGe(e) { + switch (e.kind) { + case 235: + case 180: + case 181: + case 263: + case 178: + case 182: + case 201: + case 175: + case 174: + case 170: + case 173: + case 172: + case 179: + case 266: + case 217: + case 261: + return !0; + default: + return !1; + } + } + function kGe(e, t) { + if (v6(t)) { + const n = e.getTypeFromTypeNode(t.type); + return n === e.getNeverType() || n === e.getVoidType() ? n : e.getUnionType( + Er([n, e.getUndefinedType()], t.postfix ? void 0 : e.getNullType()) + ); + } + return e.getTypeFromTypeNode(t); + } + var Mle = "fixMissingCallParentheses", L6e = [ + p.This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead.code + ]; + Qs({ + errorCodes: L6e, + fixIds: [Mle], + getCodeActions(e) { + const { sourceFile: t, span: n } = e, i = R6e(t, n.start); + if (!i) return; + const s = cn.ChangeTracker.with(e, (o) => M6e(o, e.sourceFile, i)); + return [Ls(Mle, s, p.Add_missing_call_parentheses, Mle, p.Add_all_missing_call_parentheses)]; + }, + getAllCodeActions: (e) => Qa(e, L6e, (t, n) => { + const i = R6e(n.file, n.start); + i && M6e(t, n.file, i); + }) + }); + function M6e(e, t, n) { + e.replaceNodeWithText(t, n, `${n.text}()`); + } + function R6e(e, t) { + const n = vi(e, t); + if (wn(n.parent)) { + let i = n.parent; + for (; wn(i.parent); ) + i = i.parent; + return i.name; + } + if (Me(n)) + return n; + } + var j6e = "fixMissingTypeAnnotationOnExports", Rle = "add-annotation", jle = "add-type-assertion", CGe = "extract-expression", B6e = [ + p.Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations.code, + p.Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations.code, + p.At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code, + p.Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code, + p.Parameter_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code, + p.Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code, + p.Expression_type_can_t_be_inferred_with_isolatedDeclarations.code, + p.Binding_elements_can_t_be_exported_directly_with_isolatedDeclarations.code, + p.Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations.code, + p.Computed_properties_must_be_number_or_string_literals_variables_or_dotted_expressions_with_isolatedDeclarations.code, + p.Enum_member_initializers_must_be_computable_without_references_to_external_symbols_with_isolatedDeclarations.code, + p.Extends_clause_can_t_contain_an_expression_with_isolatedDeclarations.code, + p.Objects_that_contain_shorthand_properties_can_t_be_inferred_with_isolatedDeclarations.code, + p.Objects_that_contain_spread_assignments_can_t_be_inferred_with_isolatedDeclarations.code, + p.Arrays_with_spread_elements_can_t_inferred_with_isolatedDeclarations.code, + p.Default_exports_can_t_be_inferred_with_isolatedDeclarations.code, + p.Only_const_arrays_can_be_inferred_with_isolatedDeclarations.code, + p.Assigning_properties_to_functions_without_declaring_them_is_not_supported_with_isolatedDeclarations_Add_an_explicit_declaration_for_the_properties_assigned_to_this_function.code, + p.Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_supported_with_isolatedDeclarations.code, + p.Type_containing_private_name_0_can_t_be_used_with_isolatedDeclarations.code, + p.Add_satisfies_and_a_type_assertion_to_this_expression_satisfies_T_as_T_to_make_the_type_explicit.code + ], EGe = /* @__PURE__ */ new Set([ + 178, + 175, + 173, + 263, + 219, + 220, + 261, + 170, + 278, + 264, + 207, + 208 + /* ArrayBindingPattern */ + ]), J6e = 531469, z6e = 1; + Qs({ + errorCodes: B6e, + fixIds: [j6e], + getCodeActions(e) { + const t = []; + return Lw(Rle, t, e, 0, (n) => n.addTypeAnnotation(e.span)), Lw(Rle, t, e, 1, (n) => n.addTypeAnnotation(e.span)), Lw(Rle, t, e, 2, (n) => n.addTypeAnnotation(e.span)), Lw(jle, t, e, 0, (n) => n.addInlineAssertion(e.span)), Lw(jle, t, e, 1, (n) => n.addInlineAssertion(e.span)), Lw(jle, t, e, 2, (n) => n.addInlineAssertion(e.span)), Lw(CGe, t, e, 0, (n) => n.extractAsVariable(e.span)), t; + }, + getAllCodeActions: (e) => { + const t = W6e(e, 0, (n) => { + vk(e, B6e, (i) => { + n.addTypeAnnotation(i); + }); + }); + return yk(t.textChanges); + } + }); + function Lw(e, t, n, i, s) { + const o = W6e(n, i, s); + o.result && o.textChanges.length && t.push(Ls( + e, + o.textChanges, + o.result, + j6e, + p.Add_all_missing_type_annotations + )); + } + function W6e(e, t, n) { + const i = { typeNode: void 0, mutatedTarget: !1 }, s = cn.ChangeTracker.fromContext(e), o = e.sourceFile, c = e.program, _ = c.getTypeChecker(), u = da(c.getCompilerOptions()), g = d2(e.sourceFile, e.program, e.preferences, e.host), m = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Set(), S = Ky({ + preserveSourceNewlines: !1 + }), T = n({ addTypeAnnotation: k, addInlineAssertion: F, extractAsVariable: R }); + return g.writeFixes(s), { + result: T, + textChanges: s.getChanges() + }; + function k(Se) { + e.cancellationToken.throwIfCancellationRequested(); + const ie = vi(o, Se.start), Ne = B(ie); + if (Ne) + return Cc(Ne) ? D(Ne) : U(Ne); + const Ee = Ye(ie); + if (Ee) + return U(Ee); + } + function D(Se) { + var ie; + if (h?.has(Se)) return; + h?.add(Se); + const Ne = _.getTypeAtLocation(Se), Ee = _.getPropertiesOfType(Ne); + if (!Se.name || Ee.length === 0) return; + const Ce = []; + for (const Bt of Ee) + R_(Bt.name, da(c.getCompilerOptions())) && (Bt.valueDeclaration && ei(Bt.valueDeclaration) || Ce.push(N.createVariableStatement( + [N.createModifier( + 95 + /* ExportKeyword */ + )], + N.createVariableDeclarationList( + [N.createVariableDeclaration( + Bt.name, + /*exclamationToken*/ + void 0, + Z(_.getTypeOfSymbol(Bt), Se), + /*initializer*/ + void 0 + )] + ) + ))); + if (Ce.length === 0) return; + const Ve = []; + (ie = Se.modifiers) != null && ie.some( + (Bt) => Bt.kind === 95 + /* ExportKeyword */ + ) && Ve.push(N.createModifier( + 95 + /* ExportKeyword */ + )), Ve.push(N.createModifier( + 138 + /* DeclareKeyword */ + )); + const St = N.createModuleDeclaration( + Ve, + Se.name, + N.createModuleBlock(Ce), + /*flags*/ + 101441696 + /* ContextFlags */ + ); + return s.insertNodeAfter(o, Se, St), [p.Annotate_types_of_properties_expando_function_in_a_namespace]; + } + function P(Se) { + return !to(Se) && !Ps(Se) && !_a(Se) && !nu(Se); + } + function A(Se, ie) { + return P(Se) && (Se = N.createParenthesizedExpression(Se)), N.createAsExpression(Se, ie); + } + function O(Se, ie) { + return P(Se) && (Se = N.createParenthesizedExpression(Se)), N.createAsExpression(N.createSatisfiesExpression(Se, qa(ie)), ie); + } + function F(Se) { + e.cancellationToken.throwIfCancellationRequested(); + const ie = vi(o, Se.start); + if (B(ie)) return; + const Ee = ne(ie, Se); + if (!Ee || pS(Ee) || pS(Ee.parent)) return; + const Ce = ut(Ee), Ve = gu(Ee); + if (!Ve && Pl(Ee) || dr(Ee, ws) || dr(Ee, Ph) || Ce && (dr(Ee, cf) || dr(Ee, li)) || dp(Ee)) + return; + const St = dr(Ee, ei), Bt = St && _.getTypeAtLocation(St); + if (Bt && Bt.flags & 8192 || !(Ce || Ve)) return; + const { typeNode: tr, mutatedTarget: Nr } = ce(Ee, Bt); + if (!(!tr || Nr)) + return Ve ? s.insertNodeAt( + o, + Ee.end, + A( + qa(Ee.name), + tr + ), + { + prefix: ": " + } + ) : Ce ? s.replaceNode( + o, + Ee, + O( + qa(Ee), + tr + ) + ) : E.assertNever(Ee), [p.Add_satisfies_and_an_inline_type_assertion_with_0, Fe(tr)]; + } + function R(Se) { + e.cancellationToken.throwIfCancellationRequested(); + const ie = vi(o, Se.start), Ne = ne(ie, Se); + if (!Ne || pS(Ne) || pS(Ne.parent) || !ut(Ne)) return; + if (nu(Ne)) + return s.replaceNode( + o, + Ne, + A(Ne, N.createTypeReferenceNode("const")) + ), [p.Mark_array_literal_as_const]; + const Ce = dr(Ne, rl); + if (Ce) { + if (Ce === Ne.parent && to(Ne)) return; + const Ve = N.createUniqueName( + Boe(Ne, o, _, o), + 16 + /* Optimistic */ + ); + let St = Ne, Bt = Ne; + if (dp(St) && (St = ad(St.parent), je(St.parent) ? Bt = St = St.parent : Bt = A( + St, + N.createTypeReferenceNode("const") + )), to(St)) return; + const tr = N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [ + N.createVariableDeclaration( + Ve, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + Bt + ) + ], + 2 + /* Const */ + ) + ), Nr = dr(Ne, Ti); + return s.insertNodeBefore(o, Nr, tr), s.replaceNode( + o, + St, + N.createAsExpression( + N.cloneNode(Ve), + N.createTypeQueryNode( + N.cloneNode(Ve) + ) + ) + ), [p.Extract_to_variable_and_replace_with_0_as_typeof_0, Fe(Ve)]; + } + } + function B(Se) { + const ie = dr(Se, (Ne) => Ti(Ne) ? "quit" : Mx(Ne)); + if (ie && Mx(ie)) { + let Ne = ie; + if (_n(Ne) && (Ne = Ne.left, !Mx(Ne))) + return; + const Ee = _.getTypeAtLocation(Ne.expression); + if (!Ee) return; + const Ce = _.getPropertiesOfType(Ee); + if (ot(Ce, (Ve) => Ve.valueDeclaration === ie || Ve.valueDeclaration === ie.parent)) { + const Ve = Ee.symbol.valueDeclaration; + if (Ve) { + if (zy(Ve) && ei(Ve.parent)) + return Ve.parent; + if (Cc(Ve)) + return Ve; + } + } + } + } + function U(Se) { + if (!m?.has(Se)) + switch (m?.add(Se), Se.kind) { + case 170: + case 173: + case 261: + return Te(Se); + case 220: + case 219: + case 263: + case 175: + case 178: + return $(Se, o); + case 278: + return W(Se); + case 264: + return _e(Se); + case 207: + case 208: + return K(Se); + default: + throw new Error(`Cannot find a fix for the given node ${Se.kind}`); + } + } + function $(Se, ie) { + if (Se.type) + return; + const { typeNode: Ne } = ce(Se); + if (Ne) + return s.tryInsertTypeAnnotation( + ie, + Se, + Ne + ), [p.Add_return_type_0, Fe(Ne)]; + } + function W(Se) { + if (Se.isExportEquals) + return; + const { typeNode: ie } = ce(Se.expression); + if (!ie) return; + const Ne = N.createUniqueName("_default"); + return s.replaceNodeWithNodes(o, Se, [ + N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [N.createVariableDeclaration( + Ne, + /*exclamationToken*/ + void 0, + ie, + Se.expression + )], + 2 + /* Const */ + ) + ), + N.updateExportAssignment(Se, Se?.modifiers, Ne) + ]), [ + p.Extract_default_export_to_variable + ]; + } + function _e(Se) { + var ie, Ne; + const Ee = (ie = Se.heritageClauses) == null ? void 0 : ie.find( + (st) => st.token === 96 + /* ExtendsKeyword */ + ), Ce = Ee?.types[0]; + if (!Ce) + return; + const { typeNode: Ve } = ce(Ce.expression); + if (!Ve) + return; + const St = N.createUniqueName( + Se.name ? Se.name.text + "Base" : "Anonymous", + 16 + /* Optimistic */ + ), Bt = N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [N.createVariableDeclaration( + St, + /*exclamationToken*/ + void 0, + Ve, + Ce.expression + )], + 2 + /* Const */ + ) + ); + s.insertNodeBefore(o, Se, Bt); + const tr = Sy(o.text, Ce.end), Nr = ((Ne = tr?.[tr.length - 1]) == null ? void 0 : Ne.end) ?? Ce.end; + return s.replaceRange( + o, + { + pos: Ce.getFullStart(), + end: Nr + }, + St, + { + prefix: " " + } + ), [p.Extract_base_class_to_variable]; + } + function K(Se) { + var ie; + const Ne = Se.parent, Ee = Se.parent.parent.parent; + if (!Ne.initializer) return; + let Ce; + const Ve = []; + if (Me(Ne.initializer)) + Ce = { expression: { kind: 3, identifier: Ne.initializer } }; + else { + const tr = N.createUniqueName( + "dest", + 16 + /* Optimistic */ + ); + Ce = { expression: { kind: 3, identifier: tr } }, Ve.push(N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [N.createVariableDeclaration( + tr, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + Ne.initializer + )], + 2 + /* Const */ + ) + )); + } + const St = []; + D0(Se) ? V(Se, St, Ce) : ae(Se, St, Ce); + const Bt = /* @__PURE__ */ new Map(); + for (const tr of St) { + if (tr.element.propertyName && Gs(tr.element.propertyName)) { + const st = tr.element.propertyName.expression, Wt = N.getGeneratedNameForNode(st), Jr = N.createVariableDeclaration( + Wt, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + st + ), ui = N.createVariableDeclarationList( + [Jr], + 2 + /* Const */ + ), Ji = N.createVariableStatement( + /*modifiers*/ + void 0, + ui + ); + Ve.push(Ji), Bt.set(st, Wt); + } + const Nr = tr.element.name; + if (D0(Nr)) + V(Nr, St, tr); + else if (Of(Nr)) + ae(Nr, St, tr); + else { + const { typeNode: st } = ce(Nr); + let Wt = se(tr, Bt); + if (tr.element.initializer) { + const ui = (ie = tr.element) == null ? void 0 : ie.propertyName, Ji = N.createUniqueName( + ui && Me(ui) ? ui.text : "temp", + 16 + /* Optimistic */ + ); + Ve.push(N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [N.createVariableDeclaration( + Ji, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + Wt + )], + 2 + /* Const */ + ) + )), Wt = N.createConditionalExpression( + N.createBinaryExpression( + Ji, + N.createToken( + 37 + /* EqualsEqualsEqualsToken */ + ), + N.createIdentifier("undefined") + ), + N.createToken( + 58 + /* QuestionToken */ + ), + tr.element.initializer, + N.createToken( + 59 + /* ColonToken */ + ), + Wt + ); + } + const Jr = Gn( + Ee, + 32 + /* Export */ + ) ? [N.createToken( + 95 + /* ExportKeyword */ + )] : void 0; + Ve.push(N.createVariableStatement( + Jr, + N.createVariableDeclarationList( + [N.createVariableDeclaration( + Nr, + /*exclamationToken*/ + void 0, + st, + Wt + )], + 2 + /* Const */ + ) + )); + } + } + return Ee.declarationList.declarations.length > 1 && Ve.push(N.updateVariableStatement( + Ee, + Ee.modifiers, + N.updateVariableDeclarationList( + Ee.declarationList, + Ee.declarationList.declarations.filter((tr) => tr !== Se.parent) + ) + )), s.replaceNodeWithNodes(o, Ee, Ve), [ + p.Extract_binding_expressions_to_variable + ]; + } + function V(Se, ie, Ne) { + for (let Ee = 0; Ee < Se.elements.length; ++Ee) { + const Ce = Se.elements[Ee]; + vl(Ce) || ie.push({ + element: Ce, + parent: Ne, + expression: { kind: 2, arrayIndex: Ee } + }); + } + } + function ae(Se, ie, Ne) { + for (const Ee of Se.elements) { + let Ce; + if (Ee.propertyName) + if (Gs(Ee.propertyName)) { + ie.push({ + element: Ee, + parent: Ne, + expression: { kind: 1, computed: Ee.propertyName.expression } + }); + continue; + } else + Ce = Ee.propertyName.text; + else + Ce = Ee.name.text; + ie.push({ + element: Ee, + parent: Ne, + expression: { kind: 0, text: Ce } + }); + } + } + function se(Se, ie) { + const Ne = [Se]; + for (; Se.parent; ) + Se = Se.parent, Ne.push(Se); + let Ee = Ne[Ne.length - 1].expression.identifier; + for (let Ce = Ne.length - 2; Ce >= 0; --Ce) { + const Ve = Ne[Ce].expression; + Ve.kind === 0 ? Ee = N.createPropertyAccessChain( + Ee, + /*questionDotToken*/ + void 0, + N.createIdentifier(Ve.text) + ) : Ve.kind === 1 ? Ee = N.createElementAccessExpression( + Ee, + ie.get(Ve.computed) + ) : Ve.kind === 2 && (Ee = N.createElementAccessExpression( + Ee, + Ve.arrayIndex + )); + } + return Ee; + } + function ce(Se, ie) { + if (t === 1) + return me(Se); + let Ne; + if (pS(Se)) { + const Ve = _.getSignatureFromDeclaration(Se); + if (Ve) { + const St = _.getTypePredicateOfSignature(Ve); + if (St) + return St.type ? { + typeNode: pe(St, dr(Se, Pl) ?? o, Ce(St.type)), + mutatedTarget: !1 + } : i; + Ne = _.getReturnTypeOfSignature(Ve); + } + } else + Ne = _.getTypeAtLocation(Se); + if (!Ne) + return i; + if (t === 2) { + ie && (Ne = ie); + const Ve = _.getWidenedLiteralType(Ne); + if (_.isTypeAssignableTo(Ve, Ne)) + return i; + Ne = Ve; + } + const Ee = dr(Se, Pl) ?? o; + return Ii(Se) && _.requiresAddingImplicitUndefined(Se, Ee) && (Ne = _.getUnionType( + [_.getUndefinedType(), Ne], + 0 + /* None */ + )), { + typeNode: Z(Ne, Ee, Ce(Ne)), + mutatedTarget: !1 + }; + function Ce(Ve) { + return (ei(Se) || os(Se) && Gn( + Se, + 264 + /* Readonly */ + )) && Ve.flags & 8192 ? 1048576 : 0; + } + } + function fe(Se) { + return N.createTypeQueryNode(qa(Se)); + } + function he(Se, ie = "temp") { + const Ne = !!dr(Se, je); + return Ne ? be( + Se, + ie, + Ne, + (Ee) => Ee.elements, + dp, + N.createSpreadElement, + (Ee) => N.createArrayLiteralExpression( + Ee, + /*multiLine*/ + !0 + ), + (Ee) => N.createTupleTypeNode(Ee.map(N.createRestTypeNode)) + ) : i; + } + function q(Se, ie = "temp") { + const Ne = !!dr(Se, je); + return be( + Se, + ie, + Ne, + (Ee) => Ee.properties, + Vg, + N.createSpreadAssignment, + (Ee) => N.createObjectLiteralExpression( + Ee, + /*multiLine*/ + !0 + ), + N.createIntersectionTypeNode + ); + } + function be(Se, ie, Ne, Ee, Ce, Ve, St, Bt) { + const tr = [], Nr = []; + let st; + const Wt = dr(Se, Ti); + for (const Ji of Ee(Se)) + Ce(Ji) ? (ui(), to(Ji.expression) ? (tr.push(fe(Ji.expression)), Nr.push(Ji)) : Jr(Ji.expression)) : (st ?? (st = [])).push(Ji); + if (Nr.length === 0) + return i; + return ui(), s.replaceNode(o, Se, St(Nr)), { + typeNode: Bt(tr), + mutatedTarget: !0 + }; + function Jr(Ji) { + const Dt = N.createUniqueName( + ie + "_Part" + (Nr.length + 1), + 16 + /* Optimistic */ + ), Mn = Ne ? N.createAsExpression( + Ji, + N.createTypeReferenceNode("const") + ) : Ji, ai = N.createVariableStatement( + /*modifiers*/ + void 0, + N.createVariableDeclarationList( + [ + N.createVariableDeclaration( + Dt, + /*exclamationToken*/ + void 0, + /*type*/ + void 0, + Mn + ) + ], + 2 + /* Const */ + ) + ); + s.insertNodeBefore(o, Wt, ai), tr.push(fe(Dt)), Nr.push(Ve(Dt)); + } + function ui() { + st && (Jr(St( + st + )), st = void 0); + } + } + function je(Se) { + return Eb(Se) && nd(Se.type); + } + function me(Se) { + if (Ii(Se)) + return i; + if (gu(Se)) + return { + typeNode: fe(Se.name), + mutatedTarget: !1 + }; + if (to(Se)) + return { + typeNode: fe(Se), + mutatedTarget: !1 + }; + if (je(Se)) + return me(Se.expression); + if (nu(Se)) { + const ie = dr(Se, ei), Ne = ie && Me(ie.name) ? ie.name.text : void 0; + return he(Se, Ne); + } + if (_a(Se)) { + const ie = dr(Se, ei), Ne = ie && Me(ie.name) ? ie.name.text : void 0; + return q(Se, Ne); + } + if (ei(Se) && Se.initializer) + return me(Se.initializer); + if (ES(Se)) { + const { typeNode: ie, mutatedTarget: Ne } = me(Se.whenTrue); + if (!ie) return i; + const { typeNode: Ee, mutatedTarget: Ce } = me(Se.whenFalse); + return Ee ? { + typeNode: N.createUnionTypeNode([ie, Ee]), + mutatedTarget: Ne || Ce + } : i; + } + return i; + } + function Z(Se, ie, Ne = 0) { + let Ee = !1; + const Ce = uEe(_, Se, ie, J6e | Ne, z6e, { + moduleResolverHost: c, + trackSymbol() { + return !0; + }, + reportTruncationError() { + Ee = !0; + } + }); + if (!Ce) + return; + const Ve = Gle(Ce, g, u); + return Ee ? N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ) : Ve; + } + function pe(Se, ie, Ne = 0) { + let Ee = !1; + const Ce = _Ee(_, g, Se, ie, u, J6e | Ne, z6e, { + moduleResolverHost: c, + trackSymbol() { + return !0; + }, + reportTruncationError() { + Ee = !0; + } + }); + return Ee ? N.createKeywordTypeNode( + 133 + /* AnyKeyword */ + ) : Ce; + } + function Te(Se) { + const { typeNode: ie } = ce(Se); + if (ie) + return Se.type ? s.replaceNode(xr(Se), Se.type, ie) : s.tryInsertTypeAnnotation(xr(Se), Se, ie), [p.Add_annotation_of_type_0, Fe(ie)]; + } + function Fe(Se) { + un( + Se, + 1 + /* SingleLine */ + ); + const ie = S.printNode(4, Se, o); + return ie.length > ND ? ie.substring(0, ND - 3) + "..." : (un( + Se, + 0 + /* None */ + ), ie); + } + function Ye(Se) { + return dr(Se, (ie) => EGe.has(ie.kind) && (!Of(ie) && !D0(ie) || ei(ie.parent))); + } + function ne(Se, ie) { + for (; Se && Se.end < ie.start + ie.length; ) + Se = Se.parent; + for (; Se.parent.pos === Se.pos && Se.parent.end === Se.end; ) + Se = Se.parent; + return Me(Se) && d0(Se.parent) && Se.parent.initializer ? Se.parent.initializer : Se; + } + } + var Ble = "fixAwaitInSyncFunction", U6e = [ + p.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code, + p.await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code, + p.for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code, + p.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function.code + ]; + Qs({ + errorCodes: U6e, + getCodeActions(e) { + const { sourceFile: t, span: n } = e, i = V6e(t, n.start); + if (!i) return; + const s = cn.ChangeTracker.with(e, (o) => q6e(o, t, i)); + return [Ls(Ble, s, p.Add_async_modifier_to_containing_function, Ble, p.Add_all_missing_async_modifiers)]; + }, + fixIds: [Ble], + getAllCodeActions: function(t) { + const n = /* @__PURE__ */ new Set(); + return Qa(t, U6e, (i, s) => { + const o = V6e(s.file, s.start); + !o || !Jp(n, Ma(o.insertBefore)) || q6e(i, t.sourceFile, o); + }); + } + }); + function DGe(e) { + if (e.type) + return e.type; + if (ei(e.parent) && e.parent.type && Zm(e.parent.type)) + return e.parent.type.type; + } + function V6e(e, t) { + const n = vi(e, t), i = Af(n); + if (!i) + return; + let s; + switch (i.kind) { + case 175: + s = i.name; + break; + case 263: + case 219: + s = Ya(i, 100, e); + break; + case 220: + const o = i.typeParameters ? 30 : 21; + s = Ya(i, o, e) || Ca(i.parameters); + break; + default: + return; + } + return s && { + insertBefore: s, + returnType: DGe(i) + }; + } + function q6e(e, t, { insertBefore: n, returnType: i }) { + if (i) { + const s = I3(i); + (!s || s.kind !== 80 || s.text !== "Promise") && e.replaceNode(t, i, N.createTypeReferenceNode("Promise", N.createNodeArray([i]))); + } + e.insertModifierBefore(t, 134, n); + } + var H6e = [ + p._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property.code, + p._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor.code + ], Jle = "fixPropertyOverrideAccessor"; + Qs({ + errorCodes: H6e, + getCodeActions(e) { + const t = G6e(e.sourceFile, e.span.start, e.span.length, e.errorCode, e); + if (t) + return [Ls(Jle, t, p.Generate_get_and_set_accessors, Jle, p.Generate_get_and_set_accessors_for_all_overriding_properties)]; + }, + fixIds: [Jle], + getAllCodeActions: (e) => Qa(e, H6e, (t, n) => { + const i = G6e(n.file, n.start, n.length, n.code, e); + if (i) + for (const s of i) + t.pushRaw(e.sourceFile, s); + }) + }); + function G6e(e, t, n, i, s) { + let o, c; + if (i === p._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property.code) + o = t, c = t + n; + else if (i === p._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor.code) { + const _ = s.program.getTypeChecker(), u = vi(e, t).parent; + if (Gs(u)) + return; + E.assert(Dy(u), "error span of fixPropertyOverrideAccessor should only be on an accessor"); + const g = u.parent; + E.assert($n(g), "erroneous accessors should only be inside classes"); + const m = wd(g); + if (!m) return; + const h = Ba(m.expression), S = Rc(h) ? h.symbol : _.getSymbolAtLocation(h); + if (!S) return; + const T = _.getDeclaredTypeOfSymbol(S), k = _.getPropertyOfType(T, Si(dx(u.name))); + if (!k || !k.valueDeclaration) return; + o = k.valueDeclaration.pos, c = k.valueDeclaration.end, e = xr(k.valueDeclaration); + } else + E.fail("fixPropertyOverrideAccessor codefix got unexpected error code " + i); + return gEe(e, s.program, o, c, s, p.Generate_get_and_set_accessors.message); + } + var zle = "inferFromUsage", $6e = [ + // Variable declarations + p.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code, + // Variable uses + p.Variable_0_implicitly_has_an_1_type.code, + // Parameter declarations + p.Parameter_0_implicitly_has_an_1_type.code, + p.Rest_parameter_0_implicitly_has_an_any_type.code, + // Get Accessor declarations + p.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation.code, + p._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type.code, + // Set Accessor declarations + p.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation.code, + // Property declarations + p.Member_0_implicitly_has_an_1_type.code, + //// Suggestions + // Variable declarations + p.Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage.code, + // Variable uses + p.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code, + // Parameter declarations + p.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code, + p.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage.code, + // Get Accessor declarations + p.Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage.code, + p._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage.code, + // Set Accessor declarations + p.Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage.code, + // Property declarations + p.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code, + // Function expressions and declarations + p.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code + ]; + Qs({ + errorCodes: $6e, + getCodeActions(e) { + const { sourceFile: t, program: n, span: { start: i }, errorCode: s, cancellationToken: o, host: c, preferences: _ } = e, u = vi(t, i); + let g; + const m = cn.ChangeTracker.with(e, (S) => { + g = X6e( + S, + t, + u, + s, + n, + o, + /*markSeen*/ + yb, + c, + _ + ); + }), h = g && _s(g); + return !h || m.length === 0 ? void 0 : [Ls(zle, m, [wGe(s, u), Qo(h)], zle, p.Infer_all_types_from_usage)]; + }, + fixIds: [zle], + getAllCodeActions(e) { + const { sourceFile: t, program: n, cancellationToken: i, host: s, preferences: o } = e, c = G6(); + return Qa(e, $6e, (_, u) => { + X6e(_, t, vi(u.file, u.start), u.code, n, i, c, s, o); + }); + } + }); + function wGe(e, t) { + switch (e) { + case p.Parameter_0_implicitly_has_an_1_type.code: + case p.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code: + return z_(Af(t)) ? p.Infer_type_of_0_from_usage : p.Infer_parameter_types_from_usage; + // TODO: GH#18217 + case p.Rest_parameter_0_implicitly_has_an_any_type.code: + case p.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage.code: + return p.Infer_parameter_types_from_usage; + case p.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code: + return p.Infer_this_type_of_0_from_usage; + default: + return p.Infer_type_of_0_from_usage; + } + } + function PGe(e) { + switch (e) { + case p.Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage.code: + return p.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code; + case p.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code: + return p.Variable_0_implicitly_has_an_1_type.code; + case p.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code: + return p.Parameter_0_implicitly_has_an_1_type.code; + case p.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage.code: + return p.Rest_parameter_0_implicitly_has_an_any_type.code; + case p.Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage.code: + return p.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation.code; + case p._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage.code: + return p._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type.code; + case p.Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage.code: + return p.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation.code; + case p.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code: + return p.Member_0_implicitly_has_an_1_type.code; + } + return e; + } + function X6e(e, t, n, i, s, o, c, _, u) { + if (!ED(n.kind) && n.kind !== 80 && n.kind !== 26 && n.kind !== 110) + return; + const { parent: g } = n, m = d2(t, s, u, _); + switch (i = PGe(i), i) { + // Variable and Property declarations + case p.Member_0_implicitly_has_an_1_type.code: + case p.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code: + if (ei(g) && c(g) || os(g) || $u(g)) + return Q6e(e, m, t, g, s, _, o), m.writeFixes(e), g; + if (wn(g)) { + const T = v8(g.name, s, o), k = Cw(T, g, s, _); + if (k) { + const D = N.createJSDocTypeTag( + /*tagName*/ + void 0, + N.createJSDocTypeExpression(k), + /*comment*/ + void 0 + ); + e.addJSDocTags(t, Us(g.parent.parent, Al), [D]); + } + return m.writeFixes(e), g; + } + return; + case p.Variable_0_implicitly_has_an_1_type.code: { + const T = s.getTypeChecker().getSymbolAtLocation(n); + return T && T.valueDeclaration && ei(T.valueDeclaration) && c(T.valueDeclaration) ? (Q6e(e, m, xr(T.valueDeclaration), T.valueDeclaration, s, _, o), m.writeFixes(e), T.valueDeclaration) : void 0; + } + } + const h = Af(n); + if (h === void 0) + return; + let S; + switch (i) { + // Parameter declarations + case p.Parameter_0_implicitly_has_an_1_type.code: + if (z_(h)) { + Y6e(e, m, t, h, s, _, o), S = h; + break; + } + // falls through + case p.Rest_parameter_0_implicitly_has_an_any_type.code: + if (c(h)) { + const T = Us(g, Ii); + NGe(e, m, t, T, h, s, _, o), S = T; + } + break; + // Get Accessor declarations + case p.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation.code: + case p._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type.code: + pp(h) && Me(h.name) && (NH(e, m, t, h, v8(h.name, s, o), s, _), S = h); + break; + // Set Accessor declarations + case p.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation.code: + z_(h) && (Y6e(e, m, t, h, s, _, o), S = h); + break; + // Function 'this' + case p.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code: + cn.isThisTypeAnnotatable(h) && c(h) && (AGe(e, t, h, s, _, o), S = h); + break; + default: + return E.fail(String(i)); + } + return m.writeFixes(e), S; + } + function Q6e(e, t, n, i, s, o, c) { + Me(i.name) && NH(e, t, n, i, v8(i.name, s, c), s, o); + } + function NGe(e, t, n, i, s, o, c, _) { + if (!Me(i.name)) + return; + const u = OGe(s, n, o, _); + if (E.assert(s.parameters.length === u.length, "Parameter count and inference count should match"), an(s)) + Z6e(e, n, u, o, c); + else { + const g = xo(s) && !Ya(s, 21, n); + g && e.insertNodeBefore(n, Ca(s.parameters), N.createToken( + 21 + /* OpenParenToken */ + )); + for (const { declaration: m, type: h } of u) + m && !m.type && !m.initializer && NH(e, t, n, m, h, o, c); + g && e.insertNodeAfter(n, pa(s.parameters), N.createToken( + 22 + /* CloseParenToken */ + )); + } + } + function AGe(e, t, n, i, s, o) { + const c = K6e(n, t, i, o); + if (!c || !c.length) + return; + const _ = Ule(i, c, o).thisParameter(), u = Cw(_, n, i, s); + u && (an(n) ? IGe(e, t, n, u) : e.tryInsertThisTypeAnnotation(t, n, u)); + } + function IGe(e, t, n, i) { + e.addJSDocTags(t, n, [ + N.createJSDocThisTag( + /*tagName*/ + void 0, + N.createJSDocTypeExpression(i) + ) + ]); + } + function Y6e(e, t, n, i, s, o, c) { + const _ = Yc(i.parameters); + if (_ && Me(i.name) && Me(_.name)) { + let u = v8(i.name, s, c); + u === s.getTypeChecker().getAnyType() && (u = v8(_.name, s, c)), an(i) ? Z6e(e, n, [{ declaration: _, type: u }], s, o) : NH(e, t, n, _, u, s, o); + } + } + function NH(e, t, n, i, s, o, c) { + const _ = Cw(s, i, o, c); + if (_) + if (an(n) && i.kind !== 172) { + const u = ei(i) ? Bn(i.parent.parent, Ic) : i; + if (!u) + return; + const g = N.createJSDocTypeExpression(_), m = pp(i) ? N.createJSDocReturnTag( + /*tagName*/ + void 0, + g, + /*comment*/ + void 0 + ) : N.createJSDocTypeTag( + /*tagName*/ + void 0, + g, + /*comment*/ + void 0 + ); + e.addJSDocTags(n, u, [m]); + } else FGe(_, i, n, e, t, da(o.getCompilerOptions())) || e.tryInsertTypeAnnotation(n, i, _); + } + function FGe(e, t, n, i, s, o) { + const c = m2(e, o); + return c && i.tryInsertTypeAnnotation(n, t, c.typeNode) ? (lr(c.symbols, (_) => s.addImportFromExportedSymbol( + _, + /*isValidTypeOnlyUseSite*/ + !0 + )), !0) : !1; + } + function Z6e(e, t, n, i, s) { + const o = n.length && n[0].declaration.parent; + if (!o) + return; + const c = Fi(n, (_) => { + const u = _.declaration; + if (u.initializer || f0(u) || !Me(u.name)) + return; + const g = _.type && Cw(_.type, u, i, s); + if (g) { + const m = N.cloneNode(u.name); + return un( + m, + 7168 + /* NoNestedComments */ + ), { name: N.cloneNode(u.name), param: u, isOptional: !!_.isOptional, typeNode: g }; + } + }); + if (c.length) + if (xo(o) || yo(o)) { + const _ = xo(o) && !Ya(o, 21, t); + _ && e.insertNodeBefore(t, Ca(o.parameters), N.createToken( + 21 + /* OpenParenToken */ + )), lr(c, ({ typeNode: u, param: g }) => { + const m = N.createJSDocTypeTag( + /*tagName*/ + void 0, + N.createJSDocTypeExpression(u) + ), h = N.createJSDocComment( + /*comment*/ + void 0, + [m] + ); + e.insertNodeAt(t, g.getStart(t), h, { suffix: " " }); + }), _ && e.insertNodeAfter(t, pa(o.parameters), N.createToken( + 22 + /* CloseParenToken */ + )); + } else { + const _ = hr(c, ({ name: u, typeNode: g, isOptional: m }) => N.createJSDocParameterTag( + /*tagName*/ + void 0, + u, + /*isBracketed*/ + !!m, + N.createJSDocTypeExpression(g), + /*isNameFirst*/ + !1, + /*comment*/ + void 0 + )); + e.addJSDocTags(t, o, _); + } + } + function Wle(e, t, n) { + return Fi(ko.getReferenceEntriesForNode(-1, e, t, t.getSourceFiles(), n), (i) => i.kind !== ko.EntryKind.Span ? Bn(i.node, Me) : void 0); + } + function v8(e, t, n) { + const i = Wle(e, t, n); + return Ule(t, i, n).single(); + } + function OGe(e, t, n, i) { + const s = K6e(e, t, n, i); + return s && Ule(n, s, i).parameters(e) || e.parameters.map((o) => ({ + declaration: o, + type: Me(o.name) ? v8(o.name, n, i) : n.getTypeChecker().getAnyType() + })); + } + function K6e(e, t, n, i) { + let s; + switch (e.kind) { + case 177: + s = Ya(e, 137, t); + break; + case 220: + case 219: + const o = e.parent; + s = (ei(o) || os(o)) && Me(o.name) ? o.name : e.name; + break; + case 263: + case 175: + case 174: + s = e.name; + break; + } + if (s) + return Wle(s, n, i); + } + function Ule(e, t, n) { + const i = e.getTypeChecker(), s = { + string: () => i.getStringType(), + number: () => i.getNumberType(), + Array: (pe) => i.createArrayType(pe), + Promise: (pe) => i.createPromiseType(pe) + }, o = [ + i.getStringType(), + i.getNumberType(), + i.createArrayType(i.getAnyType()), + i.createPromiseType(i.getAnyType()) + ]; + return { + single: u, + parameters: g, + thisParameter: m + }; + function c() { + return { + isNumber: void 0, + isString: void 0, + isNumberOrString: void 0, + candidateTypes: void 0, + properties: void 0, + calls: void 0, + constructs: void 0, + numberIndex: void 0, + stringIndex: void 0, + candidateThisTypes: void 0, + inferredTypes: void 0 + }; + } + function _(pe) { + const Te = /* @__PURE__ */ new Map(); + for (const Ye of pe) + Ye.properties && Ye.properties.forEach((ne, Se) => { + Te.has(Se) || Te.set(Se, []), Te.get(Se).push(ne); + }); + const Fe = /* @__PURE__ */ new Map(); + return Te.forEach((Ye, ne) => { + Fe.set(ne, _(Ye)); + }), { + isNumber: pe.some((Ye) => Ye.isNumber), + isString: pe.some((Ye) => Ye.isString), + isNumberOrString: pe.some((Ye) => Ye.isNumberOrString), + candidateTypes: ka(pe, (Ye) => Ye.candidateTypes), + properties: Fe, + calls: ka(pe, (Ye) => Ye.calls), + constructs: ka(pe, (Ye) => Ye.constructs), + numberIndex: lr(pe, (Ye) => Ye.numberIndex), + stringIndex: lr(pe, (Ye) => Ye.stringIndex), + candidateThisTypes: ka(pe, (Ye) => Ye.candidateThisTypes), + inferredTypes: void 0 + // clear type cache + }; + } + function u() { + return _e(h(t)); + } + function g(pe) { + if (t.length === 0 || !pe.parameters) + return; + const Te = c(); + for (const Ye of t) + n.throwIfCancellationRequested(), S(Ye, Te); + const Fe = [...Te.constructs || [], ...Te.calls || []]; + return pe.parameters.map((Ye, ne) => { + const Se = [], ie = Hm(Ye); + let Ne = !1; + for (const Ce of Fe) + if (Ce.argumentTypes.length <= ne) + Ne = an(pe), Se.push(i.getUndefinedType()); + else if (ie) + for (let Ve = ne; Ve < Ce.argumentTypes.length; Ve++) + Se.push(i.getBaseTypeOfLiteralType(Ce.argumentTypes[Ve])); + else + Se.push(i.getBaseTypeOfLiteralType(Ce.argumentTypes[ne])); + if (Me(Ye.name)) { + const Ce = h(Wle(Ye.name, e, n)); + Se.push(...ie ? Fi(Ce, i.getElementTypeOfArrayType) : Ce); + } + const Ee = _e(Se); + return { + type: ie ? i.createArrayType(Ee) : Ee, + isOptional: Ne && !ie, + declaration: Ye + }; + }); + } + function m() { + const pe = c(); + for (const Te of t) + n.throwIfCancellationRequested(), S(Te, pe); + return _e(pe.candidateThisTypes || Ge); + } + function h(pe) { + const Te = c(); + for (const Fe of pe) + n.throwIfCancellationRequested(), S(Fe, Te); + return V(Te); + } + function S(pe, Te) { + for (; r4(pe); ) + pe = pe.parent; + switch (pe.parent.kind) { + case 245: + k(pe, Te); + break; + case 226: + Te.isNumber = !0; + break; + case 225: + D(pe.parent, Te); + break; + case 227: + P(pe, pe.parent, Te); + break; + case 297: + case 298: + A(pe.parent, Te); + break; + case 214: + case 215: + pe.parent.expression === pe ? O(pe.parent, Te) : T(pe, Te); + break; + case 212: + F(pe.parent, Te); + break; + case 213: + R(pe.parent, pe, Te); + break; + case 304: + case 305: + B(pe.parent, Te); + break; + case 173: + U(pe.parent, Te); + break; + case 261: { + const { name: Fe, initializer: Ye } = pe.parent; + if (pe === Fe) { + Ye && me(Te, i.getTypeAtLocation(Ye)); + break; + } + } + // falls through + default: + return T(pe, Te); + } + } + function T(pe, Te) { + Xm(pe) && me(Te, i.getContextualType(pe)); + } + function k(pe, Te) { + me(Te, Ps(pe) ? i.getVoidType() : i.getAnyType()); + } + function D(pe, Te) { + switch (pe.operator) { + case 46: + case 47: + case 41: + case 55: + Te.isNumber = !0; + break; + case 40: + Te.isNumberOrString = !0; + break; + } + } + function P(pe, Te, Fe) { + switch (Te.operatorToken.kind) { + // ExponentiationOperator + case 43: + // MultiplicativeOperator + // falls through + case 42: + case 44: + case 45: + // ShiftOperator + // falls through + case 48: + case 49: + case 50: + // BitwiseOperator + // falls through + case 51: + case 52: + case 53: + // CompoundAssignmentOperator + // falls through + case 66: + case 68: + case 67: + case 69: + case 70: + case 74: + case 75: + case 79: + case 71: + case 73: + case 72: + // AdditiveOperator + // falls through + case 41: + // RelationalOperator + // falls through + case 30: + case 33: + case 32: + case 34: + const Ye = i.getTypeAtLocation(Te.left === pe ? Te.right : Te.left); + Ye.flags & 1056 ? me(Fe, Ye) : Fe.isNumber = !0; + break; + case 65: + case 40: + const ne = i.getTypeAtLocation(Te.left === pe ? Te.right : Te.left); + ne.flags & 1056 ? me(Fe, ne) : ne.flags & 296 ? Fe.isNumber = !0 : ne.flags & 402653316 ? Fe.isString = !0 : ne.flags & 1 || (Fe.isNumberOrString = !0); + break; + // AssignmentOperators + case 64: + case 35: + case 37: + case 38: + case 36: + case 77: + case 78: + case 76: + me(Fe, i.getTypeAtLocation(Te.left === pe ? Te.right : Te.left)); + break; + case 103: + pe === Te.left && (Fe.isString = !0); + break; + // LogicalOperator Or NullishCoalescing + case 57: + case 61: + pe === Te.left && (pe.parent.parent.kind === 261 || Nl( + pe.parent.parent, + /*excludeCompoundAssignment*/ + !0 + )) && me(Fe, i.getTypeAtLocation(Te.right)); + break; + } + } + function A(pe, Te) { + me(Te, i.getTypeAtLocation(pe.parent.parent.expression)); + } + function O(pe, Te) { + const Fe = { + argumentTypes: [], + return_: c() + }; + if (pe.arguments) + for (const Ye of pe.arguments) + Fe.argumentTypes.push(i.getTypeAtLocation(Ye)); + S(pe, Fe.return_), pe.kind === 214 ? (Te.calls || (Te.calls = [])).push(Fe) : (Te.constructs || (Te.constructs = [])).push(Fe); + } + function F(pe, Te) { + const Fe = tc(pe.name.text); + Te.properties || (Te.properties = /* @__PURE__ */ new Map()); + const Ye = Te.properties.get(Fe) || c(); + S(pe, Ye), Te.properties.set(Fe, Ye); + } + function R(pe, Te, Fe) { + if (Te === pe.argumentExpression) { + Fe.isNumberOrString = !0; + return; + } else { + const Ye = i.getTypeAtLocation(pe.argumentExpression), ne = c(); + S(pe, ne), Ye.flags & 296 ? Fe.numberIndex = ne : Fe.stringIndex = ne; + } + } + function B(pe, Te) { + const Fe = ei(pe.parent.parent) ? pe.parent.parent : pe.parent; + Z(Te, i.getTypeAtLocation(Fe)); + } + function U(pe, Te) { + Z(Te, i.getTypeAtLocation(pe.parent)); + } + function $(pe, Te) { + const Fe = []; + for (const Ye of pe) + for (const { high: ne, low: Se } of Te) + ne(Ye) && (E.assert(!Se(Ye), "Priority can't have both low and high"), Fe.push(Se)); + return pe.filter((Ye) => Fe.every((ne) => !ne(Ye))); + } + function W(pe) { + return _e(V(pe)); + } + function _e(pe) { + if (!pe.length) return i.getAnyType(); + const Te = i.getUnionType([i.getStringType(), i.getNumberType()]); + let Ye = $(pe, [ + { + high: (Se) => Se === i.getStringType() || Se === i.getNumberType(), + low: (Se) => Se === Te + }, + { + high: (Se) => !(Se.flags & 16385), + low: (Se) => !!(Se.flags & 16385) + }, + { + high: (Se) => !(Se.flags & 114689) && !(Dn(Se) & 16), + low: (Se) => !!(Dn(Se) & 16) + } + ]); + const ne = Ye.filter( + (Se) => Dn(Se) & 16 + /* Anonymous */ + ); + return ne.length && (Ye = Ye.filter((Se) => !(Dn(Se) & 16)), Ye.push(K(ne))), i.getWidenedType(i.getUnionType( + Ye.map(i.getBaseTypeOfLiteralType), + 2 + /* Subtype */ + )); + } + function K(pe) { + if (pe.length === 1) + return pe[0]; + const Te = [], Fe = [], Ye = [], ne = []; + let Se = !1, ie = !1; + const Ne = Fp(); + for (const Ve of pe) { + for (const tr of i.getPropertiesOfType(Ve)) + Ne.add(tr.escapedName, tr.valueDeclaration ? i.getTypeOfSymbolAtLocation(tr, tr.valueDeclaration) : i.getAnyType()); + Te.push(...i.getSignaturesOfType( + Ve, + 0 + /* Call */ + )), Fe.push(...i.getSignaturesOfType( + Ve, + 1 + /* Construct */ + )); + const St = i.getIndexInfoOfType( + Ve, + 0 + /* String */ + ); + St && (Ye.push(St.type), Se = Se || St.isReadonly); + const Bt = i.getIndexInfoOfType( + Ve, + 1 + /* Number */ + ); + Bt && (ne.push(Bt.type), ie = ie || Bt.isReadonly); + } + const Ee = rQ(Ne, (Ve, St) => { + const Bt = St.length < pe.length ? 16777216 : 0, tr = i.createSymbol(4 | Bt, Ve); + return tr.links.type = i.getUnionType(St), [Ve, tr]; + }), Ce = []; + return Ye.length && Ce.push(i.createIndexInfo(i.getStringType(), i.getUnionType(Ye), Se)), ne.length && Ce.push(i.createIndexInfo(i.getNumberType(), i.getUnionType(ne), ie)), i.createAnonymousType( + pe[0].symbol, + Ee, + Te, + Fe, + Ce + ); + } + function V(pe) { + var Te, Fe, Ye; + const ne = []; + pe.isNumber && ne.push(i.getNumberType()), pe.isString && ne.push(i.getStringType()), pe.isNumberOrString && ne.push(i.getUnionType([i.getStringType(), i.getNumberType()])), pe.numberIndex && ne.push(i.createArrayType(W(pe.numberIndex))), ((Te = pe.properties) != null && Te.size || (Fe = pe.constructs) != null && Fe.length || pe.stringIndex) && ne.push(ae(pe)); + const Se = (pe.candidateTypes || []).map((Ne) => i.getBaseTypeOfLiteralType(Ne)), ie = (Ye = pe.calls) != null && Ye.length ? ae(pe) : void 0; + return ie && Se ? ne.push(i.getUnionType( + [ie, ...Se], + 2 + /* Subtype */ + )) : (ie && ne.push(ie), wr(Se) && ne.push(...Se)), ne.push(...se(pe)), ne; + } + function ae(pe) { + const Te = /* @__PURE__ */ new Map(); + pe.properties && pe.properties.forEach((Se, ie) => { + const Ne = i.createSymbol(4, ie); + Ne.links.type = W(Se), Te.set(ie, Ne); + }); + const Fe = pe.calls ? [je(pe.calls)] : [], Ye = pe.constructs ? [je(pe.constructs)] : [], ne = pe.stringIndex ? [i.createIndexInfo( + i.getStringType(), + W(pe.stringIndex), + /*isReadonly*/ + !1 + )] : []; + return i.createAnonymousType( + /*symbol*/ + void 0, + Te, + Fe, + Ye, + ne + ); + } + function se(pe) { + if (!pe.properties || !pe.properties.size) return []; + const Te = o.filter((Fe) => ce(Fe, pe)); + return 0 < Te.length && Te.length < 3 ? Te.map((Fe) => fe(Fe, pe)) : []; + } + function ce(pe, Te) { + return Te.properties ? !hl(Te.properties, (Fe, Ye) => { + const ne = i.getTypeOfPropertyOfType(pe, Ye); + return ne ? Fe.calls ? !i.getSignaturesOfType( + ne, + 0 + /* Call */ + ).length || !i.isTypeAssignableTo(ne, be(Fe.calls)) : !i.isTypeAssignableTo(ne, W(Fe)) : !0; + }) : !1; + } + function fe(pe, Te) { + if (!(Dn(pe) & 4) || !Te.properties) + return pe; + const Fe = pe.target, Ye = xg(Fe.typeParameters); + if (!Ye) return pe; + const ne = []; + return Te.properties.forEach((Se, ie) => { + const Ne = i.getTypeOfPropertyOfType(Fe, ie); + E.assert(!!Ne, "generic should have all the properties of its reference."), ne.push(...he(Ne, W(Se), Ye)); + }), s[pe.symbol.escapedName](_e(ne)); + } + function he(pe, Te, Fe) { + if (pe === Fe) + return [Te]; + if (pe.flags & 3145728) + return ka(pe.types, (Se) => he(Se, Te, Fe)); + if (Dn(pe) & 4 && Dn(Te) & 4) { + const Se = i.getTypeArguments(pe), ie = i.getTypeArguments(Te), Ne = []; + if (Se && ie) + for (let Ee = 0; Ee < Se.length; Ee++) + ie[Ee] && Ne.push(...he(Se[Ee], ie[Ee], Fe)); + return Ne; + } + const Ye = i.getSignaturesOfType( + pe, + 0 + /* Call */ + ), ne = i.getSignaturesOfType( + Te, + 0 + /* Call */ + ); + return Ye.length === 1 && ne.length === 1 ? q(Ye[0], ne[0], Fe) : []; + } + function q(pe, Te, Fe) { + var Ye; + const ne = []; + for (let Ne = 0; Ne < pe.parameters.length; Ne++) { + const Ee = pe.parameters[Ne], Ce = Te.parameters[Ne], Ve = pe.declaration && Hm(pe.declaration.parameters[Ne]); + if (!Ce) + break; + let St = Ee.valueDeclaration ? i.getTypeOfSymbolAtLocation(Ee, Ee.valueDeclaration) : i.getAnyType(); + const Bt = Ve && i.getElementTypeOfArrayType(St); + Bt && (St = Bt); + const tr = ((Ye = Bn(Ce, Ng)) == null ? void 0 : Ye.links.type) || (Ce.valueDeclaration ? i.getTypeOfSymbolAtLocation(Ce, Ce.valueDeclaration) : i.getAnyType()); + ne.push(...he(St, tr, Fe)); + } + const Se = i.getReturnTypeOfSignature(pe), ie = i.getReturnTypeOfSignature(Te); + return ne.push(...he(Se, ie, Fe)), ne; + } + function be(pe) { + return i.createAnonymousType( + /*symbol*/ + void 0, + Bs(), + [je(pe)], + Ge, + Ge + ); + } + function je(pe) { + const Te = [], Fe = Math.max(...pe.map((ne) => ne.argumentTypes.length)); + for (let ne = 0; ne < Fe; ne++) { + const Se = i.createSymbol(1, tc(`arg${ne}`)); + Se.links.type = _e(pe.map((ie) => ie.argumentTypes[ne] || i.getUndefinedType())), pe.some((ie) => ie.argumentTypes[ne] === void 0) && (Se.flags |= 16777216), Te.push(Se); + } + const Ye = W(_(pe.map((ne) => ne.return_))); + return i.createSignature( + /*declaration*/ + void 0, + /*typeParameters*/ + void 0, + /*thisParameter*/ + void 0, + Te, + Ye, + /*typePredicate*/ + void 0, + Fe, + 0 + /* None */ + ); + } + function me(pe, Te) { + Te && !(Te.flags & 1) && !(Te.flags & 131072) && (pe.candidateTypes || (pe.candidateTypes = [])).push(Te); + } + function Z(pe, Te) { + Te && !(Te.flags & 1) && !(Te.flags & 131072) && (pe.candidateThisTypes || (pe.candidateThisTypes = [])).push(Te); + } + } + var Vle = "fixReturnTypeInAsyncFunction", eEe = [ + p.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0.code + ]; + Qs({ + errorCodes: eEe, + fixIds: [Vle], + getCodeActions: function(t) { + const { sourceFile: n, program: i, span: s } = t, o = i.getTypeChecker(), c = tEe(n, i.getTypeChecker(), s.start); + if (!c) + return; + const { returnTypeNode: _, returnType: u, promisedTypeNode: g, promisedType: m } = c, h = cn.ChangeTracker.with(t, (S) => rEe(S, n, _, g)); + return [Ls( + Vle, + h, + [p.Replace_0_with_Promise_1, o.typeToString(u), o.typeToString(m)], + Vle, + p.Fix_all_incorrect_return_type_of_an_async_functions + )]; + }, + getAllCodeActions: (e) => Qa(e, eEe, (t, n) => { + const i = tEe(n.file, e.program.getTypeChecker(), n.start); + i && rEe(t, n.file, i.returnTypeNode, i.promisedTypeNode); + }) + }); + function tEe(e, t, n) { + if (an(e)) + return; + const i = vi(e, n), s = dr(i, io), o = s?.type; + if (!o) + return; + const c = t.getTypeFromTypeNode(o), _ = t.getAwaitedType(c) || t.getVoidType(), u = t.typeToTypeNode( + _, + /*enclosingDeclaration*/ + o, + /*flags*/ + void 0 + ); + if (u) + return { returnTypeNode: o, returnType: c, promisedTypeNode: u, promisedType: _ }; + } + function rEe(e, t, n, i) { + e.replaceNode(t, n, N.createTypeReferenceNode("Promise", [i])); + } + var nEe = "disableJsDiagnostics", iEe = "disableJsDiagnostics", sEe = Fi(Object.keys(p), (e) => { + const t = p[e]; + return t.category === 1 ? t.code : void 0; + }); + Qs({ + errorCodes: sEe, + getCodeActions: function(t) { + const { sourceFile: n, program: i, span: s, host: o, formatContext: c } = t; + if (!an(n) || !d4(n, i.getCompilerOptions())) + return; + const _ = n.checkJsDirective ? "" : Fh(o, c.options), u = [ + // fixId unnecessary because adding `// @ts-nocheck` even once will ignore every error in the file. + jd( + nEe, + [$Te(n.fileName, [ + qA( + n.checkJsDirective ? Nc(n.checkJsDirective.pos, n.checkJsDirective.end) : Kl(0, 0), + `// @ts-nocheck${_}` + ) + ])], + p.Disable_checking_for_this_file + ) + ]; + return cn.isValidLocationToAddComment(n, s.start) && u.unshift(Ls(nEe, cn.ChangeTracker.with(t, (g) => aEe(g, n, s.start)), p.Ignore_this_error_message, iEe, p.Add_ts_ignore_to_all_error_messages)), u; + }, + fixIds: [iEe], + getAllCodeActions: (e) => { + const t = /* @__PURE__ */ new Set(); + return Qa(e, sEe, (n, i) => { + cn.isValidLocationToAddComment(i.file, i.start) && aEe(n, i.file, i.start, t); + }); + } + }); + function aEe(e, t, n, i) { + const { line: s } = js(t, n); + (!i || u0(i, s)) && e.insertCommentBeforeLine(t, s, n, " @ts-ignore"); + } + function qle(e, t, n, i, s, o, c) { + const _ = e.symbol.members; + for (const u of t) + _.has(u.escapedName) || cEe( + u, + e, + n, + i, + s, + o, + c, + /*body*/ + void 0 + ); + } + function iE(e) { + return { + trackSymbol: () => !1, + moduleResolverHost: UV(e.program, e.host) + }; + } + var oEe = /* @__PURE__ */ ((e) => (e[e.Method = 1] = "Method", e[e.Property = 2] = "Property", e[e.All = 3] = "All", e))(oEe || {}); + function cEe(e, t, n, i, s, o, c, _, u = 3, g = !1) { + const m = e.getDeclarations(), h = Yc(m), S = i.program.getTypeChecker(), T = da(i.program.getCompilerOptions()), k = h?.kind ?? 172, D = ce(e, h), P = h ? pu(h) : 0; + let A = P & 256; + A |= P & 1 ? 1 : P & 4 ? 4 : 0, h && b_(h) && (A |= 512); + const O = _e(), F = S.getWidenedType(S.getTypeOfSymbolAtLocation(e, t)), R = !!(e.flags & 16777216), B = !!(t.flags & 33554432) || g, U = _f(n, s), $ = 1 | (U === 0 ? 268435456 : 0); + switch (k) { + case 172: + case 173: + let fe = S.typeToTypeNode(F, t, $, 8, iE(i)); + if (o) { + const q = m2(fe, T); + q && (fe = q.typeNode, HS(o, q.symbols)); + } + c(N.createPropertyDeclaration( + O, + h ? V(D) : e.getName(), + R && u & 2 ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, + fe, + /*initializer*/ + void 0 + )); + break; + case 178: + case 179: { + E.assertIsDefined(m); + let q = S.typeToTypeNode( + F, + t, + $, + /*internalFlags*/ + void 0, + iE(i) + ); + const be = Bb(m, h), je = be.secondAccessor ? [be.firstAccessor, be.secondAccessor] : [be.firstAccessor]; + if (o) { + const me = m2(q, T); + me && (q = me.typeNode, HS(o, me.symbols)); + } + for (const me of je) + if (pp(me)) + c(N.createGetAccessorDeclaration( + O, + V(D), + Ge, + se(q), + ae(_, U, B) + )); + else { + E.assertNode(me, z_, "The counterpart to a getter should be a setter"); + const Z = e4(me), pe = Z && Me(Z.name) ? An(Z.name) : void 0; + c(N.createSetAccessorDeclaration( + O, + V(D), + $le( + 1, + [pe], + [se(q)], + 1, + /*inJs*/ + !1 + ), + ae(_, U, B) + )); + } + break; + } + case 174: + case 175: + E.assertIsDefined(m); + const he = F.isUnion() ? ka(F.types, (q) => q.getCallSignatures()) : F.getCallSignatures(); + if (!ot(he)) + break; + if (m.length === 1) { + E.assert(he.length === 1, "One declaration implies one signature"); + const q = he[0]; + W(U, q, O, V(D), ae(_, U, B)); + break; + } + for (const q of he) + q.declaration && q.declaration.flags & 33554432 || W(U, q, O, V(D)); + if (!B) + if (m.length > he.length) { + const q = S.getSignatureFromDeclaration(m[m.length - 1]); + W(U, q, O, V(D), ae(_, U)); + } else + E.assert(m.length === he.length, "Declarations and signatures should match count"), c(BGe(S, i, t, he, V(D), R && !!(u & 1), O, U, _)); + break; + } + function W(fe, he, q, be, je) { + const me = AH(175, i, fe, he, je, be, q, R && !!(u & 1), t, o); + me && c(me); + } + function _e() { + let fe; + return A && (fe = GT(fe, N.createModifiersFromModifierFlags(A))), K() && (fe = Er(fe, N.createToken( + 164 + /* OverrideKeyword */ + ))), fe && N.createNodeArray(fe); + } + function K() { + return !!(i.program.getCompilerOptions().noImplicitOverride && h && Jb(h)); + } + function V(fe) { + return Me(fe) && fe.escapedText === "constructor" ? N.createComputedPropertyName(N.createStringLiteral( + An(fe), + U === 0 + /* Single */ + )) : qa( + fe, + /*includeTrivia*/ + !1 + ); + } + function ae(fe, he, q) { + return q ? void 0 : qa( + fe, + /*includeTrivia*/ + !1 + ) || Xle(he); + } + function se(fe) { + return qa( + fe, + /*includeTrivia*/ + !1 + ); + } + function ce(fe, he) { + if (uc(fe) & 262144) { + const q = fe.links.nameType; + if (q && _p(q)) + return N.createIdentifier(Si(fp(q))); + } + return qa( + _s(he), + /*includeTrivia*/ + !1 + ); + } + } + function AH(e, t, n, i, s, o, c, _, u, g) { + const m = t.program, h = m.getTypeChecker(), S = da(m.getCompilerOptions()), T = an(u), k = 524545 | (n === 0 ? 268435456 : 0), D = h.signatureToSignatureDeclaration(i, e, u, k, 8, iE(t)); + if (!D) + return; + let P = T ? void 0 : D.typeParameters, A = D.parameters, O = T ? void 0 : qa(D.type); + if (g) { + if (P) { + const U = Qc(P, ($) => { + let W = $.constraint, _e = $.default; + if (W) { + const K = m2(W, S); + K && (W = K.typeNode, HS(g, K.symbols)); + } + if (_e) { + const K = m2(_e, S); + K && (_e = K.typeNode, HS(g, K.symbols)); + } + return N.updateTypeParameterDeclaration( + $, + $.modifiers, + $.name, + W, + _e + ); + }); + P !== U && (P = ct(N.createNodeArray(U, P.hasTrailingComma), P)); + } + const B = Qc(A, (U) => { + let $ = T ? void 0 : U.type; + if ($) { + const W = m2($, S); + W && ($ = W.typeNode, HS(g, W.symbols)); + } + return N.updateParameterDeclaration( + U, + U.modifiers, + U.dotDotDotToken, + U.name, + T ? void 0 : U.questionToken, + $, + U.initializer + ); + }); + if (A !== B && (A = ct(N.createNodeArray(B, A.hasTrailingComma), A)), O) { + const U = m2(O, S); + U && (O = U.typeNode, HS(g, U.symbols)); + } + } + const F = _ ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, R = D.asteriskToken; + if (yo(D)) + return N.updateFunctionExpression(D, c, D.asteriskToken, Bn(o, Me), P, A, O, s ?? D.body); + if (xo(D)) + return N.updateArrowFunction(D, c, P, A, O, D.equalsGreaterThanToken, s ?? D.body); + if (rc(D)) + return N.updateMethodDeclaration(D, c, R, o ?? N.createIdentifier(""), F, P, A, O, s); + if (Cc(D)) + return N.updateFunctionDeclaration(D, c, D.asteriskToken, Bn(o, Me), P, A, O, s ?? D.body); + } + function Hle(e, t, n, i, s, o, c) { + const _ = _f(t.sourceFile, t.preferences), u = da(t.program.getCompilerOptions()), g = iE(t), m = t.program.getTypeChecker(), h = an(c), { typeArguments: S, arguments: T, parent: k } = i, D = h ? void 0 : m.getContextualType(i), P = hr(T, (_e) => Me(_e) ? _e.text : wn(_e) && Me(_e.name) ? _e.name.text : void 0), A = h ? [] : hr(T, (_e) => m.getTypeAtLocation(_e)), { argumentTypeNodes: O, argumentTypeParameters: F } = RGe( + m, + n, + A, + c, + u, + 1, + 8, + g + ), R = o ? N.createNodeArray(N.createModifiersFromModifierFlags(o)) : void 0, B = BN(k) ? N.createToken( + 42 + /* AsteriskToken */ + ) : void 0, U = h ? void 0 : LGe(m, F, S), $ = $le( + T.length, + P, + O, + /*minArgumentCount*/ + void 0, + h + ), W = h || D === void 0 ? void 0 : m.typeToTypeNode( + D, + c, + /*flags*/ + void 0, + /*internalFlags*/ + void 0, + g + ); + switch (e) { + case 175: + return N.createMethodDeclaration( + R, + B, + s, + /*questionToken*/ + void 0, + U, + $, + W, + Xle(_) + ); + case 174: + return N.createMethodSignature( + R, + s, + /*questionToken*/ + void 0, + U, + $, + W === void 0 ? N.createKeywordTypeNode( + 159 + /* UnknownKeyword */ + ) : W + ); + case 263: + return E.assert(typeof s == "string" || Me(s), "Unexpected name"), N.createFunctionDeclaration( + R, + B, + s, + U, + $, + W, + TL(p.Function_not_implemented.message, _) + ); + default: + E.fail("Unexpected kind"); + } + } + function LGe(e, t, n) { + const i = new Set(t.map((o) => o[0])), s = new Map(t); + if (n) { + const o = n.filter((_) => !t.some((u) => { + var g; + return e.getTypeAtLocation(_) === ((g = u[1]) == null ? void 0 : g.argumentType); + })), c = i.size + o.length; + for (let _ = 0; i.size < c; _ += 1) + i.add(lEe(_)); + } + return is( + i.values(), + (o) => { + var c; + return N.createTypeParameterDeclaration( + /*modifiers*/ + void 0, + o, + (c = s.get(o)) == null ? void 0 : c.constraint + ); + } + ); + } + function lEe(e) { + return 84 + e <= 90 ? String.fromCharCode(84 + e) : `T${e}`; + } + function IH(e, t, n, i, s, o, c, _) { + const u = e.typeToTypeNode(n, i, o, c, _); + if (u) + return Gle(u, t, s); + } + function Gle(e, t, n) { + const i = m2(e, n); + return i && (HS(t, i.symbols), e = i.typeNode), qa(e); + } + function MGe(e, t) { + var n; + E.assert(t.typeArguments); + const i = t.typeArguments, s = t.target; + for (let o = 0; o < i.length; o++) { + if (((n = s.localTypeParameters) == null ? void 0 : n[o].constraint) === void 0) + continue; + const c = i.slice(0, o); + if (e.fillMissingTypeArguments( + c, + s.typeParameters, + o, + /*isJavaScriptImplicitAny*/ + !1 + ).every((u, g) => u === i[g])) + return o; + } + return i.length; + } + function uEe(e, t, n, i, s, o) { + let c = e.typeToTypeNode(t, n, i, s, o); + if (c) { + if (of(c)) { + const _ = t; + if (_.typeArguments && c.typeArguments) { + const u = MGe(e, _); + if (u < c.typeArguments.length) { + const g = N.createNodeArray(c.typeArguments.slice(0, u)); + c = N.updateTypeReferenceNode(c, c.typeName, g); + } + } + } + return c; + } + } + function _Ee(e, t, n, i, s, o, c, _) { + let u = e.typePredicateToTypePredicateNode(n, i, o, c, _); + if (u?.type && ym(u.type)) { + const g = m2(u.type, s); + g && (HS(t, g.symbols), u = N.updateTypePredicateNode(u, u.assertsModifier, u.parameterName, g.typeNode)); + } + return qa(u); + } + function fEe(e) { + return e.isUnionOrIntersection() ? e.types.some(fEe) : e.flags & 262144; + } + function RGe(e, t, n, i, s, o, c, _) { + const u = [], g = /* @__PURE__ */ new Map(); + for (let m = 0; m < n.length; m += 1) { + const h = n[m]; + if (h.isUnionOrIntersection() && h.types.some(fEe)) { + const P = lEe(m); + u.push(N.createTypeReferenceNode(P)), g.set(P, void 0); + continue; + } + const S = e.getBaseTypeOfLiteralType(h), T = IH(e, t, S, i, s, o, c, _); + if (!T) + continue; + u.push(T); + const k = pEe(h), D = h.isTypeParameter() && h.constraint && !jGe(h.constraint) ? IH(e, t, h.constraint, i, s, o, c, _) : void 0; + k && g.set(k, { argumentType: h, constraint: D }); + } + return { argumentTypeNodes: u, argumentTypeParameters: is(g.entries()) }; + } + function jGe(e) { + return e.flags & 524288 && e.objectFlags === 16; + } + function pEe(e) { + var t; + if (e.flags & 3145728) + for (const n of e.types) { + const i = pEe(n); + if (i) + return i; + } + return e.flags & 262144 ? (t = e.getSymbol()) == null ? void 0 : t.getName() : void 0; + } + function $le(e, t, n, i, s) { + const o = [], c = /* @__PURE__ */ new Map(); + for (let _ = 0; _ < e; _++) { + const u = t?.[_] || `arg${_}`, g = c.get(u); + c.set(u, (g || 0) + 1); + const m = N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + /*name*/ + u + (g || ""), + /*questionToken*/ + i !== void 0 && _ >= i ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, + /*type*/ + s ? void 0 : n?.[_] || N.createKeywordTypeNode( + 159 + /* UnknownKeyword */ + ), + /*initializer*/ + void 0 + ); + o.push(m); + } + return o; + } + function BGe(e, t, n, i, s, o, c, _, u) { + let g = i[0], m = i[0].minArgumentCount, h = !1; + for (const D of i) + m = Math.min(D.minArgumentCount, m), Iu(D) && (h = !0), D.parameters.length >= g.parameters.length && (!Iu(D) || Iu(g)) && (g = D); + const S = g.parameters.length - (Iu(g) ? 1 : 0), T = g.parameters.map((D) => D.name), k = $le( + S, + T, + /*types*/ + void 0, + m, + /*inJs*/ + !1 + ); + if (h) { + const D = N.createParameterDeclaration( + /*modifiers*/ + void 0, + N.createToken( + 26 + /* DotDotDotToken */ + ), + T[S] || "rest", + /*questionToken*/ + S >= m ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, + N.createArrayTypeNode(N.createKeywordTypeNode( + 159 + /* UnknownKeyword */ + )), + /*initializer*/ + void 0 + ); + k.push(D); + } + return zGe( + c, + s, + o, + /*typeParameters*/ + void 0, + k, + JGe(i, e, t, n), + _, + u + ); + } + function JGe(e, t, n, i) { + if (wr(e)) { + const s = t.getUnionType(hr(e, t.getReturnTypeOfSignature)); + return t.typeToTypeNode(s, i, 1, 8, iE(n)); + } + } + function zGe(e, t, n, i, s, o, c, _) { + return N.createMethodDeclaration( + e, + /*asteriskToken*/ + void 0, + t, + n ? N.createToken( + 58 + /* QuestionToken */ + ) : void 0, + i, + s, + o, + _ || Xle(c) + ); + } + function Xle(e) { + return TL(p.Method_not_implemented.message, e); + } + function TL(e, t) { + return N.createBlock( + [N.createThrowStatement( + N.createNewExpression( + N.createIdentifier("Error"), + /*typeArguments*/ + void 0, + // TODO Handle auto quote preference. + [N.createStringLiteral( + e, + /*isSingleQuote*/ + t === 0 + /* Single */ + )] + ) + )], + /*multiLine*/ + !0 + ); + } + function Qle(e, t, n) { + const i = MD(t); + if (!i) return; + const s = dEe(i, "compilerOptions"); + if (s === void 0) { + e.insertNodeAtObjectStart( + t, + i, + Zle( + "compilerOptions", + N.createObjectLiteralExpression( + n.map(([c, _]) => Zle(c, _)), + /*multiLine*/ + !0 + ) + ) + ); + return; + } + const o = s.initializer; + if (_a(o)) + for (const [c, _] of n) { + const u = dEe(o, c); + u === void 0 ? e.insertNodeAtObjectStart(t, o, Zle(c, _)) : e.replaceNode(t, u.initializer, _); + } + } + function Yle(e, t, n, i) { + Qle(e, t, [[n, i]]); + } + function Zle(e, t) { + return N.createPropertyAssignment(N.createStringLiteral(e), t); + } + function dEe(e, t) { + return Nn(e.properties, (n) => rl(n) && !!n.name && ca(n.name) && n.name.text === t); + } + function m2(e, t) { + let n; + const i = Qe(e, s, li); + if (n && i) + return { typeNode: i, symbols: n }; + function s(o) { + if (bh(o) && o.qualifier) { + const c = i_(o.qualifier); + if (!c.symbol) + return br( + o, + s, + /*context*/ + void 0 + ); + const _ = V9(c.symbol, t), u = _ !== c.text ? mEe(o.qualifier, N.createIdentifier(_)) : o.qualifier; + n = Er(n, c.symbol); + const g = Ar(o.typeArguments, s, li); + return N.createTypeReferenceNode(u, g); + } + return br( + o, + s, + /*context*/ + void 0 + ); + } + } + function mEe(e, t) { + return e.kind === 80 ? t : N.createQualifiedName(mEe(e.left, t), e.right); + } + function HS(e, t) { + t.forEach((n) => e.addImportFromExportedSymbol( + n, + /*isValidTypeOnlyUseSite*/ + !0 + )); + } + function Kle(e, t) { + const n = ec(t); + let i = vi(e, t.start); + for (; i.end < n; ) + i = i.parent; + return i; + } + function gEe(e, t, n, i, s, o) { + const c = vEe(e, t, n, i); + if (!c || gk.isRefactorErrorInfo(c)) return; + const _ = cn.ChangeTracker.fromContext(s), { isStatic: u, isReadonly: g, fieldName: m, accessorName: h, originalName: S, type: T, container: k, declaration: D } = c; + af(m), af(h), af(D), af(k); + let P, A; + if ($n(k)) { + const F = pu(D); + if (n_(e)) { + const R = N.createModifiersFromModifierFlags(F); + P = R, A = R; + } else + P = N.createModifiersFromModifierFlags(VGe(F)), A = N.createModifiersFromModifierFlags(qGe(F)); + e2(D) && (A = Bi(Ty(D), A)); + } + QGe(_, e, D, T, m, A); + const O = HGe(m, h, T, P, u, k); + if (af(O), bEe(_, e, O, D, k), g) { + const F = Mg(k); + F && YGe(_, e, F, m.text, S); + } else { + const F = GGe(m, h, T, P, u, k); + af(F), bEe(_, e, F, D, k); + } + return _.getChanges(); + } + function WGe(e) { + return Me(e) || ca(e); + } + function UGe(e) { + return K_(e, e.parent) || os(e) || rl(e); + } + function hEe(e, t) { + return Me(t) ? N.createIdentifier(e) : N.createStringLiteral(e); + } + function yEe(e, t, n) { + const i = t ? n.name : N.createThis(); + return Me(e) ? N.createPropertyAccessExpression(i, e) : N.createElementAccessExpression(i, N.createStringLiteralFromNode(e)); + } + function VGe(e) { + return e &= -9, e &= -3, e & 4 || (e |= 1), e; + } + function qGe(e) { + return e &= -2, e &= -5, e |= 2, e; + } + function vEe(e, t, n, i, s = !0) { + const o = vi(e, n), c = n === i && s, _ = dr(o.parent, UGe), u = 271; + if (!_ || !(y9(_.name, e, n, i) || c)) + return { + error: Ss(p.Could_not_find_property_for_which_to_generate_accessor) + }; + if (!WGe(_.name)) + return { + error: Ss(p.Name_is_not_valid) + }; + if ((pu(_) & 98303 | u) !== u) + return { + error: Ss(p.Can_only_convert_property_with_modifier) + }; + const g = _.name.text, m = dq(g), h = hEe(m ? g : qS(`_${g}`, e), _.name), S = hEe(m ? qS(g.substring(1), e) : g, _.name); + return { + isStatic: cl(_), + isReadonly: gS(_), + type: ZGe(_, t), + container: _.kind === 170 ? _.parent.parent : _.parent, + originalName: _.name.text, + declaration: _, + fieldName: h, + accessorName: S, + renameAccessor: m + }; + } + function HGe(e, t, n, i, s, o) { + return N.createGetAccessorDeclaration( + i, + t, + [], + n, + N.createBlock( + [ + N.createReturnStatement( + yEe(e, s, o) + ) + ], + /*multiLine*/ + !0 + ) + ); + } + function GGe(e, t, n, i, s, o) { + return N.createSetAccessorDeclaration( + i, + t, + [N.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + N.createIdentifier("value"), + /*questionToken*/ + void 0, + n + )], + N.createBlock( + [ + N.createExpressionStatement( + N.createAssignment( + yEe(e, s, o), + N.createIdentifier("value") + ) + ) + ], + /*multiLine*/ + !0 + ) + ); + } + function $Ge(e, t, n, i, s, o) { + const c = N.updatePropertyDeclaration( + n, + o, + s, + n.questionToken || n.exclamationToken, + i, + n.initializer + ); + e.replaceNode(t, n, c); + } + function XGe(e, t, n, i) { + let s = N.updatePropertyAssignment(n, i, n.initializer); + (s.modifiers || s.questionToken || s.exclamationToken) && (s === n && (s = N.cloneNode(s)), s.modifiers = void 0, s.questionToken = void 0, s.exclamationToken = void 0), e.replacePropertyAssignment(t, n, s); + } + function QGe(e, t, n, i, s, o) { + os(n) ? $Ge(e, t, n, i, s, o) : rl(n) ? XGe(e, t, n, s) : e.replaceNode(t, n, N.updateParameterDeclaration(n, o, n.dotDotDotToken, Us(s, Me), n.questionToken, n.type, n.initializer)); + } + function bEe(e, t, n, i, s) { + K_(i, i.parent) ? e.insertMemberAtStart(t, s, n) : rl(i) ? e.insertNodeAfterComma(t, i, n) : e.insertNodeAfter(t, i, n); + } + function YGe(e, t, n, i, s) { + n.body && n.body.forEachChild(function o(c) { + uo(c) && c.expression.kind === 110 && ca(c.argumentExpression) && c.argumentExpression.text === s && Ex(c) && e.replaceNode(t, c.argumentExpression, N.createStringLiteral(i)), wn(c) && c.expression.kind === 110 && c.name.text === s && Ex(c) && e.replaceNode(t, c.name, N.createIdentifier(i)), !Es(c) && !$n(c) && c.forEachChild(o); + }); + } + function ZGe(e, t) { + const n = QK(e); + if (os(e) && n && e.questionToken) { + const i = t.getTypeChecker(), s = i.getTypeFromTypeNode(n); + if (!i.isTypeAssignableTo(i.getUndefinedType(), s)) { + const o = C0(n) ? n.types : [n]; + return N.createUnionTypeNode([...o, N.createKeywordTypeNode( + 157 + /* UndefinedKeyword */ + )]); + } + } + return n; + } + var SEe = "invalidImportSyntax"; + function KGe(e, t) { + const n = xr(t), i = qC(t), s = e.program.getCompilerOptions(), o = []; + return o.push(TEe(e, n, t, r1( + i.name, + /*namedImports*/ + void 0, + t.moduleSpecifier, + _f(n, e.preferences) + ))), Hu(s) === 1 && o.push(TEe( + e, + n, + t, + N.createImportEqualsDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + i.name, + N.createExternalModuleReference(t.moduleSpecifier) + ) + )), o; + } + function TEe(e, t, n, i) { + const s = cn.ChangeTracker.with(e, (o) => o.replaceNode(t, n, i)); + return jd(SEe, s, [p.Replace_import_with_0, s[0].textChanges[0].newText]); + } + Qs({ + errorCodes: [ + p.This_expression_is_not_callable.code, + p.This_expression_is_not_constructable.code + ], + getCodeActions: e$e + }); + function e$e(e) { + const t = e.sourceFile, n = p.This_expression_is_not_callable.code === e.errorCode ? 214 : 215, i = dr(vi(t, e.span.start), (o) => o.kind === n); + if (!i) + return []; + const s = i.expression; + return xEe(e, s); + } + Qs({ + errorCodes: [ + // The following error codes cover pretty much all assignability errors that could involve an expression + p.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code, + p.Type_0_does_not_satisfy_the_constraint_1.code, + p.Type_0_is_not_assignable_to_type_1.code, + p.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated.code, + p.Type_predicate_0_is_not_assignable_to_1.code, + p.Property_0_of_type_1_is_not_assignable_to_2_index_type_3.code, + p._0_index_type_1_is_not_assignable_to_2_index_type_3.code, + p.Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2.code, + p.Property_0_in_type_1_is_not_assignable_to_type_2.code, + p.Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property.code, + p.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1.code + ], + getCodeActions: t$e + }); + function t$e(e) { + const t = e.sourceFile, n = dr(vi(t, e.span.start), (i) => i.getStart() === e.span.start && i.getEnd() === e.span.start + e.span.length); + return n ? xEe(e, n) : []; + } + function xEe(e, t) { + const n = e.program.getTypeChecker().getTypeAtLocation(t); + if (!(n.symbol && Ng(n.symbol) && n.symbol.links.originatingImport)) + return []; + const i = [], s = n.symbol.links.originatingImport; + if (T_(s) || In(i, KGe(e, s)), ut(t) && !(wl(t.parent) && t.parent.name === t)) { + const o = e.sourceFile, c = cn.ChangeTracker.with(e, (_) => _.replaceNode(o, t, N.createPropertyAccessExpression(t, "default"), {})); + i.push(jd(SEe, c, p.Use_synthetic_default_member)); + } + return i; + } + var eue = "strictClassInitialization", tue = "addMissingPropertyDefiniteAssignmentAssertions", rue = "addMissingPropertyUndefinedType", nue = "addMissingPropertyInitializer", kEe = [p.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor.code]; + Qs({ + errorCodes: kEe, + getCodeActions: function(t) { + const n = CEe(t.sourceFile, t.span.start); + if (!n) return; + const i = []; + return Er(i, n$e(t, n)), Er(i, r$e(t, n)), Er(i, i$e(t, n)), i; + }, + fixIds: [tue, rue, nue], + getAllCodeActions: (e) => Qa(e, kEe, (t, n) => { + const i = CEe(n.file, n.start); + if (i) + switch (e.fixId) { + case tue: + EEe(t, n.file, i.prop); + break; + case rue: + DEe(t, n.file, i); + break; + case nue: + const s = e.program.getTypeChecker(), o = PEe(s, i.prop); + if (!o) return; + wEe(t, n.file, i.prop, o); + break; + default: + E.fail(JSON.stringify(e.fixId)); + } + }) + }); + function CEe(e, t) { + const n = vi(e, t); + if (Me(n) && os(n.parent)) { + const i = Kc(n.parent); + if (i) + return { type: i, prop: n.parent, isJs: an(n.parent) }; + } + } + function r$e(e, t) { + if (t.isJs) return; + const n = cn.ChangeTracker.with(e, (i) => EEe(i, e.sourceFile, t.prop)); + return Ls(eue, n, [p.Add_definite_assignment_assertion_to_property_0, t.prop.getText()], tue, p.Add_definite_assignment_assertions_to_all_uninitialized_properties); + } + function EEe(e, t, n) { + af(n); + const i = N.updatePropertyDeclaration( + n, + n.modifiers, + n.name, + N.createToken( + 54 + /* ExclamationToken */ + ), + n.type, + n.initializer + ); + e.replaceNode(t, n, i); + } + function n$e(e, t) { + const n = cn.ChangeTracker.with(e, (i) => DEe(i, e.sourceFile, t)); + return Ls(eue, n, [p.Add_undefined_type_to_property_0, t.prop.name.getText()], rue, p.Add_undefined_type_to_all_uninitialized_properties); + } + function DEe(e, t, n) { + const i = N.createKeywordTypeNode( + 157 + /* UndefinedKeyword */ + ), s = C0(n.type) ? n.type.types.concat(i) : [n.type, i], o = N.createUnionTypeNode(s); + n.isJs ? e.addJSDocTags(t, n.prop, [N.createJSDocTypeTag( + /*tagName*/ + void 0, + N.createJSDocTypeExpression(o) + )]) : e.replaceNode(t, n.type, o); + } + function i$e(e, t) { + if (t.isJs) return; + const n = e.program.getTypeChecker(), i = PEe(n, t.prop); + if (!i) return; + const s = cn.ChangeTracker.with(e, (o) => wEe(o, e.sourceFile, t.prop, i)); + return Ls(eue, s, [p.Add_initializer_to_property_0, t.prop.name.getText()], nue, p.Add_initializers_to_all_uninitialized_properties); + } + function wEe(e, t, n, i) { + af(n); + const s = N.updatePropertyDeclaration( + n, + n.modifiers, + n.name, + n.questionToken, + n.type, + i + ); + e.replaceNode(t, n, s); + } + function PEe(e, t) { + return NEe(e, e.getTypeFromTypeNode(t.type)); + } + function NEe(e, t) { + if (t.flags & 512) + return t === e.getFalseType() || t === e.getFalseType( + /*fresh*/ + !0 + ) ? N.createFalse() : N.createTrue(); + if (t.isStringLiteral()) + return N.createStringLiteral(t.value); + if (t.isNumberLiteral()) + return N.createNumericLiteral(t.value); + if (t.flags & 2048) + return N.createBigIntLiteral(t.value); + if (t.isUnion()) + return Lc(t.types, (n) => NEe(e, n)); + if (t.isClass()) { + const n = Eh(t.symbol); + if (!n || Gn( + n, + 64 + /* Abstract */ + )) return; + const i = Mg(n); + return i && i.parameters.length ? void 0 : N.createNewExpression( + N.createIdentifier(t.symbol.name), + /*typeArguments*/ + void 0, + /*argumentsArray*/ + void 0 + ); + } else if (e.isArrayLikeType(t)) + return N.createArrayLiteralExpression(); + } + var iue = "requireInTs", AEe = [p.require_call_may_be_converted_to_an_import.code]; + Qs({ + errorCodes: AEe, + getCodeActions(e) { + const t = FEe(e.sourceFile, e.program, e.span.start, e.preferences); + if (!t) + return; + const n = cn.ChangeTracker.with(e, (i) => IEe(i, e.sourceFile, t)); + return [Ls(iue, n, p.Convert_require_to_import, iue, p.Convert_all_require_to_import)]; + }, + fixIds: [iue], + getAllCodeActions: (e) => Qa(e, AEe, (t, n) => { + const i = FEe(n.file, e.program, n.start, e.preferences); + i && IEe(t, e.sourceFile, i); + }) + }); + function IEe(e, t, n) { + const { allowSyntheticDefaults: i, defaultImportName: s, namedImports: o, statement: c, moduleSpecifier: _ } = n; + e.replaceNode( + t, + c, + s && !i ? N.createImportEqualsDeclaration( + /*modifiers*/ + void 0, + /*isTypeOnly*/ + !1, + s, + N.createExternalModuleReference(_) + ) : N.createImportDeclaration( + /*modifiers*/ + void 0, + N.createImportClause( + /*phaseModifier*/ + void 0, + s, + o + ), + _, + /*attributes*/ + void 0 + ) + ); + } + function FEe(e, t, n, i) { + const { parent: s } = vi(e, n); + x_( + s, + /*requireStringLiteralLikeArgument*/ + !0 + ) || E.failBadSyntaxKind(s); + const o = Us(s.parent, ei), c = _f(e, i), _ = Bn(o.name, Me), u = Of(o.name) ? s$e(o.name) : void 0; + if (_ || u) { + const g = Ca(s.arguments); + return { + allowSyntheticDefaults: Ax(t.getCompilerOptions()), + defaultImportName: _, + namedImports: u, + statement: Us(o.parent.parent, Ic), + moduleSpecifier: TS(g) ? N.createStringLiteral( + g.text, + c === 0 + /* Single */ + ) : g + }; + } + } + function s$e(e) { + const t = []; + for (const n of e.elements) { + if (!Me(n.name) || n.initializer) + return; + t.push(N.createImportSpecifier( + /*isTypeOnly*/ + !1, + Bn(n.propertyName, Me), + n.name + )); + } + if (t.length) + return N.createNamedImports(t); + } + var sue = "useDefaultImport", OEe = [p.Import_may_be_converted_to_a_default_import.code]; + Qs({ + errorCodes: OEe, + getCodeActions(e) { + const { sourceFile: t, span: { start: n } } = e, i = LEe(t, n); + if (!i) return; + const s = cn.ChangeTracker.with(e, (o) => MEe(o, t, i, e.preferences)); + return [Ls(sue, s, p.Convert_to_default_import, sue, p.Convert_all_to_default_imports)]; + }, + fixIds: [sue], + getAllCodeActions: (e) => Qa(e, OEe, (t, n) => { + const i = LEe(n.file, n.start); + i && MEe(t, n.file, i, e.preferences); + }) + }); + function LEe(e, t) { + const n = vi(e, t); + if (!Me(n)) return; + const { parent: i } = n; + if (_l(i) && wh(i.moduleReference)) + return { importNode: i, name: n, moduleSpecifier: i.moduleReference.expression }; + if (Ug(i) && qo(i.parent.parent)) { + const s = i.parent.parent; + return { importNode: s, name: n, moduleSpecifier: s.moduleSpecifier }; + } + } + function MEe(e, t, n, i) { + e.replaceNode(t, n.importNode, r1( + n.name, + /*namedImports*/ + void 0, + n.moduleSpecifier, + _f(t, i) + )); + } + var aue = "useBigintLiteral", REe = [ + p.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers.code + ]; + Qs({ + errorCodes: REe, + getCodeActions: function(t) { + const n = cn.ChangeTracker.with(t, (i) => jEe(i, t.sourceFile, t.span)); + if (n.length > 0) + return [Ls(aue, n, p.Convert_to_a_bigint_numeric_literal, aue, p.Convert_all_to_bigint_numeric_literals)]; + }, + fixIds: [aue], + getAllCodeActions: (e) => Qa(e, REe, (t, n) => jEe(t, n.file, n)) + }); + function jEe(e, t, n) { + const i = Bn(vi(t, n.start), E_); + if (!i) + return; + const s = i.getText(t) + "n"; + e.replaceNode(t, i, N.createBigIntLiteral(s)); + } + var a$e = "fixAddModuleReferTypeMissingTypeof", oue = a$e, BEe = [p.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0.code]; + Qs({ + errorCodes: BEe, + getCodeActions: function(t) { + const { sourceFile: n, span: i } = t, s = JEe(n, i.start), o = cn.ChangeTracker.with(t, (c) => zEe(c, n, s)); + return [Ls(oue, o, p.Add_missing_typeof, oue, p.Add_missing_typeof)]; + }, + fixIds: [oue], + getAllCodeActions: (e) => Qa(e, BEe, (t, n) => zEe(t, e.sourceFile, JEe(n.file, n.start))) + }); + function JEe(e, t) { + const n = vi(e, t); + return E.assert(n.kind === 102, "This token should be an ImportKeyword"), E.assert(n.parent.kind === 206, "Token parent should be an ImportType"), n.parent; + } + function zEe(e, t, n) { + const i = N.updateImportTypeNode( + n, + n.argument, + n.attributes, + n.qualifier, + n.typeArguments, + /*isTypeOf*/ + !0 + ); + e.replaceNode(t, n, i); + } + var cue = "wrapJsxInFragment", WEe = [p.JSX_expressions_must_have_one_parent_element.code]; + Qs({ + errorCodes: WEe, + getCodeActions: function(t) { + const { sourceFile: n, span: i } = t, s = UEe(n, i.start); + if (!s) return; + const o = cn.ChangeTracker.with(t, (c) => VEe(c, n, s)); + return [Ls(cue, o, p.Wrap_in_JSX_fragment, cue, p.Wrap_all_unparented_JSX_in_JSX_fragment)]; + }, + fixIds: [cue], + getAllCodeActions: (e) => Qa(e, WEe, (t, n) => { + const i = UEe(e.sourceFile, n.start); + i && VEe(t, e.sourceFile, i); + }) + }); + function UEe(e, t) { + let s = vi(e, t).parent.parent; + if (!(!_n(s) && (s = s.parent, !_n(s))) && lc(s.operatorToken)) + return s; + } + function VEe(e, t, n) { + const i = o$e(n); + i && e.replaceNode(t, n, N.createJsxFragment(N.createJsxOpeningFragment(), i, N.createJsxJsxClosingFragment())); + } + function o$e(e) { + const t = []; + let n = e; + for (; ; ) + if (_n(n) && lc(n.operatorToken) && n.operatorToken.kind === 28) { + if (t.push(n.left), g3(n.right)) + return t.push(n.right), t; + if (_n(n.right)) { + n = n.right; + continue; + } else return; + } else return; + } + var lue = "wrapDecoratorInParentheses", qEe = [p.Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator.code]; + Qs({ + errorCodes: qEe, + getCodeActions: function(t) { + const n = cn.ChangeTracker.with(t, (i) => HEe(i, t.sourceFile, t.span.start)); + return [Ls(lue, n, p.Wrap_in_parentheses, lue, p.Wrap_all_invalid_decorator_expressions_in_parentheses)]; + }, + fixIds: [lue], + getAllCodeActions: (e) => Qa(e, qEe, (t, n) => HEe(t, n.file, n.start)) + }); + function HEe(e, t, n) { + const i = vi(t, n), s = dr(i, ul); + E.assert(!!s, "Expected position to be owned by a decorator."); + const o = N.createParenthesizedExpression(s.expression); + e.replaceNode(t, s.expression, o); + } + var uue = "fixConvertToMappedObjectType", GEe = [p.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead.code]; + Qs({ + errorCodes: GEe, + getCodeActions: function(t) { + const { sourceFile: n, span: i } = t, s = $Ee(n, i.start); + if (!s) return; + const o = cn.ChangeTracker.with(t, (_) => XEe(_, n, s)), c = An(s.container.name); + return [Ls(uue, o, [p.Convert_0_to_mapped_object_type, c], uue, [p.Convert_0_to_mapped_object_type, c])]; + }, + fixIds: [uue], + getAllCodeActions: (e) => Qa(e, GEe, (t, n) => { + const i = $Ee(n.file, n.start); + i && XEe(t, n.file, i); + }) + }); + function $Ee(e, t) { + const n = vi(e, t), i = Bn(n.parent.parent, qy); + if (!i) return; + const s = Vl(i.parent) ? i.parent : Bn(i.parent.parent, Wp); + if (s) + return { indexSignature: i, container: s }; + } + function c$e(e, t) { + return N.createTypeAliasDeclaration(e.modifiers, e.name, e.typeParameters, t); + } + function XEe(e, t, { indexSignature: n, container: i }) { + const o = (Vl(i) ? i.members : i.type.members).filter((m) => !qy(m)), c = Ca(n.parameters), _ = N.createTypeParameterDeclaration( + /*modifiers*/ + void 0, + Us(c.name, Me), + c.type + ), u = N.createMappedTypeNode( + gS(n) ? N.createModifier( + 148 + /* ReadonlyKeyword */ + ) : void 0, + _, + /*nameType*/ + void 0, + n.questionToken, + n.type, + /*members*/ + void 0 + ), g = N.createIntersectionTypeNode([ + ...HD(i), + u, + ...o.length ? [N.createTypeLiteralNode(o)] : Ge + ]); + e.replaceNode(t, i, c$e(i, g)); + } + var QEe = "removeAccidentalCallParentheses", l$e = [ + p.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without.code + ]; + Qs({ + errorCodes: l$e, + getCodeActions(e) { + const t = dr(vi(e.sourceFile, e.span.start), Ps); + if (!t) + return; + const n = cn.ChangeTracker.with(e, (i) => { + i.deleteRange(e.sourceFile, { pos: t.expression.end, end: t.end }); + }); + return [jd(QEe, n, p.Remove_parentheses)]; + }, + fixIds: [QEe] + }); + var _ue = "removeUnnecessaryAwait", YEe = [ + p.await_has_no_effect_on_the_type_of_this_expression.code + ]; + Qs({ + errorCodes: YEe, + getCodeActions: function(t) { + const n = cn.ChangeTracker.with(t, (i) => ZEe(i, t.sourceFile, t.span)); + if (n.length > 0) + return [Ls(_ue, n, p.Remove_unnecessary_await, _ue, p.Remove_all_unnecessary_uses_of_await)]; + }, + fixIds: [_ue], + getAllCodeActions: (e) => Qa(e, YEe, (t, n) => ZEe(t, n.file, n)) + }); + function ZEe(e, t, n) { + const i = Bn( + vi(t, n.start), + (_) => _.kind === 135 + /* AwaitKeyword */ + ), s = i && Bn(i.parent, Hy); + if (!s) + return; + let o = s; + if (o_(s.parent)) { + const _ = n6( + s.expression, + /*stopAtCallExpressions*/ + !1 + ); + if (Me(_)) { + const u = pl(s.parent.pos, t); + u && u.kind !== 105 && (o = s.parent); + } + } + e.replaceNode(t, o, s.expression); + } + var KEe = [p.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code], fue = "splitTypeOnlyImport"; + Qs({ + errorCodes: KEe, + fixIds: [fue], + getCodeActions: function(t) { + const n = cn.ChangeTracker.with(t, (i) => tDe(i, eDe(t.sourceFile, t.span), t)); + if (n.length) + return [Ls(fue, n, p.Split_into_two_separate_import_declarations, fue, p.Split_all_invalid_type_only_imports)]; + }, + getAllCodeActions: (e) => Qa(e, KEe, (t, n) => { + tDe(t, eDe(e.sourceFile, n), e); + }) + }); + function eDe(e, t) { + return dr(vi(e, t.start), qo); + } + function tDe(e, t, n) { + if (!t) + return; + const i = E.checkDefined(t.importClause); + e.replaceNode( + n.sourceFile, + t, + N.updateImportDeclaration( + t, + t.modifiers, + N.updateImportClause( + i, + i.phaseModifier, + i.name, + /*namedBindings*/ + void 0 + ), + t.moduleSpecifier, + t.attributes + ) + ), e.insertNodeAfter( + n.sourceFile, + t, + N.createImportDeclaration( + /*modifiers*/ + void 0, + N.updateImportClause( + i, + i.phaseModifier, + /*name*/ + void 0, + i.namedBindings + ), + t.moduleSpecifier, + t.attributes + ) + ); + } + var pue = "fixConvertConstToLet", rDe = [p.Cannot_assign_to_0_because_it_is_a_constant.code]; + Qs({ + errorCodes: rDe, + getCodeActions: function(t) { + const { sourceFile: n, span: i, program: s } = t, o = nDe(n, i.start, s); + if (o === void 0) return; + const c = cn.ChangeTracker.with(t, (_) => iDe(_, n, o.token)); + return [kce(pue, c, p.Convert_const_to_let, pue, p.Convert_all_const_to_let)]; + }, + getAllCodeActions: (e) => { + const { program: t } = e, n = /* @__PURE__ */ new Set(); + return yk(cn.ChangeTracker.with(e, (i) => { + vk(e, rDe, (s) => { + const o = nDe(s.file, s.start, t); + if (o && Jp(n, Xs(o.symbol))) + return iDe(i, s.file, o.token); + }); + })); + }, + fixIds: [pue] + }); + function nDe(e, t, n) { + var i; + const o = n.getTypeChecker().getSymbolAtLocation(vi(e, t)); + if (o === void 0) return; + const c = Bn((i = o?.valueDeclaration) == null ? void 0 : i.parent, Ul); + if (c === void 0) return; + const _ = Ya(c, 87, e); + if (_ !== void 0) + return { symbol: o, token: _ }; + } + function iDe(e, t, n) { + e.replaceNode(t, n, N.createToken( + 121 + /* LetKeyword */ + )); + } + var due = "fixExpectedComma", u$e = p._0_expected.code, sDe = [u$e]; + Qs({ + errorCodes: sDe, + getCodeActions(e) { + const { sourceFile: t } = e, n = aDe(t, e.span.start, e.errorCode); + if (!n) return; + const i = cn.ChangeTracker.with(e, (s) => oDe(s, t, n)); + return [Ls( + due, + i, + [p.Change_0_to_1, ";", ","], + due, + [p.Change_0_to_1, ";", ","] + )]; + }, + fixIds: [due], + getAllCodeActions: (e) => Qa(e, sDe, (t, n) => { + const i = aDe(n.file, n.start, n.code); + i && oDe(t, e.sourceFile, i); + }) + }); + function aDe(e, t, n) { + const i = vi(e, t); + return i.kind === 27 && i.parent && (_a(i.parent) || nu(i.parent)) ? { node: i } : void 0; + } + function oDe(e, t, { node: n }) { + const i = N.createToken( + 28 + /* CommaToken */ + ); + e.replaceNode(t, n, i); + } + var _$e = "addVoidToPromise", cDe = "addVoidToPromise", lDe = [ + p.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments.code, + p.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise.code + ]; + Qs({ + errorCodes: lDe, + fixIds: [cDe], + getCodeActions(e) { + const t = cn.ChangeTracker.with(e, (n) => uDe(n, e.sourceFile, e.span, e.program)); + if (t.length > 0) + return [Ls(_$e, t, p.Add_void_to_Promise_resolved_without_a_value, cDe, p.Add_void_to_all_Promises_resolved_without_a_value)]; + }, + getAllCodeActions(e) { + return Qa(e, lDe, (t, n) => uDe(t, n.file, n, e.program, /* @__PURE__ */ new Set())); + } + }); + function uDe(e, t, n, i, s) { + const o = vi(t, n.start); + if (!Me(o) || !Ps(o.parent) || o.parent.expression !== o || o.parent.arguments.length !== 0) return; + const c = i.getTypeChecker(), _ = c.getSymbolAtLocation(o), u = _?.valueDeclaration; + if (!u || !Ii(u) || !Xb(u.parent.parent) || s?.has(u)) return; + s?.add(u); + const g = f$e(u.parent.parent); + if (ot(g)) { + const m = g[0], h = !C0(m) && !kS(m) && kS(N.createUnionTypeNode([m, N.createKeywordTypeNode( + 116 + /* VoidKeyword */ + )]).types[0]); + h && e.insertText(t, m.pos, "("), e.insertText(t, m.end, h ? ") | void" : " | void"); + } else { + const m = c.getResolvedSignature(o.parent), h = m?.parameters[0], S = h && c.getTypeOfSymbolAtLocation(h, u.parent.parent); + an(u) ? (!S || S.flags & 3) && (e.insertText(t, u.parent.parent.end, ")"), e.insertText(t, oa(t.text, u.parent.parent.pos), "/** @type {Promise} */(")) : (!S || S.flags & 2) && e.insertText(t, u.parent.parent.expression.end, ""); + } + } + function f$e(e) { + var t; + if (an(e)) { + if (o_(e.parent)) { + const n = (t = z1(e.parent)) == null ? void 0 : t.typeExpression.type; + if (n && of(n) && Me(n.typeName) && An(n.typeName) === "Promise") + return n.typeArguments; + } + } else + return e.typeArguments; + } + var Tk = {}; + Na(Tk, { + CompletionKind: () => DDe, + CompletionSource: () => fDe, + SortText: () => hu, + StringCompletions: () => VH, + SymbolOriginInfoKind: () => pDe, + createCompletionDetails: () => CL, + createCompletionDetailsForSymbol: () => xue, + getCompletionEntriesFromSymbols: () => Sue, + getCompletionEntryDetails: () => U$e, + getCompletionEntrySymbol: () => q$e, + getCompletionsAtPosition: () => b$e, + getDefaultCommitCharacters: () => GS, + getPropertiesForObjectExpression: () => zH, + moduleSpecifierResolutionCacheAttemptLimit: () => _De, + moduleSpecifierResolutionLimit: () => mue + }); + var mue = 100, _De = 1e3, hu = { + // Presets + LocalDeclarationPriority: "10", + LocationPriority: "11", + OptionalMember: "12", + MemberDeclaredBySpreadAssignment: "13", + SuggestedClassMembers: "14", + GlobalsOrKeywords: "15", + AutoImportSuggestions: "16", + ClassMemberSnippets: "17", + JavascriptIdentifiers: "18", + // Transformations + Deprecated(e) { + return "z" + e; + }, + ObjectLiteralProperty(e, t) { + return `${e}\0${t}\0`; + }, + SortBelow(e) { + return e + "1"; + } + }, Em = [".", ",", ";"], FH = [".", ";"], fDe = /* @__PURE__ */ ((e) => (e.ThisProperty = "ThisProperty/", e.ClassMemberSnippet = "ClassMemberSnippet/", e.TypeOnlyAlias = "TypeOnlyAlias/", e.ObjectLiteralMethodSnippet = "ObjectLiteralMethodSnippet/", e.SwitchCases = "SwitchCases/", e.ObjectLiteralMemberWithComma = "ObjectLiteralMemberWithComma/", e))(fDe || {}), pDe = /* @__PURE__ */ ((e) => (e[e.ThisType = 1] = "ThisType", e[e.SymbolMember = 2] = "SymbolMember", e[e.Export = 4] = "Export", e[e.Promise = 8] = "Promise", e[e.Nullable = 16] = "Nullable", e[e.ResolvedExport = 32] = "ResolvedExport", e[e.TypeOnlyAlias = 64] = "TypeOnlyAlias", e[e.ObjectLiteralMethod = 128] = "ObjectLiteralMethod", e[e.Ignore = 256] = "Ignore", e[e.ComputedPropertyName = 512] = "ComputedPropertyName", e[ + e.SymbolMemberNoExport = 2 + /* SymbolMember */ + ] = "SymbolMemberNoExport", e[e.SymbolMemberExport = 6] = "SymbolMemberExport", e))(pDe || {}); + function p$e(e) { + return !!(e.kind & 1); + } + function d$e(e) { + return !!(e.kind & 2); + } + function xL(e) { + return !!(e && e.kind & 4); + } + function Mw(e) { + return !!(e && e.kind === 32); + } + function m$e(e) { + return xL(e) || Mw(e) || gue(e); + } + function g$e(e) { + return (xL(e) || Mw(e)) && !!e.isFromPackageJson; + } + function h$e(e) { + return !!(e.kind & 8); + } + function y$e(e) { + return !!(e.kind & 16); + } + function dDe(e) { + return !!(e && e.kind & 64); + } + function mDe(e) { + return !!(e && e.kind & 128); + } + function v$e(e) { + return !!(e && e.kind & 256); + } + function gue(e) { + return !!(e && e.kind & 512); + } + function gDe(e, t, n, i, s, o, c, _, u) { + var g, m, h, S; + const T = ao(), k = c || dN(i.getCompilerOptions()) || ((g = o.autoImportSpecifierExcludeRegexes) == null ? void 0 : g.length); + let D = !1, P = 0, A = 0, O = 0, F = 0; + const R = u({ + tryResolve: U, + skippedAny: () => D, + resolvedAny: () => A > 0, + resolvedBeyondLimit: () => A > mue + }), B = F ? ` (${(O / F * 100).toFixed(1)}% hit rate)` : ""; + return (m = t.log) == null || m.call(t, `${e}: resolved ${A} module specifiers, plus ${P} ambient and ${O} from cache${B}`), (h = t.log) == null || h.call(t, `${e}: response is ${D ? "incomplete" : "complete"}`), (S = t.log) == null || S.call(t, `${e}: ${ao() - T}`), R; + function U($, W) { + if (W) { + const ae = n.getModuleSpecifierForBestExportInfo($, s, _); + return ae && P++, ae || "failed"; + } + const _e = k || o.allowIncompleteCompletions && A < mue, K = !_e && o.allowIncompleteCompletions && F < _De, V = _e || K ? n.getModuleSpecifierForBestExportInfo($, s, _, K) : void 0; + return (!_e && !K || K && !V) && (D = !0), A += V?.computedWithoutCacheCount || 0, O += $.length - (V?.computedWithoutCacheCount || 0), K && F++, V || (k ? "failed" : "skipped"); + } + } + function GS(e) { + return e ? [] : Em; + } + function b$e(e, t, n, i, s, o, c, _, u, g, m = !1) { + var h; + const { previousToken: S } = RH(s, i); + if (c && !_k(i, s, S) && !rXe(i, c, S, s)) + return; + if (c === " ") + return o.includeCompletionsForImportStatements && o.includeCompletionsWithInsertText ? { + isGlobalCompletion: !0, + isMemberCompletion: !1, + isNewIdentifierLocation: !0, + isIncomplete: !0, + entries: [], + defaultCommitCharacters: GS( + /*isNewIdentifierLocation*/ + !0 + ) + } : void 0; + const T = t.getCompilerOptions(), k = t.getTypeChecker(), D = o.allowIncompleteCompletions ? (h = e.getIncompleteCompletionsCache) == null ? void 0 : h.call(e) : void 0; + if (D && _ === 3 && S && Me(S)) { + const O = S$e(D, i, S, t, e, o, u, s); + if (O) + return O; + } else + D?.clear(); + const P = VH.getStringLiteralCompletions(i, s, S, T, e, t, n, o, m); + if (P) + return P; + if (S && xD(S.parent) && (S.kind === 83 || S.kind === 88 || S.kind === 80)) + return z$e(S.parent); + const A = wDe( + t, + n, + i, + T, + s, + o, + /*detailsEntryId*/ + void 0, + e, + g, + u + ); + if (A) + switch (A.kind) { + case 0: + const O = E$e(i, e, t, T, n, A, o, g, s, m); + return O?.isIncomplete && D?.set(O), O; + case 1: + return hue([ + ...Ev.getJSDocTagNameCompletions(), + ...yDe( + i, + s, + k, + T, + o, + /*tagNameOnly*/ + !0 + ) + ]); + case 2: + return hue([ + ...Ev.getJSDocTagCompletions(), + ...yDe( + i, + s, + k, + T, + o, + /*tagNameOnly*/ + !1 + ) + ]); + case 3: + return hue(Ev.getJSDocParameterNameCompletions(A.tag)); + case 4: + return k$e(A.keywordCompletions, A.isNewIdentifierLocation); + default: + return E.assertNever(A); + } + } + function kL(e, t) { + var n, i; + let s = WP(e.sortText, t.sortText); + return s === 0 && (s = WP(e.name, t.name)), s === 0 && ((n = e.data) != null && n.moduleSpecifier) && ((i = t.data) != null && i.moduleSpecifier) && (s = SN( + e.data.moduleSpecifier, + t.data.moduleSpecifier + )), s === 0 ? -1 : s; + } + function hDe(e) { + return !!e?.moduleSpecifier; + } + function S$e(e, t, n, i, s, o, c, _) { + const u = e.get(); + if (!u) return; + const g = w_(t, _), m = n.text.toLowerCase(), h = i8(t, s, i, o, c), S = gDe( + "continuePreviousIncompleteResponse", + s, + Ou.createImportSpecifierResolver(t, i, s, o), + i, + n.getStart(), + o, + /*isForImportStatementCompletion*/ + !1, + K1(n), + (T) => { + const k = Fi(u.entries, (D) => { + var P; + if (!D.hasAction || !D.source || !D.data || hDe(D.data)) + return D; + if (!UDe(D.name, m)) + return; + const { origin: A } = E.checkDefined(PDe(D.name, D.data, i, s)), O = h.get(t.path, D.data.exportMapKey), F = O && T.tryResolve(O, !Dl(Bp(A.moduleSymbol.name))); + if (F === "skipped") return D; + if (!F || F === "failed") { + (P = s.log) == null || P.call(s, `Unexpected failure resolving auto import for '${D.name}' from '${D.source}'`); + return; + } + const R = { + ...A, + kind: 32, + moduleSpecifier: F.moduleSpecifier + }; + return D.data = CDe(R), D.source = bue(R), D.sourceDisplay = [Bf(R.moduleSpecifier)], D; + }); + return T.skippedAny() || (u.isIncomplete = void 0), k; + } + ); + return u.entries = S, u.flags = (u.flags || 0) | 4, u.optionalReplacementSpan = SDe(g), u; + } + function hue(e) { + return { + isGlobalCompletion: !1, + isMemberCompletion: !1, + isNewIdentifierLocation: !1, + entries: e, + defaultCommitCharacters: GS( + /*isNewIdentifierLocation*/ + !1 + ) + }; + } + function yDe(e, t, n, i, s, o) { + const c = vi(e, t); + if (!OC(c) && !Od(c)) + return []; + const _ = Od(c) ? c : c.parent; + if (!Od(_)) + return []; + const u = _.parent; + if (!Es(u)) + return []; + const g = n_(e), m = s.includeCompletionsWithSnippetText || void 0, h = l0(_.tags, (S) => Lf(S) && S.getEnd() <= t); + return Fi(u.parameters, (S) => { + if (!wC(S).length) { + if (Me(S.name)) { + const T = { tabstop: 1 }, k = S.name.text; + let D = b8( + k, + S.initializer, + S.dotDotDotToken, + g, + /*isObject*/ + !1, + /*isSnippet*/ + !1, + n, + i, + s + ), P = m ? b8( + k, + S.initializer, + S.dotDotDotToken, + g, + /*isObject*/ + !1, + /*isSnippet*/ + !0, + n, + i, + s, + T + ) : void 0; + return o && (D = D.slice(1), P && (P = P.slice(1))), { + name: D, + kind: "parameter", + sortText: hu.LocationPriority, + insertText: m ? P : void 0, + isSnippet: m + }; + } else if (S.parent.parameters.indexOf(S) === h) { + const T = `param${h}`, k = vDe( + T, + S.name, + S.initializer, + S.dotDotDotToken, + g, + /*isSnippet*/ + !1, + n, + i, + s + ), D = m ? vDe( + T, + S.name, + S.initializer, + S.dotDotDotToken, + g, + /*isSnippet*/ + !0, + n, + i, + s + ) : void 0; + let P = k.join(v0(i) + "* "), A = D?.join(v0(i) + "* "); + return o && (P = P.slice(1), A && (A = A.slice(1))), { + name: P, + kind: "parameter", + sortText: hu.LocationPriority, + insertText: m ? A : void 0, + isSnippet: m + }; + } + } + }); + } + function vDe(e, t, n, i, s, o, c, _, u) { + if (!s) + return [ + b8( + e, + n, + i, + s, + /*isObject*/ + !1, + o, + c, + _, + u, + { tabstop: 1 } + ) + ]; + return g(e, t, n, i, { tabstop: 1 }); + function g(h, S, T, k, D) { + if (Of(S) && !k) { + const A = { tabstop: D.tabstop }, O = b8( + h, + T, + k, + s, + /*isObject*/ + !0, + o, + c, + _, + u, + A + ); + let F = []; + for (const R of S.elements) { + const B = m(h, R, A); + if (B) + F.push(...B); + else { + F = void 0; + break; + } + } + if (F) + return D.tabstop = A.tabstop, [O, ...F]; + } + return [ + b8( + h, + T, + k, + s, + /*isObject*/ + !1, + o, + c, + _, + u, + D + ) + ]; + } + function m(h, S, T) { + if (!S.propertyName && Me(S.name) || Me(S.name)) { + const k = S.propertyName ? FD(S.propertyName) : S.name.text; + if (!k) + return; + const D = `${h}.${k}`; + return [ + b8( + D, + S.initializer, + S.dotDotDotToken, + s, + /*isObject*/ + !1, + o, + c, + _, + u, + T + ) + ]; + } else if (S.propertyName) { + const k = FD(S.propertyName); + return k && g(`${h}.${k}`, S.name, S.initializer, S.dotDotDotToken, T); + } + } + } + function b8(e, t, n, i, s, o, c, _, u, g) { + if (o && E.assertIsDefined(g), t && (e = T$e(e, t)), o && (e = Vb(e)), i) { + let m = "*"; + if (s) + E.assert(!n, "Cannot annotate a rest parameter with type 'Object'."), m = "Object"; + else { + if (t) { + const T = c.getTypeAtLocation(t.parent); + if (!(T.flags & 16385)) { + const k = t.getSourceFile(), P = _f(k, u) === 0 ? 268435456 : 0, A = c.typeToTypeNode(T, dr(t, Es), P); + if (A) { + const O = o ? MH({ + removeComments: !0, + module: _.module, + moduleResolution: _.moduleResolution, + target: _.target + }) : Ky({ + removeComments: !0, + module: _.module, + moduleResolution: _.moduleResolution, + target: _.target + }); + un( + A, + 1 + /* SingleLine */ + ), m = O.printNode(4, A, k); + } + } + } + o && m === "*" && (m = `\${${g.tabstop++}:${m}}`); + } + const h = !s && n ? "..." : "", S = o ? `\${${g.tabstop++}}` : ""; + return `@param {${h}${m}} ${e} ${S}`; + } else { + const m = o ? `\${${g.tabstop++}}` : ""; + return `@param ${e} ${m}`; + } + } + function T$e(e, t) { + const n = t.getText().trim(); + return n.includes(` +`) || n.length > 80 ? `[${e}]` : `[${e}=${n}]`; + } + function x$e(e) { + return { + name: qs(e), + kind: "keyword", + kindModifiers: "", + sortText: hu.GlobalsOrKeywords + }; + } + function k$e(e, t) { + return { + isGlobalCompletion: !1, + isMemberCompletion: !1, + isNewIdentifierLocation: t, + entries: e.slice(), + defaultCommitCharacters: GS(t) + }; + } + function bDe(e, t, n) { + return { + kind: 4, + keywordCompletions: ADe(e, t), + isNewIdentifierLocation: n + }; + } + function C$e(e) { + switch (e) { + case 156: + return 8; + default: + E.fail("Unknown mapping from SyntaxKind to KeywordCompletionFilters"); + } + } + function SDe(e) { + return e?.kind === 80 ? u_(e) : void 0; + } + function E$e(e, t, n, i, s, o, c, _, u, g) { + const { + symbols: m, + contextToken: h, + completionKind: S, + isInSnippetScope: T, + isNewIdentifierLocation: k, + location: D, + propertyAccessToConvert: P, + keywordFilters: A, + symbolToOriginInfoMap: O, + recommendedCompletion: F, + isJsxInitializer: R, + isTypeOnlyLocation: B, + isJsxIdentifierExpected: U, + isRightOfOpenTag: $, + isRightOfDotOrQuestionDot: W, + importStatementCompletion: _e, + insideJsDocTagTypeExpression: K, + symbolToSortTextMap: V, + hasUnresolvedAutoImports: ae, + defaultCommitCharacters: se + } = o; + let ce = o.literals; + const fe = n.getTypeChecker(); + if (fN(e.scriptKind) === 1) { + const Z = w$e(D, e); + if (Z) + return Z; + } + const he = dr(h, y6); + if (he && (Mte(h) || Ob(h, he.expression))) { + const Z = $9(fe, he.parent.clauses); + ce = ce.filter((pe) => !Z.hasValue(pe)), m.forEach((pe, Te) => { + if (pe.valueDeclaration && Ph(pe.valueDeclaration)) { + const Fe = fe.getConstantValue(pe.valueDeclaration); + Fe !== void 0 && Z.hasValue(Fe) && (O[Te] = { + kind: 256 + /* Ignore */ + }); + } + }); + } + const q = PR(), be = TDe(e, i); + if (be && !k && (!m || m.length === 0) && A === 0) + return; + const je = Sue( + m, + q, + /*replacementToken*/ + void 0, + h, + D, + u, + e, + t, + n, + da(i), + s, + S, + c, + i, + _, + B, + P, + U, + R, + _e, + F, + O, + V, + U, + $, + g + ); + if (A !== 0) + for (const Z of ADe(A, !K && n_(e))) + (B && yw(Q2(Z.name)) || !B && _Xe(Z.name) || !je.has(Z.name)) && (je.add(Z.name), _y( + q, + Z, + kL, + /*equalityComparer*/ + void 0, + /*allowDuplicates*/ + !0 + )); + for (const Z of Y$e(h, u)) + je.has(Z.name) || (je.add(Z.name), _y( + q, + Z, + kL, + /*equalityComparer*/ + void 0, + /*allowDuplicates*/ + !0 + )); + for (const Z of ce) { + const pe = N$e(e, c, Z); + je.add(pe.name), _y( + q, + pe, + kL, + /*equalityComparer*/ + void 0, + /*allowDuplicates*/ + !0 + ); + } + be || P$e(e, D.pos, je, da(i), q); + let me; + if (c.includeCompletionsWithInsertText && h && !$ && !W && (me = dr(h, O4))) { + const Z = xDe(me, e, c, i, t, n, _); + Z && q.push(Z.entry); + } + return { + flags: o.flags, + isGlobalCompletion: T, + isIncomplete: c.allowIncompleteCompletions && ae ? !0 : void 0, + isMemberCompletion: D$e(S), + isNewIdentifierLocation: k, + optionalReplacementSpan: SDe(D), + entries: q, + defaultCommitCharacters: se ?? GS(k) + }; + } + function TDe(e, t) { + return !n_(e) || !!d4(e, t); + } + function xDe(e, t, n, i, s, o, c) { + const _ = e.clauses, u = o.getTypeChecker(), g = u.getTypeAtLocation(e.parent.expression); + if (g && g.isUnion() && Ni(g.types, (m) => m.isLiteral())) { + const m = $9(u, _), h = da(i), S = _f(t, n), T = Ou.createImportAdder(t, o, n, s), k = []; + for (const B of g.types) + if (B.flags & 1024) { + E.assert(B.symbol, "An enum member type should have a symbol"), E.assert(B.symbol.parent, "An enum member type should have a parent symbol (the enum symbol)"); + const U = B.symbol.valueDeclaration && u.getConstantValue(B.symbol.valueDeclaration); + if (U !== void 0) { + if (m.hasValue(U)) + continue; + m.addValue(U); + } + const $ = Ou.typeToAutoImportableTypeNode(u, T, B, e, h); + if (!$) + return; + const W = OH($, h, S); + if (!W) + return; + k.push(W); + } else if (!m.hasValue(B.value)) + switch (typeof B.value) { + case "object": + k.push(B.value.negative ? N.createPrefixUnaryExpression(41, N.createBigIntLiteral({ negative: !1, base10Value: B.value.base10Value })) : N.createBigIntLiteral(B.value)); + break; + case "number": + k.push(B.value < 0 ? N.createPrefixUnaryExpression(41, N.createNumericLiteral(-B.value)) : N.createNumericLiteral(B.value)); + break; + case "string": + k.push(N.createStringLiteral( + B.value, + S === 0 + /* Single */ + )); + break; + } + if (k.length === 0) + return; + const D = hr(k, (B) => N.createCaseClause(B, [])), P = Fh(s, c?.options), A = MH({ + removeComments: !0, + module: i.module, + moduleResolution: i.moduleResolution, + target: i.target, + newLine: n8(P) + }), O = c ? (B) => A.printAndFormatNode(4, B, t, c) : (B) => A.printNode(4, B, t), F = hr(D, (B, U) => n.includeCompletionsWithSnippetText ? `${O(B)}$${U + 1}` : `${O(B)}`).join(P); + return { + entry: { + name: `${A.printNode(4, D[0], t)} ...`, + kind: "", + sortText: hu.GlobalsOrKeywords, + insertText: F, + hasAction: T.hasFixes() || void 0, + source: "SwitchCases/", + isSnippet: n.includeCompletionsWithSnippetText ? !0 : void 0 + }, + importAdder: T + }; + } + } + function OH(e, t, n) { + switch (e.kind) { + case 184: + const i = e.typeName; + return LH(i, t, n); + case 200: + const s = OH(e.objectType, t, n), o = OH(e.indexType, t, n); + return s && o && N.createElementAccessExpression(s, o); + case 202: + const c = e.literal; + switch (c.kind) { + case 11: + return N.createStringLiteral( + c.text, + n === 0 + /* Single */ + ); + case 9: + return N.createNumericLiteral(c.text, c.numericLiteralFlags); + } + return; + case 197: + const _ = OH(e.type, t, n); + return _ && (Me(_) ? _ : N.createParenthesizedExpression(_)); + case 187: + return LH(e.exprName, t, n); + case 206: + E.fail("We should not get an import type after calling 'codefix.typeToAutoImportableTypeNode'."); + } + } + function LH(e, t, n) { + if (Me(e)) + return e; + const i = Si(e.right.escapedText); + return WJ(i, t) ? N.createPropertyAccessExpression( + LH(e.left, t, n), + i + ) : N.createElementAccessExpression( + LH(e.left, t, n), + N.createStringLiteral( + i, + n === 0 + /* Single */ + ) + ); + } + function D$e(e) { + switch (e) { + case 0: + case 3: + case 2: + return !0; + default: + return !1; + } + } + function w$e(e, t) { + const n = dr(e, (i) => { + switch (i.kind) { + case 288: + return !0; + case 44: + case 32: + case 80: + case 212: + return !1; + default: + return "quit"; + } + }); + if (n) { + const i = !!Ya(n, 32, t), c = n.parent.openingElement.tagName.getText(t) + (i ? "" : ">"), _ = u_(n.tagName), u = { + name: c, + kind: "class", + kindModifiers: void 0, + sortText: hu.LocationPriority + }; + return { + isGlobalCompletion: !1, + isMemberCompletion: !0, + isNewIdentifierLocation: !1, + optionalReplacementSpan: _, + entries: [u], + defaultCommitCharacters: GS( + /*isNewIdentifierLocation*/ + !1 + ) + }; + } + } + function P$e(e, t, n, i, s) { + nH(e).forEach((o, c) => { + if (o === t) + return; + const _ = Si(c); + !n.has(_) && R_(_, i) && (n.add(_), _y(s, { + name: _, + kind: "warning", + kindModifiers: "", + sortText: hu.JavascriptIdentifiers, + isFromUncheckedFile: !0, + commitCharacters: [] + }, kL)); + }); + } + function yue(e, t, n) { + return typeof n == "object" ? Ub(n) + "n" : gs(n) ? kw(e, t, n) : JSON.stringify(n); + } + function N$e(e, t, n) { + return { + name: yue(e, t, n), + kind: "string", + kindModifiers: "", + sortText: hu.LocationPriority, + commitCharacters: [] + }; + } + function A$e(e, t, n, i, s, o, c, _, u, g, m, h, S, T, k, D, P, A, O, F, R, B, U, $) { + var W, _e; + let K, V, ae = RV(n, o), se, ce, fe = bue(h), he, q, be; + const je = u.getTypeChecker(), me = h && y$e(h), Z = h && d$e(h) || m; + if (h && p$e(h)) + K = m ? `this${me ? "?." : ""}[${vue(c, O, g)}]` : `this${me ? "?." : "."}${g}`; + else if ((Z || me) && T) { + K = Z ? m ? `[${vue(c, O, g)}]` : `[${g}]` : g, (me || T.questionDotToken) && (K = `?.${K}`); + const Ye = Ya(T, 25, c) || Ya(T, 29, c); + if (!Ye) + return; + const ne = Ui(g, T.name.text) ? T.name.end : Ye.end; + ae = Nc(Ye.getStart(c), ne); + } + if (k && (K === void 0 && (K = g), K = `{${K}}`, typeof k != "boolean" && (ae = u_(k, c))), h && h$e(h) && T) { + K === void 0 && (K = g); + const Ye = pl(T.pos, c); + let ne = ""; + Ye && B9(Ye.end, Ye.parent, c) && (ne = ";"), ne += `(await ${T.expression.getText()})`, K = m ? `${ne}${K}` : `${ne}${me ? "?." : "."}${K}`; + const ie = Bn(T.parent, Hy) ? T.parent : T.expression; + ae = Nc(ie.getStart(c), T.end); + } + if (Mw(h) && (he = [Bf(h.moduleSpecifier)], D && ({ insertText: K, replacementSpan: ae } = B$e(g, D, h, P, c, u, O), ce = O.includeCompletionsWithSnippetText ? !0 : void 0)), h?.kind === 64 && (q = !0), F === 0 && i && ((W = pl(i.pos, c, i)) == null ? void 0 : W.kind) !== 28 && (rc(i.parent.parent) || pp(i.parent.parent) || z_(i.parent.parent) || Vg(i.parent) || ((_e = dr(i.parent, rl)) == null ? void 0 : _e.getLastToken(c)) === i || gu(i.parent) && js(c, i.getEnd()).line !== js(c, o).line) && (fe = "ObjectLiteralMemberWithComma/", q = !0), O.includeCompletionsWithClassMemberSnippets && O.includeCompletionsWithInsertText && F === 3 && F$e(e, s, c)) { + let Ye; + const ne = kDe( + _, + u, + A, + O, + g, + e, + s, + o, + i, + R + ); + if (ne) + ({ insertText: K, filterText: V, isSnippet: ce, importAdder: Ye } = ne), (Ye?.hasFixes() || ne.eraseRange) && (q = !0, fe = "ClassMemberSnippet/"); + else + return; + } + if (h && mDe(h) && ({ insertText: K, isSnippet: ce, labelDetails: be } = h, O.useLabelDetailsInCompletionEntries || (g = g + be.detail, be = void 0), fe = "ObjectLiteralMethodSnippet/", t = hu.SortBelow(t)), B && !U && O.includeCompletionsWithSnippetText && O.jsxAttributeCompletionStyle && O.jsxAttributeCompletionStyle !== "none" && !(Tm(s.parent) && s.parent.initializer)) { + let Ye = O.jsxAttributeCompletionStyle === "braces"; + const ne = je.getTypeOfSymbolAtLocation(e, s); + O.jsxAttributeCompletionStyle === "auto" && !(ne.flags & 528) && !(ne.flags & 1048576 && Nn(ne.types, (Se) => !!(Se.flags & 528))) && (ne.flags & 402653316 || ne.flags & 1048576 && Ni(ne.types, (Se) => !!(Se.flags & 402686084 || uae(Se))) ? (K = `${Vb(g)}=${kw(c, O, "$1")}`, ce = !0) : Ye = !0), Ye && (K = `${Vb(g)}={$1}`, ce = !0); + } + if (K !== void 0 && !O.includeCompletionsWithInsertText) + return; + (xL(h) || Mw(h)) && (se = CDe(h), q = !D); + const pe = dr(s, B5); + if (pe) { + const Ye = da(_.getCompilationSettings()); + if (!R_(g, Ye)) + K = vue(c, O, g), pe.kind === 276 && (ql.setText(c.text), ql.resetTokenState(o), ql.scan() === 130 && ql.scan() === 80 || (K += " as " + I$e(g, Ye))); + else if (pe.kind === 276) { + const ne = Q2(g); + ne && (ne === 135 || jB(ne)) && (K = `${g} as ${g}_`); + } + } + const Te = O0.getSymbolKind(je, e, s), Fe = Te === "warning" || Te === "string" ? [] : void 0; + return { + name: g, + kind: Te, + kindModifiers: O0.getSymbolModifiers(je, e), + sortText: t, + source: fe, + hasAction: q ? !0 : void 0, + isRecommended: J$e(e, S, je) || void 0, + insertText: K, + filterText: V, + replacementSpan: ae, + sourceDisplay: he, + labelDetails: be, + isSnippet: ce, + isPackageJsonImport: g$e(h) || void 0, + isImportStatementCompletion: !!D || void 0, + data: se, + commitCharacters: Fe, + ...$ ? { symbol: e } : void 0 + }; + } + function I$e(e, t) { + let n = !1, i = "", s; + for (let o = 0; o < e.length; o += s !== void 0 && s >= 65536 ? 2 : 1) + s = e.codePointAt(o), s !== void 0 && (o === 0 ? Vm(s, t) : hh(s, t)) ? (n && (i += "_"), i += String.fromCodePoint(s), n = !1) : n = !0; + return n && (i += "_"), i || "_"; + } + function F$e(e, t, n) { + return an(t) ? !1 : !!(e.flags & 106500) && ($n(t) || t.parent && t.parent.parent && Hc(t.parent) && t === t.parent.name && t.parent.getLastToken(n) === t.parent.name && $n(t.parent.parent) || t.parent && T6(t) && $n(t.parent)); + } + function kDe(e, t, n, i, s, o, c, _, u, g) { + const m = dr(c, $n); + if (!m) + return; + let h, S = s; + const T = s, k = t.getTypeChecker(), D = c.getSourceFile(), P = MH({ + removeComments: !0, + module: n.module, + moduleResolution: n.moduleResolution, + target: n.target, + omitTrailingSemicolon: !1, + newLine: n8(Fh(e, g?.options)) + }), A = Ou.createImportAdder(D, t, i, e); + let O; + if (i.includeCompletionsWithSnippetText) { + h = !0; + const _e = N.createEmptyStatement(); + O = N.createBlock( + [_e], + /*multiLine*/ + !0 + ), oz(_e, { kind: 0, order: 0 }); + } else + O = N.createBlock( + [], + /*multiLine*/ + !0 + ); + let F = 0; + const { modifiers: R, range: B, decorators: U } = O$e(u, D, _), $ = R & 64 && m.modifierFlagsCache & 64; + let W = []; + if (Ou.addNewNodeForMemberSymbol( + o, + m, + D, + { program: t, host: e }, + i, + A, + // `addNewNodeForMemberSymbol` calls this callback function for each new member node + // it adds for the given member symbol. + // We store these member nodes in the `completionNodes` array. + // Note: there might be: + // - No nodes if `addNewNodeForMemberSymbol` cannot figure out a node for the member; + // - One node; + // - More than one node if the member is overloaded (e.g. a method with overload signatures). + (_e) => { + let K = 0; + $ && (K |= 64), Hc(_e) && k.getMemberOverrideModifierStatus(m, _e, o) === 1 && (K |= 16), W.length || (F = _e.modifierFlagsCache | K), _e = N.replaceModifiers(_e, F), W.push(_e); + }, + O, + Ou.PreserveOptionalFlags.Property, + !!$ + ), W.length) { + const _e = o.flags & 8192; + let K = F | 16 | 1; + _e ? K |= 1024 : K |= 136; + const V = R & K; + if (R & ~K) + return; + if (F & 4 && V & 1 && (F &= -5), V !== 0 && !(V & 1) && (F &= -2), F |= V, W = W.map((se) => N.replaceModifiers(se, F)), U?.length) { + const se = W[W.length - 1]; + e2(se) && (W[W.length - 1] = N.replaceDecoratorsAndModifiers(se, U.concat(Tb(se) || []))); + } + const ae = 131073; + g ? S = P.printAndFormatSnippetList( + ae, + N.createNodeArray(W), + D, + g + ) : S = P.printSnippetList( + ae, + N.createNodeArray(W), + D + ); + } + return { insertText: S, filterText: T, isSnippet: h, importAdder: A, eraseRange: B }; + } + function O$e(e, t, n) { + if (!e || js(t, n).line > js(t, e.getEnd()).line) + return { + modifiers: 0 + /* None */ + }; + let i = 0, s, o; + const c = { pos: n, end: n }; + if (os(e.parent) && (o = L$e(e))) { + e.parent.modifiers && (i |= pm(e.parent.modifiers) & 98303, s = e.parent.modifiers.filter(ul) || [], c.pos = Math.min(...e.parent.modifiers.map((u) => u.getStart(t)))); + const _ = kx(o); + i & _ || (i |= _, c.pos = Math.min(c.pos, e.getStart(t))), e.parent.name !== e && (c.end = e.parent.name.getStart(t)); + } + return { modifiers: i, decorators: s, range: c.pos < c.end ? c : void 0 }; + } + function L$e(e) { + if (Zs(e)) + return e.kind; + if (Me(e)) { + const t = Z2(e); + if (t && Ey(t)) + return t; + } + } + function M$e(e, t, n, i, s, o, c, _) { + const u = c.includeCompletionsWithSnippetText || void 0; + let g = t; + const m = n.getSourceFile(), h = R$e(e, n, m, i, s, c); + if (!h) + return; + const S = MH({ + removeComments: !0, + module: o.module, + moduleResolution: o.moduleResolution, + target: o.target, + omitTrailingSemicolon: !1, + newLine: n8(Fh(s, _?.options)) + }); + _ ? g = S.printAndFormatSnippetList(80, N.createNodeArray( + [h], + /*hasTrailingComma*/ + !0 + ), m, _) : g = S.printSnippetList(80, N.createNodeArray( + [h], + /*hasTrailingComma*/ + !0 + ), m); + const T = Ky({ + removeComments: !0, + module: o.module, + moduleResolution: o.moduleResolution, + target: o.target, + omitTrailingSemicolon: !0 + }), k = N.createMethodSignature( + /*modifiers*/ + void 0, + /*name*/ + "", + h.questionToken, + h.typeParameters, + h.parameters, + h.type + ), D = { detail: T.printNode(4, k, m) }; + return { isSnippet: u, insertText: g, labelDetails: D }; + } + function R$e(e, t, n, i, s, o) { + const c = e.getDeclarations(); + if (!(c && c.length)) + return; + const _ = i.getTypeChecker(), u = c[0], g = qa( + _s(u), + /*includeTrivia*/ + !1 + ), m = _.getWidenedType(_.getTypeOfSymbolAtLocation(e, t)), S = 33554432 | (_f(n, o) === 0 ? 268435456 : 0); + switch (u.kind) { + case 172: + case 173: + case 174: + case 175: { + let T = m.flags & 1048576 && m.types.length < 10 ? _.getUnionType( + m.types, + 2 + /* Subtype */ + ) : m; + if (T.flags & 1048576) { + const O = kn(T.types, (F) => _.getSignaturesOfType( + F, + 0 + /* Call */ + ).length > 0); + if (O.length === 1) + T = O[0]; + else + return; + } + if (_.getSignaturesOfType( + T, + 0 + /* Call */ + ).length !== 1) + return; + const D = _.typeToTypeNode( + T, + t, + S, + /*internalFlags*/ + void 0, + Ou.getNoopSymbolTrackerWithResolver({ program: i, host: s }) + ); + if (!D || !Zm(D)) + return; + let P; + if (o.includeCompletionsWithSnippetText) { + const O = N.createEmptyStatement(); + P = N.createBlock( + [O], + /*multiLine*/ + !0 + ), oz(O, { kind: 0, order: 0 }); + } else + P = N.createBlock( + [], + /*multiLine*/ + !0 + ); + const A = D.parameters.map( + (O) => N.createParameterDeclaration( + /*modifiers*/ + void 0, + O.dotDotDotToken, + O.name, + /*questionToken*/ + void 0, + /*type*/ + void 0, + O.initializer + ) + ); + return N.createMethodDeclaration( + /*modifiers*/ + void 0, + /*asteriskToken*/ + void 0, + g, + /*questionToken*/ + void 0, + /*typeParameters*/ + void 0, + A, + /*type*/ + void 0, + P + ); + } + default: + return; + } + } + function MH(e) { + let t; + const n = cn.createWriter(v0(e)), i = Ky(e, n), s = { + ...n, + write: (S) => o(S, () => n.write(S)), + nonEscapingWrite: n.write, + writeLiteral: (S) => o(S, () => n.writeLiteral(S)), + writeStringLiteral: (S) => o(S, () => n.writeStringLiteral(S)), + writeSymbol: (S, T) => o(S, () => n.writeSymbol(S, T)), + writeParameter: (S) => o(S, () => n.writeParameter(S)), + writeComment: (S) => o(S, () => n.writeComment(S)), + writeProperty: (S) => o(S, () => n.writeProperty(S)) + }; + return { + printSnippetList: c, + printAndFormatSnippetList: u, + printNode: g, + printAndFormatNode: h + }; + function o(S, T) { + const k = Vb(S); + if (k !== S) { + const D = n.getTextPos(); + T(); + const P = n.getTextPos(); + t = Er(t || (t = []), { newText: k, span: { start: D, length: P - D } }); + } else + T(); + } + function c(S, T, k) { + const D = _(S, T, k); + return t ? cn.applyChanges(D, t) : D; + } + function _(S, T, k) { + return t = void 0, s.clear(), i.writeList(S, T, k, s), s.getText(); + } + function u(S, T, k, D) { + const P = { + text: _( + S, + T, + k + ), + getLineAndCharacterOfPosition(R) { + return js(this, R); + } + }, A = G9(D, k), O = ka(T, (R) => { + const B = cn.assignPositionsToNode(R); + return nl.formatNodeGivenIndentation( + B, + P, + k.languageVariant, + /* indentation */ + 0, + /* delta */ + 0, + { ...D, options: A } + ); + }), F = t ? X_(Bi(O, t), (R, B) => QI(R.span, B.span)) : O; + return cn.applyChanges(P.text, F); + } + function g(S, T, k) { + const D = m(S, T, k); + return t ? cn.applyChanges(D, t) : D; + } + function m(S, T, k) { + return t = void 0, s.clear(), i.writeNode(S, T, k, s), s.getText(); + } + function h(S, T, k, D) { + const P = { + text: m( + S, + T, + k + ), + getLineAndCharacterOfPosition(B) { + return js(this, B); + } + }, A = G9(D, k), O = cn.assignPositionsToNode(T), F = nl.formatNodeGivenIndentation( + O, + P, + k.languageVariant, + /* indentation */ + 0, + /* delta */ + 0, + { ...D, options: A } + ), R = t ? X_(Bi(F, t), (B, U) => QI(B.span, U.span)) : F; + return cn.applyChanges(P.text, R); + } + } + function CDe(e) { + const t = e.fileName ? void 0 : Bp(e.moduleSymbol.name), n = e.isFromPackageJson ? !0 : void 0; + return Mw(e) ? { + exportName: e.exportName, + exportMapKey: e.exportMapKey, + moduleSpecifier: e.moduleSpecifier, + ambientModuleName: t, + fileName: e.fileName, + isPackageJsonImport: n + } : { + exportName: e.exportName, + exportMapKey: e.exportMapKey, + fileName: e.fileName, + ambientModuleName: e.fileName ? void 0 : Bp(e.moduleSymbol.name), + isPackageJsonImport: e.isFromPackageJson ? !0 : void 0 + }; + } + function j$e(e, t, n) { + const i = e.exportName === "default", s = !!e.isPackageJsonImport; + return hDe(e) ? { + kind: 32, + exportName: e.exportName, + exportMapKey: e.exportMapKey, + moduleSpecifier: e.moduleSpecifier, + symbolName: t, + fileName: e.fileName, + moduleSymbol: n, + isDefaultExport: i, + isFromPackageJson: s + } : { + kind: 4, + exportName: e.exportName, + exportMapKey: e.exportMapKey, + symbolName: t, + fileName: e.fileName, + moduleSymbol: n, + isDefaultExport: i, + isFromPackageJson: s + }; + } + function B$e(e, t, n, i, s, o, c) { + const _ = t.replacementSpan, u = Vb(kw(s, c, n.moduleSpecifier)), g = n.isDefaultExport ? 1 : n.exportName === "export=" ? 2 : 0, m = c.includeCompletionsWithSnippetText ? "$1" : "", h = Ou.getImportKind( + s, + g, + o, + /*forceImportKeyword*/ + !0 + ), S = t.couldBeTypeOnlyImportSpecifier, T = t.isTopLevelTypeOnly ? ` ${qs( + 156 + /* TypeKeyword */ + )} ` : " ", k = S ? `${qs( + 156 + /* TypeKeyword */ + )} ` : "", D = i ? ";" : ""; + switch (h) { + case 3: + return { replacementSpan: _, insertText: `import${T}${Vb(e)}${m} = require(${u})${D}` }; + case 1: + return { replacementSpan: _, insertText: `import${T}${Vb(e)}${m} from ${u}${D}` }; + case 2: + return { replacementSpan: _, insertText: `import${T}* as ${Vb(e)} from ${u}${D}` }; + case 0: + return { replacementSpan: _, insertText: `import${T}{ ${k}${Vb(e)}${m} } from ${u}${D}` }; + } + } + function vue(e, t, n) { + return /^\d+$/.test(n) ? n : kw(e, t, n); + } + function J$e(e, t, n) { + return e === t || !!(e.flags & 1048576) && n.getExportSymbolOfSymbol(e) === t; + } + function bue(e) { + if (xL(e)) + return Bp(e.moduleSymbol.name); + if (Mw(e)) + return e.moduleSpecifier; + if (e?.kind === 1) + return "ThisProperty/"; + if (e?.kind === 64) + return "TypeOnlyAlias/"; + } + function Sue(e, t, n, i, s, o, c, _, u, g, m, h, S, T, k, D, P, A, O, F, R, B, U, $, W, _e = !1) { + const K = ao(), V = oXe(i, s), ae = KA(c), se = u.getTypeChecker(), ce = /* @__PURE__ */ new Map(); + for (let q = 0; q < e.length; q++) { + const be = e[q], je = B?.[q], me = jH(be, g, je, h, !!A); + if (!me || ce.get(me.name) && (!je || !mDe(je)) || h === 1 && U && !fe(be, U) || !D && an(c) && he(be)) + continue; + const { name: Z, needsConvertPropertyAccess: pe } = me, Te = U?.[Xs(be)] ?? hu.LocationPriority, Fe = lXe(be, se) ? hu.Deprecated(Te) : Te, Ye = A$e( + be, + Fe, + n, + i, + s, + o, + c, + _, + u, + Z, + pe, + je, + R, + P, + O, + F, + ae, + T, + S, + h, + k, + $, + W, + _e + ); + if (!Ye) + continue; + const ne = (!je || dDe(je)) && !(be.parent === void 0 && !ot(be.declarations, (Se) => Se.getSourceFile() === s.getSourceFile())); + ce.set(Z, ne), _y( + t, + Ye, + kL, + /*equalityComparer*/ + void 0, + /*allowDuplicates*/ + !0 + ); + } + return m("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (ao() - K)), { + has: (q) => ce.has(q), + add: (q) => ce.set(q, !0) + }; + function fe(q, be) { + var je; + let me = q.flags; + if (s.parent && Mo(s.parent)) + return !0; + if (V && Bn(V, ei) && (q.valueDeclaration === V || ws(V.name) && V.name.elements.some((Te) => Te === q.valueDeclaration))) + return !1; + const Z = q.valueDeclaration ?? ((je = q.declarations) == null ? void 0 : je[0]); + if (V && Z) { + if (Ii(V) && Ii(Z)) { + const Te = V.parent.parameters; + if (Z.pos >= V.pos && Z.pos < Te.end) + return !1; + } else if (Lo(V) && Lo(Z)) { + if (V === Z && i?.kind === 96) + return !1; + if (cXe(i) && !xS(V.parent)) { + const Te = V.parent.typeParameters; + if (Te && Z.pos >= V.pos && Z.pos < Te.end) + return !1; + } + } + } + const pe = eu(q, se); + return c.externalModuleIndicator && !T.allowUmdGlobalAccess && be[Xs(q)] === hu.GlobalsOrKeywords && (be[Xs(pe)] === hu.AutoImportSuggestions || be[Xs(pe)] === hu.LocationPriority) ? !1 : (me |= t6(pe), d9(s) ? !!(me & 1920) : D ? Eue(q, se) : !!(me & 111551)); + } + function he(q) { + var be; + const je = t6(eu(q, se)); + return !(je & 111551) && (!an((be = q.declarations) == null ? void 0 : be[0]) || !!(je & 788968)); + } + } + function z$e(e) { + const t = W$e(e); + if (t.length) + return { + isGlobalCompletion: !1, + isMemberCompletion: !1, + isNewIdentifierLocation: !1, + entries: t, + defaultCommitCharacters: GS( + /*isNewIdentifierLocation*/ + !1 + ) + }; + } + function W$e(e) { + const t = [], n = /* @__PURE__ */ new Map(); + let i = e; + for (; i && !Es(i); ) { + if (Gy(i)) { + const s = i.label.text; + n.has(s) || (n.set(s, !0), t.push({ + name: s, + kindModifiers: "", + kind: "label", + sortText: hu.LocationPriority + })); + } + i = i.parent; + } + return t; + } + function EDe(e, t, n, i, s, o, c) { + if (s.source === "SwitchCases/") + return { type: "cases" }; + if (s.data) { + const F = PDe(s.name, s.data, e, o); + if (F) { + const { contextToken: R, previousToken: B } = RH(i, n); + return { + type: "symbol", + symbol: F.symbol, + location: w_(n, i), + previousToken: B, + contextToken: R, + isJsxInitializer: !1, + isTypeOnlyLocation: !1, + origin: F.origin + }; + } + } + const _ = e.getCompilerOptions(), u = wDe( + e, + t, + n, + _, + i, + { includeCompletionsForModuleExports: !0, includeCompletionsWithInsertText: !0 }, + s, + o, + /*formatContext*/ + void 0 + ); + if (!u) + return { type: "none" }; + if (u.kind !== 0) + return { type: "request", request: u }; + const { symbols: g, literals: m, location: h, completionKind: S, symbolToOriginInfoMap: T, contextToken: k, previousToken: D, isJsxInitializer: P, isTypeOnlyLocation: A } = u, O = Nn(m, (F) => yue(n, c, F) === s.name); + return O !== void 0 ? { type: "literal", literal: O } : Lc(g, (F, R) => { + const B = T[R], U = jH(F, da(_), B, S, u.isJsxIdentifierExpected); + return U && U.name === s.name && (s.source === "ClassMemberSnippet/" && F.flags & 106500 || s.source === "ObjectLiteralMethodSnippet/" && F.flags & 8196 || bue(B) === s.source || s.source === "ObjectLiteralMemberWithComma/") ? { type: "symbol", symbol: F, location: h, origin: B, contextToken: k, previousToken: D, isJsxInitializer: P, isTypeOnlyLocation: A } : void 0; + }) || { type: "none" }; + } + function U$e(e, t, n, i, s, o, c, _, u) { + const g = e.getTypeChecker(), m = e.getCompilerOptions(), { name: h, source: S, data: T } = s, { previousToken: k, contextToken: D } = RH(i, n); + if (_k(n, i, k)) + return VH.getStringLiteralCompletionDetails(h, n, i, k, e, o, u, _); + const P = EDe(e, t, n, i, s, o, _); + switch (P.type) { + case "request": { + const { request: A } = P; + switch (A.kind) { + case 1: + return Ev.getJSDocTagNameCompletionDetails(h); + case 2: + return Ev.getJSDocTagCompletionDetails(h); + case 3: + return Ev.getJSDocParameterNameCompletionDetails(h); + case 4: + return ot(A.keywordCompletions, (O) => O.name === h) ? Tue( + h, + "keyword", + 5 + /* keyword */ + ) : void 0; + default: + return E.assertNever(A); + } + } + case "symbol": { + const { symbol: A, location: O, contextToken: F, origin: R, previousToken: B } = P, { codeActions: U, sourceDisplay: $ } = V$e(h, O, F, R, A, e, o, m, n, i, B, c, _, T, S, u), W = gue(R) ? R.symbolName : A.name; + return xue(A, W, g, n, O, u, U, $); + } + case "literal": { + const { literal: A } = P; + return Tue( + yue(n, _, A), + "string", + typeof A == "string" ? 8 : 7 + /* numericLiteral */ + ); + } + case "cases": { + const A = xDe( + D.parent, + n, + _, + e.getCompilerOptions(), + o, + e, + /*formatContext*/ + void 0 + ); + if (A?.importAdder.hasFixes()) { + const { entry: O, importAdder: F } = A, R = cn.ChangeTracker.with( + { host: o, formatContext: c, preferences: _ }, + F.writeFixes + ); + return { + name: O.name, + kind: "", + kindModifiers: "", + displayParts: [], + sourceDisplay: void 0, + codeActions: [{ + changes: R, + description: l2([p.Includes_imports_of_types_referenced_by_0, h]) + }] + }; + } + return { + name: h, + kind: "", + kindModifiers: "", + displayParts: [], + sourceDisplay: void 0 + }; + } + case "none": + return NDe().some((A) => A.name === h) ? Tue( + h, + "keyword", + 5 + /* keyword */ + ) : void 0; + default: + E.assertNever(P); + } + } + function Tue(e, t, n) { + return CL(e, "", t, [W_(e, n)]); + } + function xue(e, t, n, i, s, o, c, _) { + const { displayParts: u, documentation: g, symbolKind: m, tags: h } = n.runWithCancellationToken(o, (S) => O0.getSymbolDisplayPartsDocumentationAndSymbolKind( + S, + e, + i, + s, + s, + 7 + /* All */ + )); + return CL(t, O0.getSymbolModifiers(n, e), m, u, g, h, c, _); + } + function CL(e, t, n, i, s, o, c, _) { + return { name: e, kindModifiers: t, kind: n, displayParts: i, documentation: s, tags: o, codeActions: c, source: _, sourceDisplay: _ }; + } + function V$e(e, t, n, i, s, o, c, _, u, g, m, h, S, T, k, D) { + if (T?.moduleSpecifier && m && jDe(n || m, u).replacementSpan) + return { codeActions: void 0, sourceDisplay: [Bf(T.moduleSpecifier)] }; + if (k === "ClassMemberSnippet/") { + const { importAdder: U, eraseRange: $ } = kDe( + c, + o, + _, + S, + e, + s, + t, + g, + n, + h + ); + if (U?.hasFixes() || $) + return { + sourceDisplay: void 0, + codeActions: [{ + changes: cn.ChangeTracker.with( + { host: c, formatContext: h, preferences: S }, + (_e) => { + U && U.writeFixes(_e), $ && _e.deleteRange(u, $); + } + ), + description: U?.hasFixes() ? l2([p.Includes_imports_of_types_referenced_by_0, e]) : l2([p.Update_modifiers_of_0, e]) + }] + }; + } + if (dDe(i)) { + const U = Ou.getPromoteTypeOnlyCompletionAction( + u, + i.declaration.name, + o, + c, + h, + S + ); + return E.assertIsDefined(U, "Expected to have a code action for promoting type-only alias"), { codeActions: [U], sourceDisplay: void 0 }; + } + if (k === "ObjectLiteralMemberWithComma/" && n) { + const U = cn.ChangeTracker.with( + { host: c, formatContext: h, preferences: S }, + ($) => $.insertText(u, n.end, ",") + ); + if (U) + return { + sourceDisplay: void 0, + codeActions: [{ + changes: U, + description: l2([p.Add_missing_comma_for_object_member_completion_0, e]) + }] + }; + } + if (!i || !(xL(i) || Mw(i))) + return { codeActions: void 0, sourceDisplay: void 0 }; + const P = i.isFromPackageJson ? c.getPackageJsonAutoImportProvider().getTypeChecker() : o.getTypeChecker(), { moduleSymbol: A } = i, O = P.getMergedSymbol(eu(s.exportSymbol || s, P)), F = n?.kind === 30 && wu(n.parent), { moduleSpecifier: R, codeAction: B } = Ou.getImportCompletionAction( + O, + A, + T?.exportMapKey, + u, + e, + F, + c, + o, + h, + m && Me(m) ? m.getStart(u) : g, + S, + D + ); + return E.assert(!T?.moduleSpecifier || R === T.moduleSpecifier), { sourceDisplay: [Bf(R)], codeActions: [B] }; + } + function q$e(e, t, n, i, s, o, c) { + const _ = EDe(e, t, n, i, s, o, c); + return _.type === "symbol" ? _.symbol : void 0; + } + var DDe = /* @__PURE__ */ ((e) => (e[e.ObjectPropertyDeclaration = 0] = "ObjectPropertyDeclaration", e[e.Global = 1] = "Global", e[e.PropertyAccess = 2] = "PropertyAccess", e[e.MemberLike = 3] = "MemberLike", e[e.String = 4] = "String", e[e.None = 5] = "None", e))(DDe || {}); + function H$e(e, t, n) { + return Lc(t && (t.isUnion() ? t.types : [t]), (i) => { + const s = i && i.symbol; + return s && s.flags & 424 && !gee(s) ? kue(s, e, n) : void 0; + }); + } + function G$e(e, t, n, i) { + const { parent: s } = e; + switch (e.kind) { + case 80: + return R9(e, i); + case 64: + switch (s.kind) { + case 261: + return i.getContextualType(s.initializer); + // TODO: GH#18217 + case 227: + return i.getTypeAtLocation(s.left); + case 292: + return i.getContextualTypeForJsxAttribute(s); + default: + return; + } + case 105: + return i.getContextualType(s); + case 84: + const o = Bn(s, y6); + return o ? sq(o, i) : void 0; + case 19: + return h6(s) && !Sm(s.parent) && !cv(s.parent) ? i.getContextualTypeForJsxAttribute(s.parent) : void 0; + default: + const c = D8.getArgumentInfoForCompletions(e, t, n, i); + return c ? i.getContextualTypeForArgumentAtIndex(c.invocation, c.argumentIndex) : j9(e.kind) && _n(s) && j9(s.operatorToken.kind) ? ( + // completion at `x ===/**/` should be for the right side + i.getTypeAtLocation(s.left) + ) : i.getContextualType( + e, + 4 + /* Completions */ + ) || i.getContextualType(e); + } + } + function kue(e, t, n) { + const i = n.getAccessibleSymbolChain( + e, + t, + /*meaning*/ + -1, + /*useOnlyExternalAliasing*/ + !1 + ); + return i ? Ca(i) : e.parent && ($$e(e.parent) ? e : kue(e.parent, t, n)); + } + function $$e(e) { + var t; + return !!((t = e.declarations) != null && t.some( + (n) => n.kind === 308 + /* SourceFile */ + )); + } + function wDe(e, t, n, i, s, o, c, _, u, g) { + const m = e.getTypeChecker(), h = TDe(n, i); + let S = ao(), T = vi(n, s); + t("getCompletionData: Get current token: " + (ao() - S)), S = ao(); + const k = P0(n, s, T); + t("getCompletionData: Is inside comment: " + (ao() - S)); + let D = !1, P = !1, A = !1; + if (k) { + if (oae(n, s)) { + if (n.text.charCodeAt(s - 1) === 64) + return { + kind: 1 + /* JsDocTagName */ + }; + { + const at = Hp(s, n); + if (!/[^*|\s(/)]/.test(n.text.substring(at, s))) + return { + kind: 2 + /* JsDocTag */ + }; + } + } + const ke = Z$e(T, s); + if (ke) { + if (ke.tagName.pos <= s && s <= ke.tagName.end) + return { + kind: 1 + /* JsDocTagName */ + }; + if (xm(ke)) + P = !0; + else { + const at = tr(ke); + if (at && (T = vi(n, s), (!T || !Qm(T) && (T.parent.kind !== 349 || T.parent.name !== T)) && (D = Mt(at))), !D && Lf(ke) && (lc(ke.name) || ke.name.pos <= s && s <= ke.name.end)) + return { kind: 3, tag: ke }; + } + } + if (!D && !P) { + t("Returning an empty list because completion was inside a regular comment or plain text part of a JsDoc comment."); + return; + } + } + S = ao(); + const O = !D && !P && n_(n), F = RH(s, n), R = F.previousToken; + let B = F.contextToken; + t("getCompletionData: Get previous token: " + (ao() - S)); + let U = T, $, W = !1, _e = !1, K = !1, V = !1, ae = !1, se = !1, ce, fe = w_(n, s), he = 0, q = !1, be = 0, je; + if (B) { + const ke = jDe(B, n); + if (ke.keywordCompletion) { + if (ke.isKeywordOnlyCompletion) + return { + kind: 4, + keywordCompletions: [x$e(ke.keywordCompletion)], + isNewIdentifierLocation: ke.isNewIdentifierLocation + }; + he = C$e(ke.keywordCompletion); + } + if (ke.replacementSpan && o.includeCompletionsForImportStatements && o.includeCompletionsWithInsertText && (be |= 2, ce = ke, q = ke.isNewIdentifierLocation), !ke.replacementSpan && Ds(B)) + return t("Returning an empty list because completion was requested in an invalid position."), he ? bDe(he, O, yr().isNewIdentifierLocation) : void 0; + let at = B.parent; + if (B.kind === 25 || B.kind === 29) + switch (W = B.kind === 25, _e = B.kind === 29, at.kind) { + case 212: + $ = at, U = $.expression; + const wt = r6($); + if (lc(wt) || (Ps(U) || Es(U)) && U.end === B.pos && U.getChildCount(n) && pa(U.getChildren(n)).kind !== 22) + return; + break; + case 167: + U = at.left; + break; + case 268: + U = at.name; + break; + case 206: + U = at; + break; + case 237: + U = at.getFirstToken(n), E.assert( + U.kind === 102 || U.kind === 105 + /* NewKeyword */ + ); + break; + default: + return; + } + else if (!ce) { + if (at && at.kind === 212 && (B = at, at = at.parent), T.parent === fe) + switch (T.kind) { + case 32: + (T.parent.kind === 285 || T.parent.kind === 287) && (fe = T); + break; + case 44: + T.parent.kind === 286 && (fe = T); + break; + } + switch (at.kind) { + case 288: + B.kind === 44 && (V = !0, fe = B); + break; + case 227: + if (!RDe(at)) + break; + // falls through + case 286: + case 285: + case 287: + se = !0, B.kind === 30 && (K = !0, fe = B); + break; + case 295: + case 294: + (R.kind === 20 || R.kind === 80 && R.parent.kind === 292) && (se = !0); + break; + case 292: + if (at.initializer === R && R.end < s) { + se = !0; + break; + } + switch (R.kind) { + case 64: + ae = !0; + break; + case 80: + se = !0, at !== R.parent && !at.initializer && Ya(at, 64, n) && (ae = R); + } + break; + } + } + } + const me = ao(); + let Z = 5, pe = !1, Te = [], Fe; + const Ye = [], ne = [], Se = /* @__PURE__ */ new Set(), ie = _i(), Ne = nm((ke) => bv(ke ? _.getPackageJsonAutoImportProvider() : e, _)); + if (W || _e) + Nr(); + else if (K) + Te = m.getJsxIntrinsicTagNamesAt(fe), E.assertEachIsDefined(Te, "getJsxIntrinsicTagNames() should all be defined"), ui(), Z = 1, he = 0; + else if (V) { + const ke = B.parent.parent.openingElement.tagName, at = m.getSymbolAtLocation(ke); + at && (Te = [at]), Z = 1, he = 0; + } else if (!ui()) + return he ? bDe(he, O, q) : void 0; + t("getCompletionData: Semantic work: " + (ao() - me)); + const Ee = R && G$e(R, s, n, m), Ve = !Bn(R, ja) && !se ? Fi( + Ee && (Ee.isUnion() ? Ee.types : [Ee]), + (ke) => ke.isLiteral() && !(ke.flags & 1024) ? ke.value : void 0 + ) : [], St = R && Ee && H$e(R, Ee, m); + return { + kind: 0, + symbols: Te, + completionKind: Z, + isInSnippetScope: A, + propertyAccessToConvert: $, + isNewIdentifierLocation: q, + location: fe, + keywordFilters: he, + literals: Ve, + symbolToOriginInfoMap: Ye, + recommendedCompletion: St, + previousToken: R, + contextToken: B, + isJsxInitializer: ae, + insideJsDocTagTypeExpression: D, + symbolToSortTextMap: ne, + isTypeOnlyLocation: ie, + isJsxIdentifierExpected: se, + isRightOfOpenTag: K, + isRightOfDotOrQuestionDot: W || _e, + importStatementCompletion: ce, + hasUnresolvedAutoImports: pe, + flags: be, + defaultCommitCharacters: je + }; + function Bt(ke) { + switch (ke.kind) { + case 342: + case 349: + case 343: + case 345: + case 347: + case 350: + case 351: + return !0; + case 346: + return !!ke.constraint; + default: + return !1; + } + } + function tr(ke) { + if (Bt(ke)) { + const at = Up(ke) ? ke.constraint : ke.typeExpression; + return at && at.kind === 310 ? at : void 0; + } + if (Yx(ke) || LF(ke)) + return ke.class; + } + function Nr() { + Z = 2; + const ke = bh(U), at = ke && !U.isTypeOf || lm(U.parent) || UA(B, n, m), wt = d9(U); + if (r_(U) || ke || wn(U)) { + const Zr = jc(U.parent); + Zr && (q = !0, je = []); + let Rr = m.getSymbolAtLocation(U); + if (Rr && (Rr = eu(Rr, m), Rr.flags & 1920)) { + const Pr = m.getExportsOfModule(Rr); + E.assertEachIsDefined(Pr, "getExportsOfModule() should all be defined"); + const rt = (Jt) => m.isValidPropertyAccess(ke ? U : U.parent, Jt.name), vt = (Jt) => Eue(Jt, m), Nt = Zr ? (Jt) => { + var _r; + return !!(Jt.flags & 1920) && !((_r = Jt.declarations) != null && _r.every((nr) => nr.parent === U.parent)); + } : wt ? ( + // Any kind is allowed when dotting off namespace in internal import equals declaration + (Jt) => vt(Jt) || rt(Jt) + ) : at || D ? vt : rt; + for (const Jt of Pr) + Nt(Jt) && Te.push(Jt); + if (!at && !D && Rr.declarations && Rr.declarations.some( + (Jt) => Jt.kind !== 308 && Jt.kind !== 268 && Jt.kind !== 267 + /* EnumDeclaration */ + )) { + let Jt = m.getTypeOfSymbolAtLocation(Rr, U).getNonOptionalType(), _r = !1; + if (Jt.isNullableType()) { + const nr = W && !_e && o.includeAutomaticOptionalChainCompletions !== !1; + (nr || _e) && (Jt = Jt.getNonNullableType(), nr && (_r = !0)); + } + st(Jt, !!(U.flags & 65536), _r); + } + return; + } + } + if (!at || Tx(U)) { + m.tryGetThisTypeAt( + U, + /*includeGlobalThis*/ + !1 + ); + let Zr = m.getTypeAtLocation(U).getNonOptionalType(); + if (at) + st( + Zr.getNonNullableType(), + /*insertAwait*/ + !1, + /*insertQuestionDot*/ + !1 + ); + else { + let Rr = !1; + if (Zr.isNullableType()) { + const Pr = W && !_e && o.includeAutomaticOptionalChainCompletions !== !1; + (Pr || _e) && (Zr = Zr.getNonNullableType(), Pr && (Rr = !0)); + } + st(Zr, !!(U.flags & 65536), Rr); + } + } + } + function st(ke, at, wt) { + ke.getStringIndexType() && (q = !0, je = []), _e && ot(ke.getCallSignatures()) && (q = !0, je ?? (je = Em)); + const Zr = U.kind === 206 ? U : U.parent; + if (h) + for (const Rr of ke.getApparentProperties()) + m.isValidPropertyAccessForCompletions(Zr, ke, Rr) && Wt( + Rr, + /*insertAwait*/ + !1, + wt + ); + else + Te.push(...kn(WH(ke, m), (Rr) => m.isValidPropertyAccessForCompletions(Zr, ke, Rr))); + if (at && o.includeCompletionsWithInsertText) { + const Rr = m.getPromisedTypeOfPromise(ke); + if (Rr) + for (const Pr of Rr.getApparentProperties()) + m.isValidPropertyAccessForCompletions(Zr, Rr, Pr) && Wt( + Pr, + /*insertAwait*/ + !0, + wt + ); + } + } + function Wt(ke, at, wt) { + var Zr; + const Rr = Lc(ke.declarations, (Nt) => Bn(_s(Nt), Gs)); + if (Rr) { + const Nt = Jr(Rr.expression), Jt = Nt && m.getSymbolAtLocation(Nt), _r = Jt && kue(Jt, B, m), nr = _r && Xs(_r); + if (nr && Jp(Se, nr)) { + const kt = Te.length; + Te.push(_r), ne[Xs(_r)] = hu.GlobalsOrKeywords; + const cr = _r.parent; + if (!cr || !lx(cr) || m.tryGetMemberInModuleExportsAndProperties(_r.name, cr) !== _r) + Ye[kt] = { kind: vt( + 2 + /* SymbolMemberNoExport */ + ) }; + else { + const fr = Dl(Bp(cr.name)) ? (Zr = y3(cr)) == null ? void 0 : Zr.fileName : void 0, { moduleSpecifier: vr } = (Fe || (Fe = Ou.createImportSpecifierResolver(n, e, _, o))).getModuleSpecifierForBestExportInfo( + [{ + exportKind: 0, + moduleFileName: fr, + isFromPackageJson: !1, + moduleSymbol: cr, + symbol: _r, + targetFlags: eu(_r, m).flags + }], + s, + K1(fe) + ) || {}; + if (vr) { + const Xt = { + kind: vt( + 6 + /* SymbolMemberExport */ + ), + moduleSymbol: cr, + isDefaultExport: !1, + symbolName: _r.name, + exportName: _r.name, + fileName: fr, + moduleSpecifier: vr + }; + Ye[kt] = Xt; + } + } + } else if (o.includeCompletionsWithInsertText) { + if (nr && Se.has(nr)) + return; + rt(ke), Pr(ke), Te.push(ke); + } + } else + rt(ke), Pr(ke), Te.push(ke); + function Pr(Nt) { + iXe(Nt) && (ne[Xs(Nt)] = hu.LocalDeclarationPriority); + } + function rt(Nt) { + o.includeCompletionsWithInsertText && (at && Jp(Se, Xs(Nt)) ? Ye[Te.length] = { kind: vt( + 8 + /* Promise */ + ) } : wt && (Ye[Te.length] = { + kind: 16 + /* Nullable */ + })); + } + function vt(Nt) { + return wt ? Nt | 16 : Nt; + } + } + function Jr(ke) { + return Me(ke) ? ke : wn(ke) ? Jr(ke.expression) : void 0; + } + function ui() { + return (Xe() || Et() || Mn() || re() || it() || Y() || Ji() || Ae() || Dt() || (ai(), 1)) === 1; + } + function Ji() { + return Ke(B) ? (Z = 5, q = !0, he = 4, 1) : 0; + } + function Dt() { + const ke = Le(B), at = ke && m.getContextualType(ke.attributes); + if (!at) return 0; + const wt = ke && m.getContextualType( + ke.attributes, + 4 + /* Completions */ + ); + return Te = Bi(Te, dt(zH(at, wt, ke.attributes, m), ke.attributes.properties)), ue(), Z = 3, q = !1, 1; + } + function Mn() { + return ce ? (q = !0, er(), 1) : 0; + } + function ai() { + he = Tt(B) ? 5 : 1, Z = 1, { isNewIdentifierLocation: q, defaultCommitCharacters: je } = yr(), R !== B && E.assert(!!R, "Expected 'contextToken' to be defined when different from 'previousToken'."); + const ke = R !== B ? R.getStart() : s, at = ki(B, ke, n) || n; + A = pn(at); + const wt = (ie ? 0 : 111551) | 788968 | 1920 | 2097152, Zr = R && !K1(R); + Te = Bi(Te, m.getSymbolsInScope(at, wt)), E.assertEachIsDefined(Te, "getSymbolsInScope() should all be defined"); + for (let Rr = 0; Rr < Te.length; Rr++) { + const Pr = Te[Rr]; + if (!m.isArgumentsSymbol(Pr) && !ot(Pr.declarations, (rt) => rt.getSourceFile() === n) && (ne[Xs(Pr)] = hu.GlobalsOrKeywords), Zr && !(Pr.flags & 111551)) { + const rt = Pr.declarations && Nn(Pr.declarations, NC); + if (rt) { + const vt = { kind: 64, declaration: rt }; + Ye[Rr] = vt; + } + } + } + if (o.includeCompletionsWithInsertText && at.kind !== 308) { + const Rr = m.tryGetThisTypeAt( + at, + /*includeGlobalThis*/ + !1, + $n(at.parent) ? at : void 0 + ); + if (Rr && !nXe(Rr, n, m)) + for (const Pr of WH(Rr, m)) + Ye[Te.length] = { + kind: 1 + /* ThisType */ + }, Te.push(Pr), ne[Xs(Pr)] = hu.SuggestedClassMembers; + } + er(), ie && (he = B && Eb(B.parent) ? 6 : 7); + } + function fi() { + var ke; + return ce ? !0 : o.includeCompletionsForModuleExports ? n.externalModuleIndicator || n.commonJsModuleIndicator || WV(e.getCompilerOptions()) ? !0 : ((ke = e.getSymlinkCache) == null ? void 0 : ke.call(e).hasAnySymlinks()) || !!e.getCompilerOptions().paths || pae(e) : !1; + } + function pn(ke) { + switch (ke.kind) { + case 308: + case 229: + case 295: + case 242: + return !0; + default: + return Ti(ke); + } + } + function _i() { + return D || P || !!ce && p0(fe.parent) || !Je(B) && (UA(B, n, m) || lm(fe) || ft(B)); + } + function Je(ke) { + return ke && (ke.kind === 114 && (ke.parent.kind === 187 || p6(ke.parent)) || ke.kind === 131 && ke.parent.kind === 183); + } + function ft(ke) { + if (ke) { + const at = ke.parent.kind; + switch (ke.kind) { + case 59: + return at === 173 || at === 172 || at === 170 || at === 261 || sx(at); + case 64: + return at === 266 || at === 169; + case 130: + return at === 235; + case 30: + return at === 184 || at === 217; + case 96: + return at === 169; + case 152: + return at === 239; + } + } + return !1; + } + function er() { + var ke, at; + if (!fi() || (E.assert(!c?.data, "Should not run 'collectAutoImports' when faster path is available via `data`"), c && !c.source)) + return; + be |= 1; + const Zr = R === B && ce ? "" : R && Me(R) ? R.text.toLowerCase() : "", Rr = (ke = _.getModuleSpecifierCache) == null ? void 0 : ke.call(_), Pr = i8(n, _, e, o, g), rt = (at = _.getPackageJsonAutoImportProvider) == null ? void 0 : at.call(_), vt = c ? void 0 : Z6(n, o, _); + gDe( + "collectAutoImports", + _, + Fe || (Fe = Ou.createImportSpecifierResolver(n, e, _, o)), + e, + s, + o, + !!ce, + K1(fe), + (Jt) => { + Pr.search( + n.path, + /*preferCapitalized*/ + K, + (_r, nr) => { + if (!R_(_r, da(_.getCompilationSettings())) || !c && Sx(_r) || !ie && !ce && !(nr & 111551) || ie && !(nr & 790504)) return !1; + const kt = _r.charCodeAt(0); + return K && (kt < 65 || kt > 90) ? !1 : c ? !0 : UDe(_r, Zr); + }, + (_r, nr, kt, cr) => { + if (c && !ot(_r, (Rs) => c.source === Bp(Rs.moduleSymbol.name)) || (_r = kn(_r, Nt), !_r.length)) + return; + const fr = Jt.tryResolve(_r, kt) || {}; + if (fr === "failed") return; + let vr = _r[0], Xt; + fr !== "skipped" && ({ exportInfo: vr = _r[0], moduleSpecifier: Xt } = fr); + const oi = vr.exportKind === 1, Fs = oi && n4(E.checkDefined(vr.symbol)) || E.checkDefined(vr.symbol); + qr(Fs, { + kind: Xt ? 32 : 4, + moduleSpecifier: Xt, + symbolName: nr, + exportMapKey: cr, + exportName: vr.exportKind === 2 ? "export=" : E.checkDefined(vr.symbol).name, + fileName: vr.moduleFileName, + isDefaultExport: oi, + moduleSymbol: vr.moduleSymbol, + isFromPackageJson: vr.isFromPackageJson + }); + } + ), pe = Jt.skippedAny(), be |= Jt.resolvedAny() ? 8 : 0, be |= Jt.resolvedBeyondLimit() ? 16 : 0; + } + ); + function Nt(Jt) { + return yq( + Jt.isFromPackageJson ? rt : e, + n, + Bn(Jt.moduleSymbol.valueDeclaration, Di), + Jt.moduleSymbol, + o, + vt, + Ne(Jt.isFromPackageJson), + Rr + ); + } + } + function qr(ke, at) { + const wt = Xs(ke); + ne[wt] !== hu.GlobalsOrKeywords && (Ye[Te.length] = at, ne[wt] = ce ? hu.LocationPriority : hu.AutoImportSuggestions, Te.push(ke)); + } + function Jn(ke, at) { + an(fe) || ke.forEach((wt) => { + if (!Un(wt)) + return; + const Zr = jH( + wt, + da(i), + /*origin*/ + void 0, + 0, + /*jsxIdentifierExpected*/ + !1 + ); + if (!Zr) + return; + const { name: Rr } = Zr, Pr = M$e( + wt, + Rr, + at, + e, + _, + i, + o, + u + ); + if (!Pr) + return; + const rt = { kind: 128, ...Pr }; + be |= 32, Ye[Te.length] = rt, Te.push(wt); + }); + } + function Un(ke) { + return !!(ke.flags & 8196); + } + function ki(ke, at, wt) { + let Zr = ke; + for (; Zr && !DV(Zr, at, wt); ) + Zr = Zr.parent; + return Zr; + } + function Ds(ke) { + const at = ao(), wt = bs(ke) || pt(ke) || Lt(ke) || Ks(ke) || u6(ke); + return t("getCompletionsAtPosition: isCompletionListBlocker: " + (ao() - at)), wt; + } + function Ks(ke) { + if (ke.kind === 12) + return !0; + if (ke.kind === 32 && ke.parent) { + if (fe === ke.parent && (fe.kind === 287 || fe.kind === 286)) + return !1; + if (ke.parent.kind === 287) + return fe.parent.kind !== 287; + if (ke.parent.kind === 288 || ke.parent.kind === 286) + return !!ke.parent.parent && ke.parent.parent.kind === 285; + } + return !1; + } + function yr() { + if (B) { + const ke = B.parent.kind, at = JH(B); + switch (at) { + case 28: + switch (ke) { + case 214: + // func( a, | + case 215: { + const wt = B.parent.expression; + return js(n, wt.end).line !== js(n, s).line ? { defaultCommitCharacters: FH, isNewIdentifierLocation: !0 } : { defaultCommitCharacters: Em, isNewIdentifierLocation: !0 }; + } + case 227: + return { defaultCommitCharacters: FH, isNewIdentifierLocation: !0 }; + case 177: + // constructor( a, | /* public, protected, private keywords are allowed here, so show completion */ + case 185: + // var x: (s: string, list| + case 211: + return { defaultCommitCharacters: [], isNewIdentifierLocation: !0 }; + case 210: + return { defaultCommitCharacters: Em, isNewIdentifierLocation: !0 }; + default: + return { defaultCommitCharacters: Em, isNewIdentifierLocation: !1 }; + } + case 21: + switch (ke) { + case 214: + // func( | + case 215: { + const wt = B.parent.expression; + return js(n, wt.end).line !== js(n, s).line ? { defaultCommitCharacters: FH, isNewIdentifierLocation: !0 } : { defaultCommitCharacters: Em, isNewIdentifierLocation: !0 }; + } + case 218: + return { defaultCommitCharacters: FH, isNewIdentifierLocation: !0 }; + case 177: + // constructor( | + case 197: + return { defaultCommitCharacters: [], isNewIdentifierLocation: !0 }; + default: + return { defaultCommitCharacters: Em, isNewIdentifierLocation: !1 }; + } + case 23: + switch (ke) { + case 210: + // [ | + case 182: + // [ | : string ] + case 190: + // [ | : string ] + case 168: + return { defaultCommitCharacters: Em, isNewIdentifierLocation: !0 }; + default: + return { defaultCommitCharacters: Em, isNewIdentifierLocation: !1 }; + } + case 144: + // module | + case 145: + // namespace | + case 102: + return { defaultCommitCharacters: [], isNewIdentifierLocation: !0 }; + case 25: + switch (ke) { + case 268: + return { defaultCommitCharacters: [], isNewIdentifierLocation: !0 }; + default: + return { defaultCommitCharacters: Em, isNewIdentifierLocation: !1 }; + } + case 19: + switch (ke) { + case 264: + // class A { | + case 211: + return { defaultCommitCharacters: [], isNewIdentifierLocation: !0 }; + default: + return { defaultCommitCharacters: Em, isNewIdentifierLocation: !1 }; + } + case 64: + switch (ke) { + case 261: + // const x = a| + case 227: + return { defaultCommitCharacters: Em, isNewIdentifierLocation: !0 }; + default: + return { defaultCommitCharacters: Em, isNewIdentifierLocation: !1 }; + } + case 16: + return { + defaultCommitCharacters: Em, + isNewIdentifierLocation: ke === 229 + /* TemplateExpression */ + // `aa ${| + }; + case 17: + return { + defaultCommitCharacters: Em, + isNewIdentifierLocation: ke === 240 + /* TemplateSpan */ + // `aa ${10} dd ${| + }; + case 134: + return ke === 175 || ke === 305 ? { defaultCommitCharacters: [], isNewIdentifierLocation: !0 } : { defaultCommitCharacters: Em, isNewIdentifierLocation: !1 }; + case 42: + return ke === 175 ? { defaultCommitCharacters: [], isNewIdentifierLocation: !0 } : { defaultCommitCharacters: Em, isNewIdentifierLocation: !1 }; + } + if (EL(at)) + return { defaultCommitCharacters: [], isNewIdentifierLocation: !0 }; + } + return { defaultCommitCharacters: Em, isNewIdentifierLocation: !1 }; + } + function bs(ke) { + return (lz(ke) || Wj(ke)) && (zA(ke, s) || s === ke.end && (!!ke.isUnterminated || lz(ke))); + } + function Xe() { + const ke = tXe(B); + if (!ke) return 0; + const wt = (Hx(ke.parent) ? ke.parent : void 0) || ke, Zr = MDe(wt, m); + if (!Zr) return 0; + const Rr = m.getTypeFromTypeNode(wt), Pr = WH(Zr, m), rt = WH(Rr, m), vt = /* @__PURE__ */ new Set(); + return rt.forEach((Nt) => vt.add(Nt.escapedName)), Te = Bi(Te, kn(Pr, (Nt) => !vt.has(Nt.escapedName))), Z = 0, q = !0, 1; + } + function Et() { + if (B?.kind === 26) return 0; + const ke = Te.length, at = X$e(B, s, n); + if (!at) return 0; + Z = 0; + let wt, Zr; + if (at.kind === 211) { + const Rr = sXe(at, m); + if (Rr === void 0) + return at.flags & 67108864 ? 2 : 0; + const Pr = m.getContextualType( + at, + 4 + /* Completions */ + ), rt = (Pr || Rr).getStringIndexType(), vt = (Pr || Rr).getNumberIndexType(); + if (q = !!rt || !!vt, wt = zH(Rr, Pr, at, m), Zr = at.properties, wt.length === 0 && !vt) + return 0; + } else { + E.assert( + at.kind === 207 + /* ObjectBindingPattern */ + ), q = !1; + const Rr = _m(at.parent); + if (!OD(Rr)) return E.fail("Root declaration is not variable-like."); + let Pr = d0(Rr) || !!Kc(Rr) || Rr.parent.parent.kind === 251; + if (!Pr && Rr.kind === 170 && (ut(Rr.parent) ? Pr = !!m.getContextualType(Rr.parent) : (Rr.parent.kind === 175 || Rr.parent.kind === 179) && (Pr = ut(Rr.parent.parent) && !!m.getContextualType(Rr.parent.parent))), Pr) { + const rt = m.getTypeAtLocation(at); + if (!rt) return 2; + wt = m.getPropertiesOfType(rt).filter((vt) => m.isPropertyAccessible( + at, + /*isSuper*/ + !1, + /*isWrite*/ + !1, + rt, + vt + )), Zr = at.elements; + } + } + if (wt && wt.length > 0) { + const Rr = Pe(wt, E.checkDefined(Zr)); + Te = Bi(Te, Rr), ue(), at.kind === 211 && o.includeCompletionsWithObjectLiteralMethodSnippets && o.includeCompletionsWithInsertText && (ye(ke), Jn(Rr, at)); + } + return 1; + } + function re() { + if (!B) return 0; + const ke = B.kind === 19 || B.kind === 28 ? Bn(B.parent, B5) : P9(B) ? Bn(B.parent.parent, B5) : void 0; + if (!ke) return 0; + P9(B) || (he = 8); + const { moduleSpecifier: at } = ke.kind === 276 ? ke.parent.parent : ke.parent; + if (!at) + return q = !0, ke.kind === 276 ? 2 : 0; + const wt = m.getSymbolAtLocation(at); + if (!wt) + return q = !0, 2; + Z = 3, q = !1; + const Zr = m.getExportsAndPropertiesOfModule(wt), Rr = new Set(ke.elements.filter((rt) => !Mt(rt)).map((rt) => wb(rt.propertyName || rt.name))), Pr = Zr.filter((rt) => rt.escapedName !== "default" && !Rr.has(rt.escapedName)); + return Te = Bi(Te, Pr), Pr.length || (he = 0), 1; + } + function it() { + if (B === void 0) return 0; + const ke = B.kind === 19 || B.kind === 28 ? Bn(B.parent, PS) : B.kind === 59 ? Bn(B.parent.parent, PS) : void 0; + if (ke === void 0) return 0; + const at = new Set(ke.elements.map(uF)); + return Te = kn(m.getTypeAtLocation(ke).getApparentProperties(), (wt) => !at.has(wt.escapedName)), 1; + } + function Y() { + var ke; + const at = B && (B.kind === 19 || B.kind === 28) ? Bn(B.parent, mp) : void 0; + if (!at) + return 0; + const wt = dr(at, Q_(Di, jc)); + return Z = 5, q = !1, (ke = wt.locals) == null || ke.forEach((Zr, Rr) => { + var Pr, rt; + Te.push(Zr), (rt = (Pr = wt.symbol) == null ? void 0 : Pr.exports) != null && rt.has(Rr) && (ne[Xs(Zr)] = hu.OptionalMember); + }), 1; + } + function Ae() { + const ke = eXe(n, B, fe, s); + if (!ke) return 0; + if (Z = 3, q = !0, he = B.kind === 42 ? 0 : $n(ke) ? 2 : 3, !$n(ke)) return 1; + const at = B.kind === 27 ? B.parent.parent : B.parent; + let wt = Hc(at) ? pu(at) : 0; + if (B.kind === 80 && !Mt(B)) + switch (B.getText()) { + case "private": + wt = wt | 2; + break; + case "static": + wt = wt | 256; + break; + case "override": + wt = wt | 16; + break; + } + if (kc(at) && (wt |= 256), !(wt & 2)) { + const Zr = $n(ke) && wt & 16 ? ZT(wd(ke)) : HD(ke), Rr = ka(Zr, (Pr) => { + const rt = m.getTypeAtLocation(Pr); + return wt & 256 ? rt?.symbol && m.getPropertiesOfType(m.getTypeOfSymbolAtLocation(rt.symbol, ke)) : rt && m.getPropertiesOfType(rt); + }); + Te = Bi(Te, Q(Rr, ke.members, wt)), lr(Te, (Pr, rt) => { + const vt = Pr?.valueDeclaration; + if (vt && Hc(vt) && vt.name && Gs(vt.name)) { + const Nt = { + kind: 512, + symbolName: m.symbolToString(Pr) + }; + Ye[rt] = Nt; + } + }); + } + return 1; + } + function $e(ke) { + return !!ke.parent && Ii(ke.parent) && nc(ke.parent.parent) && (ED(ke.kind) || Qm(ke)); + } + function Ke(ke) { + if (ke) { + const at = ke.parent; + switch (ke.kind) { + case 21: + case 28: + return nc(ke.parent) ? ke.parent : void 0; + default: + if ($e(ke)) + return at.parent; + } + } + } + function Tt(ke) { + if (ke) { + let at; + const wt = dr(ke.parent, (Zr) => $n(Zr) ? "quit" : io(Zr) && at === Zr.body ? !0 : (at = Zr, !1)); + return wt && wt; + } + } + function Le(ke) { + if (ke) { + const at = ke.parent; + switch (ke.kind) { + case 32: + // End of a type argument list + case 31: + case 44: + case 80: + case 212: + case 293: + case 292: + case 294: + if (at && (at.kind === 286 || at.kind === 287)) { + if (ke.kind === 32) { + const wt = pl( + ke.pos, + n, + /*startNode*/ + void 0 + ); + if (!at.typeArguments || wt && wt.kind === 44) break; + } + return at; + } else if (at.kind === 292) + return at.parent.parent; + break; + // The context token is the closing } or " of an attribute, which means + // its parent is a JsxExpression, whose parent is a JsxAttribute, + // whose parent is a JsxOpeningLikeElement + case 11: + if (at && (at.kind === 292 || at.kind === 294)) + return at.parent.parent; + break; + case 20: + if (at && at.kind === 295 && at.parent && at.parent.kind === 292) + return at.parent.parent.parent; + if (at && at.kind === 294) + return at.parent.parent; + break; + } + } + } + function mt(ke, at) { + return n.getLineEndOfPosition(ke.getEnd()) < at; + } + function pt(ke) { + const at = ke.parent, wt = at.kind; + switch (ke.kind) { + case 28: + return wt === 261 || rn(ke) || wt === 244 || wt === 267 || // enum a { foo, | + qe(wt) || wt === 265 || // interface A= ke.pos; + case 25: + return wt === 208; + // var [.| + case 59: + return wt === 209; + // var {x :html| + case 23: + return wt === 208; + // var [x| + case 21: + return wt === 300 || qe(wt); + case 19: + return wt === 267; + // enum a { | + case 30: + return wt === 264 || // class A< | + wt === 232 || // var C = class D< | + wt === 265 || // interface A< | + wt === 266 || // type List< | + sx(wt); + case 126: + return wt === 173 && !$n(at.parent); + case 26: + return wt === 170 || !!at.parent && at.parent.kind === 208; + // var [...z| + case 125: + case 123: + case 124: + return wt === 170 && !nc(at.parent); + case 130: + return wt === 277 || wt === 282 || wt === 275; + case 139: + case 153: + return !UH(ke); + case 80: { + if ((wt === 277 || wt === 282) && ke === at.name && ke.text === "type" || dr( + ke.parent, + ei + ) && mt(ke, s)) + return !1; + break; + } + case 86: + case 94: + case 120: + case 100: + case 115: + case 102: + case 121: + case 87: + case 140: + return !0; + case 156: + return wt !== 277; + case 42: + return Es(ke.parent) && !rc(ke.parent); + } + if (EL(JH(ke)) && UH(ke) || $e(ke) && (!Me(ke) || ED(JH(ke)) || Mt(ke))) + return !1; + switch (JH(ke)) { + case 128: + case 86: + case 87: + case 138: + case 94: + case 100: + case 120: + case 121: + case 123: + case 124: + case 125: + case 126: + case 115: + return !0; + case 134: + return os(ke.parent); + } + if (dr(ke.parent, $n) && ke === R && Ct(ke, s)) + return !1; + const Rr = Q1( + ke.parent, + 173 + /* PropertyDeclaration */ + ); + if (Rr && ke !== R && $n(R.parent.parent) && s <= R.end) { + if (Ct(ke, R.end)) + return !1; + if (ke.kind !== 64 && (dA(Rr) || O7(Rr))) + return !0; + } + return Qm(ke) && !gu(ke.parent) && !Tm(ke.parent) && !(($n(ke.parent) || Vl(ke.parent) || Lo(ke.parent)) && (ke !== R || s > R.end)); + } + function Ct(ke, at) { + return ke.kind !== 64 && (ke.kind === 27 || !lp(ke.end, at, n)); + } + function qe(ke) { + return sx(ke) && ke !== 177; + } + function Lt(ke) { + if (ke.kind === 9) { + const at = ke.getFullText(); + return at.charAt(at.length - 1) === "."; + } + return !1; + } + function rn(ke) { + return ke.parent.kind === 262 && !UA(ke, n, m); + } + function Pe(ke, at) { + if (at.length === 0) + return ke; + const wt = /* @__PURE__ */ new Set(), Zr = /* @__PURE__ */ new Set(); + for (const Pr of at) { + if (Pr.kind !== 304 && Pr.kind !== 305 && Pr.kind !== 209 && Pr.kind !== 175 && Pr.kind !== 178 && Pr.kind !== 179 && Pr.kind !== 306 || Mt(Pr)) + continue; + let rt; + if (Vg(Pr)) + yt(Pr, wt); + else if (ya(Pr) && Pr.propertyName) + Pr.propertyName.kind === 80 && (rt = Pr.propertyName.escapedText); + else { + const vt = _s(Pr); + rt = vt && um(vt) ? XD(vt) : void 0; + } + rt !== void 0 && Zr.add(rt); + } + const Rr = ke.filter((Pr) => !Zr.has(Pr.escapedName)); + return M(wt, Rr), Rr; + } + function yt(ke, at) { + const wt = ke.expression, Zr = m.getSymbolAtLocation(wt), Rr = Zr && m.getTypeOfSymbolAtLocation(Zr, wt), Pr = Rr && Rr.properties; + Pr && Pr.forEach((rt) => { + at.add(rt.name); + }); + } + function ue() { + Te.forEach((ke) => { + if (ke.flags & 16777216) { + const at = Xs(ke); + ne[at] = ne[at] ?? hu.OptionalMember; + } + }); + } + function M(ke, at) { + if (ke.size !== 0) + for (const wt of at) + ke.has(wt.name) && (ne[Xs(wt)] = hu.MemberDeclaredBySpreadAssignment); + } + function ye(ke) { + for (let at = ke; at < Te.length; at++) { + const wt = Te[at], Zr = Xs(wt), Rr = Ye?.[at], Pr = da(i), rt = jH( + wt, + Pr, + Rr, + 0, + /*jsxIdentifierExpected*/ + !1 + ); + if (rt) { + const vt = ne[Zr] ?? hu.LocationPriority, { name: Nt } = rt; + ne[Zr] = hu.ObjectLiteralProperty(vt, Nt); + } + } + } + function Q(ke, at, wt) { + const Zr = /* @__PURE__ */ new Set(); + for (const Rr of at) { + if (Rr.kind !== 173 && Rr.kind !== 175 && Rr.kind !== 178 && Rr.kind !== 179 || Mt(Rr) || sf( + Rr, + 2 + /* Private */ + ) || Js(Rr) !== !!(wt & 256)) + continue; + const Pr = dS(Rr.name); + Pr && Zr.add(Pr); + } + return ke.filter( + (Rr) => !Zr.has(Rr.escapedName) && !!Rr.declarations && !(up(Rr) & 2) && !(Rr.valueDeclaration && Du(Rr.valueDeclaration)) + ); + } + function dt(ke, at) { + const wt = /* @__PURE__ */ new Set(), Zr = /* @__PURE__ */ new Set(); + for (const Pr of at) + Mt(Pr) || (Pr.kind === 292 ? wt.add(S4(Pr.name)) : Qx(Pr) && yt(Pr, Zr)); + const Rr = ke.filter((Pr) => !wt.has(Pr.escapedName)); + return M(Zr, Rr), Rr; + } + function Mt(ke) { + return ke.getStart(n) <= s && s <= ke.getEnd(); + } + } + function X$e(e, t, n) { + var i; + if (e) { + const { parent: s } = e; + switch (e.kind) { + case 19: + // const x = { | + case 28: + if (_a(s) || Of(s)) + return s; + break; + case 42: + return rc(s) ? Bn(s.parent, _a) : void 0; + case 134: + return Bn(s.parent, _a); + case 80: + if (e.text === "async" && gu(e.parent)) + return e.parent.parent; + { + if (_a(e.parent.parent) && (Vg(e.parent) || gu(e.parent) && js(n, e.getEnd()).line !== js(n, t).line)) + return e.parent.parent; + const c = dr(s, rl); + if (c?.getLastToken(n) === e && _a(c.parent)) + return c.parent; + } + break; + default: + if ((i = s.parent) != null && i.parent && (rc(s.parent) || pp(s.parent) || z_(s.parent)) && _a(s.parent.parent)) + return s.parent.parent; + if (Vg(s) && _a(s.parent)) + return s.parent; + const o = dr(s, rl); + if (e.kind !== 59 && o?.getLastToken(n) === e && _a(o.parent)) + return o.parent; + } + } + } + function RH(e, t) { + const n = pl(e, t); + return n && e <= n.end && (wg(n) || k_(n.kind)) ? { contextToken: pl( + n.getFullStart(), + t, + /*startNode*/ + void 0 + ), previousToken: n } : { contextToken: n, previousToken: n }; + } + function PDe(e, t, n, i) { + const s = t.isPackageJsonImport ? i.getPackageJsonAutoImportProvider() : n, o = s.getTypeChecker(), c = t.ambientModuleName ? o.tryFindAmbientModule(t.ambientModuleName) : t.fileName ? o.getMergedSymbol(E.checkDefined(s.getSourceFile(t.fileName)).symbol) : void 0; + if (!c) return; + let _ = t.exportName === "export=" ? o.resolveExternalModuleSymbol(c) : o.tryGetMemberInModuleExportsAndProperties(t.exportName, c); + return _ ? (_ = t.exportName === "default" && n4(_) || _, { symbol: _, origin: j$e(t, e, c) }) : void 0; + } + function jH(e, t, n, i, s) { + if (v$e(n)) + return; + const o = m$e(n) ? n.symbolName : e.name; + if (o === void 0 || e.flags & 1536 && R3(o.charCodeAt(0)) || QD(e)) + return; + const c = { name: o, needsConvertPropertyAccess: !1 }; + if (R_( + o, + t, + s ? 1 : 0 + /* Standard */ + ) || e.valueDeclaration && Du(e.valueDeclaration)) + return c; + if (e.flags & 2097152) + return { name: o, needsConvertPropertyAccess: !0 }; + switch (i) { + case 3: + return gue(n) ? { name: n.symbolName, needsConvertPropertyAccess: !1 } : void 0; + case 0: + return { name: JSON.stringify(o), needsConvertPropertyAccess: !1 }; + case 2: + case 1: + return o.charCodeAt(0) === 32 ? void 0 : { name: o, needsConvertPropertyAccess: !0 }; + case 5: + case 4: + return c; + default: + E.assertNever(i); + } + } + var BH = [], NDe = Uu(() => { + const e = []; + for (let t = 83; t <= 166; t++) + e.push({ + name: qs(t), + kind: "keyword", + kindModifiers: "", + sortText: hu.GlobalsOrKeywords + }); + return e; + }); + function ADe(e, t) { + if (!t) return IDe(e); + const n = e + 8 + 1; + return BH[n] || (BH[n] = IDe(e).filter((i) => !Q$e(Q2(i.name)))); + } + function IDe(e) { + return BH[e] || (BH[e] = NDe().filter((t) => { + const n = Q2(t.name); + switch (e) { + case 0: + return !1; + case 1: + return ODe(n) || n === 138 || n === 144 || n === 156 || n === 145 || n === 128 || yw(n) && n !== 157; + case 5: + return ODe(n); + case 2: + return EL(n); + case 3: + return FDe(n); + case 4: + return ED(n); + case 6: + return yw(n) || n === 87; + case 7: + return yw(n); + case 8: + return n === 156; + default: + return E.assertNever(e); + } + })); + } + function Q$e(e) { + switch (e) { + case 128: + case 133: + case 163: + case 136: + case 138: + case 94: + case 162: + case 119: + case 140: + case 120: + case 142: + case 143: + case 144: + case 145: + case 146: + case 150: + case 151: + case 164: + case 123: + case 124: + case 125: + case 148: + case 154: + case 155: + case 156: + case 158: + case 159: + return !0; + default: + return !1; + } + } + function FDe(e) { + return e === 148; + } + function EL(e) { + switch (e) { + case 128: + case 129: + case 137: + case 139: + case 153: + case 134: + case 138: + case 164: + return !0; + default: + return Uj(e); + } + } + function ODe(e) { + return e === 134 || e === 135 || e === 160 || e === 130 || e === 152 || e === 156 || !h5(e) && !EL(e); + } + function JH(e) { + return Me(e) ? Z2(e) ?? 0 : e.kind; + } + function Y$e(e, t) { + const n = []; + if (e) { + const i = e.getSourceFile(), s = e.parent, o = i.getLineAndCharacterOfPosition(e.end).line, c = i.getLineAndCharacterOfPosition(t).line; + (qo(s) || Bc(s) && s.moduleSpecifier) && e === s.moduleSpecifier && o === c && n.push({ + name: qs( + 132 + /* AssertKeyword */ + ), + kind: "keyword", + kindModifiers: "", + sortText: hu.GlobalsOrKeywords + }); + } + return n; + } + function Z$e(e, t) { + return dr(e, (n) => OC(n) && q6(n, t) ? !0 : Od(n) ? "quit" : !1); + } + function zH(e, t, n, i) { + const s = t && t !== e, o = i.getUnionType( + kn( + e.flags & 1048576 ? e.types : [e], + (g) => !i.getPromisedTypeOfPromise(g) + ) + ), c = s && !(t.flags & 3) ? i.getUnionType([o, t]) : o, _ = K$e(c, n, i); + return c.isClass() && LDe(_) ? [] : s ? kn(_, u) : _; + function u(g) { + return wr(g.declarations) ? ot(g.declarations, (m) => m.parent !== n) : !0; + } + } + function K$e(e, t, n) { + return e.isUnion() ? n.getAllPossiblePropertiesOfTypes(kn(e.types, (i) => !(i.flags & 402784252 || n.isArrayLikeType(i) || n.isTypeInvalidDueToUnionDiscriminant(i, t) || n.typeHasCallOrConstructSignatures(i) || i.isClass() && LDe(i.getApparentProperties())))) : e.getApparentProperties(); + } + function LDe(e) { + return ot(e, (t) => !!(up(t) & 6)); + } + function WH(e, t) { + return e.isUnion() ? E.checkEachDefined(t.getAllPossiblePropertiesOfTypes(e.types), "getAllPossiblePropertiesOfTypes() should all be defined") : E.checkEachDefined(e.getApparentProperties(), "getApparentProperties() should all be defined"); + } + function eXe(e, t, n, i) { + switch (n.kind) { + case 353: + return Bn(n.parent, Dx); + case 1: + const s = Bn(Do(Us(n.parent, Di).statements), Dx); + if (s && !Ya(s, 20, e)) + return s; + break; + case 81: + if (Bn(n.parent, os)) + return dr(n, $n); + break; + case 80: { + if (Z2(n) || os(n.parent) && n.parent.initializer === n) + return; + if (UH(n)) + return dr(n, Dx); + } + } + if (t) { + if (n.kind === 137 || Me(t) && os(t.parent) && $n(n)) + return dr(t, $n); + switch (t.kind) { + case 64: + return; + case 27: + // class c {getValue(): number; | } + case 20: + return UH(n) && n.parent.name === n ? n.parent.parent : Bn(n, Dx); + case 19: + // class c { | + case 28: + return Bn(t.parent, Dx); + default: + if (Dx(n)) { + if (js(e, t.getEnd()).line !== js(e, i).line) + return n; + const s = $n(t.parent.parent) ? EL : FDe; + return s(t.kind) || t.kind === 42 || Me(t) && s( + Z2(t) ?? 0 + /* Unknown */ + ) ? t.parent.parent : void 0; + } + return; + } + } + } + function tXe(e) { + if (!e) return; + const t = e.parent; + switch (e.kind) { + case 19: + if (a_(t)) + return t; + break; + case 27: + case 28: + case 80: + if (t.kind === 172 && a_(t.parent)) + return t.parent; + break; + } + } + function MDe(e, t) { + if (!e) return; + if (li(e) && L7(e.parent)) + return t.getTypeArgumentConstraint(e); + const n = MDe(e.parent, t); + if (n) + switch (e.kind) { + case 172: + return t.getTypeOfPropertyOfContextualType(n, e.symbol.escapedName); + case 194: + case 188: + case 193: + return n; + } + } + function UH(e) { + return e.parent && D7(e.parent) && Dx(e.parent.parent); + } + function rXe(e, t, n, i) { + switch (t) { + case ".": + case "@": + return !0; + case '"': + case "'": + case "`": + return !!n && wae(n) && i === n.getStart(e) + 1; + case "#": + return !!n && Ai(n) && !!Wl(n); + case "<": + return !!n && n.kind === 30 && (!_n(n.parent) || RDe(n.parent)); + case "/": + return !!n && (ja(n) ? !!U3(n) : n.kind === 44 && Qb(n.parent)); + case " ": + return !!n && P4(n) && n.parent.kind === 308; + default: + return E.assertNever(t); + } + } + function RDe({ left: e }) { + return lc(e); + } + function nXe(e, t, n) { + const i = n.resolveName( + "self", + /*location*/ + void 0, + 111551, + /*excludeGlobals*/ + !1 + ); + if (i && n.getTypeOfSymbolAtLocation(i, t) === e) + return !0; + const s = n.resolveName( + "global", + /*location*/ + void 0, + 111551, + /*excludeGlobals*/ + !1 + ); + if (s && n.getTypeOfSymbolAtLocation(s, t) === e) + return !0; + const o = n.resolveName( + "globalThis", + /*location*/ + void 0, + 111551, + /*excludeGlobals*/ + !1 + ); + return !!(o && n.getTypeOfSymbolAtLocation(o, t) === e); + } + function iXe(e) { + return !!(e.valueDeclaration && pu(e.valueDeclaration) & 256 && $n(e.valueDeclaration.parent)); + } + function sXe(e, t) { + const n = t.getContextualType(e); + if (n) + return n; + const i = ad(e.parent); + if (_n(i) && i.operatorToken.kind === 64 && e === i.left) + return t.getTypeAtLocation(i); + if (ut(i)) + return t.getContextualType(i); + } + function jDe(e, t) { + var n, i, s; + let o, c = !1; + const _ = u(); + return { + isKeywordOnlyCompletion: c, + keywordCompletion: o, + isNewIdentifierLocation: !!(_ || o === 156), + isTopLevelTypeOnly: !!((i = (n = Bn(_, qo)) == null ? void 0 : n.importClause) != null && i.isTypeOnly) || !!((s = Bn(_, _l)) != null && s.isTypeOnly), + couldBeTypeOnlyImportSpecifier: !!_ && JDe(_, e), + replacementSpan: aXe(_) + }; + function u() { + const g = e.parent; + if (_l(g)) { + const m = g.getLastToken(t); + if (Me(e) && m !== e) { + o = 161, c = !0; + return; + } + return o = e.kind === 156 ? void 0 : 156, Cue(g.moduleReference) ? g : void 0; + } + if (JDe(g, e) && zDe(g.parent)) + return g; + if (bm(g) || Ug(g)) { + if (!g.parent.isTypeOnly && (e.kind === 19 || e.kind === 102 || e.kind === 28) && (o = 156), zDe(g)) + if (e.kind === 20 || e.kind === 80) + c = !0, o = 161; + else + return g.parent.parent; + return; + } + if (Bc(g) && e.kind === 42 || mp(g) && e.kind === 20) { + c = !0, o = 161; + return; + } + if (P4(e) && Di(g)) + return o = 156, e; + if (P4(e) && qo(g)) + return o = 156, Cue(g.moduleSpecifier) ? g : void 0; + } + } + function aXe(e) { + var t; + if (!e) return; + const n = dr(e, Q_(qo, _l, xm)) ?? e, i = n.getSourceFile(); + if (hS(n, i)) + return u_(n, i); + E.assert( + n.kind !== 102 && n.kind !== 277 + /* ImportSpecifier */ + ); + const s = n.kind === 273 || n.kind === 352 ? BDe((t = n.importClause) == null ? void 0 : t.namedBindings) ?? n.moduleSpecifier : n.moduleReference, o = { + pos: n.getFirstToken().getStart(), + end: s.pos + }; + if (hS(o, i)) + return A0(o); + } + function BDe(e) { + var t; + return Nn( + (t = Bn(e, bm)) == null ? void 0 : t.elements, + (n) => { + var i; + return !n.propertyName && Sx(n.name.text) && ((i = pl(n.name.pos, e.getSourceFile(), e)) == null ? void 0 : i.kind) !== 28; + } + ); + } + function JDe(e, t) { + return Xu(e) && (e.isTypeOnly || t === e.name && P9(t)); + } + function zDe(e) { + if (!Cue(e.parent.parent.moduleSpecifier) || e.parent.name) + return !1; + if (bm(e)) { + const t = BDe(e); + return (t ? e.elements.indexOf(t) : e.elements.length) < 2; + } + return !0; + } + function Cue(e) { + var t; + return lc(e) ? !0 : !((t = Bn(wh(e) ? e.expression : e, ja)) != null && t.text); + } + function oXe(e, t) { + if (!e) return; + let n = dr(e, (i) => Nb(i) || WDe(i) || ws(i) ? "quit" : (Ii(i) || Lo(i)) && !qy(i.parent)); + return n || (n = dr(t, (i) => Nb(i) || WDe(i) || ws(i) ? "quit" : ei(i))), n; + } + function cXe(e) { + if (!e) + return !1; + let t = e, n = e.parent; + for (; n; ) { + if (Lo(n)) + return n.default === t || t.kind === 64; + t = n, n = n.parent; + } + return !1; + } + function WDe(e) { + return e.parent && xo(e.parent) && (e.parent.body === e || // const a = () => /**/; + e.kind === 39); + } + function Eue(e, t, n = /* @__PURE__ */ new Set()) { + return i(e) || i(eu(e.exportSymbol || e, t)); + function i(s) { + return !!(s.flags & 788968) || t.isUnknownSymbol(s) || !!(s.flags & 1536) && Jp(n, s) && t.getExportsOfModule(s).some((o) => Eue(o, t, n)); + } + } + function lXe(e, t) { + const n = eu(e, t).declarations; + return !!wr(n) && Ni(n, q9); + } + function UDe(e, t) { + if (t.length === 0) + return !0; + let n = !1, i, s = 0; + const o = e.length; + for (let c = 0; c < o; c++) { + const _ = e.charCodeAt(c), u = t.charCodeAt(s); + if ((_ === u || _ === uXe(u)) && (n || (n = i === void 0 || // Beginning of word + 97 <= i && i <= 122 && 65 <= _ && _ <= 90 || // camelCase transition + i === 95 && _ !== 95), n && s++, s === t.length)) + return !0; + i = _; + } + return !1; + } + function uXe(e) { + return 97 <= e && e <= 122 ? e - 32 : e; + } + function _Xe(e) { + return e === "abstract" || e === "async" || e === "await" || e === "declare" || e === "module" || e === "namespace" || e === "type" || e === "satisfies" || e === "as"; + } + var VH = {}; + Na(VH, { + getStringLiteralCompletionDetails: () => dXe, + getStringLiteralCompletions: () => fXe + }); + var VDe = { + directory: 0, + script: 1, + "external module name": 2 + }; + function Due() { + const e = /* @__PURE__ */ new Map(); + function t(n) { + const i = e.get(n.name); + (!i || VDe[i.kind] < VDe[n.kind]) && e.set(n.name, n); + } + return { + add: t, + has: e.has.bind(e), + values: e.values.bind(e) + }; + } + function fXe(e, t, n, i, s, o, c, _, u) { + if (_ae(e, t)) { + const g = wXe(e, t, o, s, bv(o, s)); + return g && qDe(g); + } + if (_k(e, t, n)) { + if (!n || !ja(n)) return; + const g = GDe(e, n, t, o, s, _); + return pXe(g, n, e, s, o, c, i, _, t, u); + } + } + function pXe(e, t, n, i, s, o, c, _, u, g) { + if (e === void 0) + return; + const m = jV(t, u); + switch (e.kind) { + case 0: + return qDe(e.paths); + case 1: { + const h = PR(); + return Sue( + e.symbols, + h, + t, + t, + n, + u, + n, + i, + s, + 99, + o, + 4, + _, + c, + /*formatContext*/ + void 0, + /*isTypeOnlyLocation*/ + void 0, + /*propertyAccessToConvert*/ + void 0, + /*jsxIdentifierExpected*/ + void 0, + /*isJsxInitializer*/ + void 0, + /*importStatementCompletion*/ + void 0, + /*recommendedCompletion*/ + void 0, + /*symbolToOriginInfoMap*/ + void 0, + /*symbolToSortTextMap*/ + void 0, + /*isJsxIdentifierExpected*/ + void 0, + /*isRightOfOpenTag*/ + void 0, + g + ), { + isGlobalCompletion: !1, + isMemberCompletion: !0, + isNewIdentifierLocation: e.hasIndexSignature, + optionalReplacementSpan: m, + entries: h, + defaultCommitCharacters: GS(e.hasIndexSignature) + }; + } + case 2: { + const h = t.kind === 15 ? 96 : Ui(Qo(t), "'") ? 39 : 34, S = e.types.map((T) => ({ + name: Ym(T.value, h), + kindModifiers: "", + kind: "string", + sortText: hu.LocationPriority, + replacementSpan: RV(t, u), + commitCharacters: [] + })); + return { + isGlobalCompletion: !1, + isMemberCompletion: !1, + isNewIdentifierLocation: e.isNewIdentifier, + optionalReplacementSpan: m, + entries: S, + defaultCommitCharacters: GS(e.isNewIdentifier) + }; + } + default: + return E.assertNever(e); + } + } + function dXe(e, t, n, i, s, o, c, _) { + if (!i || !ja(i)) return; + const u = GDe(t, i, n, s, o, _); + return u && mXe(e, i, u, t, s.getTypeChecker(), c); + } + function mXe(e, t, n, i, s, o) { + switch (n.kind) { + case 0: { + const c = Nn(n.paths, (_) => _.name === e); + return c && CL(e, HDe(c.extension), c.kind, [Bf(e)]); + } + case 1: { + const c = Nn(n.symbols, (_) => _.name === e); + return c && xue(c, c.name, s, i, t, o); + } + case 2: + return Nn(n.types, (c) => c.value === e) ? CL(e, "", "string", [Bf(e)]) : void 0; + default: + return E.assertNever(n); + } + } + function qDe(e) { + return { + isGlobalCompletion: !1, + isMemberCompletion: !1, + isNewIdentifierLocation: !0, + entries: e.map(({ name: s, kind: o, span: c, extension: _ }) => ({ name: s, kind: o, kindModifiers: HDe(_), sortText: hu.LocationPriority, replacementSpan: c })), + defaultCommitCharacters: GS(!0) + }; + } + function HDe(e) { + switch (e) { + case ".d.ts": + return ".d.ts"; + case ".js": + return ".js"; + case ".json": + return ".json"; + case ".jsx": + return ".jsx"; + case ".ts": + return ".ts"; + case ".tsx": + return ".tsx"; + case ".d.mts": + return ".d.mts"; + case ".mjs": + return ".mjs"; + case ".mts": + return ".mts"; + case ".d.cts": + return ".d.cts"; + case ".cjs": + return ".cjs"; + case ".cts": + return ".cts"; + case ".tsbuildinfo": + return E.fail("Extension .tsbuildinfo is unsupported."); + case void 0: + return ""; + default: + return E.assertNever(e); + } + } + function GDe(e, t, n, i, s, o) { + const c = i.getTypeChecker(), _ = wue(t.parent); + switch (_.kind) { + case 202: { + const R = wue(_.parent); + return R.kind === 206 ? { kind: 0, paths: QDe(e, t, i, s, o) } : u(R); + } + case 304: + return _a(_.parent) && _.name === t ? yXe(c, _.parent) : g() || g( + 0 + /* None */ + ); + case 213: { + const { expression: R, argumentExpression: B } = _; + return t === Ba(B) ? $De(c.getTypeAtLocation(R)) : void 0; + } + case 214: + case 215: + case 292: + if (!OXe(t) && !T_(_)) { + const R = D8.getArgumentInfoForCompletions(_.kind === 292 ? _.parent : t, n, e, c); + return R && hXe(R.invocation, t, R, c) || g( + 0 + /* None */ + ); + } + // falls through (is `require("")` or `require(""` or `import("")`) + case 273: + case 279: + case 284: + case 352: + return { kind: 0, paths: QDe(e, t, i, s, o) }; + case 297: + const m = $9(c, _.parent.clauses), h = g(); + return h ? { kind: 2, types: h.types.filter((R) => !m.hasValue(R.value)), isNewIdentifier: !1 } : void 0; + case 277: + case 282: + const T = _; + if (T.propertyName && t !== T.propertyName) + return; + const k = T.parent, { moduleSpecifier: D } = k.kind === 276 ? k.parent.parent : k.parent; + if (!D) return; + const P = c.getSymbolAtLocation(D); + if (!P) return; + const A = c.getExportsAndPropertiesOfModule(P), O = new Set(k.elements.map((R) => wb(R.propertyName || R.name))); + return { kind: 1, symbols: A.filter((R) => R.escapedName !== "default" && !O.has(R.escapedName)), hasIndexSignature: !1 }; + case 227: + if (_.operatorToken.kind === 103) { + const R = c.getTypeAtLocation(_.right); + return { + kind: 1, + symbols: (R.isUnion() ? c.getAllPossiblePropertiesOfTypes(R.types) : R.getApparentProperties()).filter((U) => !U.valueDeclaration || !Du(U.valueDeclaration)), + hasIndexSignature: !1 + }; + } + return g( + 0 + /* None */ + ); + default: + return g() || g( + 0 + /* None */ + ); + } + function u(m) { + switch (m.kind) { + case 234: + case 184: { + const T = dr(_, (k) => k.parent === m); + return T ? { kind: 2, types: qH(c.getTypeArgumentConstraint(T)), isNewIdentifier: !1 } : void 0; + } + case 200: + const { indexType: h, objectType: S } = m; + return q6(h, n) ? $De(c.getTypeFromTypeNode(S)) : void 0; + case 193: { + const T = u(wue(m.parent)); + if (!T) + return; + const k = gXe(m, _); + return T.kind === 1 ? { kind: 1, symbols: T.symbols.filter((D) => !ms(k, D.name)), hasIndexSignature: T.hasIndexSignature } : { kind: 2, types: T.types.filter((D) => !ms(k, D.value)), isNewIdentifier: !1 }; + } + default: + return; + } + } + function g(m = 4) { + const h = qH(R9(t, c, m)); + if (h.length) + return { kind: 2, types: h, isNewIdentifier: !1 }; + } + } + function wue(e) { + switch (e.kind) { + case 197: + return $3(e); + case 218: + return ad(e); + default: + return e; + } + } + function gXe(e, t) { + return Fi(e.types, (n) => n !== t && E0(n) && ca(n.literal) ? n.literal.text : void 0); + } + function hXe(e, t, n, i) { + let s = !1; + const o = /* @__PURE__ */ new Set(), c = wu(e) ? E.checkDefined(dr(t.parent, Tm)) : t, _ = i.getCandidateSignaturesForStringLiteralCompletions(e, c), u = ka(_, (g) => { + if (!Iu(g) && n.argumentCount > g.parameters.length) return; + let m = g.getTypeParameterAtPosition(n.argumentIndex); + if (wu(e)) { + const h = i.getTypeOfPropertyOfType(m, DN(c.name)); + h && (m = h); + } + return s = s || !!(m.flags & 4), qH(m, o); + }); + return wr(u) ? { kind: 2, types: u, isNewIdentifier: s } : void 0; + } + function $De(e) { + return e && { + kind: 1, + symbols: kn(e.getApparentProperties(), (t) => !(t.valueDeclaration && Du(t.valueDeclaration))), + hasIndexSignature: iq(e) + }; + } + function yXe(e, t) { + const n = e.getContextualType(t); + if (!n) return; + const i = e.getContextualType( + t, + 4 + /* Completions */ + ); + return { + kind: 1, + symbols: zH( + n, + i, + t, + e + ), + hasIndexSignature: iq(n) + }; + } + function qH(e, t = /* @__PURE__ */ new Set()) { + return e ? (e = zV(e), e.isUnion() ? ka(e.types, (n) => qH(n, t)) : e.isStringLiteral() && !(e.flags & 1024) && Jp(t, e.value) ? [e] : Ge) : Ge; + } + function Rw(e, t, n) { + return { name: e, kind: t, extension: n }; + } + function Pue(e) { + return Rw( + e, + "directory", + /*extension*/ + void 0 + ); + } + function XDe(e, t, n) { + const i = NXe(e, t), s = e.length === 0 ? void 0 : Kl(t, e.length); + return n.map(({ name: o, kind: c, extension: _ }) => o.includes(So) || o.includes(o7) ? { name: o, kind: c, extension: _, span: s } : { name: o, kind: c, extension: _, span: i }); + } + function QDe(e, t, n, i, s) { + return XDe(t.text, t.getStart(e) + 1, vXe(e, t, n, i, s)); + } + function vXe(e, t, n, i, s) { + const o = zl(t.text), c = ja(t) ? n.getModeForUsageLocation(e, t) : void 0, _ = e.path, u = Hn(_), g = n.getCompilerOptions(), m = n.getTypeChecker(), h = bv(n, i), S = Nue(g, 1, e, m, s, c); + return AXe(o) || !g.baseUrl && !g.paths && (Z_(o) || LY(o)) ? bXe(o, u, n, i, h, _, S) : kXe(o, u, c, n, i, h, S); + } + function Nue(e, t, n, i, s, o) { + return { + extensionsToSearch: Ip(SXe(e, i)), + referenceKind: t, + importingSourceFile: n, + endingPreference: s?.importModuleSpecifierEnding, + resolutionMode: o + }; + } + function bXe(e, t, n, i, s, o, c) { + const _ = n.getCompilerOptions(); + return _.rootDirs ? xXe( + _.rootDirs, + e, + t, + c, + n, + i, + s, + o + ) : is(S8( + e, + t, + c, + n, + i, + s, + /*moduleSpecifierIsRelative*/ + !0, + o + ).values()); + } + function SXe(e, t) { + const n = t ? Fi(t.getAmbientModules(), (o) => { + const c = o.name.slice(1, -1); + if (!(!c.startsWith("*.") || c.includes("/"))) + return c.slice(1); + }) : [], i = [..._4(e), n], s = Pu(e); + return N9(s) ? bN(e, i) : i; + } + function TXe(e, t, n, i) { + e = e.map((o) => gl(Hs(Z_(o) ? o : On(t, o)))); + const s = Lc(e, (o) => np(o, n, t, i) ? n.substr(o.length) : void 0); + return hb( + [...e.map((o) => On(o, s)), n].map((o) => _0(o)), + bb, + _u + ); + } + function xXe(e, t, n, i, s, o, c, _) { + const g = s.getCompilerOptions().project || o.getCurrentDirectory(), m = !(o.useCaseSensitiveFileNames && o.useCaseSensitiveFileNames()), h = TXe(e, g, n, m); + return hb( + ka(h, (S) => is(S8( + t, + S, + i, + s, + o, + c, + /*moduleSpecifierIsRelative*/ + !0, + _ + ).values())), + (S, T) => S.name === T.name && S.kind === T.kind && S.extension === T.extension + ); + } + function S8(e, t, n, i, s, o, c, _, u = Due()) { + var g; + e === void 0 && (e = ""), e = zl(e), vy(e) || (e = Hn(e)), e === "" && (e = "." + So), e = gl(e); + const m = by(t, e), h = vy(m) ? m : Hn(m); + if (!c) { + const D = Iae(h, s); + if (D) { + const A = e6(D, s).typesVersions; + if (typeof A == "object") { + const O = (g = cO(A)) == null ? void 0 : g.paths; + if (O) { + const F = Hn(D), R = m.slice(gl(F).length); + if (ZDe(u, R, F, n, i, s, o, O)) + return u; + } + } + } + } + const S = !(s.useCaseSensitiveFileNames && s.useCaseSensitiveFileNames()); + if (!z9(s, h)) return u; + const T = oq( + s, + h, + n.extensionsToSearch, + /*exclude*/ + void 0, + /*include*/ + ["./*"] + ); + if (T) + for (let D of T) { + if (D = Hs(D), _ && gh(D, _, t, S) === 0) + continue; + const { name: P, extension: A } = YDe( + Zc(D), + i, + n, + /*isExportsOrImportsWildcard*/ + !1 + ); + u.add(Rw(P, "script", A)); + } + const k = J9(s, h); + if (k) + for (const D of k) { + const P = Zc(Hs(D)); + P !== "@types" && u.add(Pue(P)); + } + return u; + } + function YDe(e, t, n, i) { + const s = Ih.tryGetRealFileNameForNonJsDeclarationFileName(e); + if (s) + return { name: s, extension: Jg(s) }; + if (n.referenceKind === 0) + return { name: e, extension: Jg(e) }; + let o = Ih.getModuleSpecifierPreferences( + { importModuleSpecifierEnding: n.endingPreference }, + t, + t.getCompilerOptions(), + n.importingSourceFile + ).getAllowedEndingsInPreferredOrder(n.resolutionMode); + if (i && (o = o.filter( + (_) => _ !== 0 && _ !== 1 + /* Index */ + )), o[0] === 3) { + if (xc(e, vN)) + return { name: e, extension: Jg(e) }; + const _ = Ih.tryGetJSExtensionForFile(e, t.getCompilerOptions()); + return _ ? { name: S0(e, _), extension: _ } : { name: e, extension: Jg(e) }; + } + if (!i && (o[0] === 0 || o[0] === 1) && xc(e, [ + ".js", + ".jsx", + ".ts", + ".tsx", + ".d.ts" + /* Dts */ + ])) + return { name: Gu(e), extension: Jg(e) }; + const c = Ih.tryGetJSExtensionForFile(e, t.getCompilerOptions()); + return c ? { name: S0(e, c), extension: c } : { name: e, extension: Jg(e) }; + } + function ZDe(e, t, n, i, s, o, c, _) { + const u = (m) => _[m], g = (m, h) => { + const S = Ix(m), T = Ix(h), k = typeof S == "object" ? S.prefix.length : m.length, D = typeof T == "object" ? T.prefix.length : h.length; + return ho(D, k); + }; + return KDe( + e, + /*isExports*/ + !1, + /*isImports*/ + !1, + t, + n, + i, + s, + o, + c, + rm(_), + u, + g + ); + } + function KDe(e, t, n, i, s, o, c, _, u, g, m, h) { + let S = [], T; + for (const k of g) { + if (k === ".") continue; + const D = k.replace(/^\.\//, "") + ((t || n) && wo(k, "/") ? "*" : ""), P = m(k); + if (P) { + const A = Ix(D); + if (!A) continue; + const O = typeof A == "object" && YI(A, i); + O && (T === void 0 || h(D, T) === -1) && (T = D, S = S.filter((R) => !R.matchedPattern)), (typeof A == "string" || T === void 0 || h(D, T) !== 1) && S.push({ + matchedPattern: O, + results: CXe(D, P, i, s, o, t, n, c, _, u).map(({ name: R, kind: B, extension: U }) => Rw(R, B, U)) + }); + } + } + return S.forEach((k) => k.results.forEach((D) => e.add(D))), T !== void 0; + } + function kXe(e, t, n, i, s, o, c) { + const _ = i.getTypeChecker(), u = i.getCompilerOptions(), { baseUrl: g, paths: m } = u, h = Due(), S = Pu(u); + if (g) { + const D = Hs(On(s.getCurrentDirectory(), g)); + S8( + e, + D, + c, + i, + s, + o, + /*moduleSpecifierIsRelative*/ + !1, + /*exclude*/ + void 0, + h + ); + } + if (m) { + const D = C5(u, s); + ZDe(h, e, D, c, i, s, o, m); + } + const T = t4e(e); + for (const D of DXe(e, T, _)) + h.add(Rw( + D, + "external module name", + /*extension*/ + void 0 + )); + if (i4e(i, s, o, t, T, c, h), N9(S)) { + let D = !1; + if (T === void 0) + for (const P of PXe(s, t)) { + const A = Rw( + P, + "external module name", + /*extension*/ + void 0 + ); + h.has(A.name) || (D = !0, h.add(A)); + } + if (!D) { + const P = dN(u), A = mN(u); + let O = !1; + const F = (B) => { + if (A && !O) { + const U = On(B, "package.json"); + if (O = Ew(s, U)) { + const $ = e6(U, s); + k( + $.imports, + e, + B, + /*isExports*/ + !1, + /*isImports*/ + !0 + ); + } + } + }; + let R = (B) => { + const U = On(B, "node_modules"); + z9(s, U) && S8( + e, + U, + c, + i, + s, + o, + /*moduleSpecifierIsRelative*/ + !1, + /*exclude*/ + void 0, + h + ), F(B); + }; + if (T && P) { + const B = R; + R = (U) => { + const $ = fu(e); + $.shift(); + let W = $.shift(); + if (!W) + return B(U); + if (Ui(W, "@")) { + const V = $.shift(); + if (!V) + return B(U); + W = On(W, V); + } + if (A && Ui(W, "#")) + return F(U); + const _e = On(U, "node_modules", W), K = On(_e, "package.json"); + if (Ew(s, K)) { + const V = e6(K, s), ae = $.join("/") + ($.length && vy(e) ? "/" : ""); + k( + V.exports, + ae, + _e, + /*isExports*/ + !0, + /*isImports*/ + !1 + ); + return; + } + return B(U); + }; + } + eg(s, t, R); + } + } + return is(h.values()); + function k(D, P, A, O, F) { + if (typeof D != "object" || D === null) + return; + const R = rm(D), B = Qy(u, n); + KDe( + h, + O, + F, + P, + A, + c, + i, + s, + o, + R, + (U) => { + const $ = e4e(D[U], B); + if ($ !== void 0) + return ZT(wo(U, "/") && wo($, "/") ? $ + "*" : $); + }, + SW + ); + } + } + function e4e(e, t) { + if (typeof e == "string") + return e; + if (e && typeof e == "object" && !as(e)) { + for (const n in e) + if (n === "default" || t.includes(n) || uA(t, n)) { + const i = e[n]; + return e4e(i, t); + } + } + } + function t4e(e) { + return Aue(e) ? vy(e) ? e : Hn(e) : void 0; + } + function CXe(e, t, n, i, s, o, c, _, u, g) { + const m = Ix(e); + if (!m) + return Ge; + if (typeof m == "string") + return S( + e, + "script" + /* scriptElement */ + ); + const h = qR(n, m.prefix); + if (h === void 0) + return wo(e, "/*") ? S( + m.prefix, + "directory" + /* directory */ + ) : ka(t, (k) => { + var D; + return (D = r4e("", i, k, s, o, c, _, u, g)) == null ? void 0 : D.map(({ name: P, ...A }) => ({ name: m.prefix + P + m.suffix, ...A })); + }); + return ka(t, (T) => r4e(h, i, T, s, o, c, _, u, g)); + function S(T, k) { + return Ui(T, n) ? [{ name: _0(T), kind: k, extension: void 0 }] : Ge; + } + } + function r4e(e, t, n, i, s, o, c, _, u) { + if (!_.readDirectory) + return; + const g = Ix(n); + if (g === void 0 || gs(g)) + return; + const m = by(g.prefix), h = vy(g.prefix) ? m : Hn(m), S = vy(g.prefix) ? "" : Zc(m), T = Aue(e), k = T ? vy(e) ? e : Hn(e) : void 0, D = () => u.getCommonSourceDirectory(), P = !mS(u), A = c.getCompilerOptions().outDir, O = c.getCompilerOptions().declarationDir, F = T ? On(h, S + k) : h, R = Hs(On(t, F)), B = o && A && ZB(R, P, A, D), U = o && O && ZB(R, P, O, D), $ = Hs(g.suffix), W = $ && k5("_" + $), _e = $ ? YB("_" + $) : void 0, K = [ + W && S0($, W), + ..._e ? _e.map((q) => S0($, q)) : [], + $ + ].filter(gs), V = $ ? K.map((q) => "**/*" + q) : ["./*"], ae = (s || o) && wo(n, "/*"); + let se = ce(R); + return B && (se = Bi(se, ce(B))), U && (se = Bi(se, ce(U))), $ || (se = Bi(se, fe(R)), B && (se = Bi(se, fe(B))), U && (se = Bi(se, fe(U)))), se; + function ce(q) { + const be = T ? q : gl(q) + S; + return Fi(oq( + _, + q, + i.extensionsToSearch, + /*exclude*/ + void 0, + V + ), (je) => { + const me = he(je, be); + if (me) { + if (Aue(me)) + return Pue(fu(n4e(me))[1]); + const { name: Z, extension: pe } = YDe(me, c, i, ae); + return Rw(Z, "script", pe); + } + }); + } + function fe(q) { + return Fi(J9(_, q), (be) => be === "node_modules" ? void 0 : Pue(be)); + } + function he(q, be) { + return Lc(K, (je) => { + const me = EXe(Hs(q), be, je); + return me === void 0 ? void 0 : n4e(me); + }); + } + } + function EXe(e, t, n) { + return Ui(e, t) && wo(e, n) ? e.slice(t.length, e.length - n.length) : void 0; + } + function n4e(e) { + return e[0] === So ? e.slice(1) : e; + } + function DXe(e, t, n) { + const s = n.getAmbientModules().map((o) => Bp(o.name)).filter((o) => Ui(o, e) && !o.includes("*")); + if (t !== void 0) { + const o = gl(t); + return s.map((c) => nD(c, o)); + } + return s; + } + function wXe(e, t, n, i, s) { + const o = n.getCompilerOptions(), c = vi(e, t), _ = Eg(e.text, c.pos), u = _ && Nn(_, (P) => t >= P.pos && t <= P.end); + if (!u) + return; + const g = e.text.slice(u.pos, t), m = IXe.exec(g); + if (!m) + return; + const [, h, S, T] = m, k = Hn(e.path), D = S === "path" ? S8( + T, + k, + Nue(o, 0, e), + n, + i, + s, + /*moduleSpecifierIsRelative*/ + !0, + e.path + ) : S === "types" ? i4e(n, i, s, k, t4e(T), Nue(o, 1, e)) : E.fail(); + return XDe(T, u.pos + h.length, is(D.values())); + } + function i4e(e, t, n, i, s, o, c = Due()) { + const _ = e.getCompilerOptions(), u = /* @__PURE__ */ new Map(), g = W9(() => q4(_, t)) || Ge; + for (const h of g) + m(h); + for (const h of cq(i, t)) { + const S = On(Hn(h), "node_modules/@types"); + m(S); + } + return c; + function m(h) { + if (z9(t, h)) + for (const S of J9(t, h)) { + const T = _A(S); + if (!(_.types && !ms(_.types, T))) + if (s === void 0) + u.has(T) || (c.add(Rw( + T, + "external module name", + /*extension*/ + void 0 + )), u.set(T, !0)); + else { + const k = On(h, S), D = DJ(s, T, xh(t)); + D !== void 0 && S8( + D, + k, + o, + e, + t, + n, + /*moduleSpecifierIsRelative*/ + !1, + /*exclude*/ + void 0, + c + ); + } + } + } + } + function PXe(e, t) { + if (!e.readFile || !e.fileExists) return Ge; + const n = []; + for (const i of cq(t, e)) { + const s = e6(i, e); + for (const o of FXe) { + const c = s[o]; + if (c) + for (const _ in c) + eo(c, _) && !Ui(_, "@types/") && n.push(_); + } + } + return n; + } + function NXe(e, t) { + const n = Math.max(e.lastIndexOf(So), e.lastIndexOf(o7)), i = n !== -1 ? n + 1 : 0, s = e.length - i; + return s === 0 || R_( + e.substr(i, s), + 99 + /* ESNext */ + ) ? void 0 : Kl(t + i, s); + } + function AXe(e) { + if (e && e.length >= 2 && e.charCodeAt(0) === 46) { + const t = e.length >= 3 && e.charCodeAt(1) === 46 ? 2 : 1, n = e.charCodeAt(t); + return n === 47 || n === 92; + } + return !1; + } + var IXe = /^(\/\/\/\s* xk, + DefinitionKind: () => _4e, + EntryKind: () => f4e, + ExportKind: () => s4e, + FindReferencesUse: () => p4e, + ImportExport: () => a4e, + createImportTracker: () => Iue, + findModuleReferences: () => o4e, + findReferenceOrRenameEntries: () => $Xe, + findReferencedSymbols: () => qXe, + getContextNode: () => $S, + getExportInfo: () => Fue, + getImplementationsAtPosition: () => GXe, + getImportOrExportSymbol: () => u4e, + getReferenceEntriesForNode: () => m4e, + isContextWithStartAndEndNode: () => Lue, + isDeclarationOfSymbol: () => b4e, + isWriteAccessForReference: () => Rue, + toContextSpan: () => Mue, + toHighlightSpan: () => tQe, + toReferenceEntry: () => y4e, + toRenameLocation: () => QXe + }); + function Iue(e, t, n, i) { + const s = jXe(e, n, i); + return (o, c, _) => { + const { directImports: u, indirectUsers: g } = LXe(e, t, s, c, n, i); + return { indirectUsers: g, ...MXe(u, o, c.exportKind, n, _) }; + }; + } + var s4e = /* @__PURE__ */ ((e) => (e[e.Named = 0] = "Named", e[e.Default = 1] = "Default", e[e.ExportEquals = 2] = "ExportEquals", e))(s4e || {}), a4e = /* @__PURE__ */ ((e) => (e[e.Import = 0] = "Import", e[e.Export = 1] = "Export", e))(a4e || {}); + function LXe(e, t, n, { exportingModuleSymbol: i, exportKind: s }, o, c) { + const _ = G6(), u = G6(), g = [], m = !!i.globalExports, h = m ? void 0 : []; + return T(i), { directImports: g, indirectUsers: S() }; + function S() { + if (m) + return e; + if (i.declarations) + for (const F of i.declarations) + Pb(F) && t.has(F.getSourceFile().fileName) && A(F); + return h.map(xr); + } + function T(F) { + const R = O(F); + if (R) { + for (const B of R) + if (_(B)) + switch (c && c.throwIfCancellationRequested(), B.kind) { + case 214: + if (T_(B)) { + k(B); + break; + } + if (!m) { + const $ = B.parent; + if (s === 2 && $.kind === 261) { + const { name: W } = $; + if (W.kind === 80) { + g.push(W); + break; + } + } + } + break; + case 80: + break; + // TODO: GH#23879 + case 272: + P( + B, + B.name, + Gn( + B, + 32 + /* Export */ + ), + /*alreadyAddedDirect*/ + !1 + ); + break; + case 273: + case 352: + g.push(B); + const U = B.importClause && B.importClause.namedBindings; + U && U.kind === 275 ? P( + B, + U.name, + /*isReExport*/ + !1, + /*alreadyAddedDirect*/ + !0 + ) : !m && fS(B) && A(DL(B)); + break; + case 279: + B.exportClause ? B.exportClause.kind === 281 ? A( + DL(B), + /*addTransitiveDependencies*/ + !0 + ) : g.push(B) : T(UXe(B, o)); + break; + case 206: + !m && B.isTypeOf && !B.qualifier && D(B) && A( + B.getSourceFile(), + /*addTransitiveDependencies*/ + !0 + ), g.push(B); + break; + default: + E.failBadSyntaxKind(B, "Unexpected import kind."); + } + } + } + function k(F) { + const R = dr(F, HH) || F.getSourceFile(); + A( + R, + /** addTransitiveDependencies */ + !!D( + F, + /*stopAtAmbientModule*/ + !0 + ) + ); + } + function D(F, R = !1) { + return dr(F, (B) => R && HH(B) ? "quit" : Vp(B) && ot(B.modifiers, zx)); + } + function P(F, R, B, U) { + if (s === 2) + U || g.push(F); + else if (!m) { + const $ = DL(F); + E.assert( + $.kind === 308 || $.kind === 268 + /* ModuleDeclaration */ + ), B || RXe($, R, o) ? A( + $, + /*addTransitiveDependencies*/ + !0 + ) : A($); + } + } + function A(F, R = !1) { + if (E.assert(!m), !u(F) || (h.push(F), !R)) return; + const U = o.getMergedSymbol(F.symbol); + if (!U) return; + E.assert(!!(U.flags & 1536)); + const $ = O(U); + if ($) + for (const W of $) + ym(W) || A( + DL(W), + /*addTransitiveDependencies*/ + !0 + ); + } + function O(F) { + return n.get(Xs(F).toString()); + } + } + function MXe(e, t, n, i, s) { + const o = [], c = []; + function _(S, T) { + o.push([S, T]); + } + if (e) + for (const S of e) + u(S); + return { importSearches: o, singleReferences: c }; + function u(S) { + if (S.kind === 272) { + Oue(S) && g(S.name); + return; + } + if (S.kind === 80) { + g(S); + return; + } + if (S.kind === 206) { + if (S.qualifier) { + const D = i_(S.qualifier); + D.escapedText === cc(t) && c.push(D); + } else n === 2 && c.push(S.argument.literal); + return; + } + if (S.moduleSpecifier.kind !== 11) + return; + if (S.kind === 279) { + S.exportClause && mp(S.exportClause) && m(S.exportClause); + return; + } + const { name: T, namedBindings: k } = S.importClause || { name: void 0, namedBindings: void 0 }; + if (k) + switch (k.kind) { + case 275: + g(k.name); + break; + case 276: + (n === 0 || n === 1) && m(k); + break; + default: + E.assertNever(k); + } + if (T && (n === 1 || n === 2) && (!s || T.escapedText === A9(t))) { + const D = i.getSymbolAtLocation(T); + _(T, D); + } + } + function g(S) { + n === 2 && (!s || h(S.escapedText)) && _(S, i.getSymbolAtLocation(S)); + } + function m(S) { + if (S) + for (const T of S.elements) { + const { name: k, propertyName: D } = T; + if (h(wb(D || k))) + if (D) + c.push(D), (!s || wb(k) === t.escapedName) && _(k, i.getSymbolAtLocation(k)); + else { + const P = T.kind === 282 && T.propertyName ? i.getExportSpecifierLocalTargetSymbol(T) : i.getSymbolAtLocation(k); + _(k, P); + } + } + } + function h(S) { + return S === t.escapedName || n !== 0 && S === "default"; + } + } + function RXe(e, t, n) { + const i = n.getSymbolAtLocation(t); + return !!c4e(e, (s) => { + if (!Bc(s)) return; + const { exportClause: o, moduleSpecifier: c } = s; + return !c && o && mp(o) && o.elements.some((_) => n.getExportSpecifierLocalTargetSymbol(_) === i); + }); + } + function o4e(e, t, n) { + var i; + const s = [], o = e.getTypeChecker(); + for (const c of t) { + const _ = n.valueDeclaration; + if (_?.kind === 308) { + for (const u of c.referencedFiles) + e.getSourceFileFromReference(c, u) === _ && s.push({ kind: "reference", referencingFile: c, ref: u }); + for (const u of c.typeReferenceDirectives) { + const g = (i = e.getResolvedTypeReferenceDirectiveFromTypeReferenceDirective(u, c)) == null ? void 0 : i.resolvedTypeReferenceDirective; + g !== void 0 && g.resolvedFileName === _.fileName && s.push({ kind: "reference", referencingFile: c, ref: u }); + } + } + l4e(c, (u, g) => { + o.getSymbolAtLocation(g) === n && s.push(lo(u) ? { kind: "implicit", literal: g, referencingFile: c } : { kind: "import", literal: g }); + }); + } + return s; + } + function jXe(e, t, n) { + const i = /* @__PURE__ */ new Map(); + for (const s of e) + n && n.throwIfCancellationRequested(), l4e(s, (o, c) => { + const _ = t.getSymbolAtLocation(c); + if (_) { + const u = Xs(_).toString(); + let g = i.get(u); + g || i.set(u, g = []), g.push(o); + } + }); + return i; + } + function c4e(e, t) { + return lr(e.kind === 308 ? e.statements : e.body.statements, (n) => ( + // TODO: GH#18217 + t(n) || HH(n) && lr(n.body && n.body.statements, t) + )); + } + function l4e(e, t) { + if (e.externalModuleIndicator || e.imports !== void 0) + for (const n of e.imports) + t(UD(n), n); + else + c4e(e, (n) => { + switch (n.kind) { + case 279: + case 273: { + const i = n; + i.moduleSpecifier && ca(i.moduleSpecifier) && t(i, i.moduleSpecifier); + break; + } + case 272: { + const i = n; + Oue(i) && t(i, i.moduleReference.expression); + break; + } + } + }); + } + function u4e(e, t, n, i) { + return i ? s() : s() || o(); + function s() { + var u; + const { parent: g } = e, m = g.parent; + if (t.exportSymbol) + return g.kind === 212 ? (u = t.declarations) != null && u.some((T) => T === g) && _n(m) ? S( + m, + /*useLhsSymbol*/ + !1 + ) : void 0 : c(t.exportSymbol, _(g)); + { + const T = JXe(g, e); + if (T && Gn( + T, + 32 + /* Export */ + )) + return _l(T) && T.moduleReference === e ? i ? void 0 : { kind: 0, symbol: n.getSymbolAtLocation(T.name) } : c(t, _(T)); + if (Km(g)) + return c( + t, + 0 + /* Named */ + ); + if (Mo(g)) + return h(g); + if (Mo(m)) + return h(m); + if (_n(g)) + return S( + g, + /*useLhsSymbol*/ + !0 + ); + if (_n(m)) + return S( + m, + /*useLhsSymbol*/ + !0 + ); + if (IS(g) || Sz(g)) + return c( + t, + 0 + /* Named */ + ); + } + function h(T) { + if (!T.symbol.parent) return; + const k = T.isExportEquals ? 2 : 1; + return { kind: 1, symbol: t, exportInfo: { exportingModuleSymbol: T.symbol.parent, exportKind: k } }; + } + function S(T, k) { + let D; + switch (Ac(T)) { + case 1: + D = 0; + break; + case 2: + D = 2; + break; + default: + return; + } + const P = k ? n.getSymbolAtLocation(vJ(Us(T.left, To))) : t; + return P && c(P, D); + } + } + function o() { + if (!zXe(e)) return; + let g = n.getImmediateAliasedSymbol(t); + if (!g || (g = WXe(g, n), g.escapedName === "export=" && (g = BXe(g, n), g === void 0))) + return; + const m = A9(g); + if (m === void 0 || m === "default" || m === t.escapedName) + return { kind: 0, symbol: g }; + } + function c(u, g) { + const m = Fue(u, g, n); + return m && { kind: 1, symbol: u, exportInfo: m }; + } + function _(u) { + return Gn( + u, + 2048 + /* Default */ + ) ? 1 : 0; + } + } + function BXe(e, t) { + var n, i; + if (e.flags & 2097152) + return t.getImmediateAliasedSymbol(e); + const s = E.checkDefined(e.valueDeclaration); + if (Mo(s)) + return (n = Bn(s.expression, Ed)) == null ? void 0 : n.symbol; + if (_n(s)) + return (i = Bn(s.right, Ed)) == null ? void 0 : i.symbol; + if (Di(s)) + return s.symbol; + } + function JXe(e, t) { + const n = ei(e) ? e : ya(e) ? Y2(e) : void 0; + return n ? e.name !== t || Zb(n.parent) ? void 0 : Ic(n.parent.parent) ? n.parent.parent : void 0 : e; + } + function zXe(e) { + const { parent: t } = e; + switch (t.kind) { + case 272: + return t.name === e && Oue(t); + case 277: + return !t.propertyName; + case 274: + case 275: + return E.assert(t.name === e), !0; + case 209: + return an(e) && Ab(t.parent.parent); + default: + return !1; + } + } + function Fue(e, t, n) { + const i = e.parent; + if (!i) return; + const s = n.getMergedSymbol(i); + return lx(s) ? { exportingModuleSymbol: s, exportKind: t } : void 0; + } + function WXe(e, t) { + if (e.declarations) + for (const n of e.declarations) { + if (Nu(n) && !n.propertyName && !n.parent.parent.moduleSpecifier) + return t.getExportSpecifierLocalTargetSymbol(n) || e; + if (wn(n) && Lg(n.expression) && !Ai(n.name)) + return t.getSymbolAtLocation(n); + if (gu(n) && _n(n.parent.parent) && Ac(n.parent.parent) === 2) + return t.getExportSpecifierLocalTargetSymbol(n.name); + } + return e; + } + function UXe(e, t) { + return t.getMergedSymbol(DL(e).symbol); + } + function DL(e) { + if (e.kind === 214 || e.kind === 352) + return e.getSourceFile(); + const { parent: t } = e; + return t.kind === 308 ? t : (E.assert( + t.kind === 269 + /* ModuleBlock */ + ), Us(t.parent, HH)); + } + function HH(e) { + return e.kind === 268 && e.name.kind === 11; + } + function Oue(e) { + return e.moduleReference.kind === 284 && e.moduleReference.expression.kind === 11; + } + var _4e = /* @__PURE__ */ ((e) => (e[e.Symbol = 0] = "Symbol", e[e.Label = 1] = "Label", e[e.Keyword = 2] = "Keyword", e[e.This = 3] = "This", e[e.String = 4] = "String", e[e.TripleSlashReference = 5] = "TripleSlashReference", e))(_4e || {}), f4e = /* @__PURE__ */ ((e) => (e[e.Span = 0] = "Span", e[e.Node = 1] = "Node", e[e.StringLiteral = 2] = "StringLiteral", e[e.SearchedLocalFoundProperty = 3] = "SearchedLocalFoundProperty", e[e.SearchedPropertyFoundLocal = 4] = "SearchedPropertyFoundLocal", e))(f4e || {}); + function Lh(e, t = 1) { + return { + kind: t, + node: e.name || e, + context: VXe(e) + }; + } + function Lue(e) { + return e && e.kind === void 0; + } + function VXe(e) { + if (Pl(e)) + return $S(e); + if (e.parent) { + if (!Pl(e.parent) && !Mo(e.parent)) { + if (an(e)) { + const n = _n(e.parent) ? e.parent : To(e.parent) && _n(e.parent.parent) && e.parent.parent.left === e.parent ? e.parent.parent : void 0; + if (n && Ac(n) !== 0) + return $S(n); + } + if (Id(e.parent) || Qb(e.parent)) + return e.parent.parent; + if (NS(e.parent) || Gy(e.parent) || xD(e.parent)) + return e.parent; + if (ja(e)) { + const n = U3(e); + if (n) { + const i = dr(n, (s) => Pl(s) || Ti(s) || OC(s)); + return Pl(i) ? $S(i) : i; + } + } + const t = dr(e, Gs); + return t ? $S(t.parent) : void 0; + } + if (e.parent.name === e || // node is name of declaration, use parent + nc(e.parent) || Mo(e.parent) || // Property name of the import export specifier or binding pattern, use parent + (Cy(e.parent) || ya(e.parent)) && e.parent.propertyName === e || // Is default export + e.kind === 90 && Gn( + e.parent, + 2080 + /* ExportDefault */ + )) + return $S(e.parent); + } + } + function $S(e) { + if (e) + switch (e.kind) { + case 261: + return !Ul(e.parent) || e.parent.declarations.length !== 1 ? e : Ic(e.parent.parent) ? e.parent.parent : nS(e.parent.parent) ? $S(e.parent.parent) : e.parent; + case 209: + return $S(e.parent.parent); + case 277: + return e.parent.parent.parent; + case 282: + case 275: + return e.parent.parent; + case 274: + case 281: + return e.parent; + case 227: + return Al(e.parent) ? e.parent : e; + case 251: + case 250: + return { + start: e.initializer, + end: e.expression + }; + case 304: + case 305: + return N0(e.parent) ? $S( + dr(e.parent, (t) => _n(t) || nS(t)) + ) : e; + case 256: + return { + start: Nn( + e.getChildren(e.getSourceFile()), + (t) => t.kind === 109 + /* SwitchKeyword */ + ), + end: e.caseBlock + }; + default: + return e; + } + } + function Mue(e, t, n) { + if (!n) return; + const i = Lue(n) ? PL(n.start, t, n.end) : PL(n, t); + return i.start !== e.start || i.length !== e.length ? { contextSpan: i } : void 0; + } + var p4e = /* @__PURE__ */ ((e) => (e[e.Other = 0] = "Other", e[e.References = 1] = "References", e[e.Rename = 2] = "Rename", e))(p4e || {}); + function qXe(e, t, n, i, s) { + const o = w_(i, s), c = { + use: 1 + /* References */ + }, _ = xk.getReferencedSymbolsForNode(s, o, e, n, t, c), u = e.getTypeChecker(), g = xk.getAdjustedNode(o, c), m = HXe(g) ? u.getSymbolAtLocation(g) : void 0; + return !_ || !_.length ? void 0 : Fi(_, ({ definition: h, references: S }) => ( + // Only include referenced symbols that have a valid definition. + h && { + definition: u.runWithCancellationToken(t, (T) => XXe(h, T, o)), + references: S.map((T) => YXe(T, m)) + } + )); + } + function HXe(e) { + return e.kind === 90 || !!qD(e) || X3(e) || e.kind === 137 && nc(e.parent); + } + function GXe(e, t, n, i, s) { + const o = w_(i, s); + let c; + const _ = d4e(e, t, n, o, s); + if (o.parent.kind === 212 || o.parent.kind === 209 || o.parent.kind === 213 || o.kind === 108) + c = _ && [..._]; + else if (_) { + const g = JP(_), m = /* @__PURE__ */ new Set(); + for (; !g.isEmpty(); ) { + const h = g.dequeue(); + if (!Jp(m, Ma(h.node))) + continue; + c = Er(c, h); + const S = d4e(e, t, n, h.node, h.node.pos); + S && g.enqueue(...S); + } + } + const u = e.getTypeChecker(); + return hr(c, (g) => KXe(g, u)); + } + function d4e(e, t, n, i, s) { + if (i.kind === 308) + return; + const o = e.getTypeChecker(); + if (i.parent.kind === 305) { + const c = []; + return xk.getReferenceEntriesForShorthandPropertyAssignment(i, o, (_) => c.push(Lh(_))), c; + } else if (i.kind === 108 || j_(i.parent)) { + const c = o.getSymbolAtLocation(i); + return c.valueDeclaration && [Lh(c.valueDeclaration)]; + } else + return m4e(s, i, e, n, t, { + implementations: !0, + use: 1 + /* References */ + }); + } + function $Xe(e, t, n, i, s, o, c) { + return hr(g4e(xk.getReferencedSymbolsForNode(s, i, e, n, t, o)), (_) => c(_, i, e.getTypeChecker())); + } + function m4e(e, t, n, i, s, o = {}, c = new Set(i.map((_) => _.fileName))) { + return g4e(xk.getReferencedSymbolsForNode(e, t, n, i, s, o, c)); + } + function g4e(e) { + return e && ka(e, (t) => t.references); + } + function XXe(e, t, n) { + const i = (() => { + switch (e.type) { + case 0: { + const { symbol: m } = e, { displayParts: h, kind: S } = h4e(m, t, n), T = h.map((P) => P.text).join(""), k = m.declarations && Yc(m.declarations), D = k ? _s(k) || k : n; + return { + ...wL(D), + name: T, + kind: S, + displayParts: h, + context: $S(k) + }; + } + case 1: { + const { node: m } = e; + return { ...wL(m), name: m.text, kind: "label", displayParts: [W_( + m.text, + 17 + /* text */ + )] }; + } + case 2: { + const { node: m } = e, h = qs(m.kind); + return { ...wL(m), name: h, kind: "keyword", displayParts: [{ + text: h, + kind: "keyword" + /* keyword */ + }] }; + } + case 3: { + const { node: m } = e, h = t.getSymbolAtLocation(m), S = h && O0.getSymbolDisplayPartsDocumentationAndSymbolKind( + t, + h, + m.getSourceFile(), + US(m), + m + ).displayParts || [Bf("this")]; + return { ...wL(m), name: "this", kind: "var", displayParts: S }; + } + case 4: { + const { node: m } = e; + return { + ...wL(m), + name: m.text, + kind: "var", + displayParts: [W_( + Qo(m), + 8 + /* stringLiteral */ + )] + }; + } + case 5: + return { + textSpan: A0(e.reference), + sourceFile: e.file, + name: e.reference.fileName, + kind: "string", + displayParts: [W_( + `"${e.reference.fileName}"`, + 8 + /* stringLiteral */ + )] + }; + default: + return E.assertNever(e); + } + })(), { sourceFile: s, textSpan: o, name: c, kind: _, displayParts: u, context: g } = i; + return { + containerKind: "", + containerName: "", + fileName: s.fileName, + kind: _, + name: c, + textSpan: o, + displayParts: u, + ...Mue(o, s, g) + }; + } + function wL(e) { + const t = e.getSourceFile(); + return { + sourceFile: t, + textSpan: PL(Gs(e) ? e.expression : e, t) + }; + } + function h4e(e, t, n) { + const i = xk.getIntersectingMeaningFromDeclarations(n, e), s = e.declarations && Yc(e.declarations) || n, { displayParts: o, symbolKind: c } = O0.getSymbolDisplayPartsDocumentationAndSymbolKind(t, e, s.getSourceFile(), s, s, i); + return { displayParts: o, kind: c }; + } + function QXe(e, t, n, i, s) { + return { ...GH(e), ...i && ZXe(e, t, n, s) }; + } + function YXe(e, t) { + const n = y4e(e); + return t ? { + ...n, + isDefinition: e.kind !== 0 && b4e(e.node, t) + } : n; + } + function y4e(e) { + const t = GH(e); + if (e.kind === 0) + return { ...t, isWriteAccess: !1 }; + const { kind: n, node: i } = e; + return { + ...t, + isWriteAccess: Rue(i), + isInString: n === 2 ? !0 : void 0 + }; + } + function GH(e) { + if (e.kind === 0) + return { textSpan: e.textSpan, fileName: e.fileName }; + { + const t = e.node.getSourceFile(), n = PL(e.node, t); + return { + textSpan: n, + fileName: t.fileName, + ...Mue(n, t, e.context) + }; + } + } + function ZXe(e, t, n, i) { + if (e.kind !== 0 && (Me(t) || ja(t))) { + const { node: s, kind: o } = e, c = s.parent, _ = t.text, u = gu(c); + if (u || $A(c) && c.name === s && c.dotDotDotToken === void 0) { + const g = { prefixText: _ + ": " }, m = { suffixText: ": " + _ }; + if (o === 3) + return g; + if (o === 4) + return m; + if (u) { + const h = c.parent; + return _a(h) && _n(h.parent) && Lg(h.parent.left) ? g : m; + } else + return g; + } else if (Xu(c) && !c.propertyName) { + const g = Nu(t.parent) ? n.getExportSpecifierLocalTargetSymbol(t.parent) : n.getSymbolAtLocation(t); + return ms(g.declarations, c) ? { prefixText: _ + " as " } : qp; + } else if (Nu(c) && !c.propertyName) + return t === e.node || n.getSymbolAtLocation(t) === n.getSymbolAtLocation(e.node) ? { prefixText: _ + " as " } : { suffixText: " as " + _ }; + } + if (e.kind !== 0 && E_(e.node) && To(e.node.parent)) { + const s = qV(i); + return { prefixText: s, suffixText: s }; + } + return qp; + } + function KXe(e, t) { + const n = GH(e); + if (e.kind !== 0) { + const { node: i } = e; + return { + ...n, + ...eQe(i, t) + }; + } else + return { ...n, kind: "", displayParts: [] }; + } + function eQe(e, t) { + const n = t.getSymbolAtLocation(Pl(e) && e.name ? e.name : e); + return n ? h4e(n, t, e) : e.kind === 211 ? { + kind: "interface", + displayParts: [Fu( + 21 + /* OpenParenToken */ + ), Bf("object literal"), Fu( + 22 + /* CloseParenToken */ + )] + } : e.kind === 232 ? { + kind: "local class", + displayParts: [Fu( + 21 + /* OpenParenToken */ + ), Bf("anonymous local class"), Fu( + 22 + /* CloseParenToken */ + )] + } : { kind: o2(e), displayParts: [] }; + } + function tQe(e) { + const t = GH(e); + if (e.kind === 0) + return { + fileName: t.fileName, + span: { + textSpan: t.textSpan, + kind: "reference" + /* reference */ + } + }; + const n = Rue(e.node), i = { + textSpan: t.textSpan, + kind: n ? "writtenReference" : "reference", + isInString: e.kind === 2 ? !0 : void 0, + ...t.contextSpan && { contextSpan: t.contextSpan } + }; + return { fileName: t.fileName, span: i }; + } + function PL(e, t, n) { + let i = e.getStart(t), s = (n || e).getEnd(); + return ja(e) && s - i > 2 && (E.assert(n === void 0), i += 1, s -= 1), n?.kind === 270 && (s = n.getFullStart()), Nc(i, s); + } + function v4e(e) { + return e.kind === 0 ? e.textSpan : PL(e.node, e.node.getSourceFile()); + } + function Rue(e) { + const t = qD(e); + return !!t && rQe(t) || e.kind === 90 || Ex(e); + } + function b4e(e, t) { + var n; + if (!t) return !1; + const i = qD(e) || (e.kind === 90 ? e.parent : X3(e) || e.kind === 137 && nc(e.parent) ? e.parent.parent : void 0), s = i && _n(i) ? i.left : void 0; + return !!(i && ((n = t.declarations) != null && n.some((o) => o === i || o === s))); + } + function rQe(e) { + if (e.flags & 33554432) return !0; + switch (e.kind) { + case 227: + case 209: + case 264: + case 232: + case 90: + case 267: + case 307: + case 282: + case 274: + // default import + case 272: + case 277: + case 265: + case 339: + case 347: + case 292: + case 268: + case 271: + case 275: + case 281: + case 170: + case 305: + case 266: + case 169: + return !0; + case 304: + return !N0(e.parent); + case 263: + case 219: + case 177: + case 175: + case 178: + case 179: + return !!e.body; + case 261: + case 173: + return !!e.initializer || Zb(e.parent); + case 174: + case 172: + case 349: + case 342: + return !1; + default: + return E.failBadSyntaxKind(e); + } + } + var xk; + ((e) => { + function t(Xe, Et, re, it, Y, Ae = {}, $e = new Set(it.map((Ke) => Ke.fileName))) { + var Ke, Tt; + if (Et = n(Et, Ae), Di(Et)) { + const rn = sE.getReferenceAtPosition(Et, Xe, re); + if (!rn?.file) + return; + const Pe = re.getTypeChecker().getMergedSymbol(rn.file.symbol); + if (Pe) + return g( + re, + Pe, + /*excludeImportTypeOfExportEquals*/ + !1, + it, + $e + ); + const yt = re.getFileIncludeReasons(); + return yt ? [{ + definition: { type: 5, reference: rn.reference, file: Et }, + references: s(rn.file, yt, re) || Ge + }] : void 0; + } + if (!Ae.implementations) { + const rn = h(Et, it, Y); + if (rn) + return rn; + } + const Le = re.getTypeChecker(), mt = Le.getSymbolAtLocation(nc(Et) && Et.parent.name || Et); + if (!mt) { + if (!Ae.implementations && ja(Et)) { + if (I9(Et)) { + const rn = re.getFileIncludeReasons(), Pe = (Tt = (Ke = re.getResolvedModuleFromModuleSpecifier(Et)) == null ? void 0 : Ke.resolvedModule) == null ? void 0 : Tt.resolvedFileName, yt = Pe ? re.getSourceFile(Pe) : void 0; + if (yt) + return [{ definition: { type: 4, node: Et }, references: s(yt, rn, re) || Ge }]; + } + return fi(Et, it, Le, Y); + } + return; + } + if (mt.escapedName === "export=") + return g( + re, + mt.parent, + /*excludeImportTypeOfExportEquals*/ + !1, + it, + $e + ); + const pt = c(mt, re, it, Y, Ae, $e); + if (pt && !(mt.flags & 33554432)) + return pt; + const Ct = o(Et, mt, Le), qe = Ct && c(Ct, re, it, Y, Ae, $e), Lt = S(mt, Et, it, $e, Le, Y, Ae); + return _(re, pt, Lt, qe); + } + e.getReferencedSymbolsForNode = t; + function n(Xe, Et) { + return Et.use === 1 ? Xe = NV(Xe) : Et.use === 2 && (Xe = T9(Xe)), Xe; + } + e.getAdjustedNode = n; + function i(Xe, Et, re, it = new Set(re.map((Y) => Y.fileName))) { + var Y, Ae; + const $e = (Y = Et.getSourceFile(Xe)) == null ? void 0 : Y.symbol; + if ($e) + return ((Ae = g( + Et, + $e, + /*excludeImportTypeOfExportEquals*/ + !1, + re, + it + )[0]) == null ? void 0 : Ae.references) || Ge; + const Ke = Et.getFileIncludeReasons(), Tt = Et.getSourceFile(Xe); + return Tt && Ke && s(Tt, Ke, Et) || Ge; + } + e.getReferencesForFileName = i; + function s(Xe, Et, re) { + let it; + const Y = Et.get(Xe.path) || Ge; + for (const Ae of Y) + if (yv(Ae)) { + const $e = re.getSourceFileByPath(Ae.file), Ke = lw(re, Ae); + j6(Ke) && (it = Er(it, { + kind: 0, + fileName: $e.fileName, + textSpan: A0(Ke) + })); + } + return it; + } + function o(Xe, Et, re) { + if (Xe.parent && zN(Xe.parent)) { + const it = re.getAliasedSymbol(Et), Y = re.getMergedSymbol(it); + if (it !== Y) + return Y; + } + } + function c(Xe, Et, re, it, Y, Ae) { + const $e = Xe.flags & 1536 && Xe.declarations && Nn(Xe.declarations, Di); + if (!$e) return; + const Ke = Xe.exports.get( + "export=" + /* ExportEquals */ + ), Tt = g(Et, Xe, !!Ke, re, Ae); + if (!Ke || !Ae.has($e.fileName)) return Tt; + const Le = Et.getTypeChecker(); + return Xe = eu(Ke, Le), _(Et, Tt, S( + Xe, + /*node*/ + void 0, + re, + Ae, + Le, + it, + Y + )); + } + function _(Xe, ...Et) { + let re; + for (const it of Et) + if (!(!it || !it.length)) { + if (!re) { + re = it; + continue; + } + for (const Y of it) { + if (!Y.definition || Y.definition.type !== 0) { + re.push(Y); + continue; + } + const Ae = Y.definition.symbol, $e = oc(re, (Tt) => !!Tt.definition && Tt.definition.type === 0 && Tt.definition.symbol === Ae); + if ($e === -1) { + re.push(Y); + continue; + } + const Ke = re[$e]; + re[$e] = { + definition: Ke.definition, + references: Ke.references.concat(Y.references).sort((Tt, Le) => { + const mt = u(Xe, Tt), pt = u(Xe, Le); + if (mt !== pt) + return ho(mt, pt); + const Ct = v4e(Tt), qe = v4e(Le); + return Ct.start !== qe.start ? ho(Ct.start, qe.start) : ho(Ct.length, qe.length); + }) + }; + } + } + return re; + } + function u(Xe, Et) { + const re = Et.kind === 0 ? Xe.getSourceFile(Et.fileName) : Et.node.getSourceFile(); + return Xe.getSourceFiles().indexOf(re); + } + function g(Xe, Et, re, it, Y) { + E.assert(!!Et.valueDeclaration); + const Ae = Fi(o4e(Xe, it, Et), (Ke) => { + if (Ke.kind === "import") { + const Tt = Ke.literal.parent; + if (E0(Tt)) { + const Le = Us(Tt.parent, ym); + if (re && !Le.qualifier) + return; + } + return Lh(Ke.literal); + } else if (Ke.kind === "implicit") { + const Tt = Ke.literal.text !== Py && Kx( + Ke.referencingFile, + (Le) => Le.transformFlags & 2 ? Sm(Le) || NS(Le) || cv(Le) ? Le : void 0 : "skip" + ) || Ke.referencingFile.statements[0] || Ke.referencingFile; + return Lh(Tt); + } else + return { + kind: 0, + fileName: Ke.referencingFile.fileName, + textSpan: A0(Ke.ref) + }; + }); + if (Et.declarations) + for (const Ke of Et.declarations) + switch (Ke.kind) { + case 308: + break; + case 268: + Y.has(Ke.getSourceFile().fileName) && Ae.push(Lh(Ke.name)); + break; + default: + E.assert(!!(Et.flags & 33554432), "Expected a module symbol to be declared by a SourceFile or ModuleDeclaration."); + } + const $e = Et.exports.get( + "export=" + /* ExportEquals */ + ); + if ($e?.declarations) + for (const Ke of $e.declarations) { + const Tt = Ke.getSourceFile(); + if (Y.has(Tt.fileName)) { + const Le = _n(Ke) && wn(Ke.left) ? Ke.left.expression : Mo(Ke) ? E.checkDefined(Ya(Ke, 95, Tt)) : _s(Ke) || Ke; + Ae.push(Lh(Le)); + } + } + return Ae.length ? [{ definition: { type: 0, symbol: Et }, references: Ae }] : Ge; + } + function m(Xe) { + return Xe.kind === 148 && rv(Xe.parent) && Xe.parent.operator === 148; + } + function h(Xe, Et, re) { + if (yw(Xe.kind)) + return Xe.kind === 116 && Gx(Xe.parent) || Xe.kind === 148 && !m(Xe) ? void 0 : je( + Et, + Xe.kind, + re, + Xe.kind === 148 ? m : void 0 + ); + if (JC(Xe.parent) && Xe.parent.name === Xe) + return be(Et, re); + if (Wx(Xe) && kc(Xe.parent)) + return [{ definition: { type: 2, node: Xe }, references: [Lh(Xe)] }]; + if (JA(Xe)) { + const it = g9(Xe.parent, Xe.text); + return it && he(it.parent, it); + } else if (SV(Xe)) + return he(Xe.parent, Xe); + if (V6(Xe)) + return ai(Xe, Et, re); + if (Xe.kind === 108) + return Dt(Xe); + } + function S(Xe, Et, re, it, Y, Ae, $e) { + const Ke = Et && D( + Xe, + Et, + Y, + /*useLocalSymbolForExportSpecifier*/ + !bs($e) + ) || Xe, Tt = Et && $e.use !== 2 ? Jn(Et, Ke) : 7, Le = [], mt = new O(re, it, Et ? k(Et) : 0, Y, Ae, Tt, $e, Le), pt = !bs($e) || !Ke.declarations ? void 0 : Nn(Ke.declarations, Nu); + if (pt) + Ye( + pt.name, + Ke, + pt, + mt.createSearch( + Et, + Xe, + /*comingFrom*/ + void 0 + ), + mt, + /*addReferencesHere*/ + !0, + /*alwaysGetReferences*/ + !0 + ); + else if (Et && Et.kind === 90 && Ke.escapedName === "default" && Ke.parent) + Ee(Et, Ke, mt), F(Et, Ke, { + exportingModuleSymbol: Ke.parent, + exportKind: 1 + /* Default */ + }, mt); + else { + const Ct = mt.createSearch( + Et, + Ke, + /*comingFrom*/ + void 0, + { allSearchSymbols: Et ? _i(Ke, Et, Y, $e.use === 2, !!$e.providePrefixAndSuffixTextForRename, !!$e.implementations) : [Ke] } + ); + T(Ke, mt, Ct); + } + return Le; + } + function T(Xe, Et, re) { + const it = _e(Xe); + if (it) + Z( + it, + it.getSourceFile(), + re, + Et, + /*addReferencesHere*/ + !(Di(it) && !ms(Et.sourceFiles, it)) + ); + else + for (const Y of Et.sourceFiles) + Et.cancellationToken.throwIfCancellationRequested(), $(Y, re, Et); + } + function k(Xe) { + switch (Xe.kind) { + case 177: + case 137: + return 1; + case 80: + if ($n(Xe.parent)) + return E.assert(Xe.parent.name === Xe), 2; + // falls through + default: + return 0; + } + } + function D(Xe, Et, re, it) { + const { parent: Y } = Et; + return Nu(Y) && it ? ne(Et, Xe, Y, re) : Lc(Xe.declarations, (Ae) => { + if (!Ae.parent) { + if (Xe.flags & 33554432) return; + E.fail(`Unexpected symbol at ${E.formatSyntaxKind(Et.kind)}: ${E.formatSymbol(Xe)}`); + } + return a_(Ae.parent) && C0(Ae.parent.parent) ? re.getPropertyOfType(re.getTypeFromTypeNode(Ae.parent.parent), Xe.name) : void 0; + }); + } + let P; + ((Xe) => { + Xe[Xe.None = 0] = "None", Xe[Xe.Constructor = 1] = "Constructor", Xe[Xe.Class = 2] = "Class"; + })(P || (P = {})); + function A(Xe) { + if (!(Xe.flags & 33555968)) return; + const Et = Xe.declarations && Nn(Xe.declarations, (re) => !Di(re) && !jc(re)); + return Et && Et.symbol; + } + class O { + constructor(Et, re, it, Y, Ae, $e, Ke, Tt) { + this.sourceFiles = Et, this.sourceFilesSet = re, this.specialSearchKind = it, this.checker = Y, this.cancellationToken = Ae, this.searchMeaning = $e, this.options = Ke, this.result = Tt, this.inheritsFromCache = /* @__PURE__ */ new Map(), this.markSeenContainingTypeReference = G6(), this.markSeenReExportRHS = G6(), this.symbolIdToReferences = [], this.sourceFileToSeenSymbols = []; + } + includesSourceFile(Et) { + return this.sourceFilesSet.has(Et.fileName); + } + /** Gets every place to look for references of an exported symbols. See `ImportsResult` in `importTracker.ts` for more documentation. */ + getImportSearches(Et, re) { + return this.importTracker || (this.importTracker = Iue(this.sourceFiles, this.sourceFilesSet, this.checker, this.cancellationToken)), this.importTracker( + Et, + re, + this.options.use === 2 + /* Rename */ + ); + } + /** @param allSearchSymbols set of additional symbols for use by `includes`. */ + createSearch(Et, re, it, Y = {}) { + const { + text: Ae = Bp(cc(n4(re) || A(re) || re)), + allSearchSymbols: $e = [re] + } = Y, Ke = tc(Ae), Tt = this.options.implementations && Et ? yr(Et, re, this.checker) : void 0; + return { symbol: re, comingFrom: it, text: Ae, escapedText: Ke, parents: Tt, allSearchSymbols: $e, includes: (Le) => ms($e, Le) }; + } + /** + * Callback to add references for a particular searched symbol. + * This initializes a reference group, so only call this if you will add at least one reference. + */ + referenceAdder(Et) { + const re = Xs(Et); + let it = this.symbolIdToReferences[re]; + return it || (it = this.symbolIdToReferences[re] = [], this.result.push({ definition: { type: 0, symbol: Et }, references: it })), (Y, Ae) => it.push(Lh(Y, Ae)); + } + /** Add a reference with no associated definition. */ + addStringOrCommentReference(Et, re) { + this.result.push({ + definition: void 0, + references: [{ kind: 0, fileName: Et, textSpan: re }] + }); + } + /** Returns `true` the first time we search for a symbol in a file and `false` afterwards. */ + markSearchedSymbols(Et, re) { + const it = Ma(Et), Y = this.sourceFileToSeenSymbols[it] || (this.sourceFileToSeenSymbols[it] = /* @__PURE__ */ new Set()); + let Ae = !1; + for (const $e of re) + Ae = u0(Y, Xs($e)) || Ae; + return Ae; + } + } + function F(Xe, Et, re, it) { + const { importSearches: Y, singleReferences: Ae, indirectUsers: $e } = it.getImportSearches(Et, re); + if (Ae.length) { + const Ke = it.referenceAdder(Et); + for (const Tt of Ae) + B(Tt, it) && Ke(Tt); + } + for (const [Ke, Tt] of Y) + me(Ke.getSourceFile(), it.createSearch( + Ke, + Tt, + 1 + /* Export */ + ), it); + if ($e.length) { + let Ke; + switch (re.exportKind) { + case 0: + Ke = it.createSearch( + Xe, + Et, + 1 + /* Export */ + ); + break; + case 1: + Ke = it.options.use === 2 ? void 0 : it.createSearch(Xe, Et, 1, { text: "default" }); + break; + } + if (Ke) + for (const Tt of $e) + $(Tt, Ke, it); + } + } + function R(Xe, Et, re, it, Y, Ae, $e, Ke) { + const Tt = Iue(Xe, new Set(Xe.map((Ct) => Ct.fileName)), Et, re), { importSearches: Le, indirectUsers: mt, singleReferences: pt } = Tt( + it, + { exportKind: $e ? 1 : 0, exportingModuleSymbol: Y }, + /*isForRename*/ + !1 + ); + for (const [Ct] of Le) + Ke(Ct); + for (const Ct of pt) + Me(Ct) && ym(Ct.parent) && Ke(Ct); + for (const Ct of mt) + for (const qe of ce(Ct, $e ? "default" : Ae)) { + const Lt = Et.getSymbolAtLocation(qe), rn = ot(Lt?.declarations, (Pe) => !!Bn(Pe, Mo)); + Me(qe) && !Cy(qe.parent) && (Lt === it || rn) && Ke(qe); + } + } + e.eachExportReference = R; + function B(Xe, Et) { + return pe(Xe, Et) ? Et.options.use !== 2 ? !0 : !Me(Xe) && !Cy(Xe.parent) ? !1 : !(Cy(Xe.parent) && Gm(Xe)) : !1; + } + function U(Xe, Et) { + if (Xe.declarations) + for (const re of Xe.declarations) { + const it = re.getSourceFile(); + me(it, Et.createSearch( + re, + Xe, + 0 + /* Import */ + ), Et, Et.includesSourceFile(it)); + } + } + function $(Xe, Et, re) { + nH(Xe).get(Et.escapedText) !== void 0 && me(Xe, Et, re); + } + function W(Xe, Et) { + return N0(Xe.parent.parent) ? Et.getPropertySymbolOfDestructuringAssignment(Xe) : void 0; + } + function _e(Xe) { + const { declarations: Et, flags: re, parent: it, valueDeclaration: Y } = Xe; + if (Y && (Y.kind === 219 || Y.kind === 232)) + return Y; + if (!Et) + return; + if (re & 8196) { + const Ke = Nn(Et, (Tt) => sf( + Tt, + 2 + /* Private */ + ) || Du(Tt)); + return Ke ? Q1( + Ke, + 264 + /* ClassDeclaration */ + ) : void 0; + } + if (Et.some($A)) + return; + const Ae = it && !(Xe.flags & 262144); + if (Ae && !(lx(it) && !it.globalExports)) + return; + let $e; + for (const Ke of Et) { + const Tt = US(Ke); + if ($e && $e !== Tt || !Tt || Tt.kind === 308 && !tf(Tt)) + return; + if ($e = Tt, yo($e)) { + let Le; + for (; Le = AB($e); ) + $e = Le; + } + } + return Ae ? $e.getSourceFile() : $e; + } + function K(Xe, Et, re, it = re) { + return V(Xe, Et, re, () => !0, it) || !1; + } + e.isSymbolReferencedInFile = K; + function V(Xe, Et, re, it, Y = re) { + const Ae = K_(Xe.parent, Xe.parent.parent) ? Ca(Et.getSymbolsOfParameterPropertyDeclaration(Xe.parent, Xe.text)) : Et.getSymbolAtLocation(Xe); + if (Ae) + for (const $e of ce(re, Ae.name, Y)) { + if (!Me($e) || $e === Xe || $e.escapedText !== Xe.escapedText) continue; + const Ke = Et.getSymbolAtLocation($e); + if (Ke === Ae || Et.getShorthandAssignmentValueSymbol($e.parent) === Ae || Nu($e.parent) && ne($e, Ke, $e.parent, Et) === Ae) { + const Tt = it($e); + if (Tt) return Tt; + } + } + } + e.eachSymbolReferenceInFile = V; + function ae(Xe, Et) { + return kn(ce(Et, Xe), (Y) => !!qD(Y)).reduce((Y, Ae) => { + const $e = it(Ae); + return !ot(Y.declarationNames) || $e === Y.depth ? (Y.declarationNames.push(Ae), Y.depth = $e) : $e < Y.depth && (Y.declarationNames = [Ae], Y.depth = $e), Y; + }, { depth: 1 / 0, declarationNames: [] }).declarationNames; + function it(Y) { + let Ae = 0; + for (; Y; ) + Y = US(Y), Ae++; + return Ae; + } + } + e.getTopMostDeclarationNamesInFile = ae; + function se(Xe, Et, re, it) { + if (!Xe.name || !Me(Xe.name)) return !1; + const Y = E.checkDefined(re.getSymbolAtLocation(Xe.name)); + for (const Ae of Et) + for (const $e of ce(Ae, Y.name)) { + if (!Me($e) || $e === Xe.name || $e.escapedText !== Xe.name.escapedText) continue; + const Ke = m9($e), Tt = Ps(Ke.parent) && Ke.parent.expression === Ke ? Ke.parent : void 0, Le = re.getSymbolAtLocation($e); + if (Le && re.getRootSymbols(Le).some((mt) => mt === Y) && it($e, Tt)) + return !0; + } + return !1; + } + e.someSignatureUsage = se; + function ce(Xe, Et, re = Xe) { + return Fi(fe(Xe, Et, re), (it) => { + const Y = w_(Xe, it); + return Y === Xe ? void 0 : Y; + }); + } + function fe(Xe, Et, re = Xe) { + const it = []; + if (!Et || !Et.length) + return it; + const Y = Xe.text, Ae = Y.length, $e = Et.length; + let Ke = Y.indexOf(Et, re.pos); + for (; Ke >= 0 && !(Ke > re.end); ) { + const Tt = Ke + $e; + (Ke === 0 || !hh( + Y.charCodeAt(Ke - 1), + 99 + /* Latest */ + )) && (Tt === Ae || !hh( + Y.charCodeAt(Tt), + 99 + /* Latest */ + )) && it.push(Ke), Ke = Y.indexOf(Et, Ke + $e + 1); + } + return it; + } + function he(Xe, Et) { + const re = Xe.getSourceFile(), it = Et.text, Y = Fi(ce(re, it, Xe), (Ae) => ( + // Only pick labels that are either the target label, or have a target that is the target label + Ae === Et || JA(Ae) && g9(Ae, it) === Et ? Lh(Ae) : void 0 + )); + return [{ definition: { type: 1, node: Et }, references: Y }]; + } + function q(Xe, Et) { + switch (Xe.kind) { + case 81: + if (uv(Xe.parent)) + return !0; + // falls through I guess + case 80: + return Xe.text.length === Et.length; + case 15: + case 11: { + const re = Xe; + return re.text.length === Et.length && (h9(re) || CV(Xe) || Kse(Xe) || Ps(Xe.parent) && uS(Xe.parent) && Xe.parent.arguments[1] === Xe || Cy(Xe.parent)); + } + case 9: + return h9(Xe) && Xe.text.length === Et.length; + case 90: + return Et.length === 7; + default: + return !1; + } + } + function be(Xe, Et) { + const re = ka(Xe, (it) => (Et.throwIfCancellationRequested(), Fi(ce(it, "meta", it), (Y) => { + const Ae = Y.parent; + if (JC(Ae)) + return Lh(Ae); + }))); + return re.length ? [{ definition: { type: 2, node: re[0].node }, references: re }] : void 0; + } + function je(Xe, Et, re, it) { + const Y = ka(Xe, (Ae) => (re.throwIfCancellationRequested(), Fi(ce(Ae, qs(Et), Ae), ($e) => { + if ($e.kind === Et && (!it || it($e))) + return Lh($e); + }))); + return Y.length ? [{ definition: { type: 2, node: Y[0].node }, references: Y }] : void 0; + } + function me(Xe, Et, re, it = !0) { + return re.cancellationToken.throwIfCancellationRequested(), Z(Xe, Xe, Et, re, it); + } + function Z(Xe, Et, re, it, Y) { + if (it.markSearchedSymbols(Et, re.allSearchSymbols)) + for (const Ae of fe(Et, re.text, Xe)) + Te(Et, Ae, re, it, Y); + } + function pe(Xe, Et) { + return !!(WS(Xe) & Et.searchMeaning); + } + function Te(Xe, Et, re, it, Y) { + const Ae = w_(Xe, Et); + if (!q(Ae, re.text)) { + !it.options.implementations && (it.options.findInStrings && _k(Xe, Et) || it.options.findInComments && fae(Xe, Et)) && it.addStringOrCommentReference(Xe.fileName, Kl(Et, re.text.length)); + return; + } + if (!pe(Ae, it)) return; + let $e = it.checker.getSymbolAtLocation(Ae); + if (!$e) + return; + const Ke = Ae.parent; + if (Xu(Ke) && Ke.propertyName === Ae) + return; + if (Nu(Ke)) { + E.assert( + Ae.kind === 80 || Ae.kind === 11 + /* StringLiteral */ + ), Ye(Ae, $e, Ke, re, it, Y); + return; + } + if (kD(Ke) && Ke.isNameFirst && Ke.typeExpression && AS(Ke.typeExpression.type) && Ke.typeExpression.type.jsDocPropertyTags && wr(Ke.typeExpression.type.jsDocPropertyTags)) { + Fe(Ke.typeExpression.type.jsDocPropertyTags, Ae, re, it); + return; + } + const Tt = qr(re, $e, Ae, it); + if (!Tt) { + Ne($e, re, it); + return; + } + switch (it.specialSearchKind) { + case 0: + Y && Ee(Ae, Tt, it); + break; + case 1: + Ce(Ae, Xe, re, it); + break; + case 2: + Ve(Ae, re, it); + break; + default: + E.assertNever(it.specialSearchKind); + } + an(Ae) && ya(Ae.parent) && Ab(Ae.parent.parent.parent) && ($e = Ae.parent.symbol, !$e) || ie(Ae, $e, re, it); + } + function Fe(Xe, Et, re, it) { + const Y = it.referenceAdder(re.symbol); + Ee(Et, re.symbol, it), lr(Xe, (Ae) => { + s_(Ae.name) && Y(Ae.name.left); + }); + } + function Ye(Xe, Et, re, it, Y, Ae, $e) { + E.assert(!$e || !!Y.options.providePrefixAndSuffixTextForRename, "If alwaysGetReferences is true, then prefix/suffix text must be enabled"); + const { parent: Ke, propertyName: Tt, name: Le } = re, mt = Ke.parent, pt = ne(Xe, Et, re, Y.checker); + if (!$e && !it.includes(pt)) + return; + if (Tt ? Xe === Tt ? (mt.moduleSpecifier || Ct(), Ae && Y.options.use !== 2 && Y.markSeenReExportRHS(Le) && Ee(Le, E.checkDefined(re.symbol), Y)) : Y.markSeenReExportRHS(Xe) && Ct() : Y.options.use === 2 && Gm(Le) || Ct(), !bs(Y.options) || $e) { + const Lt = Gm(Xe) || Gm(re.name) ? 1 : 0, rn = E.checkDefined(re.symbol), Pe = Fue(rn, Lt, Y.checker); + Pe && F(Xe, rn, Pe, Y); + } + if (it.comingFrom !== 1 && mt.moduleSpecifier && !Tt && !bs(Y.options)) { + const qe = Y.checker.getExportSpecifierLocalTargetSymbol(re); + qe && U(qe, Y); + } + function Ct() { + Ae && Ee(Xe, pt, Y); + } + } + function ne(Xe, Et, re, it) { + return Se(Xe, re) && it.getExportSpecifierLocalTargetSymbol(re) || Et; + } + function Se(Xe, Et) { + const { parent: re, propertyName: it, name: Y } = Et; + return E.assert(it === Xe || Y === Xe), it ? it === Xe : !re.parent.moduleSpecifier; + } + function ie(Xe, Et, re, it) { + const Y = u4e( + Xe, + Et, + it.checker, + re.comingFrom === 1 + /* Export */ + ); + if (!Y) return; + const { symbol: Ae } = Y; + Y.kind === 0 ? bs(it.options) || U(Ae, it) : F(Xe, Ae, Y.exportInfo, it); + } + function Ne({ flags: Xe, valueDeclaration: Et }, re, it) { + const Y = it.checker.getShorthandAssignmentValueSymbol(Et), Ae = Et && _s(Et); + !(Xe & 33554432) && Ae && re.includes(Y) && Ee(Ae, Y, it); + } + function Ee(Xe, Et, re) { + const { kind: it, symbol: Y } = "kind" in Et ? Et : { kind: void 0, symbol: Et }; + if (re.options.use === 2 && Xe.kind === 90) + return; + const Ae = re.referenceAdder(Y); + re.options.implementations ? Wt(Xe, Ae, re) : Ae(Xe, it); + } + function Ce(Xe, Et, re, it) { + dw(Xe) && Ee(Xe, re.symbol, it); + const Y = () => it.referenceAdder(re.symbol); + if ($n(Xe.parent)) + E.assert(Xe.kind === 90 || Xe.parent.name === Xe), St(re.symbol, Et, Y()); + else { + const Ae = Ks(Xe); + Ae && (tr(Ae, Y()), st(Ae, it)); + } + } + function Ve(Xe, Et, re) { + Ee(Xe, Et.symbol, re); + const it = Xe.parent; + if (re.options.use === 2 || !$n(it)) return; + E.assert(it.name === Xe); + const Y = re.referenceAdder(Et.symbol); + for (const Ae of it.members) + ax(Ae) && Js(Ae) && Ae.body && Ae.body.forEachChild(function $e(Ke) { + Ke.kind === 110 ? Y(Ke) : !Es(Ke) && !$n(Ke) && Ke.forEachChild($e); + }); + } + function St(Xe, Et, re) { + const it = Bt(Xe); + if (it && it.declarations) + for (const Y of it.declarations) { + const Ae = Ya(Y, 137, Et); + E.assert(Y.kind === 177 && !!Ae), re(Ae); + } + Xe.exports && Xe.exports.forEach((Y) => { + const Ae = Y.valueDeclaration; + if (Ae && Ae.kind === 175) { + const $e = Ae.body; + $e && Ds($e, 110, (Ke) => { + dw(Ke) && re(Ke); + }); + } + }); + } + function Bt(Xe) { + return Xe.members && Xe.members.get( + "__constructor" + /* Constructor */ + ); + } + function tr(Xe, Et) { + const re = Bt(Xe.symbol); + if (re && re.declarations) + for (const it of re.declarations) { + E.assert( + it.kind === 177 + /* Constructor */ + ); + const Y = it.body; + Y && Ds(Y, 108, (Ae) => { + yV(Ae) && Et(Ae); + }); + } + } + function Nr(Xe) { + return !!Bt(Xe.symbol); + } + function st(Xe, Et) { + if (Nr(Xe)) return; + const re = Xe.symbol, it = Et.createSearch( + /*location*/ + void 0, + re, + /*comingFrom*/ + void 0 + ); + T(re, Et, it); + } + function Wt(Xe, Et, re) { + if (Qm(Xe) && Un(Xe.parent)) { + Et(Xe); + return; + } + if (Xe.kind !== 80) + return; + Xe.parent.kind === 305 && ki(Xe, re.checker, Et); + const it = Jr(Xe); + if (it) { + Et(it); + return; + } + const Y = dr(Xe, (Ke) => !s_(Ke.parent) && !li(Ke.parent) && !kb(Ke.parent)), Ae = Y.parent; + if (O7(Ae) && Ae.type === Y && re.markSeenContainingTypeReference(Ae)) + if (d0(Ae)) + $e(Ae.initializer); + else if (Es(Ae) && Ae.body) { + const Ke = Ae.body; + Ke.kind === 242 ? Fy(Ke, (Tt) => { + Tt.expression && $e(Tt.expression); + }) : $e(Ke); + } else (Eb(Ae) || m6(Ae)) && $e(Ae.expression); + function $e(Ke) { + ui(Ke) && Et(Ke); + } + } + function Jr(Xe) { + return Me(Xe) || wn(Xe) ? Jr(Xe.parent) : Dh(Xe) ? Bn(Xe.parent.parent, Q_($n, Vl)) : void 0; + } + function ui(Xe) { + switch (Xe.kind) { + case 218: + return ui(Xe.expression); + case 220: + case 219: + case 211: + case 232: + case 210: + return !0; + default: + return !1; + } + } + function Ji(Xe, Et, re, it) { + if (Xe === Et) + return !0; + const Y = Xs(Xe) + "," + Xs(Et), Ae = re.get(Y); + if (Ae !== void 0) + return Ae; + re.set(Y, !1); + const $e = !!Xe.declarations && Xe.declarations.some( + (Ke) => HD(Ke).some((Tt) => { + const Le = it.getTypeAtLocation(Tt); + return !!Le && !!Le.symbol && Ji(Le.symbol, Et, re, it); + }) + ); + return re.set(Y, $e), $e; + } + function Dt(Xe) { + let Et = N3( + Xe, + /*stopOnFunctions*/ + !1 + ); + if (!Et) + return; + let re = 256; + switch (Et.kind) { + case 173: + case 172: + case 175: + case 174: + case 177: + case 178: + case 179: + re &= h0(Et), Et = Et.parent; + break; + default: + return; + } + const it = Et.getSourceFile(), Y = Fi(ce(it, "super", Et), (Ae) => { + if (Ae.kind !== 108) + return; + const $e = N3( + Ae, + /*stopOnFunctions*/ + !1 + ); + return $e && Js($e) === !!re && $e.parent.symbol === Et.symbol ? Lh(Ae) : void 0; + }); + return [{ definition: { type: 0, symbol: Et.symbol }, references: Y }]; + } + function Mn(Xe) { + return Xe.kind === 80 && Xe.parent.kind === 170 && Xe.parent.name === Xe; + } + function ai(Xe, Et, re) { + let it = qu( + Xe, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ), Y = 256; + switch (it.kind) { + case 175: + case 174: + if (Rp(it)) { + Y &= h0(it), it = it.parent; + break; + } + // falls through + case 173: + case 172: + case 177: + case 178: + case 179: + Y &= h0(it), it = it.parent; + break; + case 308: + if (fl(it) || Mn(Xe)) + return; + // falls through + case 263: + case 219: + break; + // Computed properties in classes are not handled here because references to this are illegal, + // so there is no point finding references to them. + default: + return; + } + const Ae = ka(it.kind === 308 ? Et : [it.getSourceFile()], (Ke) => (re.throwIfCancellationRequested(), ce(Ke, "this", Di(it) ? Ke : it).filter((Tt) => { + if (!V6(Tt)) + return !1; + const Le = qu( + Tt, + /*includeArrowFunctions*/ + !1, + /*includeClassComputedPropertyName*/ + !1 + ); + if (!Ed(Le)) return !1; + switch (it.kind) { + case 219: + case 263: + return it.symbol === Le.symbol; + case 175: + case 174: + return Rp(it) && it.symbol === Le.symbol; + case 232: + case 264: + case 211: + return Le.parent && Ed(Le.parent) && it.symbol === Le.parent.symbol && Js(Le) === !!Y; + case 308: + return Le.kind === 308 && !fl(Le) && !Mn(Tt); + } + }))).map((Ke) => Lh(Ke)); + return [{ + definition: { type: 3, node: Lc(Ae, (Ke) => Ii(Ke.node.parent) ? Ke.node : void 0) || Xe }, + references: Ae + }]; + } + function fi(Xe, Et, re, it) { + const Y = S9(Xe, re), Ae = ka(Et, ($e) => (it.throwIfCancellationRequested(), Fi(ce($e, Xe.text), (Ke) => { + if (ja(Ke) && Ke.text === Xe.text) + if (Y) { + const Tt = S9(Ke, re); + if (Y !== re.getStringType() && (Y === Tt || pn(Ke, re))) + return Lh( + Ke, + 2 + /* StringLiteral */ + ); + } else + return TS(Ke) && !hS(Ke, $e) ? void 0 : Lh( + Ke, + 2 + /* StringLiteral */ + ); + }))); + return [{ + definition: { type: 4, node: Xe }, + references: Ae + }]; + } + function pn(Xe, Et) { + if ($u(Xe.parent)) + return Et.getPropertyOfType(Et.getTypeAtLocation(Xe.parent.parent), Xe.text); + } + function _i(Xe, Et, re, it, Y, Ae) { + const $e = []; + return Je( + Xe, + Et, + re, + it, + !(it && Y), + (Ke, Tt, Le) => { + Le && er(Xe) !== er(Le) && (Le = void 0), $e.push(Le || Tt || Ke); + }, + // when try to find implementation, implementations is true, and not allowed to find base class + /*allowBaseTypes*/ + () => !Ae + ), $e; + } + function Je(Xe, Et, re, it, Y, Ae, $e) { + const Ke = f8(Et); + if (Ke) { + const Lt = re.getShorthandAssignmentValueSymbol(Et.parent); + if (Lt && it) + return Ae( + Lt, + /*rootSymbol*/ + void 0, + /*baseSymbol*/ + void 0, + 3 + /* SearchedLocalFoundProperty */ + ); + const rn = re.getContextualType(Ke.parent), Pe = rn && Lc( + mL( + Ke, + re, + rn, + /*unionSymbolOk*/ + !0 + ), + (ye) => Ct( + ye, + 4 + /* SearchedPropertyFoundLocal */ + ) + ); + if (Pe) return Pe; + const yt = W(Et, re), ue = yt && Ae( + yt, + /*rootSymbol*/ + void 0, + /*baseSymbol*/ + void 0, + 4 + /* SearchedPropertyFoundLocal */ + ); + if (ue) return ue; + const M = Lt && Ae( + Lt, + /*rootSymbol*/ + void 0, + /*baseSymbol*/ + void 0, + 3 + /* SearchedLocalFoundProperty */ + ); + if (M) return M; + } + const Tt = o(Et, Xe, re); + if (Tt) { + const Lt = Ae( + Tt, + /*rootSymbol*/ + void 0, + /*baseSymbol*/ + void 0, + 1 + /* Node */ + ); + if (Lt) return Lt; + } + const Le = Ct(Xe); + if (Le) return Le; + if (Xe.valueDeclaration && K_(Xe.valueDeclaration, Xe.valueDeclaration.parent)) { + const Lt = re.getSymbolsOfParameterPropertyDeclaration(Us(Xe.valueDeclaration, Ii), Xe.name); + return E.assert(Lt.length === 2 && !!(Lt[0].flags & 1) && !!(Lt[1].flags & 4)), Ct(Xe.flags & 1 ? Lt[1] : Lt[0]); + } + const mt = Oo( + Xe, + 282 + /* ExportSpecifier */ + ); + if (!it || mt && !mt.propertyName) { + const Lt = mt && re.getExportSpecifierLocalTargetSymbol(mt); + if (Lt) { + const rn = Ae( + Lt, + /*rootSymbol*/ + void 0, + /*baseSymbol*/ + void 0, + 1 + /* Node */ + ); + if (rn) return rn; + } + } + if (!it) { + let Lt; + return Y ? Lt = $A(Et.parent) ? F9(re, Et.parent) : void 0 : Lt = qe(Xe, re), Lt && Ct( + Lt, + 4 + /* SearchedPropertyFoundLocal */ + ); + } + if (E.assert(it), Y) { + const Lt = qe(Xe, re); + return Lt && Ct( + Lt, + 4 + /* SearchedPropertyFoundLocal */ + ); + } + function Ct(Lt, rn) { + return Lc(re.getRootSymbols(Lt), (Pe) => Ae( + Lt, + Pe, + /*baseSymbol*/ + void 0, + rn + ) || (Pe.parent && Pe.parent.flags & 96 && $e(Pe) ? ft(Pe.parent, Pe.name, re, (yt) => Ae(Lt, Pe, yt, rn)) : void 0)); + } + function qe(Lt, rn) { + const Pe = Oo( + Lt, + 209 + /* BindingElement */ + ); + if (Pe && $A(Pe)) + return F9(rn, Pe); + } + } + function ft(Xe, Et, re, it) { + const Y = /* @__PURE__ */ new Set(); + return Ae(Xe); + function Ae($e) { + if (!(!($e.flags & 96) || !Jp(Y, $e))) + return Lc($e.declarations, (Ke) => Lc(HD(Ke), (Tt) => { + const Le = re.getTypeAtLocation(Tt), mt = Le.symbol && re.getPropertyOfType(Le, Et); + return mt && Lc(re.getRootSymbols(mt), it) || Le.symbol && Ae(Le.symbol); + })); + } + } + function er(Xe) { + return Xe.valueDeclaration ? !!(pu(Xe.valueDeclaration) & 256) : !1; + } + function qr(Xe, Et, re, it) { + const { checker: Y } = it; + return Je( + Et, + re, + Y, + /*isForRenamePopulateSearchSymbolSet*/ + !1, + /*onlyIncludeBindingElementAtReferenceLocation*/ + it.options.use !== 2 || !!it.options.providePrefixAndSuffixTextForRename, + (Ae, $e, Ke, Tt) => (Ke && er(Et) !== er(Ke) && (Ke = void 0), Xe.includes(Ke || $e || Ae) ? { symbol: $e && !(uc(Ae) & 6) ? $e : Ae, kind: Tt } : void 0), + /*allowBaseTypes*/ + (Ae) => !(Xe.parents && !Xe.parents.some(($e) => Ji(Ae.parent, $e, it.inheritsFromCache, Y))) + ); + } + function Jn(Xe, Et) { + let re = WS(Xe); + const { declarations: it } = Et; + if (it) { + let Y; + do { + Y = re; + for (const Ae of it) { + const $e = p9(Ae); + $e & re && (re |= $e); + } + } while (re !== Y); + } + return re; + } + e.getIntersectingMeaningFromDeclarations = Jn; + function Un(Xe) { + return Xe.flags & 33554432 ? !(Vl(Xe) || Wp(Xe)) : OD(Xe) ? d0(Xe) : io(Xe) ? !!Xe.body : $n(Xe) || d3(Xe); + } + function ki(Xe, Et, re) { + const it = Et.getSymbolAtLocation(Xe), Y = Et.getShorthandAssignmentValueSymbol(it.valueDeclaration); + if (Y) + for (const Ae of Y.getDeclarations()) + p9(Ae) & 1 && re(Ae); + } + e.getReferenceEntriesForShorthandPropertyAssignment = ki; + function Ds(Xe, Et, re) { + xs(Xe, (it) => { + it.kind === Et && re(it), Ds(it, Et, re); + }); + } + function Ks(Xe) { + return aJ(m9(Xe).parent); + } + function yr(Xe, Et, re) { + const it = U6(Xe) ? Xe.parent : void 0, Y = it && re.getTypeAtLocation(it.expression), Ae = Fi(Y && (Y.isUnionOrIntersection() ? Y.types : Y.symbol === Et.parent ? void 0 : [Y]), ($e) => $e.symbol && $e.symbol.flags & 96 ? $e.symbol : void 0); + return Ae.length === 0 ? void 0 : Ae; + } + function bs(Xe) { + return Xe.use === 2 && Xe.providePrefixAndSuffixTextForRename; + } + })(xk || (xk = {})); + var sE = {}; + Na(sE, { + createDefinitionInfo: () => x8, + getDefinitionAndBoundSpan: () => lQe, + getDefinitionAtPosition: () => S4e, + getReferenceAtPosition: () => x4e, + getTypeDefinitionAtPosition: () => oQe + }); + function S4e(e, t, n, i, s) { + var o; + const c = x4e(t, n, e), _ = c && [dQe(c.reference.fileName, c.fileName, c.unverified)] || Ge; + if (c?.file) + return _; + const u = w_(t, n); + if (u === t) + return; + const { parent: g } = u, m = e.getTypeChecker(); + if (u.kind === 164 || Me(u) && FF(g) && g.tagName === u) { + const A = iQe(m, u); + if (A !== void 0 || u.kind !== 164) + return A || Ge; + } + if (JA(u)) { + const A = g9(u.parent, u.text); + return A ? [jue( + m, + A, + "label", + u.text, + /*containerName*/ + void 0 + )] : void 0; + } + switch (u.kind) { + case 90: + if (!L4(u.parent)) + break; + // falls through + case 84: + const A = dr(u.parent, F4); + if (A) + return [pQe(A, t)]; + break; + } + let h; + switch (u.kind) { + case 107: + case 135: + case 127: + h = io; + const A = dr(u, h); + return A ? [Jue(m, A)] : void 0; + } + if (Wx(u) && kc(u.parent)) { + const A = u.parent.parent, { symbol: O, failedAliasResolution: F } = $H(A, m, s), R = kn(A.members, kc), B = O ? m.symbolToString(O, A) : "", U = u.getSourceFile(); + return hr(R, ($) => { + let { pos: W } = dm($); + return W = oa(U.text, W), jue( + m, + $, + "constructor", + "static {}", + B, + /*unverified*/ + !1, + F, + { start: W, length: 6 } + ); + }); + } + let { symbol: S, failedAliasResolution: T } = $H(u, m, s), k = u; + if (i && T) { + const A = lr([u, ...S?.declarations || Ge], (F) => dr(F, rK)), O = A && gx(A); + O && ({ symbol: S, failedAliasResolution: T } = $H(O, m, s), k = O); + } + if (!S && I9(k)) { + const A = (o = e.getResolvedModuleFromModuleSpecifier(k, t)) == null ? void 0 : o.resolvedModule; + if (A) + return [{ + name: k.text, + fileName: A.resolvedFileName, + containerName: void 0, + containerKind: void 0, + kind: "script", + textSpan: Kl(0, 0), + failedAliasResolution: T, + isAmbient: Il(A.resolvedFileName), + unverified: k !== u + }]; + } + if (Zs(u) && (Hc(g) || wl(g)) && (S = g.symbol), !S) + return Bi(_, uQe(u, m)); + if (i && Ni(S.declarations, (A) => A.getSourceFile().fileName === t.fileName)) return; + const D = gQe(m, u); + if (D && !(wu(u.parent) && hQe(D))) { + const A = Jue(m, D, T); + let O = (R) => R !== D; + if (m.getRootSymbols(S).some((R) => nQe(R, D))) { + if (!nc(D)) return [A]; + O = (R) => R !== D && (tl(R) || Rc(R)); + } + const F = jw(m, S, u, T, O) || Ge; + return u.kind === 108 ? [A, ...F] : [...F, A]; + } + if (u.parent.kind === 305) { + const A = m.getShorthandAssignmentValueSymbol(S.valueDeclaration), O = A?.declarations ? A.declarations.map((F) => x8( + F, + m, + A, + u, + /*unverified*/ + !1, + T + )) : Ge; + return Bi(O, T4e(m, u)); + } + if (qc(u) && ya(g) && Of(g.parent) && u === (g.propertyName || g.name)) { + const A = GA(u), O = m.getTypeAtLocation(g.parent); + return A === void 0 ? Ge : ka(O.isUnion() ? O.types : [O], (F) => { + const R = F.getProperty(A); + return R && jw(m, R, u); + }); + } + const P = T4e(m, u); + return Bi(_, P.length ? P : jw(m, S, u, T)); + } + function nQe(e, t) { + var n; + return e === t.symbol || e === t.symbol.parent || Nl(t.parent) || !Cb(t.parent) && e === ((n = Bn(t.parent, Ed)) == null ? void 0 : n.symbol); + } + function T4e(e, t) { + const n = f8(t); + if (n) { + const i = n && e.getContextualType(n.parent); + if (i) + return ka(mL( + n, + e, + i, + /*unionSymbolOk*/ + !1 + ), (s) => jw(e, s, t)); + } + return Ge; + } + function iQe(e, t) { + const n = dr(t, Hc); + if (!(n && n.name)) return; + const i = dr(n, $n); + if (!i) return; + const s = wd(i); + if (!s) return; + const o = Ba(s.expression), c = Rc(o) ? o.symbol : e.getSymbolAtLocation(o); + if (!c) return; + const _ = cl(n) ? e.getTypeOfSymbol(c) : e.getDeclaredTypeOfSymbol(c); + let u; + if (Gs(n.name)) { + const g = e.getSymbolAtLocation(n.name); + if (!g) + return; + QD(g) ? u = Nn(e.getPropertiesOfType(_), (m) => m.escapedName === g.escapedName) : u = e.getPropertyOfType(_, Si(g.escapedName)); + } else + u = e.getPropertyOfType(_, Si(dx(n.name))); + if (u) + return jw(e, u, t); + } + function x4e(e, t, n) { + var i, s; + const o = k8(e.referencedFiles, t); + if (o) { + const u = n.getSourceFileFromReference(e, o); + return u && { reference: o, fileName: u.fileName, file: u, unverified: !1 }; + } + const c = k8(e.typeReferenceDirectives, t); + if (c) { + const u = (i = n.getResolvedTypeReferenceDirectiveFromTypeReferenceDirective(c, e)) == null ? void 0 : i.resolvedTypeReferenceDirective, g = u && n.getSourceFile(u.resolvedFileName); + return g && { reference: c, fileName: g.fileName, file: g, unverified: !1 }; + } + const _ = k8(e.libReferenceDirectives, t); + if (_) { + const u = n.getLibFileFromReference(_); + return u && { reference: _, fileName: u.fileName, file: u, unverified: !1 }; + } + if (e.imports.length || e.moduleAugmentations.length) { + const u = H6(e, t); + let g; + if (I9(u) && Dl(u.text) && (g = n.getResolvedModuleFromModuleSpecifier(u, e))) { + const m = (s = g.resolvedModule) == null ? void 0 : s.resolvedFileName, h = m || by(Hn(e.fileName), u.text); + return { + file: n.getSourceFile(h), + fileName: h, + reference: { + pos: u.getStart(), + end: u.getEnd(), + fileName: u.text + }, + unverified: !m + }; + } + } + } + var k4e = /* @__PURE__ */ new Set([ + "Array", + "ArrayLike", + "ReadonlyArray", + "Promise", + "PromiseLike", + "Iterable", + "IterableIterator", + "AsyncIterable", + "Set", + "WeakSet", + "ReadonlySet", + "Map", + "WeakMap", + "ReadonlyMap", + "Partial", + "Required", + "Readonly", + "Pick", + "Omit" + ]); + function sQe(e, t) { + const n = t.symbol.name; + if (!k4e.has(n)) + return !1; + const i = e.resolveName( + n, + /*location*/ + void 0, + 788968, + /*excludeGlobals*/ + !1 + ); + return !!i && i === t.target.symbol; + } + function C4e(e, t) { + if (!t.aliasSymbol) + return !1; + const n = t.aliasSymbol.name; + if (!k4e.has(n)) + return !1; + const i = e.resolveName( + n, + /*location*/ + void 0, + 788968, + /*excludeGlobals*/ + !1 + ); + return !!i && i === t.aliasSymbol; + } + function aQe(e, t, n, i) { + var s, o; + if (Dn(t) & 4 && sQe(e, t)) + return T8(e.getTypeArguments(t)[0], e, n, i); + if (C4e(e, t) && t.aliasTypeArguments) + return T8(t.aliasTypeArguments[0], e, n, i); + if (Dn(t) & 32 && t.target && C4e(e, t.target)) { + const c = (o = (s = t.aliasSymbol) == null ? void 0 : s.declarations) == null ? void 0 : o[0]; + if (c && Wp(c) && of(c.type) && c.type.typeArguments) + return T8(e.getTypeAtLocation(c.type.typeArguments[0]), e, n, i); + } + return []; + } + function oQe(e, t, n) { + const i = w_(t, n); + if (i === t) + return; + if (JC(i.parent) && i.parent.name === i) + return T8( + e.getTypeAtLocation(i.parent), + e, + i.parent, + /*failedAliasResolution*/ + !1 + ); + let { symbol: s, failedAliasResolution: o } = $H( + i, + e, + /*stopAtAlias*/ + !1 + ); + if (Zs(i) && (Hc(i.parent) || wl(i.parent)) && (s = i.parent.symbol, o = !1), !s) return; + const c = e.getTypeOfSymbolAtLocation(s, i), _ = cQe(s, c, e), u = _ && T8(_, e, i, o), [g, m] = u && u.length !== 0 ? [_, u] : [c, T8(c, e, i, o)]; + return m.length ? [...aQe(e, g, i, o), ...m] : !(s.flags & 111551) && s.flags & 788968 ? jw(e, eu(s, e), i, o) : void 0; + } + function T8(e, t, n, i) { + return ka(e.isUnion() && !(e.flags & 32) ? e.types : [e], (s) => s.symbol && jw(t, s.symbol, n, i)); + } + function cQe(e, t, n) { + if (t.symbol === e || // At `const f = () => {}`, the symbol is `f` and the type symbol is at `() => {}` + e.valueDeclaration && t.symbol && ei(e.valueDeclaration) && e.valueDeclaration.initializer === t.symbol.valueDeclaration) { + const i = t.getCallSignatures(); + if (i.length === 1) return n.getReturnTypeOfSignature(Ca(i)); + } + } + function lQe(e, t, n) { + const i = S4e(e, t, n); + if (!i || i.length === 0) + return; + const s = k8(t.referencedFiles, n) || k8(t.typeReferenceDirectives, n) || k8(t.libReferenceDirectives, n); + if (s) + return { definitions: i, textSpan: A0(s) }; + const o = w_(t, n), c = Kl(o.getStart(), o.getWidth()); + return { definitions: i, textSpan: c }; + } + function uQe(e, t) { + return Fi(t.getIndexInfosAtLocation(e), (n) => n.declaration && Jue(t, n.declaration)); + } + function $H(e, t, n) { + const i = t.getSymbolAtLocation(e); + let s = !1; + if (i?.declarations && i.flags & 2097152 && !n && _Qe(e, i.declarations[0])) { + const o = t.getAliasedSymbol(i); + if (o.declarations) + return { symbol: o }; + s = !0; + } + return { symbol: i, failedAliasResolution: s }; + } + function _Qe(e, t) { + return e.kind !== 80 && (e.kind !== 11 || !Cy(e.parent)) ? !1 : e.parent === t ? !0 : t.kind !== 275; + } + function fQe(e) { + if (!JD(e)) return !1; + const t = dr(e, (n) => Nl(n) ? !0 : JD(n) ? !1 : "quit"); + return !!t && Ac(t) === 5; + } + function jw(e, t, n, i, s) { + const o = s !== void 0 ? kn(t.declarations, s) : t.declarations, c = !s && (g() || m()); + if (c) + return c; + const _ = kn(o, (S) => !fQe(S)), u = ot(_) ? _ : o; + return hr(u, (S) => x8( + S, + e, + t, + n, + /*unverified*/ + !1, + i + )); + function g() { + if (t.flags & 32 && !(t.flags & 19) && (dw(n) || n.kind === 137)) { + const S = Nn(o, $n); + return S && h( + S.members, + /*selectConstructors*/ + !0 + ); + } + } + function m() { + return vV(n) || EV(n) ? h( + o, + /*selectConstructors*/ + !1 + ) : void 0; + } + function h(S, T) { + if (!S) + return; + const k = S.filter(T ? nc : Es), D = k.filter((P) => !!P.body); + return k.length ? D.length !== 0 ? D.map((P) => x8(P, e, t, n)) : [x8( + pa(k), + e, + t, + n, + /*unverified*/ + !1, + i + )] : void 0; + } + } + function x8(e, t, n, i, s, o) { + const c = t.symbolToString(n), _ = O0.getSymbolKind(t, n, i), u = n.parent ? t.symbolToString(n.parent, i) : ""; + return jue(t, e, _, c, u, s, o); + } + function jue(e, t, n, i, s, o, c, _) { + const u = t.getSourceFile(); + if (!_) { + const g = _s(t) || t; + _ = u_(g, u); + } + return { + fileName: u.fileName, + textSpan: _, + kind: n, + name: i, + containerKind: void 0, + // TODO: GH#18217 + containerName: s, + ...ko.toContextSpan( + _, + u, + ko.getContextNode(t) + ), + isLocal: !Bue(e, t), + isAmbient: !!(t.flags & 33554432), + unverified: o, + failedAliasResolution: c + }; + } + function pQe(e, t) { + const n = ko.getContextNode(e), i = u_(Lue(n) ? n.start : n, t); + return { + fileName: t.fileName, + textSpan: i, + kind: "keyword", + name: "switch", + containerKind: void 0, + containerName: "", + ...ko.toContextSpan(i, t, n), + isLocal: !0, + isAmbient: !1, + unverified: !1, + failedAliasResolution: void 0 + }; + } + function Bue(e, t) { + if (e.isDeclarationVisible(t)) return !0; + if (!t.parent) return !1; + if (d0(t.parent) && t.parent.initializer === t) return Bue(e, t.parent); + switch (t.kind) { + case 173: + case 178: + case 179: + case 175: + if (sf( + t, + 2 + /* Private */ + )) return !1; + // Public properties/methods are visible if its parents are visible, so: + // falls through + case 177: + case 304: + case 305: + case 211: + case 232: + case 220: + case 219: + return Bue(e, t.parent); + default: + return !1; + } + } + function Jue(e, t, n) { + return x8( + t, + e, + t.symbol, + t, + /*unverified*/ + !1, + n + ); + } + function k8(e, t) { + return Nn(e, (n) => KP(n, t)); + } + function dQe(e, t, n) { + return { + fileName: t, + textSpan: Nc(0, 0), + kind: "script", + name: e, + containerName: void 0, + containerKind: void 0, + // TODO: GH#18217 + unverified: n + }; + } + function mQe(e) { + const t = dr(e, (i) => !U6(i)), n = t?.parent; + return n && Cb(n) && s5(n) === t ? n : void 0; + } + function gQe(e, t) { + const n = mQe(t), i = n && e.getResolvedSignature(n); + return Bn(i && i.declaration, (s) => Es(s) && !Zm(s)); + } + function hQe(e) { + switch (e.kind) { + case 177: + case 186: + case 180: + case 181: + return !0; + default: + return !1; + } + } + var XH = {}; + Na(XH, { + provideInlayHints: () => SQe + }); + var yQe = (e) => new RegExp(`^\\s?/\\*\\*?\\s?${e}\\s?\\*\\/\\s?$`); + function vQe(e) { + return e.includeInlayParameterNameHints === "literals" || e.includeInlayParameterNameHints === "all"; + } + function bQe(e) { + return e.includeInlayParameterNameHints === "literals"; + } + function zue(e) { + return e.interactiveInlayHints === !0; + } + function SQe(e) { + const { file: t, program: n, span: i, cancellationToken: s, preferences: o } = e, c = t.text, _ = n.getCompilerOptions(), u = _f(t, o), g = n.getTypeChecker(), m = []; + return h(t), m; + function h(me) { + if (!(!me || me.getFullWidth() === 0)) { + switch (me.kind) { + case 268: + case 264: + case 265: + case 263: + case 232: + case 219: + case 175: + case 220: + s.throwIfCancellationRequested(); + } + if (e3(i, me.pos, me.getFullWidth()) && !(li(me) && !Dh(me))) + return o.includeInlayVariableTypeHints && ei(me) || o.includeInlayPropertyDeclarationTypeHints && os(me) ? O(me) : o.includeInlayEnumMemberValueHints && Ph(me) ? P(me) : vQe(o) && (Ps(me) || Xb(me)) ? F(me) : (o.includeInlayFunctionParameterTypeHints && io(me) && aF(me) && _e(me), o.includeInlayFunctionLikeReturnTypeHints && S(me) && $(me)), xs(me, h); + } + } + function S(me) { + return xo(me) || yo(me) || Cc(me) || rc(me) || pp(me); + } + function T(me, Z, pe, Te) { + let Fe = `${Te ? "..." : ""}${me}`, Ye; + zue(o) ? (Ye = [je(Fe, Z), { text: ":" }], Fe = "") : Fe += ":", m.push({ + text: Fe, + position: pe, + kind: "Parameter", + whitespaceAfter: !0, + displayParts: Ye + }); + } + function k(me, Z) { + m.push({ + text: typeof me == "string" ? `: ${me}` : "", + displayParts: typeof me == "string" ? void 0 : [{ text: ": " }, ...me], + position: Z, + kind: "Type", + whitespaceBefore: !0 + }); + } + function D(me, Z) { + m.push({ + text: `= ${me}`, + position: Z, + kind: "Enum", + whitespaceBefore: !0 + }); + } + function P(me) { + if (me.initializer) + return; + const Z = g.getConstantValue(me); + Z !== void 0 && D(Z.toString(), me.end); + } + function A(me) { + return me.symbol && me.symbol.flags & 1536; + } + function O(me) { + if (me.initializer === void 0 && !(os(me) && !(g.getTypeAtLocation(me).flags & 1)) || ws(me.name) || ei(me) && !be(me) || Kc(me)) + return; + const pe = g.getTypeAtLocation(me); + if (A(pe)) + return; + const Te = ce(pe); + if (Te) { + const Fe = typeof Te == "string" ? Te : Te.map((ne) => ne.text).join(""); + if (o.includeInlayVariableTypeHintsWhenTypeMatchesName === !1 && hy(me.name.getText(), Fe)) + return; + k(Te, me.name.end); + } + } + function F(me) { + const Z = me.arguments; + if (!Z || !Z.length) + return; + const pe = g.getResolvedSignature(me); + if (pe === void 0) return; + let Te = 0; + for (const Fe of Z) { + const Ye = Ba(Fe); + if (bQe(o) && !U(Ye)) { + Te++; + continue; + } + let ne = 0; + if (dp(Ye)) { + const ie = g.getTypeAtLocation(Ye.expression); + if (g.isTupleType(ie)) { + const { elementFlags: Ne, fixedLength: Ee } = ie.target; + if (Ee === 0) + continue; + const Ce = oc(Ne, (St) => !(St & 1)); + (Ce < 0 ? Ee : Ce) > 0 && (ne = Ce < 0 ? Ee : Ce); + } + } + const Se = g.getParameterIdentifierInfoAtPosition(pe, Te); + if (Te = Te + (ne || 1), Se) { + const { parameter: ie, parameterName: Ne, isRestParameter: Ee } = Se; + if (!(o.includeInlayParameterNameHintsWhenArgumentMatchesName || !R(Ye, Ne)) && !Ee) + continue; + const Ve = Si(Ne); + if (B(Ye, Ve)) + continue; + T(Ve, ie, Fe.getStart(), Ee); + } + } + } + function R(me, Z) { + return Me(me) ? me.text === Z : wn(me) ? me.name.text === Z : !1; + } + function B(me, Z) { + if (!R_(Z, da(_), fN(t.scriptKind))) + return !1; + const pe = Eg(c, me.pos); + if (!pe?.length) + return !1; + const Te = yQe(Z); + return ot(pe, (Fe) => Te.test(c.substring(Fe.pos, Fe.end))); + } + function U(me) { + switch (me.kind) { + case 225: { + const Z = me.operand; + return eS(Z) || Me(Z) && v4(Z.escapedText); + } + case 112: + case 97: + case 106: + case 15: + case 229: + return !0; + case 80: { + const Z = me.escapedText; + return q(Z) || v4(Z); + } + } + return eS(me); + } + function $(me) { + if (xo(me) && !Ya(me, 21, t) || nf(me) || !me.body) + return; + const pe = g.getSignatureFromDeclaration(me); + if (!pe) + return; + const Te = g.getTypePredicateOfSignature(pe); + if (Te?.type) { + const ne = fe(Te); + if (ne) { + k(ne, W(me)); + return; + } + } + const Fe = g.getReturnTypeOfSignature(pe); + if (A(Fe)) + return; + const Ye = ce(Fe); + Ye && k(Ye, W(me)); + } + function W(me) { + const Z = Ya(me, 22, t); + return Z ? Z.end : me.parameters.end; + } + function _e(me) { + const Z = g.getSignatureFromDeclaration(me); + if (!Z) + return; + let pe = 0; + for (const Te of me.parameters) + be(Te) && K(Te, My(Te) ? Z.thisParameter : Z.parameters[pe]), !My(Te) && pe++; + } + function K(me, Z) { + if (Kc(me) || Z === void 0) return; + const Te = V(Z); + Te !== void 0 && k(Te, me.questionToken ? me.questionToken.end : me.name.end); + } + function V(me) { + const Z = me.valueDeclaration; + if (!Z || !Ii(Z)) + return; + const pe = g.getTypeOfSymbolAtLocation(me, Z); + if (!A(pe)) + return ce(pe); + } + function ae(me) { + const pe = i2(); + return LC((Te) => { + const Fe = g.typeToTypeNode( + me, + /*enclosingDeclaration*/ + void 0, + 71286784 + ); + E.assertIsDefined(Fe, "should always get typenode"), pe.writeNode( + 4, + Fe, + /*sourceFile*/ + t, + Te + ); + }); + } + function se(me) { + const pe = i2(); + return LC((Te) => { + const Fe = g.typePredicateToTypePredicateNode( + me, + /*enclosingDeclaration*/ + void 0, + 71286784 + ); + E.assertIsDefined(Fe, "should always get typePredicateNode"), pe.writeNode( + 4, + Fe, + /*sourceFile*/ + t, + Te + ); + }); + } + function ce(me) { + if (!zue(o)) + return ae(me); + const pe = g.typeToTypeNode( + me, + /*enclosingDeclaration*/ + void 0, + 71286784 + ); + return E.assertIsDefined(pe, "should always get typeNode"), he(pe); + } + function fe(me) { + if (!zue(o)) + return se(me); + const pe = g.typePredicateToTypePredicateNode( + me, + /*enclosingDeclaration*/ + void 0, + 71286784 + ); + return E.assertIsDefined(pe, "should always get typenode"), he(pe); + } + function he(me) { + const Z = []; + return pe(me), Z; + function pe(ne) { + var Se, ie; + if (!ne) + return; + const Ne = qs(ne.kind); + if (Ne) { + Z.push({ text: Ne }); + return; + } + if (eS(ne)) { + Z.push({ text: Ye(ne) }); + return; + } + switch (ne.kind) { + case 80: + E.assertNode(ne, Me); + const Ee = An(ne), Ce = ne.symbol && ne.symbol.declarations && ne.symbol.declarations.length && _s(ne.symbol.declarations[0]); + Ce ? Z.push(je(Ee, Ce)) : Z.push({ text: Ee }); + break; + case 167: + E.assertNode(ne, s_), pe(ne.left), Z.push({ text: "." }), pe(ne.right); + break; + case 183: + E.assertNode(ne, Vx), ne.assertsModifier && Z.push({ text: "asserts " }), pe(ne.parameterName), ne.type && (Z.push({ text: " is " }), pe(ne.type)); + break; + case 184: + E.assertNode(ne, of), pe(ne.typeName), ne.typeArguments && (Z.push({ text: "<" }), Fe(ne.typeArguments, ", "), Z.push({ text: ">" })); + break; + case 169: + E.assertNode(ne, Lo), ne.modifiers && Fe(ne.modifiers, " "), pe(ne.name), ne.constraint && (Z.push({ text: " extends " }), pe(ne.constraint)), ne.default && (Z.push({ text: " = " }), pe(ne.default)); + break; + case 170: + E.assertNode(ne, Ii), ne.modifiers && Fe(ne.modifiers, " "), ne.dotDotDotToken && Z.push({ text: "..." }), pe(ne.name), ne.questionToken && Z.push({ text: "?" }), ne.type && (Z.push({ text: ": " }), pe(ne.type)); + break; + case 186: + E.assertNode(ne, _6), Z.push({ text: "new " }), Te(ne), Z.push({ text: " => " }), pe(ne.type); + break; + case 187: + E.assertNode(ne, Hb), Z.push({ text: "typeof " }), pe(ne.exprName), ne.typeArguments && (Z.push({ text: "<" }), Fe(ne.typeArguments, ", "), Z.push({ text: ">" })); + break; + case 188: + E.assertNode(ne, a_), Z.push({ text: "{" }), ne.members.length && (Z.push({ text: " " }), Fe(ne.members, "; "), Z.push({ text: " " })), Z.push({ text: "}" }); + break; + case 189: + E.assertNode(ne, jN), pe(ne.elementType), Z.push({ text: "[]" }); + break; + case 190: + E.assertNode(ne, qx), Z.push({ text: "[" }), Fe(ne.elements, ", "), Z.push({ text: "]" }); + break; + case 203: + E.assertNode(ne, f6), ne.dotDotDotToken && Z.push({ text: "..." }), pe(ne.name), ne.questionToken && Z.push({ text: "?" }), Z.push({ text: ": " }), pe(ne.type); + break; + case 191: + E.assertNode(ne, CF), pe(ne.type), Z.push({ text: "?" }); + break; + case 192: + E.assertNode(ne, EF), Z.push({ text: "..." }), pe(ne.type); + break; + case 193: + E.assertNode(ne, C0), Fe(ne.types, " | "); + break; + case 194: + E.assertNode(ne, Hx), Fe(ne.types, " & "); + break; + case 195: + E.assertNode(ne, Gb), pe(ne.checkType), Z.push({ text: " extends " }), pe(ne.extendsType), Z.push({ text: " ? " }), pe(ne.trueType), Z.push({ text: " : " }), pe(ne.falseType); + break; + case 196: + E.assertNode(ne, xS), Z.push({ text: "infer " }), pe(ne.typeParameter); + break; + case 197: + E.assertNode(ne, kS), Z.push({ text: "(" }), pe(ne.type), Z.push({ text: ")" }); + break; + case 199: + E.assertNode(ne, rv), Z.push({ text: `${qs(ne.operator)} ` }), pe(ne.type); + break; + case 200: + E.assertNode(ne, $b), pe(ne.objectType), Z.push({ text: "[" }), pe(ne.indexType), Z.push({ text: "]" }); + break; + case 201: + E.assertNode(ne, CS), Z.push({ text: "{ " }), ne.readonlyToken && (ne.readonlyToken.kind === 40 ? Z.push({ text: "+" }) : ne.readonlyToken.kind === 41 && Z.push({ text: "-" }), Z.push({ text: "readonly " })), Z.push({ text: "[" }), pe(ne.typeParameter), ne.nameType && (Z.push({ text: " as " }), pe(ne.nameType)), Z.push({ text: "]" }), ne.questionToken && (ne.questionToken.kind === 40 ? Z.push({ text: "+" }) : ne.questionToken.kind === 41 && Z.push({ text: "-" }), Z.push({ text: "?" })), Z.push({ text: ": " }), ne.type && pe(ne.type), Z.push({ text: "; }" }); + break; + case 202: + E.assertNode(ne, E0), pe(ne.literal); + break; + case 185: + E.assertNode(ne, Zm), Te(ne), Z.push({ text: " => " }), pe(ne.type); + break; + case 206: + E.assertNode(ne, ym), ne.isTypeOf && Z.push({ text: "typeof " }), Z.push({ text: "import(" }), pe(ne.argument), ne.assertions && (Z.push({ text: ", { assert: " }), Fe(ne.assertions.assertClause.elements, ", "), Z.push({ text: " }" })), Z.push({ text: ")" }), ne.qualifier && (Z.push({ text: "." }), pe(ne.qualifier)), ne.typeArguments && (Z.push({ text: "<" }), Fe(ne.typeArguments, ", "), Z.push({ text: ">" })); + break; + case 172: + E.assertNode(ne, $u), (Se = ne.modifiers) != null && Se.length && (Fe(ne.modifiers, " "), Z.push({ text: " " })), pe(ne.name), ne.questionToken && Z.push({ text: "?" }), ne.type && (Z.push({ text: ": " }), pe(ne.type)); + break; + case 182: + E.assertNode(ne, qy), Z.push({ text: "[" }), Fe(ne.parameters, ", "), Z.push({ text: "]" }), ne.type && (Z.push({ text: ": " }), pe(ne.type)); + break; + case 174: + E.assertNode(ne, cd), (ie = ne.modifiers) != null && ie.length && (Fe(ne.modifiers, " "), Z.push({ text: " " })), pe(ne.name), ne.questionToken && Z.push({ text: "?" }), Te(ne), ne.type && (Z.push({ text: ": " }), pe(ne.type)); + break; + case 180: + E.assertNode(ne, Ux), Te(ne), ne.type && (Z.push({ text: ": " }), pe(ne.type)); + break; + case 181: + E.assertNode(ne, N4), Z.push({ text: "new " }), Te(ne), ne.type && (Z.push({ text: ": " }), pe(ne.type)); + break; + case 208: + E.assertNode(ne, D0), Z.push({ text: "[" }), Fe(ne.elements, ", "), Z.push({ text: "]" }); + break; + case 207: + E.assertNode(ne, Of), Z.push({ text: "{" }), ne.elements.length && (Z.push({ text: " " }), Fe(ne.elements, ", "), Z.push({ text: " " })), Z.push({ text: "}" }); + break; + case 209: + E.assertNode(ne, ya), pe(ne.name); + break; + case 225: + E.assertNode(ne, iv), Z.push({ text: qs(ne.operator) }), pe(ne.operand); + break; + case 204: + E.assertNode(ne, Rte), pe(ne.head), ne.templateSpans.forEach(pe); + break; + case 16: + E.assertNode(ne, Jx), Z.push({ text: Ye(ne) }); + break; + case 205: + E.assertNode(ne, mz), pe(ne.type), pe(ne.literal); + break; + case 17: + E.assertNode(ne, uz), Z.push({ text: Ye(ne) }); + break; + case 18: + E.assertNode(ne, SF), Z.push({ text: Ye(ne) }); + break; + case 198: + E.assertNode(ne, A4), Z.push({ text: "this" }); + break; + case 168: + E.assertNode(ne, Gs), Z.push({ text: "[" }), pe(ne.expression), Z.push({ text: "]" }); + break; + default: + E.failBadSyntaxKind(ne); + } + } + function Te(ne) { + ne.typeParameters && (Z.push({ text: "<" }), Fe(ne.typeParameters, ", "), Z.push({ text: ">" })), Z.push({ text: "(" }), Fe(ne.parameters, ", "), Z.push({ text: ")" }); + } + function Fe(ne, Se) { + ne.forEach((ie, Ne) => { + Ne > 0 && Z.push({ text: Se }), pe(ie); + }); + } + function Ye(ne) { + switch (ne.kind) { + case 11: + return u === 0 ? `'${Ym( + ne.text, + 39 + /* singleQuote */ + )}'` : `"${Ym( + ne.text, + 34 + /* doubleQuote */ + )}"`; + case 16: + case 17: + case 18: { + const Se = ne.rawText ?? qB(Ym( + ne.text, + 96 + /* backtick */ + )); + switch (ne.kind) { + case 16: + return "`" + Se + "${"; + case 17: + return "}" + Se + "${"; + case 18: + return "}" + Se + "`"; + } + } + } + return ne.text; + } + } + function q(me) { + return me === "undefined"; + } + function be(me) { + if ((Y1(me) || ei(me) && BC(me)) && me.initializer) { + const Z = Ba(me.initializer); + return !(U(Z) || Xb(Z) || _a(Z) || Eb(Z)); + } + return !0; + } + function je(me, Z) { + const pe = Z.getSourceFile(); + return { + text: me, + span: u_(Z, pe), + file: pe.fileName + }; + } + } + var Ev = {}; + Na(Ev, { + getDocCommentTemplateAtPosition: () => IQe, + getJSDocParameterNameCompletionDetails: () => AQe, + getJSDocParameterNameCompletions: () => NQe, + getJSDocTagCompletionDetails: () => I4e, + getJSDocTagCompletions: () => PQe, + getJSDocTagNameCompletionDetails: () => wQe, + getJSDocTagNameCompletions: () => DQe, + getJsDocCommentsFromDeclarations: () => TQe, + getJsDocTagsFromDeclarations: () => CQe + }); + var E4e = [ + "abstract", + "access", + "alias", + "argument", + "async", + "augments", + "author", + "borrows", + "callback", + "class", + "classdesc", + "constant", + "constructor", + "constructs", + "copyright", + "default", + "deprecated", + "description", + "emits", + "enum", + "event", + "example", + "exports", + "extends", + "external", + "field", + "file", + "fileoverview", + "fires", + "function", + "generator", + "global", + "hideconstructor", + "host", + "ignore", + "implements", + "import", + "inheritdoc", + "inner", + "instance", + "interface", + "kind", + "lends", + "license", + "link", + "linkcode", + "linkplain", + "listens", + "member", + "memberof", + "method", + "mixes", + "module", + "name", + "namespace", + "overload", + "override", + "package", + "param", + "private", + "prop", + "property", + "protected", + "public", + "readonly", + "requires", + "returns", + "satisfies", + "see", + "since", + "static", + "summary", + "template", + "this", + "throws", + "todo", + "tutorial", + "type", + "typedef", + "var", + "variation", + "version", + "virtual", + "yields" + ], D4e, w4e; + function TQe(e, t) { + const n = []; + return YV(e, (i) => { + for (const s of kQe(i)) { + const o = Od(s) && s.tags && Nn(s.tags, (_) => _.kind === 328 && (_.tagName.escapedText === "inheritDoc" || _.tagName.escapedText === "inheritdoc")); + if (s.comment === void 0 && !o || Od(s) && i.kind !== 347 && i.kind !== 339 && s.tags && s.tags.some( + (_) => _.kind === 347 || _.kind === 339 + /* JSDocCallbackTag */ + ) && !s.tags.some( + (_) => _.kind === 342 || _.kind === 343 + /* JSDocReturnTag */ + )) + continue; + let c = s.comment ? aE(s.comment, t) : []; + o && o.comment && (c = c.concat(aE(o.comment, t))), ms(n, c, xQe) || n.push(c); + } + }), Ip(xR(n, [Q6()])); + } + function xQe(e, t) { + return Tf(e, t, (n, i) => n.kind === i.kind && n.text === i.text); + } + function kQe(e) { + switch (e.kind) { + case 342: + case 349: + return [e]; + case 339: + case 347: + return [e, e.parent]; + case 324: + if (S6(e.parent)) + return [e.parent.parent]; + // falls through + default: + return NB(e); + } + } + function CQe(e, t) { + const n = []; + return YV(e, (i) => { + const s = W1(i); + if (!(s.some( + (o) => o.kind === 347 || o.kind === 339 + /* JSDocCallbackTag */ + ) && !s.some( + (o) => o.kind === 342 || o.kind === 343 + /* JSDocReturnTag */ + ))) + for (const o of s) + n.push({ name: o.tagName.text, text: A4e(o, t) }), n.push(...P4e(N4e(o), t)); + }), n; + } + function P4e(e, t) { + return ka(e, (n) => Bi([{ name: n.tagName.text, text: A4e(n, t) }], P4e(N4e(n), t))); + } + function N4e(e) { + return kD(e) && e.isNameFirst && e.typeExpression && AS(e.typeExpression.type) ? e.typeExpression.type.jsDocPropertyTags : void 0; + } + function aE(e, t) { + return typeof e == "string" ? [Bf(e)] : ka( + e, + (n) => n.kind === 322 ? [Bf(n.text)] : xae(n, t) + ); + } + function A4e(e, t) { + const { comment: n, kind: i } = e, s = EQe(i); + switch (i) { + case 350: + const _ = e.typeExpression; + return _ ? o(_) : n === void 0 ? void 0 : aE(n, t); + case 330: + return o(e.class); + case 329: + return o(e.class); + case 346: + const u = e, g = []; + if (u.constraint && g.push(Bf(u.constraint.getText())), wr(u.typeParameters)) { + wr(g) && g.push(fc()); + const h = u.typeParameters[u.typeParameters.length - 1]; + lr(u.typeParameters, (S) => { + g.push(s(S.getText())), h !== S && g.push(Fu( + 28 + /* CommaToken */ + ), fc()); + }); + } + return n && g.push(fc(), ...aE(n, t)), g; + case 345: + case 351: + return o(e.typeExpression); + case 347: + case 339: + case 349: + case 342: + case 348: + const { name: m } = e; + return m ? o(m) : n === void 0 ? void 0 : aE(n, t); + default: + return n === void 0 ? void 0 : aE(n, t); + } + function o(_) { + return c(_.getText()); + } + function c(_) { + return n ? _.match(/^https?$/) ? [Bf(_), ...aE(n, t)] : [s(_), fc(), ...aE(n, t)] : [Bf(_)]; + } + } + function EQe(e) { + switch (e) { + case 342: + return yae; + case 349: + return vae; + case 346: + return Sae; + case 347: + case 339: + return bae; + default: + return Bf; + } + } + function DQe() { + return D4e || (D4e = hr(E4e, (e) => ({ + name: e, + kind: "keyword", + kindModifiers: "", + sortText: Tk.SortText.LocationPriority + }))); + } + var wQe = I4e; + function PQe() { + return w4e || (w4e = hr(E4e, (e) => ({ + name: `@${e}`, + kind: "keyword", + kindModifiers: "", + sortText: Tk.SortText.LocationPriority + }))); + } + function I4e(e) { + return { + name: e, + kind: "", + // TODO: should have its own kind? + kindModifiers: "", + displayParts: [Bf(e)], + documentation: Ge, + tags: void 0, + codeActions: void 0 + }; + } + function NQe(e) { + if (!Me(e.name)) + return Ge; + const t = e.name.text, n = e.parent, i = n.parent; + return Es(i) ? Fi(i.parameters, (s) => { + if (!Me(s.name)) return; + const o = s.name.text; + if (!(n.tags.some((c) => c !== e && Lf(c) && Me(c.name) && c.name.escapedText === o) || t !== void 0 && !Ui(o, t))) + return { name: o, kind: "parameter", kindModifiers: "", sortText: Tk.SortText.LocationPriority }; + }) : []; + } + function AQe(e) { + return { + name: e, + kind: "parameter", + kindModifiers: "", + displayParts: [Bf(e)], + documentation: Ge, + tags: void 0, + codeActions: void 0 + }; + } + function IQe(e, t, n, i) { + const s = vi(t, n), o = dr(s, Od); + if (o && (o.comment !== void 0 || wr(o.tags))) + return; + const c = s.getStart(t); + if (!o && c < n) + return; + const _ = MQe(s, i); + if (!_) + return; + const { commentOwner: u, parameters: g, hasReturn: m } = _, h = kf(u) && u.jsDoc ? u.jsDoc : void 0, S = Do(h); + if (u.getStart(t) < n || S && o && S !== o) + return; + const T = FQe(t, n), k = Bg(t.fileName), D = (g ? OQe(g || [], k, T, e) : "") + (m ? LQe(T, e) : ""), P = "/**", A = " */", O = wr(W1(u)) > 0; + if (D && !O) { + const F = P + e + T + " * ", R = c === n ? e + T : ""; + return { newText: F + e + D + T + A + R, caretOffset: F.length }; + } + return { newText: P + A, caretOffset: 3 }; + } + function FQe(e, t) { + const { text: n } = e, i = Hp(t, e); + let s = i; + for (; s <= t && im(n.charCodeAt(s)); s++) ; + return n.slice(i, s); + } + function OQe(e, t, n, i) { + return e.map(({ name: s, dotDotDotToken: o }, c) => { + const _ = s.kind === 80 ? s.text : "param" + c; + return `${n} * @param ${t ? o ? "{...any} " : "{any} " : ""}${_}${i}`; + }).join(""); + } + function LQe(e, t) { + return `${e} * @returns${t}`; + } + function MQe(e, t) { + return VZ(e, (n) => Wue(n, t)); + } + function Wue(e, t) { + switch (e.kind) { + case 263: + case 219: + case 175: + case 177: + case 174: + case 220: + const n = e; + return { commentOwner: e, parameters: n.parameters, hasReturn: NL(n, t) }; + case 304: + return Wue(e.initializer, t); + case 264: + case 265: + case 267: + case 307: + case 266: + return { commentOwner: e }; + case 172: { + const s = e; + return s.type && Zm(s.type) ? { commentOwner: e, parameters: s.type.parameters, hasReturn: NL(s.type, t) } : { commentOwner: e }; + } + case 244: { + const o = e.declarationList.declarations, c = o.length === 1 && o[0].initializer ? RQe(o[0].initializer) : void 0; + return c ? { commentOwner: e, parameters: c.parameters, hasReturn: NL(c, t) } : { commentOwner: e }; + } + case 308: + return "quit"; + case 268: + return e.parent.kind === 268 ? void 0 : { commentOwner: e }; + case 245: + return Wue(e.expression, t); + case 227: { + const s = e; + return Ac(s) === 0 ? "quit" : Es(s.right) ? { commentOwner: e, parameters: s.right.parameters, hasReturn: NL(s.right, t) } : { commentOwner: e }; + } + case 173: + const i = e.initializer; + if (i && (yo(i) || xo(i))) + return { commentOwner: e, parameters: i.parameters, hasReturn: NL(i, t) }; + } + } + function NL(e, t) { + return !!t?.generateReturnInDocTemplate && (Zm(e) || xo(e) && ut(e.body) || io(e) && e.body && Ns(e.body) && !!Fy(e.body, (n) => n)); + } + function RQe(e) { + for (; e.kind === 218; ) + e = e.expression; + switch (e.kind) { + case 219: + case 220: + return e; + case 232: + return Nn(e.members, nc); + } + } + var QH = {}; + Na(QH, { + mapCode: () => jQe + }); + function jQe(e, t, n, i, s, o) { + return cn.ChangeTracker.with( + { host: i, formatContext: s, preferences: o }, + (c) => { + const _ = t.map((g) => BQe(e, g)), u = n && Ip(n); + for (const g of _) + JQe( + e, + c, + g, + u + ); + } + ); + } + function BQe(e, t) { + const n = [ + { + parse: () => ek( + "__mapcode_content_nodes.ts", + t, + e.languageVersion, + /*setParentNodes*/ + !0, + e.scriptKind + ), + body: (o) => o.statements + }, + { + parse: () => ek( + "__mapcode_class_content_nodes.ts", + `class __class { +${t} +}`, + e.languageVersion, + /*setParentNodes*/ + !0, + e.scriptKind + ), + body: (o) => o.statements[0].members + } + ], i = []; + for (const { parse: o, body: c } of n) { + const _ = o(), u = c(_); + if (u.length && _.parseDiagnostics.length === 0) + return u; + u.length && i.push({ sourceFile: _, body: u }); + } + i.sort( + (o, c) => o.sourceFile.parseDiagnostics.length - c.sourceFile.parseDiagnostics.length + ); + const { body: s } = i[0]; + return s; + } + function JQe(e, t, n, i) { + Hc(n[0]) || kb(n[0]) ? zQe( + e, + t, + n, + i + ) : WQe( + e, + t, + n, + i + ); + } + function zQe(e, t, n, i) { + let s; + if (!i || !i.length ? s = Nn(e.statements, Q_($n, Vl)) : s = lr(i, (c) => dr( + vi(e, c.start), + Q_($n, Vl) + )), !s) + return; + const o = s.members.find((c) => n.some((_) => AL(_, c))); + if (o) { + const c = gb( + s.members, + (_) => n.some((u) => AL(u, _)) + ); + lr(n, YH), t.replaceNodeRangeWithNodes( + e, + o, + c, + n + ); + return; + } + lr(n, YH), t.insertNodesAfter( + e, + s.members[s.members.length - 1], + n + ); + } + function WQe(e, t, n, i) { + if (!i?.length) { + t.insertNodesAtEndOfFile( + e, + n, + /*blankLineBetween*/ + !1 + ); + return; + } + for (const o of i) { + const c = dr( + vi(e, o.start), + (_) => Q_(Ns, Di)(_) && ot(_.statements, (u) => n.some((g) => AL(g, u))) + ); + if (c) { + const _ = c.statements.find((u) => n.some((g) => AL(g, u))); + if (_) { + const u = gb(c.statements, (g) => n.some((m) => AL(m, g))); + lr(n, YH), t.replaceNodeRangeWithNodes( + e, + _, + u, + n + ); + return; + } + } + } + let s = e.statements; + for (const o of i) { + const c = dr( + vi(e, o.start), + Ns + ); + if (c) { + s = c.statements; + break; + } + } + lr(n, YH), t.insertNodesAfter( + e, + s[s.length - 1], + n + ); + } + function AL(e, t) { + var n, i, s, o, c, _; + return e.kind !== t.kind ? !1 : e.kind === 177 ? e.kind === t.kind : wl(e) && wl(t) ? e.name.getText() === t.name.getText() : sv(e) && sv(t) || yz(e) && yz(t) ? e.expression.getText() === t.expression.getText() : av(e) && av(t) ? ((n = e.initializer) == null ? void 0 : n.getText()) === ((i = t.initializer) == null ? void 0 : i.getText()) && ((s = e.incrementor) == null ? void 0 : s.getText()) === ((o = t.incrementor) == null ? void 0 : o.getText()) && ((c = e.condition) == null ? void 0 : c.getText()) === ((_ = t.condition) == null ? void 0 : _.getText()) : nS(e) && nS(t) ? e.expression.getText() === t.expression.getText() && e.initializer.getText() === t.initializer.getText() : Gy(e) && Gy(t) ? e.label.getText() === t.label.getText() : e.getText() === t.getText(); + } + function YH(e) { + F4e(e), e.parent = void 0; + } + function F4e(e) { + e.pos = -1, e.end = -1, e.forEachChild(F4e); + } + var Dv = {}; + Na(Dv, { + compareImportsOrRequireStatements: () => Que, + compareModuleSpecifiers: () => oYe, + getImportDeclarationInsertionIndex: () => nYe, + getImportSpecifierInsertionIndex: () => iYe, + getNamedImportSpecifierComparerWithDetection: () => rYe, + getOrganizeImportsStringComparerWithDetection: () => tYe, + organizeImports: () => UQe, + testCoalesceExports: () => aYe, + testCoalesceImports: () => sYe + }); + function UQe(e, t, n, i, s, o) { + const c = cn.ChangeTracker.fromContext({ host: n, formatContext: t, preferences: s }), _ = o === "SortAndCombine" || o === "All", u = _, g = o === "RemoveUnused" || o === "All", m = e.statements.filter(qo), h = Vue(e, m), { comparersToTest: S, typeOrdersToTest: T } = Uue(s), k = S[0], D = { + moduleSpecifierComparer: typeof s.organizeImportsIgnoreCase == "boolean" ? k : void 0, + namedImportComparer: typeof s.organizeImportsIgnoreCase == "boolean" ? k : void 0, + typeOrder: s.organizeImportsTypeOrder + }; + if (typeof s.organizeImportsIgnoreCase != "boolean" && ({ comparer: D.moduleSpecifierComparer } = M4e(h, S)), !D.typeOrder || typeof s.organizeImportsIgnoreCase != "boolean") { + const F = $ue(m, S, T); + if (F) { + const { namedImportComparer: R, typeOrder: B } = F; + D.namedImportComparer = D.namedImportComparer ?? R, D.typeOrder = D.typeOrder ?? B; + } + } + h.forEach((F) => A(F, D)), o !== "RemoveUnused" && qQe(e).forEach((F) => O(F, D.namedImportComparer)); + for (const F of e.statements.filter(Vu)) { + if (!F.body) continue; + if (Vue(e, F.body.statements.filter(qo)).forEach((B) => A(B, D)), o !== "RemoveUnused") { + const B = F.body.statements.filter(Bc); + O(B, D.namedImportComparer); + } + } + return c.getChanges(); + function P(F, R) { + if (wr(F) === 0) + return; + un( + F[0], + 1024 + /* NoLeadingComments */ + ); + const B = u ? yC(F, (W) => IL(W.moduleSpecifier)) : [F], U = _ ? X_(B, (W, _e) => Hue(W[0].moduleSpecifier, _e[0].moduleSpecifier, D.moduleSpecifierComparer ?? k)) : B, $ = ka(U, (W) => IL(W[0].moduleSpecifier) || W[0].moduleSpecifier === void 0 ? R(W) : W); + if ($.length === 0) + c.deleteNodes( + e, + F, + { + leadingTriviaOption: cn.LeadingTriviaOption.Exclude, + trailingTriviaOption: cn.TrailingTriviaOption.Include + }, + /*hasTrailingComment*/ + !0 + ); + else { + const W = { + leadingTriviaOption: cn.LeadingTriviaOption.Exclude, + // Leave header comment in place + trailingTriviaOption: cn.TrailingTriviaOption.Include, + suffix: Fh(n, t.options) + }; + c.replaceNodeWithNodes(e, F[0], $, W); + const _e = c.nodeHasTrailingComment(e, F[0], W); + c.deleteNodes(e, F.slice(1), { + trailingTriviaOption: cn.TrailingTriviaOption.Include + }, _e); + } + } + function A(F, R) { + const B = R.moduleSpecifierComparer ?? k, U = R.namedImportComparer ?? k, $ = R.typeOrder ?? "last", W = E8({ organizeImportsTypeOrder: $ }, U); + P(F, (K) => (g && (K = HQe(K, e, i)), u && (K = O4e(K, B, W, e)), _ && (K = X_(K, (V, ae) => Que(V, ae, B))), K)); + } + function O(F, R) { + const B = E8(s, R); + P(F, (U) => L4e(U, B)); + } + } + function Uue(e) { + return { + comparersToTest: typeof e.organizeImportsIgnoreCase == "boolean" ? [Xue(e, e.organizeImportsIgnoreCase)] : [Xue( + e, + /*ignoreCase*/ + !0 + ), Xue( + e, + /*ignoreCase*/ + !1 + )], + typeOrdersToTest: e.organizeImportsTypeOrder ? [e.organizeImportsTypeOrder] : ["last", "inline", "first"] + }; + } + function Vue(e, t) { + const n = Dg( + e.languageVersion, + /*skipTrivia*/ + !1, + e.languageVariant + ), i = []; + let s = 0; + for (const o of t) + i[s] && VQe(e, o, n) && s++, i[s] || (i[s] = []), i[s].push(o); + return i; + } + function VQe(e, t, n) { + const i = t.getFullStart(), s = t.getStart(); + n.setText(e.text, i, s - i); + let o = 0; + for (; n.getTokenStart() < s; ) + if (n.scan() === 4 && (o++, o >= 2)) + return !0; + return !1; + } + function qQe(e) { + const t = [], n = e.statements, i = wr(n); + let s = 0, o = 0; + for (; s < i; ) + if (Bc(n[s])) { + t[o] === void 0 && (t[o] = []); + const c = n[s]; + if (c.moduleSpecifier) + t[o].push(c), s++; + else { + for (; s < i && Bc(n[s]); ) + t[o].push(n[s++]); + o++; + } + } else + s++; + return ka(t, (c) => Vue(e, c)); + } + function HQe(e, t, n) { + const i = n.getTypeChecker(), s = n.getCompilerOptions(), o = i.getJsxNamespace(t), c = i.getJsxFragmentFactory(t), _ = !!(t.transformFlags & 2), u = []; + for (const m of e) { + const { importClause: h, moduleSpecifier: S } = m; + if (!h) { + u.push(m); + continue; + } + let { name: T, namedBindings: k } = h; + if (T && !g(T) && (T = void 0), k) + if (Ug(k)) + g(k.name) || (k = void 0); + else { + const D = k.elements.filter((P) => g(P.name)); + D.length < k.elements.length && (k = D.length ? N.updateNamedImports(k, D) : void 0); + } + T || k ? u.push(C8(m, T, k)) : XQe(t, S) && (t.isDeclarationFile ? u.push(N.createImportDeclaration( + m.modifiers, + /*importClause*/ + void 0, + S, + /*attributes*/ + void 0 + )) : u.push(m)); + } + return u; + function g(m) { + return _ && (m.text === o || c && m.text === c) && mq(s.jsx) || ko.Core.isSymbolReferencedInFile(m, i, t); + } + } + function IL(e) { + return e !== void 0 && ja(e) ? e.text : void 0; + } + function GQe(e) { + let t; + const n = { defaultImports: [], namespaceImports: [], namedImports: [] }, i = { defaultImports: [], namespaceImports: [], namedImports: [] }; + for (const s of e) { + if (s.importClause === void 0) { + t = t || s; + continue; + } + const o = s.importClause.isTypeOnly ? n : i, { name: c, namedBindings: _ } = s.importClause; + c && o.defaultImports.push(s), _ && (Ug(_) ? o.namespaceImports.push(s) : o.namedImports.push(s)); + } + return { + importWithoutClause: t, + typeOnlyImports: n, + regularImports: i + }; + } + function O4e(e, t, n, i) { + if (e.length === 0) + return e; + const s = LR(e, (c) => { + if (c.attributes) { + let _ = c.attributes.token + " "; + for (const u of X_(c.attributes.elements, (g, m) => _u(g.name.text, m.name.text))) + _ += u.name.text + ":", _ += ja(u.value) ? `"${u.value.text}"` : u.value.getText() + " "; + return _; + } + return ""; + }), o = []; + for (const c in s) { + const _ = s[c], { importWithoutClause: u, typeOnlyImports: g, regularImports: m } = GQe(_); + u && o.push(u); + for (const h of [m, g]) { + const S = h === g, { defaultImports: T, namespaceImports: k, namedImports: D } = h; + if (!S && T.length === 1 && k.length === 1 && D.length === 0) { + const W = T[0]; + o.push( + C8(W, W.importClause.name, k[0].importClause.namedBindings) + ); + continue; + } + const P = X_(k, (W, _e) => t(W.importClause.namedBindings.name.text, _e.importClause.namedBindings.name.text)); + for (const W of P) + o.push( + C8( + W, + /*name*/ + void 0, + W.importClause.namedBindings + ) + ); + const A = Yc(T), O = Yc(D), F = A ?? O; + if (!F) + continue; + let R; + const B = []; + if (T.length === 1) + R = T[0].importClause.name; + else + for (const W of T) + B.push( + N.createImportSpecifier( + /*isTypeOnly*/ + !1, + N.createIdentifier("default"), + W.importClause.name + ) + ); + B.push(...QQe(D)); + const U = N.createNodeArray( + X_(B, n), + O?.importClause.namedBindings.elements.hasTrailingComma + ), $ = U.length === 0 ? R ? void 0 : N.createNamedImports(Ge) : O ? N.updateNamedImports(O.importClause.namedBindings, U) : N.createNamedImports(U); + i && $ && O?.importClause.namedBindings && !hS(O.importClause.namedBindings, i) && un( + $, + 2 + /* MultiLine */ + ), S && R && $ ? (o.push( + C8( + F, + R, + /*namedBindings*/ + void 0 + ) + ), o.push( + C8( + O ?? F, + /*name*/ + void 0, + $ + ) + )) : o.push( + C8(F, R, $) + ); + } + } + return o; + } + function L4e(e, t) { + if (e.length === 0) + return e; + const { exportWithoutClause: n, namedExports: i, typeOnlyExports: s } = c(e), o = []; + n && o.push(n); + for (const _ of [i, s]) { + if (_.length === 0) + continue; + const u = []; + u.push(...ka(_, (h) => h.exportClause && mp(h.exportClause) ? h.exportClause.elements : Ge)); + const g = X_(u, t), m = _[0]; + o.push( + N.updateExportDeclaration( + m, + m.modifiers, + m.isTypeOnly, + m.exportClause && (mp(m.exportClause) ? N.updateNamedExports(m.exportClause, g) : N.updateNamespaceExport(m.exportClause, m.exportClause.name)), + m.moduleSpecifier, + m.attributes + ) + ); + } + return o; + function c(_) { + let u; + const g = [], m = []; + for (const h of _) + h.exportClause === void 0 ? u = u || h : h.isTypeOnly ? m.push(h) : g.push(h); + return { + exportWithoutClause: u, + namedExports: g, + typeOnlyExports: m + }; + } + } + function C8(e, t, n) { + return N.updateImportDeclaration( + e, + e.modifiers, + N.updateImportClause(e.importClause, e.importClause.phaseModifier, t, n), + // TODO: GH#18217 + e.moduleSpecifier, + e.attributes + ); + } + function que(e, t, n, i) { + switch (i?.organizeImportsTypeOrder) { + case "first": + return j1(t.isTypeOnly, e.isTypeOnly) || n(e.name.text, t.name.text); + case "inline": + return n(e.name.text, t.name.text); + default: + return j1(e.isTypeOnly, t.isTypeOnly) || n(e.name.text, t.name.text); + } + } + function Hue(e, t, n) { + const i = e === void 0 ? void 0 : IL(e), s = t === void 0 ? void 0 : IL(t); + return j1(i === void 0, s === void 0) || j1(Dl(i), Dl(s)) || n(i, s); + } + function $Qe(e) { + return e.map((t) => IL(Gue(t)) || ""); + } + function Gue(e) { + var t; + switch (e.kind) { + case 272: + return (t = Bn(e.moduleReference, wh)) == null ? void 0 : t.expression; + case 273: + return e.moduleSpecifier; + case 244: + return e.declarationList.declarations[0].initializer.arguments[0]; + } + } + function XQe(e, t) { + const n = ca(t) && t.text; + return gs(n) && ot(e.moduleAugmentations, (i) => ca(i) && i.text === n); + } + function QQe(e) { + return ka(e, (t) => hr(YQe(t), (n) => n.name && n.propertyName && wb(n.name) === wb(n.propertyName) ? N.updateImportSpecifier( + n, + n.isTypeOnly, + /*propertyName*/ + void 0, + n.name + ) : n)); + } + function YQe(e) { + var t; + return (t = e.importClause) != null && t.namedBindings && bm(e.importClause.namedBindings) ? e.importClause.namedBindings.elements : void 0; + } + function M4e(e, t) { + const n = []; + return e.forEach((i) => { + n.push($Qe(i)); + }), j4e(n, t); + } + function $ue(e, t, n) { + let i = !1; + const s = e.filter((u) => { + var g, m; + const h = (m = Bn((g = u.importClause) == null ? void 0 : g.namedBindings, bm)) == null ? void 0 : m.elements; + return h?.length ? (!i && h.some((S) => S.isTypeOnly) && h.some((S) => !S.isTypeOnly) && (i = !0), !0) : !1; + }); + if (s.length === 0) return; + const o = s.map((u) => { + var g, m; + return (m = Bn((g = u.importClause) == null ? void 0 : g.namedBindings, bm)) == null ? void 0 : m.elements; + }).filter((u) => u !== void 0); + if (!i || n.length === 0) { + const u = j4e(o.map((g) => g.map((m) => m.name.text)), t); + return { + namedImportComparer: u.comparer, + typeOrder: n.length === 1 ? n[0] : void 0, + isSorted: u.isSorted + }; + } + const c = { first: 1 / 0, last: 1 / 0, inline: 1 / 0 }, _ = { first: t[0], last: t[0], inline: t[0] }; + for (const u of t) { + const g = { first: 0, last: 0, inline: 0 }; + for (const m of o) + for (const h of n) + g[h] = (g[h] ?? 0) + R4e(m, (S, T) => que(S, T, u, { organizeImportsTypeOrder: h })); + for (const m of n) { + const h = m; + g[h] < c[h] && (c[h] = g[h], _[h] = u); + } + } + e: for (const u of n) { + const g = u; + for (const m of n) + if (c[m] < c[g]) continue e; + return { namedImportComparer: _[g], typeOrder: g, isSorted: c[g] === 0 }; + } + return { namedImportComparer: _.last, typeOrder: "last", isSorted: c.last === 0 }; + } + function R4e(e, t) { + let n = 0; + for (let i = 0; i < e.length - 1; i++) + t(e[i], e[i + 1]) > 0 && n++; + return n; + } + function j4e(e, t) { + let n, i = 1 / 0; + for (const s of t) { + let o = 0; + for (const c of e) { + if (c.length <= 1) continue; + const _ = R4e(c, s); + o += _; + } + o < i && (i = o, n = s); + } + return { + comparer: n ?? t[0], + isSorted: i === 0 + }; + } + function ZQe(e, t) { + return ho(B4e(e), B4e(t)); + } + function B4e(e) { + var t; + switch (e.kind) { + case 273: + return e.importClause ? e.importClause.isTypeOnly ? 1 : ((t = e.importClause.namedBindings) == null ? void 0 : t.kind) === 275 ? 2 : e.importClause.name ? 3 : 4 : 0; + case 272: + return 5; + case 244: + return 6; + } + } + function FL(e) { + return e ? uQ : _u; + } + function KQe(e, t) { + const n = eYe(t), i = t.organizeImportsCaseFirst ?? !1, s = t.organizeImportsNumericCollation ?? !1, o = t.organizeImportsAccentCollation ?? !0, c = e ? o ? "accent" : "base" : o ? "variant" : "case"; + return new Intl.Collator(n, { + usage: "sort", + caseFirst: i || "false", + sensitivity: c, + numeric: s + }).compare; + } + function eYe(e) { + let t = e.organizeImportsLocale; + t === "auto" && (t = _Q()), t === void 0 && (t = "en"); + const n = Intl.Collator.supportedLocalesOf(t); + return n.length ? n[0] : "en"; + } + function Xue(e, t) { + return (e.organizeImportsCollation ?? "ordinal") === "unicode" ? KQe(t, e) : FL(t); + } + function tYe(e, t) { + return M4e([e], Uue(t).comparersToTest); + } + function E8(e, t) { + const n = t ?? FL(!!e.organizeImportsIgnoreCase); + return (i, s) => que(i, s, n, e); + } + function rYe(e, t, n) { + const { comparersToTest: i, typeOrdersToTest: s } = Uue(t), o = $ue([e], i, s); + let c = E8(t, i[0]), _; + if (typeof t.organizeImportsIgnoreCase != "boolean" || !t.organizeImportsTypeOrder) { + if (o) { + const { namedImportComparer: u, typeOrder: g, isSorted: m } = o; + _ = m, c = E8({ organizeImportsTypeOrder: g }, u); + } else if (n) { + const u = $ue(n.statements.filter(qo), i, s); + if (u) { + const { namedImportComparer: g, typeOrder: m, isSorted: h } = u; + _ = h, c = E8({ organizeImportsTypeOrder: m }, g); + } + } + } + return { specifierComparer: c, isSorted: _ }; + } + function nYe(e, t, n) { + const i = py(e, t, go, (s, o) => Que(s, o, n)); + return i < 0 ? ~i : i; + } + function iYe(e, t, n) { + const i = py(e, t, go, n); + return i < 0 ? ~i : i; + } + function Que(e, t, n) { + return Hue(Gue(e), Gue(t), n) || ZQe(e, t); + } + function sYe(e, t, n, i) { + const s = FL(t), o = E8({ organizeImportsTypeOrder: i?.organizeImportsTypeOrder }, s); + return O4e(e, s, o, n); + } + function aYe(e, t, n) { + return L4e(e, (s, o) => que(s, o, FL(t), { organizeImportsTypeOrder: n?.organizeImportsTypeOrder ?? "last" })); + } + function oYe(e, t, n) { + const i = FL(!!n); + return Hue(e, t, i); + } + var ZH = {}; + Na(ZH, { + collectElements: () => cYe + }); + function cYe(e, t) { + const n = []; + return lYe(e, t, n), uYe(e, n), n.sort((i, s) => i.textSpan.start - s.textSpan.start), n; + } + function lYe(e, t, n) { + let i = 40, s = 0; + const o = e.statements, c = o.length; + for (; s < c; ) { + for (; s < c && !px(o[s]); ) + _(o[s]), s++; + if (s === c) break; + const u = s; + for (; s < c && px(o[s]); ) + _(o[s]), s++; + const g = s - 1; + g !== u && n.push(OL( + Ya(o[u], 102, e).getStart(e), + o[g].getEnd(), + "imports" + /* Imports */ + )); + } + _(e.endOfFileToken); + function _(u) { + var g; + if (i === 0) return; + t.throwIfCancellationRequested(), (Pl(u) || Ic(u) || Cf(u) || sm(u) || u.kind === 1) && z4e(u, e, t, n), Es(u) && _n(u.parent) && wn(u.parent.left) && z4e(u.parent.left, e, t, n), (Ns(u) || vm(u)) && Yue(u.statements.end, e, t, n), ($n(u) || Vl(u)) && Yue(u.members.end, e, t, n); + const m = fYe(u, e); + m && n.push(m), i--, Ps(u) ? (i++, _(u.expression), i--, u.arguments.forEach(_), (g = u.typeArguments) == null || g.forEach(_)) : sv(u) && u.elseStatement && sv(u.elseStatement) ? (_(u.expression), _(u.thenStatement), i++, _(u.elseStatement), i--) : u.forEachChild(_), i++; + } + } + function uYe(e, t) { + const n = [], i = e.getLineStarts(); + for (const s of i) { + const o = e.getLineEndOfPosition(s), c = e.text.substring(s, o), _ = J4e(c); + if (!(!_ || P0(e, s))) + if (_.isStart) { + const u = Nc(e.text.indexOf("//", s), o); + n.push(kk( + u, + "region", + u, + /*autoCollapse*/ + !1, + _.name || "#region" + )); + } else { + const u = n.pop(); + u && (u.textSpan.length = o - u.textSpan.start, u.hintSpan.length = o - u.textSpan.start, t.push(u)); + } + } + } + var _Ye = /^#(end)?region(.*)\r?$/; + function J4e(e) { + if (e = e.trimStart(), !Ui(e, "//")) + return null; + e = e.slice(2).trim(); + const t = _Ye.exec(e); + if (t) + return { isStart: !t[1], name: t[2].trim() }; + } + function Yue(e, t, n, i) { + const s = Eg(t.text, e); + if (!s) return; + let o = -1, c = -1, _ = 0; + const u = t.getFullText(); + for (const { kind: m, pos: h, end: S } of s) + switch (n.throwIfCancellationRequested(), m) { + case 2: + const T = u.slice(h, S); + if (J4e(T)) { + g(), _ = 0; + break; + } + _ === 0 && (o = h), c = S, _++; + break; + case 3: + g(), i.push(OL( + h, + S, + "comment" + /* Comment */ + )), _ = 0; + break; + default: + E.assertNever(m); + } + g(); + function g() { + _ > 1 && i.push(OL( + o, + c, + "comment" + /* Comment */ + )); + } + } + function z4e(e, t, n, i) { + Bx(e) || Yue(e.pos, t, n, i); + } + function OL(e, t, n) { + return kk(Nc(e, t), n); + } + function fYe(e, t) { + switch (e.kind) { + case 242: + if (Es(e.parent)) + return pYe(e.parent, e, t); + switch (e.parent.kind) { + case 247: + case 250: + case 251: + case 249: + case 246: + case 248: + case 255: + case 300: + return m(e.parent); + case 259: + const T = e.parent; + if (T.tryBlock === e) + return m(e.parent); + if (T.finallyBlock === e) { + const k = Ya(T, 98, t); + if (k) return m(k); + } + // falls through + default: + return kk( + u_(e, t), + "code" + /* Code */ + ); + } + case 269: + return m(e.parent); + case 264: + case 232: + case 265: + case 267: + case 270: + case 188: + case 207: + return m(e); + case 190: + return m( + e, + /*autoCollapse*/ + !1, + /*useFullStart*/ + !qx(e.parent), + 23 + /* OpenBracketToken */ + ); + case 297: + case 298: + return h(e.statements); + case 211: + return g(e); + case 210: + return g( + e, + 23 + /* OpenBracketToken */ + ); + case 285: + return o(e); + case 289: + return c(e); + case 286: + case 287: + return _(e.attributes); + case 229: + case 15: + return u(e); + case 208: + return m( + e, + /*autoCollapse*/ + !1, + /*useFullStart*/ + !ya(e.parent), + 23 + /* OpenBracketToken */ + ); + case 220: + return s(e); + case 214: + return i(e); + case 218: + return S(e); + case 276: + case 280: + case 301: + return n(e); + } + function n(T) { + if (!T.elements.length) + return; + const k = Ya(T, 19, t), D = Ya(T, 20, t); + if (!(!k || !D || lp(k.pos, D.pos, t))) + return KH( + k, + D, + T, + t, + /*autoCollapse*/ + !1, + /*useFullStart*/ + !1 + ); + } + function i(T) { + if (!T.arguments.length) + return; + const k = Ya(T, 21, t), D = Ya(T, 22, t); + if (!(!k || !D || lp(k.pos, D.pos, t))) + return KH( + k, + D, + T, + t, + /*autoCollapse*/ + !1, + /*useFullStart*/ + !0 + ); + } + function s(T) { + if (Ns(T.body) || o_(T.body) || lp(T.body.getFullStart(), T.body.getEnd(), t)) + return; + const k = Nc(T.body.getFullStart(), T.body.getEnd()); + return kk(k, "code", u_(T)); + } + function o(T) { + const k = Nc(T.openingElement.getStart(t), T.closingElement.getEnd()), D = T.openingElement.tagName.getText(t), P = "<" + D + ">..."; + return kk( + k, + "code", + k, + /*autoCollapse*/ + !1, + P + ); + } + function c(T) { + const k = Nc(T.openingFragment.getStart(t), T.closingFragment.getEnd()); + return kk( + k, + "code", + k, + /*autoCollapse*/ + !1, + "<>..." + ); + } + function _(T) { + if (T.properties.length !== 0) + return OL( + T.getStart(t), + T.getEnd(), + "code" + /* Code */ + ); + } + function u(T) { + if (!(T.kind === 15 && T.text.length === 0)) + return OL( + T.getStart(t), + T.getEnd(), + "code" + /* Code */ + ); + } + function g(T, k = 19) { + return m( + T, + /*autoCollapse*/ + !1, + /*useFullStart*/ + !nu(T.parent) && !Ps(T.parent), + k + ); + } + function m(T, k = !1, D = !0, P = 19, A = P === 19 ? 20 : 24) { + const O = Ya(e, P, t), F = Ya(e, A, t); + return O && F && KH(O, F, T, t, k, D); + } + function h(T) { + return T.length ? kk( + A0(T), + "code" + /* Code */ + ) : void 0; + } + function S(T) { + if (lp(T.getStart(), T.getEnd(), t)) return; + const k = Nc(T.getStart(), T.getEnd()); + return kk(k, "code", u_(T)); + } + } + function pYe(e, t, n) { + const i = dYe(e, t, n), s = Ya(t, 20, n); + return i && s && KH( + i, + s, + e, + n, + /*autoCollapse*/ + e.kind !== 220 + /* ArrowFunction */ + ); + } + function KH(e, t, n, i, s = !1, o = !0) { + const c = Nc(o ? e.getFullStart() : e.getStart(i), t.getEnd()); + return kk(c, "code", u_(n, i), s); + } + function kk(e, t, n = e, i = !1, s = "...") { + return { textSpan: e, kind: t, hintSpan: n, bannerText: s, autoCollapse: i }; + } + function dYe(e, t, n) { + if (pee(e.parameters, n)) { + const i = Ya(e, 21, n); + if (i) + return i; + } + return Ya(t, 19, n); + } + var LL = {}; + Na(LL, { + getRenameInfo: () => mYe, + nodeIsEligibleForRename: () => U4e + }); + function mYe(e, t, n, i) { + const s = T9(w_(t, n)); + if (U4e(s)) { + const o = gYe(s, e.getTypeChecker(), t, e, i); + if (o) + return o; + } + return eG(p.You_cannot_rename_this_element); + } + function gYe(e, t, n, i, s) { + const o = t.getSymbolAtLocation(e); + if (!o) { + if (ja(e)) { + const S = S9(e, t); + if (S && (S.flags & 128 || S.flags & 1048576 && Ni(S.types, (T) => !!(T.flags & 128)))) + return Zue(e.text, e.text, "string", "", e, n); + } else if (TV(e)) { + const S = Qo(e); + return Zue(S, S, "label", "", e, n); + } + return; + } + const { declarations: c } = o; + if (!c || c.length === 0) return; + if (c.some((S) => hYe(i, S))) + return eG(p.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library); + if (Me(e) && e.escapedText === "default" && o.parent && o.parent.flags & 1536) + return; + if (ja(e) && U3(e)) + return s.allowRenameOfImportPath ? vYe(e, n, o) : void 0; + const _ = yYe(n, o, t, s); + if (_) + return eG(_); + const u = O0.getSymbolKind(t, o, e), g = kae(e) || If(e) && e.parent.kind === 168 ? Bp(op(e)) : void 0, m = g || t.symbolToString(o), h = g || t.getFullyQualifiedName(o); + return Zue(m, h, u, O0.getSymbolModifiers(t, o), e, n); + } + function hYe(e, t) { + const n = t.getSourceFile(); + return e.isSourceFileDefaultLibrary(n) && Xo( + n.fileName, + ".d.ts" + /* Dts */ + ); + } + function yYe(e, t, n, i) { + if (!i.providePrefixAndSuffixTextForRename && t.flags & 2097152) { + const c = t.declarations && Nn(t.declarations, (_) => Xu(_)); + c && !c.propertyName && (t = n.getAliasedSymbol(t)); + } + const { declarations: s } = t; + if (!s) + return; + const o = W4e(e.path); + if (o === void 0) + return ot(s, (c) => e8(c.getSourceFile().path)) ? p.You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder : void 0; + for (const c of s) { + const _ = W4e(c.getSourceFile().path); + if (_) { + const u = Math.min(o.length, _.length); + for (let g = 0; g <= u; g++) + if (_u(o[g], _[g]) !== 0) + return p.You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder; + } + } + } + function W4e(e) { + const t = fu(e), n = t.lastIndexOf("node_modules"); + if (n !== -1) + return t.slice(0, n + 2); + } + function vYe(e, t, n) { + if (!Dl(e.text)) + return eG(p.You_cannot_rename_a_module_via_a_global_import); + const i = n.declarations && Nn(n.declarations, Di); + if (!i) return; + const s = wo(e.text, "/index") || wo(e.text, "/index.js") ? void 0 : dQ(Gu(i.fileName), "/index"), o = s === void 0 ? i.fileName : s, c = s === void 0 ? "module" : "directory", _ = e.text.lastIndexOf("/") + 1, u = Kl(e.getStart(t) + 1 + _, e.text.length - _); + return { + canRename: !0, + fileToRename: o, + kind: c, + displayName: o, + fullDisplayName: e.text, + kindModifiers: "", + triggerSpan: u + }; + } + function Zue(e, t, n, i, s, o) { + return { + canRename: !0, + fileToRename: void 0, + kind: n, + displayName: e, + fullDisplayName: t, + kindModifiers: i, + triggerSpan: bYe(s, o) + }; + } + function eG(e) { + return { canRename: !1, localizedErrorMessage: Ss(e) }; + } + function bYe(e, t) { + let n = e.getStart(t), i = e.getWidth(t); + return ja(e) && (n += 1, i -= 2), Kl(n, i); + } + function U4e(e) { + switch (e.kind) { + case 80: + case 81: + case 11: + case 15: + case 110: + return !0; + case 9: + return h9(e); + default: + return !1; + } + } + var D8 = {}; + Na(D8, { + getArgumentInfoForCompletions: () => CYe, + getSignatureHelpItems: () => SYe + }); + function SYe(e, t, n, i, s) { + const o = e.getTypeChecker(), c = gw(t, n); + if (!c) + return; + const _ = !!i && i.kind === "characterTyped"; + if (_ && (_k(t, n, c) || P0(t, n))) + return; + const u = !!i && i.kind === "invoked", g = jYe(c, n, t, o, u); + if (!g) return; + s.throwIfCancellationRequested(); + const m = TYe(g, o, t, c, _); + return s.throwIfCancellationRequested(), m ? o.runWithCancellationToken(s, (h) => m.kind === 0 ? Y4e(m.candidates, m.resolvedSignature, g, t, h) : JYe(m.symbol, g, t, h)) : n_(t) ? kYe(g, e, s) : void 0; + } + function TYe({ invocation: e, argumentCount: t }, n, i, s, o) { + switch (e.kind) { + case 0: { + if (o && !xYe(s, e.node, i)) + return; + const c = [], _ = n.getResolvedSignatureForSignatureHelp(e.node, c, t); + return c.length === 0 ? void 0 : { kind: 0, candidates: c, resolvedSignature: _ }; + } + case 1: { + const { called: c } = e; + if (o && !V4e(s, i, Me(c) ? c.parent : c)) + return; + const _ = IV(c, t, n); + if (_.length !== 0) return { kind: 0, candidates: _, resolvedSignature: Ca(_) }; + const u = n.getSymbolAtLocation(c); + return u && { kind: 1, symbol: u }; + } + case 2: + return { kind: 0, candidates: [e.signature], resolvedSignature: e.signature }; + default: + return E.assertNever(e); + } + } + function xYe(e, t, n) { + if (!sm(t)) return !1; + const i = t.getChildren(n); + switch (e.kind) { + case 21: + return ms(i, e); + case 28: { + const s = b9(e); + return !!s && ms(i, s); + } + case 30: + return V4e(e, n, t.expression); + default: + return !1; + } + } + function kYe(e, t, n) { + if (e.invocation.kind === 2) return; + const i = X4e(e.invocation), s = wn(i) ? i.name.text : void 0, o = t.getTypeChecker(); + return s === void 0 ? void 0 : Lc(t.getSourceFiles(), (c) => Lc(c.getNamedDeclarations().get(s), (_) => { + const u = _.symbol && o.getTypeOfSymbolAtLocation(_.symbol, _), g = u && u.getCallSignatures(); + if (g && g.length) + return o.runWithCancellationToken( + n, + (m) => Y4e( + g, + g[0], + e, + c, + m, + /*useFullPrefix*/ + !0 + ) + ); + })); + } + function V4e(e, t, n) { + const i = e.getFullStart(); + let s = e.parent; + for (; s; ) { + const o = pl( + i, + t, + s, + /*excludeJsdoc*/ + !0 + ); + if (o) + return C_(n, o); + s = s.parent; + } + return E.fail("Could not find preceding token"); + } + function CYe(e, t, n, i) { + const s = H4e(e, t, n, i); + return !s || s.isTypeParameterList || s.invocation.kind !== 0 ? void 0 : { invocation: s.invocation.node, argumentCount: s.argumentCount, argumentIndex: s.argumentIndex }; + } + function q4e(e, t, n, i) { + const s = EYe(e, n, i); + if (!s) return; + const { list: o, argumentIndex: c } = s, _ = OYe(i, o), u = MYe(o, n); + return { list: o, argumentIndex: c, argumentCount: _, argumentsSpan: u }; + } + function EYe(e, t, n) { + if (e.kind === 30 || e.kind === 21) + return { list: BYe(e.parent, e, t), argumentIndex: 0 }; + { + const i = b9(e); + return i && { list: i, argumentIndex: FYe(n, i, e) }; + } + } + function H4e(e, t, n, i) { + const { parent: s } = e; + if (sm(s)) { + const o = s, c = q4e(e, t, n, i); + if (!c) return; + const { list: _, argumentIndex: u, argumentCount: g, argumentsSpan: m } = c; + return { isTypeParameterList: !!s.typeArguments && s.typeArguments.pos === _.pos, invocation: { kind: 0, node: o }, argumentsSpan: m, argumentIndex: u, argumentCount: g }; + } else { + if (TS(e) && nv(s)) + return VA(e, t, n) ? e_e( + s, + /*argumentIndex*/ + 0, + n + ) : void 0; + if (Jx(e) && s.parent.kind === 216) { + const o = s, c = o.parent; + E.assert( + o.kind === 229 + /* TemplateExpression */ + ); + const _ = VA(e, t, n) ? 0 : 1; + return e_e(c, _, n); + } else if (g6(s) && nv(s.parent.parent)) { + const o = s, c = s.parent.parent; + if (SF(e) && !VA(e, t, n)) + return; + const _ = o.parent.templateSpans.indexOf(o), u = LYe(_, e, t, n); + return e_e(c, u, n); + } else if (wu(s)) { + const o = s.attributes.pos, c = oa( + n.text, + s.attributes.end, + /*stopAfterLineBreak*/ + !1 + ); + return { + isTypeParameterList: !1, + invocation: { kind: 0, node: s }, + argumentsSpan: Kl(o, c - o), + argumentIndex: 0, + argumentCount: 1 + }; + } else { + const o = FV(e, n); + if (o) { + const { called: c, nTypeArguments: _ } = o, u = { kind: 1, called: c }, g = Nc(c.getStart(n), e.end); + return { isTypeParameterList: !0, invocation: u, argumentsSpan: g, argumentIndex: _, argumentCount: _ + 1 }; + } + return; + } + } + } + function DYe(e, t, n, i) { + return wYe(e, t, n, i) || H4e(e, t, n, i); + } + function G4e(e) { + return _n(e.parent) ? G4e(e.parent) : e; + } + function Kue(e) { + return _n(e.left) ? Kue(e.left) + 1 : 2; + } + function wYe(e, t, n, i) { + const s = PYe(e); + if (s === void 0) return; + const o = NYe(s, n, t, i); + if (o === void 0) return; + const { contextualType: c, argumentIndex: _, argumentCount: u, argumentsSpan: g } = o, m = c.getNonNullableType(), h = m.symbol; + if (h === void 0) return; + const S = Do(m.getCallSignatures()); + return S === void 0 ? void 0 : { isTypeParameterList: !1, invocation: { kind: 2, signature: S, node: e, symbol: AYe(h) }, argumentsSpan: g, argumentIndex: _, argumentCount: u }; + } + function PYe(e) { + switch (e.kind) { + case 21: + case 28: + return e; + default: + return dr(e.parent, (t) => Ii(t) ? !0 : ya(t) || Of(t) || D0(t) ? !1 : "quit"); + } + } + function NYe(e, t, n, i) { + const { parent: s } = e; + switch (s.kind) { + case 218: + case 175: + case 219: + case 220: + const o = q4e(e, n, t, i); + if (!o) return; + const { argumentIndex: c, argumentCount: _, argumentsSpan: u } = o, g = rc(s) ? i.getContextualTypeForObjectLiteralElement(s) : i.getContextualType(s); + return g && { contextualType: g, argumentIndex: c, argumentCount: _, argumentsSpan: u }; + case 227: { + const m = G4e(s), h = i.getContextualType(m), S = e.kind === 21 ? 0 : Kue(s) - 1, T = Kue(m); + return h && { contextualType: h, argumentIndex: S, argumentCount: T, argumentsSpan: u_(s) }; + } + default: + return; + } + } + function AYe(e) { + return e.name === "__type" && Lc(e.declarations, (t) => { + var n; + return Zm(t) ? (n = Bn(t.parent, Ed)) == null ? void 0 : n.symbol : void 0; + }) || e; + } + function IYe(e, t) { + const n = t.getTypeAtLocation(e.expression); + if (t.isTupleType(n)) { + const { elementFlags: i, fixedLength: s } = n.target; + if (s === 0) + return 0; + const o = oc(i, (c) => !(c & 1)); + return o < 0 ? s : o; + } + return 0; + } + function FYe(e, t, n) { + return $4e(e, t, n); + } + function OYe(e, t) { + return $4e( + e, + t, + /*node*/ + void 0 + ); + } + function $4e(e, t, n) { + const i = t.getChildren(); + let s = 0, o = !1; + for (const c of i) { + if (n && c === n) + return !o && c.kind === 28 && s++, s; + if (dp(c)) { + s += IYe(c, e), o = !0; + continue; + } + if (c.kind !== 28) { + s++, o = !0; + continue; + } + if (o) { + o = !1; + continue; + } + s++; + } + return n ? s : i.length && pa(i).kind === 28 ? s + 1 : s; + } + function LYe(e, t, n, i) { + return E.assert(n >= t.getStart(), "Assumed 'position' could not occur before node."), bZ(t) ? VA(t, n, i) ? 0 : e + 2 : e + 1; + } + function e_e(e, t, n) { + const i = TS(e.template) ? 1 : e.template.templateSpans.length + 1; + return t !== 0 && E.assertLessThan(t, i), { + isTypeParameterList: !1, + invocation: { kind: 0, node: e }, + argumentsSpan: RYe(e, n), + argumentIndex: t, + argumentCount: i + }; + } + function MYe(e, t) { + const n = e.getFullStart(), i = oa( + t.text, + e.getEnd(), + /*stopAfterLineBreak*/ + !1 + ); + return Kl(n, i - n); + } + function RYe(e, t) { + const n = e.template, i = n.getStart(); + let s = n.getEnd(); + return n.kind === 229 && pa(n.templateSpans).literal.getFullWidth() === 0 && (s = oa( + t.text, + s, + /*stopAfterLineBreak*/ + !1 + )), Kl(i, s - i); + } + function jYe(e, t, n, i, s) { + for (let o = e; !Di(o) && (s || !Ns(o)); o = o.parent) { + E.assert(C_(o.parent, o), "Not a subspan", () => `Child: ${E.formatSyntaxKind(o.kind)}, parent: ${E.formatSyntaxKind(o.parent.kind)}`); + const c = DYe(o, t, n, i); + if (c) + return c; + } + } + function BYe(e, t, n) { + const i = e.getChildren(n), s = i.indexOf(t); + return E.assert(s >= 0 && i.length > s + 1), i[s + 1]; + } + function X4e(e) { + return e.kind === 0 ? s5(e.node) : e.called; + } + function Q4e(e) { + return e.kind === 0 ? e.node : e.kind === 1 ? e.called : e.node; + } + var ML = 70246400; + function Y4e(e, t, { isTypeParameterList: n, argumentCount: i, argumentsSpan: s, invocation: o, argumentIndex: c }, _, u, g) { + var m; + const h = Q4e(o), S = o.kind === 2 ? o.symbol : u.getSymbolAtLocation(X4e(o)) || g && ((m = t.declaration) == null ? void 0 : m.symbol), T = S ? Tw( + u, + S, + g ? _ : void 0, + /*meaning*/ + void 0 + ) : Ge, k = hr(e, (F) => WYe(F, T, n, u, h, _)); + let D = 0, P = 0; + for (let F = 0; F < k.length; F++) { + const R = k[F]; + if (e[F] === t && (D = P, R.length > 1)) { + let B = 0; + for (const U of R) { + if (U.isVariadic || U.parameters.length >= i) { + D = P + B; + break; + } + B++; + } + } + P += R.length; + } + E.assert(D !== -1); + const A = { items: KE(k, go), applicableSpan: s, selectedItemIndex: D, argumentIndex: c, argumentCount: i }, O = A.items[D]; + if (O.isVariadic) { + const F = oc(O.parameters, (R) => !!R.isRest); + -1 < F && F < O.parameters.length - 1 ? A.argumentIndex = O.parameters.length : A.argumentIndex = Math.min(A.argumentIndex, O.parameters.length - 1); + } + return A; + } + function JYe(e, { argumentCount: t, argumentsSpan: n, invocation: i, argumentIndex: s }, o, c) { + const _ = c.getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(e); + return _ ? { items: [zYe(e, _, c, Q4e(i), o)], applicableSpan: n, selectedItemIndex: 0, argumentIndex: s, argumentCount: t } : void 0; + } + function zYe(e, t, n, i, s) { + const o = Tw(n, e), c = i2(), _ = t.map((h) => K4e(h, n, i, s, c)), u = e.getDocumentationComment(n), g = e.getJsDocTags(n); + return { isVariadic: !1, prefixDisplayParts: [...o, Fu( + 30 + /* LessThanToken */ + )], suffixDisplayParts: [Fu( + 32 + /* GreaterThanToken */ + )], separatorDisplayParts: Z4e, parameters: _, documentation: u, tags: g }; + } + var Z4e = [Fu( + 28 + /* CommaToken */ + ), fc()]; + function WYe(e, t, n, i, s, o) { + const c = (n ? VYe : qYe)(e, i, s, o); + return hr(c, ({ isVariadic: _, parameters: u, prefix: g, suffix: m }) => { + const h = [...t, ...g], S = [...m, ...UYe(e, s, i)], T = e.getDocumentationComment(i), k = e.getJsDocTags(); + return { isVariadic: _, prefixDisplayParts: h, suffixDisplayParts: S, separatorDisplayParts: Z4e, parameters: u, documentation: T, tags: k }; + }); + } + function UYe(e, t, n) { + return n1((i) => { + i.writePunctuation(":"), i.writeSpace(" "); + const s = n.getTypePredicateOfSignature(e); + s ? n.writeTypePredicate( + s, + t, + /*flags*/ + void 0, + i + ) : n.writeType( + n.getReturnTypeOfSignature(e), + t, + /*flags*/ + void 0, + i + ); + }); + } + function VYe(e, t, n, i) { + const s = (e.target || e).typeParameters, o = i2(), c = (s || Ge).map((u) => K4e(u, t, n, i, o)), _ = e.thisParameter ? [t.symbolToParameterDeclaration(e.thisParameter, n, ML)] : []; + return t.getExpandedParameters(e).map((u) => { + const g = N.createNodeArray([..._, ...hr(u, (h) => t.symbolToParameterDeclaration(h, n, ML))]), m = n1((h) => { + o.writeList(2576, g, i, h); + }); + return { isVariadic: !1, parameters: c, prefix: [Fu( + 30 + /* LessThanToken */ + )], suffix: [Fu( + 32 + /* GreaterThanToken */ + ), ...m] }; + }); + } + function qYe(e, t, n, i) { + const s = i2(), o = n1((u) => { + if (e.typeParameters && e.typeParameters.length) { + const g = N.createNodeArray(e.typeParameters.map((m) => t.typeParameterToDeclaration(m, n, ML))); + s.writeList(53776, g, i, u); + } + }), c = t.getExpandedParameters(e), _ = t.hasEffectiveRestParameter(e) ? c.length === 1 ? (u) => !0 : (u) => { + var g; + return !!(u.length && ((g = Bn(u[u.length - 1], Ng)) == null ? void 0 : g.links.checkFlags) & 32768); + } : (u) => !1; + return c.map((u) => ({ + isVariadic: _(u), + parameters: u.map((g) => HYe(g, t, n, i, s)), + prefix: [...o, Fu( + 21 + /* OpenParenToken */ + )], + suffix: [Fu( + 22 + /* CloseParenToken */ + )] + })); + } + function HYe(e, t, n, i, s) { + const o = n1((u) => { + const g = t.symbolToParameterDeclaration(e, n, ML); + s.writeNode(4, g, i, u); + }), c = t.isOptionalParameter(e.valueDeclaration), _ = Ng(e) && !!(e.links.checkFlags & 32768); + return { name: e.name, documentation: e.getDocumentationComment(t), displayParts: o, isOptional: c, isRest: _ }; + } + function K4e(e, t, n, i, s) { + const o = n1((c) => { + const _ = t.typeParameterToDeclaration(e, n, ML); + s.writeNode(4, _, i, c); + }); + return { name: e.symbol.name, documentation: e.symbol.getDocumentationComment(t), displayParts: o, isOptional: !1, isRest: !1 }; + } + var tG = {}; + Na(tG, { + getSmartSelectionRange: () => GYe + }); + function GYe(e, t) { + var n, i; + let s = { + textSpan: Nc(t.getFullStart(), t.getEnd()) + }, o = t; + e: + for (; ; ) { + const u = QYe(o); + if (!u.length) break; + for (let g = 0; g < u.length; g++) { + const m = u[g - 1], h = u[g], S = u[g + 1]; + if (Ay( + h, + t, + /*includeJsDoc*/ + !0 + ) > e) + break e; + const T = xg(Sy(t.text, h.end)); + if (T && T.kind === 2 && _(T.pos, T.end), $Ye(t, e, h)) { + if (Xj(h) && io(o) && !lp(h.getStart(t), h.getEnd(), t) && c(h.getStart(t), h.getEnd()), Ns(h) || g6(h) || Jx(h) || SF(h) || m && Jx(m) || Ul(h) && Ic(o) || T6(h) && Ul(o) || ei(h) && T6(o) && u.length === 1 || lv(h) || w0(h) || AS(h)) { + o = h; + break; + } + if (g6(o) && S && E7(S)) { + const A = h.getFullStart() - 2, O = S.getStart() + 1; + c(A, O); + } + const k = T6(h) && YYe(m) && ZYe(S) && !lp(m.getStart(), S.getStart(), t); + let D = k ? m.getEnd() : h.getStart(); + const P = k ? S.getStart() : KYe(t, h); + if (kf(h) && ((n = h.jsDoc) != null && n.length) && c(Ca(h.jsDoc).getStart(), P), T6(h)) { + const A = h.getChildren()[0]; + A && kf(A) && ((i = A.jsDoc) != null && i.length) && A.getStart() !== h.pos && (D = Math.min(D, Ca(A.jsDoc).getStart())); + } + c(D, P), (ca(h) || ox(h)) && c(D + 1, P - 1), o = h; + break; + } + if (g === u.length - 1) + break e; + } + } + return s; + function c(u, g) { + if (u !== g) { + const m = Nc(u, g); + (!s || // Skip ranges that are identical to the parent + !X6(m, s.textSpan) && // Skip ranges that don't contain the original position + YY(m, e)) && (s = { textSpan: m, ...s && { parent: s } }); + } + } + function _(u, g) { + c(u, g); + let m = u; + for (; t.text.charCodeAt(m) === 47; ) + m++; + c(m, g); + } + } + function $Ye(e, t, n) { + return E.assert(n.pos <= t), t < n.end ? !0 : n.getEnd() === t ? w_(e, t).pos < n.end : !1; + } + var XYe = Q_(qo, _l); + function QYe(e) { + var t; + if (Di(e)) + return w8(e.getChildAt(0).getChildren(), XYe); + if (CS(e)) { + const [n, ...i] = e.getChildren(), s = E.checkDefined(i.pop()); + E.assertEqual( + n.kind, + 19 + /* OpenBraceToken */ + ), E.assertEqual( + s.kind, + 20 + /* CloseBraceToken */ + ); + const o = w8( + i, + (_) => _ === e.readonlyToken || _.kind === 148 || _ === e.questionToken || _.kind === 58 + /* QuestionToken */ + ), c = w8( + o, + ({ kind: _ }) => _ === 23 || _ === 169 || _ === 24 + /* CloseBracketToken */ + ); + return [ + n, + // Pivot on `:` + P8(rG( + c, + ({ kind: _ }) => _ === 59 + /* ColonToken */ + )), + s + ]; + } + if ($u(e)) { + const n = w8(e.getChildren(), (c) => c === e.name || ms(e.modifiers, c)), i = ((t = n[0]) == null ? void 0 : t.kind) === 321 ? n[0] : void 0, s = i ? n.slice(1) : n, o = rG( + s, + ({ kind: c }) => c === 59 + /* ColonToken */ + ); + return i ? [i, P8(o)] : o; + } + if (Ii(e)) { + const n = w8(e.getChildren(), (s) => s === e.dotDotDotToken || s === e.name), i = w8(n, (s) => s === n[0] || s === e.questionToken); + return rG( + i, + ({ kind: s }) => s === 64 + /* EqualsToken */ + ); + } + return ya(e) ? rG( + e.getChildren(), + ({ kind: n }) => n === 64 + /* EqualsToken */ + ) : e.getChildren(); + } + function w8(e, t) { + const n = []; + let i; + for (const s of e) + t(s) ? (i = i || [], i.push(s)) : (i && (n.push(P8(i)), i = void 0), n.push(s)); + return i && n.push(P8(i)), n; + } + function rG(e, t, n = !0) { + if (e.length < 2) + return e; + const i = oc(e, t); + if (i === -1) + return e; + const s = e.slice(0, i), o = e[i], c = pa(e), _ = n && c.kind === 27, u = e.slice(i + 1, _ ? e.length - 1 : void 0), g = RP([ + s.length ? P8(s) : void 0, + o, + u.length ? P8(u) : void 0 + ]); + return _ ? g.concat(c) : g; + } + function P8(e) { + return E.assertGreaterThanOrEqual(e.length, 1), Ad(fv.createSyntaxList(e), e[0].pos, pa(e).end); + } + function YYe(e) { + const t = e && e.kind; + return t === 19 || t === 23 || t === 21 || t === 287; + } + function ZYe(e) { + const t = e && e.kind; + return t === 20 || t === 24 || t === 22 || t === 288; + } + function KYe(e, t) { + switch (t.kind) { + case 342: + case 339: + case 349: + case 347: + case 344: + return e.getLineEndOfPosition(t.getStart()); + default: + return t.getEnd(); + } + } + var O0 = {}; + Na(O0, { + getSymbolDisplayPartsDocumentationAndSymbolKind: () => tZe, + getSymbolKind: () => twe, + getSymbolModifiers: () => eZe + }); + var ewe = 70246400; + function twe(e, t, n) { + const i = rwe(e, t, n); + if (i !== "") + return i; + const s = t6(t); + return s & 32 ? Oo( + t, + 232 + /* ClassExpression */ + ) ? "local class" : "class" : s & 384 ? "enum" : s & 524288 ? "type" : s & 64 ? "interface" : s & 262144 ? "type parameter" : s & 8 ? "enum member" : s & 2097152 ? "alias" : s & 1536 ? "module" : i; + } + function rwe(e, t, n) { + const i = e.getRootSymbols(t); + if (i.length === 1 && Ca(i).flags & 8192 && e.getTypeOfSymbolAtLocation(t, n).getNonNullableType().getCallSignatures().length !== 0) + return "method"; + if (e.isUndefinedSymbol(t)) + return "var"; + if (e.isArgumentsSymbol(t)) + return "local var"; + if (n.kind === 110 && ut(n) || jb(n)) + return "parameter"; + const s = t6(t); + if (s & 3) + return KV(t) ? "parameter" : t.valueDeclaration && BC(t.valueDeclaration) ? "const" : t.valueDeclaration && D3(t.valueDeclaration) ? "using" : t.valueDeclaration && E3(t.valueDeclaration) ? "await using" : lr(t.declarations, X7) ? "let" : swe(t) ? "local var" : "var"; + if (s & 16) return swe(t) ? "local function" : "function"; + if (s & 32768) return "getter"; + if (s & 65536) return "setter"; + if (s & 8192) return "method"; + if (s & 16384) return "constructor"; + if (s & 131072) return "index"; + if (s & 4) { + if (s & 33554432 && t.links.checkFlags & 6) { + const o = lr(e.getRootSymbols(t), (c) => { + if (c.getFlags() & 98311) + return "property"; + }); + return o || (e.getTypeOfSymbolAtLocation(t, n).getCallSignatures().length ? "method" : "property"); + } + return "property"; + } + return ""; + } + function nwe(e) { + if (e.declarations && e.declarations.length) { + const [t, ...n] = e.declarations, i = wr(n) && q9(t) && ot(n, (o) => !q9(o)) ? 65536 : 0, s = hw(t, i); + if (s) + return s.split(","); + } + return []; + } + function eZe(e, t) { + if (!t) + return ""; + const n = new Set(nwe(t)); + if (t.flags & 2097152) { + const i = e.getAliasedSymbol(t); + i !== t && lr(nwe(i), (s) => { + n.add(s); + }); + } + return t.flags & 16777216 && n.add( + "optional" + /* optionalModifier */ + ), n.size > 0 ? is(n.values()).join(",") : ""; + } + function iwe(e, t, n, i, s, o, c, _, u, g) { + var m; + const h = []; + let S = [], T = []; + const k = t6(t); + let D = c & 1 ? rwe(e, t, s) : "", P = !1; + const A = s.kind === 110 && a5(s) || jb(s); + let O, F, R = !1; + const B = { canIncreaseExpansionDepth: !1, truncated: !1 }; + let U = !1; + if (s.kind === 110 && !A) + return { displayParts: [ff( + 110 + /* ThisKeyword */ + )], documentation: [], symbolKind: "primitive type", tags: void 0 }; + if (D !== "" || k & 32 || k & 2097152) { + if (D === "getter" || D === "setter") { + const pe = Nn( + t.declarations, + (Te) => Te.name === s && Te.kind !== 212 + /* PropertyAccessExpression */ + ); + if (pe) + switch (pe.kind) { + case 178: + D = "getter"; + break; + case 179: + D = "setter"; + break; + case 173: + D = "accessor"; + break; + default: + E.assertNever(pe); + } + else + D = "property"; + } + let me; + if (o ?? (o = A ? e.getTypeAtLocation(s) : e.getTypeOfSymbolAtLocation(t, s)), s.parent && s.parent.kind === 212) { + const pe = s.parent.name; + (pe === s || pe && pe.getFullWidth() === 0) && (s = s.parent); + } + let Z; + if (sm(s) ? Z = s : (yV(s) || dw(s) || s.parent && (wu(s.parent) || nv(s.parent)) && Es(t.valueDeclaration)) && (Z = s.parent), Z) { + me = e.getResolvedSignature(Z); + const pe = Z.kind === 215 || Ps(Z) && Z.expression.kind === 108, Te = pe ? o.getConstructSignatures() : o.getCallSignatures(); + if (me && !ms(Te, me.target) && !ms(Te, me) && (me = Te.length ? Te[0] : void 0), me) { + switch (pe && k & 32 ? (D = "constructor", he(o.symbol, D)) : k & 2097152 ? (D = "alias", q(D), h.push(fc()), pe && (me.flags & 4 && (h.push(ff( + 128 + /* AbstractKeyword */ + )), h.push(fc())), h.push(ff( + 105 + /* NewKeyword */ + )), h.push(fc())), fe(t)) : he(t, D), D) { + case "JSX attribute": + case "property": + case "var": + case "const": + case "let": + case "parameter": + case "local var": + h.push(Fu( + 59 + /* ColonToken */ + )), h.push(fc()), !(Dn(o) & 16) && o.symbol && (In(h, Tw( + e, + o.symbol, + i, + /*meaning*/ + void 0, + 5 + /* WriteTypeParametersOrArguments */ + )), h.push(Q6())), pe && (me.flags & 4 && (h.push(ff( + 128 + /* AbstractKeyword */ + )), h.push(fc())), h.push(ff( + 105 + /* NewKeyword */ + )), h.push(fc())), be( + me, + Te, + 262144 + /* WriteArrowStyleSignature */ + ); + break; + default: + be(me, Te); + } + P = !0, R = Te.length > 1; + } + } else if (EV(s) && !(k & 98304) || // name of function declaration + s.kind === 137 && s.parent.kind === 177) { + const pe = s.parent; + if (t.declarations && Nn(t.declarations, (Fe) => Fe === (s.kind === 137 ? pe.parent : pe))) { + const Fe = pe.kind === 177 ? o.getNonNullableType().getConstructSignatures() : o.getNonNullableType().getCallSignatures(); + e.isImplementationOfOverload(pe) ? me = Fe[0] : me = e.getSignatureFromDeclaration(pe), pe.kind === 177 ? (D = "constructor", he(o.symbol, D)) : he( + pe.kind === 180 && !(o.symbol.flags & 2048 || o.symbol.flags & 4096) ? o.symbol : t, + D + ), me && be(me, Fe), P = !0, R = Fe.length > 1; + } + } + } + if (k & 32 && !P && !A) { + K(); + const me = Oo( + t, + 232 + /* ClassExpression */ + ); + me && (q( + "local class" + /* localClassElement */ + ), h.push(fc())), ce(t, c) || (me || (h.push(ff( + 86 + /* ClassKeyword */ + )), h.push(fc())), fe(t), je(t, n)); + } + if (k & 64 && c & 2 && (_e(), ce(t, c) || (h.push(ff( + 120 + /* InterfaceKeyword */ + )), h.push(fc()), fe(t), je(t, n))), k & 524288 && c & 2 && (_e(), h.push(ff( + 156 + /* TypeKeyword */ + )), h.push(fc()), fe(t), je(t, n), h.push(fc()), h.push(Sw( + 64 + /* EqualsToken */ + )), h.push(fc()), In( + h, + QA( + e, + s.parent && nd(s.parent) ? e.getTypeAtLocation(s.parent) : e.getDeclaredTypeOfSymbol(t), + i, + 8388608, + u, + g, + B + ) + )), k & 384 && (_e(), ce(t, c) || (ot(t.declarations, (me) => ov(me) && V1(me)) && (h.push(ff( + 87 + /* ConstKeyword */ + )), h.push(fc())), h.push(ff( + 94 + /* EnumKeyword */ + )), h.push(fc()), fe( + t, + /*enclosingDeclaration*/ + void 0 + ))), k & 1536 && !A && (_e(), !ce(t, c))) { + const me = Oo( + t, + 268 + /* ModuleDeclaration */ + ), Z = me && me.name && me.name.kind === 80; + h.push(ff( + Z ? 145 : 144 + /* ModuleKeyword */ + )), h.push(fc()), fe(t); + } + if (k & 262144 && c & 2) + if (_e(), h.push(Fu( + 21 + /* OpenParenToken */ + )), h.push(Bf("type parameter")), h.push(Fu( + 22 + /* CloseParenToken */ + )), h.push(fc()), fe(t), t.parent) + V(), fe(t.parent, i), je(t.parent, i); + else { + const me = Oo( + t, + 169 + /* TypeParameter */ + ); + if (me === void 0) return E.fail(); + const Z = me.parent; + if (Z) + if (Es(Z)) { + V(); + const pe = e.getSignatureFromDeclaration(Z); + Z.kind === 181 ? (h.push(ff( + 105 + /* NewKeyword */ + )), h.push(fc())) : Z.kind !== 180 && Z.name && fe(Z.symbol), In(h, tq( + e, + pe, + n, + 32 + /* WriteTypeArgumentsOfSignature */ + )); + } else Wp(Z) && (V(), h.push(ff( + 156 + /* TypeKeyword */ + )), h.push(fc()), fe(Z.symbol), je(Z.symbol, n)); + } + if (k & 8) { + D = "enum member", he(t, "enum member"); + const me = (m = t.declarations) == null ? void 0 : m[0]; + if (me?.kind === 307) { + const Z = e.getConstantValue(me); + Z !== void 0 && (h.push(fc()), h.push(Sw( + 64 + /* EqualsToken */ + )), h.push(fc()), h.push(W_( + KZ(Z), + typeof Z == "number" ? 7 : 8 + /* stringLiteral */ + ))); + } + } + if (t.flags & 2097152) { + if (_e(), !P || S.length === 0 && T.length === 0) { + const me = e.getAliasedSymbol(t); + if (me !== t && me.declarations && me.declarations.length > 0) { + const Z = me.declarations[0], pe = _s(Z); + if (pe && !P) { + const Te = q7(Z) && Gn( + Z, + 128 + /* Ambient */ + ), Fe = t.name !== "default" && !Te, Ye = iwe( + e, + me, + xr(Z), + i, + pe, + o, + c, + Fe ? t : me, + u, + g + ); + h.push(...Ye.displayParts), h.push(Q6()), O = Ye.documentation, F = Ye.tags, B && Ye.canIncreaseVerbosityLevel && (B.canIncreaseExpansionDepth = !0); + } else + O = me.getContextualDocumentationComment(Z, e), F = me.getJsDocTags(e); + } + } + if (t.declarations) + switch (t.declarations[0].kind) { + case 271: + h.push(ff( + 95 + /* ExportKeyword */ + )), h.push(fc()), h.push(ff( + 145 + /* NamespaceKeyword */ + )); + break; + case 278: + h.push(ff( + 95 + /* ExportKeyword */ + )), h.push(fc()), h.push(ff( + t.declarations[0].isExportEquals ? 64 : 90 + /* DefaultKeyword */ + )); + break; + case 282: + h.push(ff( + 95 + /* ExportKeyword */ + )); + break; + default: + h.push(ff( + 102 + /* ImportKeyword */ + )); + } + h.push(fc()), fe(t), lr(t.declarations, (me) => { + if (me.kind === 272) { + const Z = me; + if (H1(Z)) + h.push(fc()), h.push(Sw( + 64 + /* EqualsToken */ + )), h.push(fc()), h.push(ff( + 149 + /* RequireKeyword */ + )), h.push(Fu( + 21 + /* OpenParenToken */ + )), h.push(W_( + Qo(jD(Z)), + 8 + /* stringLiteral */ + )), h.push(Fu( + 22 + /* CloseParenToken */ + )); + else { + const pe = e.getSymbolAtLocation(Z.moduleReference); + pe && (h.push(fc()), h.push(Sw( + 64 + /* EqualsToken */ + )), h.push(fc()), fe(pe, i)); + } + return !0; + } + }); + } + if (!P) + if (D !== "") { + if (o) { + if (A ? (_e(), h.push(ff( + 110 + /* ThisKeyword */ + ))) : he(t, D), D === "property" || D === "accessor" || D === "getter" || D === "setter" || D === "JSX attribute" || k & 3 || D === "local var" || D === "index" || D === "using" || D === "await using" || A) { + if (h.push(Fu( + 59 + /* ColonToken */ + )), h.push(fc()), o.symbol && o.symbol.flags & 262144 && D !== "index") { + const me = n1((Z) => { + const pe = e.typeParameterToDeclaration( + o, + i, + ewe, + /*internalFlags*/ + void 0, + /*tracker*/ + void 0, + u, + g, + B + ); + W().writeNode(4, pe, xr(vs(i)), Z); + }, u); + In(h, me); + } else + In( + h, + QA( + e, + o, + i, + /*flags*/ + void 0, + u, + g, + B + ) + ); + if (Ng(t) && t.links.target && Ng(t.links.target) && t.links.target.links.tupleLabelDeclaration) { + const me = t.links.target.links.tupleLabelDeclaration; + E.assertNode(me.name, Me), h.push(fc()), h.push(Fu( + 21 + /* OpenParenToken */ + )), h.push(Bf(An(me.name))), h.push(Fu( + 22 + /* CloseParenToken */ + )); + } + } else if (k & 16 || k & 8192 || k & 16384 || k & 131072 || k & 98304 || D === "method") { + const me = o.getNonNullableType().getCallSignatures(); + me.length && (be(me[0], me), R = me.length > 1); + } + } + } else + D = twe(e, t, s); + if (S.length === 0 && !R && (S = t.getContextualDocumentationComment(i, e)), S.length === 0 && k & 4 && t.parent && t.declarations && lr( + t.parent.declarations, + (me) => me.kind === 308 + /* SourceFile */ + )) + for (const me of t.declarations) { + if (!me.parent || me.parent.kind !== 227) + continue; + const Z = e.getSymbolAtLocation(me.parent.right); + if (Z && (S = Z.getDocumentationComment(e), T = Z.getJsDocTags(e), S.length > 0)) + break; + } + if (S.length === 0 && Me(s) && t.valueDeclaration && ya(t.valueDeclaration)) { + const me = t.valueDeclaration, Z = me.parent, pe = me.propertyName || me.name; + if (Me(pe) && Of(Z)) { + const Te = op(pe), Fe = e.getTypeAtLocation(Z); + S = Lc(Fe.isUnion() ? Fe.types : [Fe], (Ye) => { + const ne = Ye.getProperty(Te); + return ne ? ne.getDocumentationComment(e) : void 0; + }) || Ge; + } + } + T.length === 0 && !R && !BD(s) && (T = t.getContextualJsDocTags(i, e)), S.length === 0 && O && (S = O), T.length === 0 && F && (T = F); + const $ = !B.truncated && B.canIncreaseExpansionDepth; + return { + displayParts: h, + documentation: S, + symbolKind: D, + tags: T.length === 0 ? void 0 : T, + canIncreaseVerbosityLevel: g !== void 0 ? $ : void 0 + }; + function W() { + return i2(); + } + function _e() { + h.length && h.push(Q6()), K(); + } + function K() { + _ && (q( + "alias" + /* alias */ + ), h.push(fc())); + } + function V() { + h.push(fc()), h.push(ff( + 103 + /* InKeyword */ + )), h.push(fc()); + } + function ae(me, Z) { + if (g === void 0) + return !1; + const pe = me.flags & 96 ? e.getDeclaredTypeOfSymbol(me) : e.getTypeOfSymbolAtLocation(me, s); + return !pe || e.isLibType(pe) ? !1 : 0 < g ? !0 : (Z && (Z.canIncreaseExpansionDepth = !0), !1); + } + function se(me) { + let Z = 0; + return me & 1 && (Z |= 111551), me & 2 && (Z |= 788968), me & 4 && (Z |= 1920), Z; + } + function ce(me, Z) { + if (U) + return !0; + if (ae(me, B)) { + const pe = se(Z), Te = n1((Fe) => { + const Ye = e.getEmitResolver().symbolToDeclarations( + me, + pe, + 17408, + u, + g !== void 0 ? g - 1 : void 0, + B + ), ne = W(), Se = me.valueDeclaration && xr(me.valueDeclaration); + Ye.forEach((ie, Ne) => { + Ne > 0 && Fe.writeLine(), ne.writeNode(4, ie, Se, Fe); + }); + }, u); + return In(h, Te), U = !0, !0; + } + return !1; + } + function fe(me, Z) { + let pe; + _ && me === t && (me = _), D === "index" && (pe = e.getIndexInfosOfIndexSymbol(me)); + let Te = []; + me.flags & 131072 && pe ? (me.parent && (Te = Tw(e, me.parent)), Te.push(Fu( + 23 + /* OpenBracketToken */ + )), pe.forEach((Fe, Ye) => { + Te.push(...QA(e, Fe.keyType)), Ye !== pe.length - 1 && (Te.push(fc()), Te.push(Fu( + 52 + /* BarToken */ + )), Te.push(fc())); + }), Te.push(Fu( + 24 + /* CloseBracketToken */ + ))) : Te = Tw( + e, + me, + Z || n, + /*meaning*/ + void 0, + 7 + /* AllowAnyNodeKind */ + ), In(h, Te), t.flags & 16777216 && h.push(Fu( + 58 + /* QuestionToken */ + )); + } + function he(me, Z) { + _e(), Z && (q(Z), me && !ot(me.declarations, (pe) => xo(pe) || (yo(pe) || Rc(pe)) && !pe.name) && (h.push(fc()), fe(me))); + } + function q(me) { + switch (me) { + case "var": + case "function": + case "let": + case "const": + case "constructor": + case "using": + case "await using": + h.push(eq(me)); + return; + default: + h.push(Fu( + 21 + /* OpenParenToken */ + )), h.push(eq(me)), h.push(Fu( + 22 + /* CloseParenToken */ + )); + return; + } + } + function be(me, Z, pe = 0) { + In(h, tq(e, me, i, pe | 32, u, g, B)), Z.length > 1 && (h.push(fc()), h.push(Fu( + 21 + /* OpenParenToken */ + )), h.push(Sw( + 40 + /* PlusToken */ + )), h.push(W_( + (Z.length - 1).toString(), + 7 + /* numericLiteral */ + )), h.push(fc()), h.push(Bf(Z.length === 2 ? "overload" : "overloads")), h.push(Fu( + 22 + /* CloseParenToken */ + ))), S = me.getDocumentationComment(e), T = me.getJsDocTags(), Z.length > 1 && S.length === 0 && T.length === 0 && (S = Z[0].getDocumentationComment(e), T = Z[0].getJsDocTags().filter((Te) => Te.name !== "deprecated")); + } + function je(me, Z) { + const pe = n1((Te) => { + const Fe = e.symbolToTypeParameterDeclarations(me, Z, ewe); + W().writeList(53776, Fe, xr(vs(Z)), Te); + }); + In(h, pe); + } + } + function tZe(e, t, n, i, s, o = WS(s), c, _, u) { + return iwe( + e, + t, + n, + i, + s, + /*type*/ + void 0, + o, + c, + _, + u + ); + } + function swe(e) { + return e.parent ? !1 : lr(e.declarations, (t) => { + if (t.kind === 219) + return !0; + if (t.kind !== 261 && t.kind !== 263) + return !1; + for (let n = t.parent; !Nb(n); n = n.parent) + if (n.kind === 308 || n.kind === 269) + return !1; + return !0; + }); + } + var cn = {}; + Na(cn, { + ChangeTracker: () => iZe, + LeadingTriviaOption: () => cwe, + TrailingTriviaOption: () => lwe, + applyChanges: () => s_e, + assignPositionsToNode: () => aG, + createWriter: () => _we, + deleteNode: () => Mh, + getAdjustedEndPosition: () => Ck, + isThisTypeAnnotatable: () => nZe, + isValidLocationToAddComment: () => fwe + }); + function awe(e) { + const t = e.__pos; + return E.assert(typeof t == "number"), t; + } + function t_e(e, t) { + E.assert(typeof t == "number"), e.__pos = t; + } + function owe(e) { + const t = e.__end; + return E.assert(typeof t == "number"), t; + } + function r_e(e, t) { + E.assert(typeof t == "number"), e.__end = t; + } + var cwe = /* @__PURE__ */ ((e) => (e[e.Exclude = 0] = "Exclude", e[e.IncludeAll = 1] = "IncludeAll", e[e.JSDoc = 2] = "JSDoc", e[e.StartLine = 3] = "StartLine", e))(cwe || {}), lwe = /* @__PURE__ */ ((e) => (e[e.Exclude = 0] = "Exclude", e[e.ExcludeWhitespace = 1] = "ExcludeWhitespace", e[e.Include = 2] = "Include", e))(lwe || {}); + function uwe(e, t) { + return oa( + e, + t, + /*stopAfterLineBreak*/ + !1, + /*stopAtComments*/ + !0 + ); + } + function rZe(e, t) { + let n = t; + for (; n < e.length; ) { + const i = e.charCodeAt(n); + if (im(i)) { + n++; + continue; + } + return i === 47; + } + return !1; + } + var N8 = { + leadingTriviaOption: 0, + trailingTriviaOption: 0 + /* Exclude */ + }; + function A8(e, t, n, i) { + return { pos: XS(e, t, i), end: Ck(e, n, i) }; + } + function XS(e, t, n, i = !1) { + var s, o; + const { leadingTriviaOption: c } = n; + if (c === 0) + return t.getStart(e); + if (c === 3) { + const T = t.getStart(e), k = Hp(T, e); + return q6(t, k) ? k : T; + } + if (c === 2) { + const T = bB(t, e.text); + if (T?.length) + return Hp(T[0].pos, e); + } + const _ = t.getFullStart(), u = t.getStart(e); + if (_ === u) + return u; + const g = Hp(_, e); + if (Hp(u, e) === g) + return c === 1 ? _ : u; + if (i) { + const T = ((s = Eg(e.text, _)) == null ? void 0 : s[0]) || ((o = Sy(e.text, _)) == null ? void 0 : o[0]); + if (T) + return oa( + e.text, + T.end, + /*stopAfterLineBreak*/ + !0, + /*stopAtComments*/ + !0 + ); + } + const h = _ > 0 ? 1 : 0; + let S = Ny(KD(e, g) + h, e); + return S = uwe(e.text, S), Ny(KD(e, S), e); + } + function n_e(e, t, n) { + const { end: i } = t, { trailingTriviaOption: s } = n; + if (s === 2) { + const o = Sy(e.text, i); + if (o) { + const c = KD(e, t.end); + for (const _ of o) { + if (_.kind === 2 || KD(e, _.pos) > c) + break; + if (KD(e, _.end) > c) + return oa( + e.text, + _.end, + /*stopAfterLineBreak*/ + !0, + /*stopAtComments*/ + !0 + ); + } + } + } + } + function Ck(e, t, n) { + var i; + const { end: s } = t, { trailingTriviaOption: o } = n; + if (o === 0) + return s; + if (o === 1) { + const u = Bi(Sy(e.text, s), Eg(e.text, s)), g = (i = u?.[u.length - 1]) == null ? void 0 : i.end; + return g || s; + } + const c = n_e(e, t, n); + if (c) + return c; + const _ = oa( + e.text, + s, + /*stopAfterLineBreak*/ + !0 + ); + return _ !== s && (o === 2 || Cu(e.text.charCodeAt(_ - 1))) ? _ : s; + } + function nG(e, t) { + return !!t && !!e.parent && (t.kind === 28 || t.kind === 27 && e.parent.kind === 211); + } + function nZe(e) { + return yo(e) || Cc(e); + } + var iZe = class uge { + /** Public for tests only. Other callers should use `ChangeTracker.with`. */ + constructor(t, n) { + this.newLineCharacter = t, this.formatContext = n, this.changes = [], this.classesWithNodesInsertedAtStart = /* @__PURE__ */ new Map(), this.deletedNodes = []; + } + static fromContext(t) { + return new uge(Fh(t.host, t.formatContext.options), t.formatContext); + } + static with(t, n) { + const i = uge.fromContext(t); + return n(i), i.getChanges(); + } + pushRaw(t, n) { + E.assertEqual(t.fileName, n.fileName); + for (const i of n.textChanges) + this.changes.push({ + kind: 3, + sourceFile: t, + text: i.newText, + range: D9(i.span) + }); + } + deleteRange(t, n) { + this.changes.push({ kind: 0, sourceFile: t, range: n }); + } + delete(t, n) { + this.deletedNodes.push({ sourceFile: t, node: n }); + } + /** Stop! Consider using `delete` instead, which has logic for deleting nodes from delimited lists. */ + deleteNode(t, n, i = { + leadingTriviaOption: 1 + /* IncludeAll */ + }) { + this.deleteRange(t, A8(t, n, n, i)); + } + deleteNodes(t, n, i = { + leadingTriviaOption: 1 + /* IncludeAll */ + }, s) { + for (const o of n) { + const c = XS(t, o, i, s), _ = Ck(t, o, i); + this.deleteRange(t, { pos: c, end: _ }), s = !!n_e(t, o, i); + } + } + deleteModifier(t, n) { + this.deleteRange(t, { pos: n.getStart(t), end: oa( + t.text, + n.end, + /*stopAfterLineBreak*/ + !0 + ) }); + } + deleteNodeRange(t, n, i, s = { + leadingTriviaOption: 1 + /* IncludeAll */ + }) { + const o = XS(t, n, s), c = Ck(t, i, s); + this.deleteRange(t, { pos: o, end: c }); + } + deleteNodeRangeExcludingEnd(t, n, i, s = { + leadingTriviaOption: 1 + /* IncludeAll */ + }) { + const o = XS(t, n, s), c = i === void 0 ? t.text.length : XS(t, i, s); + this.deleteRange(t, { pos: o, end: c }); + } + replaceRange(t, n, i, s = {}) { + this.changes.push({ kind: 1, sourceFile: t, range: n, options: s, node: i }); + } + replaceNode(t, n, i, s = N8) { + this.replaceRange(t, A8(t, n, n, s), i, s); + } + replaceNodeRange(t, n, i, s, o = N8) { + this.replaceRange(t, A8(t, n, i, o), s, o); + } + replaceRangeWithNodes(t, n, i, s = {}) { + this.changes.push({ kind: 2, sourceFile: t, range: n, options: s, nodes: i }); + } + replaceNodeWithNodes(t, n, i, s = N8) { + this.replaceRangeWithNodes(t, A8(t, n, n, s), i, s); + } + replaceNodeWithText(t, n, i) { + this.replaceRangeWithText(t, A8(t, n, n, N8), i); + } + replaceNodeRangeWithNodes(t, n, i, s, o = N8) { + this.replaceRangeWithNodes(t, A8(t, n, i, o), s, o); + } + nodeHasTrailingComment(t, n, i = N8) { + return !!n_e(t, n, i); + } + nextCommaToken(t, n) { + const i = c2(n, n.parent, t); + return i && i.kind === 28 ? i : void 0; + } + replacePropertyAssignment(t, n, i) { + const s = this.nextCommaToken(t, n) ? "" : "," + this.newLineCharacter; + this.replaceNode(t, n, i, { suffix: s }); + } + insertNodeAt(t, n, i, s = {}) { + this.replaceRange(t, cp(n), i, s); + } + insertNodesAt(t, n, i, s = {}) { + this.replaceRangeWithNodes(t, cp(n), i, s); + } + insertNodeAtTopOfFile(t, n, i) { + this.insertAtTopOfFile(t, n, i); + } + insertNodesAtTopOfFile(t, n, i) { + this.insertAtTopOfFile(t, n, i); + } + insertAtTopOfFile(t, n, i) { + const s = fZe(t), o = { + prefix: s === 0 ? void 0 : this.newLineCharacter, + suffix: (Cu(t.text.charCodeAt(s)) ? "" : this.newLineCharacter) + (i ? this.newLineCharacter : "") + }; + as(n) ? this.insertNodesAt(t, s, n, o) : this.insertNodeAt(t, s, n, o); + } + insertNodesAtEndOfFile(t, n, i) { + this.insertAtEndOfFile(t, n, i); + } + insertAtEndOfFile(t, n, i) { + const s = t.end + 1, o = { + prefix: this.newLineCharacter, + suffix: this.newLineCharacter + (i ? this.newLineCharacter : "") + }; + this.insertNodesAt(t, s, n, o); + } + insertStatementsInNewFile(t, n, i) { + this.newFileChanges || (this.newFileChanges = Fp()), this.newFileChanges.add(t, { oldFile: i, statements: n }); + } + insertFirstParameter(t, n, i) { + const s = Yc(n); + s ? this.insertNodeBefore(t, s, i) : this.insertNodeAt(t, n.pos, i); + } + insertNodeBefore(t, n, i, s = !1, o = {}) { + this.insertNodeAt(t, XS(t, n, o), i, this.getOptionsForInsertNodeBefore(n, i, s)); + } + insertNodesBefore(t, n, i, s = !1, o = {}) { + this.insertNodesAt(t, XS(t, n, o), i, this.getOptionsForInsertNodeBefore(n, Ca(i), s)); + } + insertModifierAt(t, n, i, s = {}) { + this.insertNodeAt(t, n, N.createToken(i), s); + } + insertModifierBefore(t, n, i) { + return this.insertModifierAt(t, i.getStart(t), n, { suffix: " " }); + } + insertCommentBeforeLine(t, n, i, s) { + const o = Ny(n, t), c = Eae(t.text, o), _ = fwe(t, c), u = H6(t, _ ? c : i), g = t.text.slice(o, c), m = `${_ ? "" : this.newLineCharacter}//${s}${this.newLineCharacter}${g}`; + this.insertText(t, u.getStart(t), m); + } + insertJsdocCommentBefore(t, n, i) { + const s = n.getStart(t); + if (n.jsDoc) + for (const _ of n.jsDoc) + this.deleteRange(t, { + pos: Hp(_.getStart(t), t), + end: Ck( + t, + _, + /*options*/ + {} + ) + }); + const o = L9(t.text, s - 1), c = t.text.slice(o, s); + this.insertNodeAt(t, s, i, { suffix: this.newLineCharacter + c }); + } + createJSDocText(t, n) { + const i = ka(n.jsDoc, (o) => gs(o.comment) ? N.createJSDocText(o.comment) : o.comment), s = xg(n.jsDoc); + return s && lp(s.pos, s.end, t) && wr(i) === 0 ? void 0 : N.createNodeArray(xR(i, N.createJSDocText(` +`))); + } + replaceJSDocComment(t, n, i) { + this.insertJsdocCommentBefore(t, sZe(n), N.createJSDocComment(this.createJSDocText(t, n), N.createNodeArray(i))); + } + addJSDocTags(t, n, i) { + const s = KE(n.jsDoc, (c) => c.tags), o = i.filter( + (c) => !s.some((_, u) => { + const g = aZe(_, c); + return g && (s[u] = g), !!g; + }) + ); + this.replaceJSDocComment(t, n, [...s, ...o]); + } + filterJSDocTags(t, n, i) { + this.replaceJSDocComment(t, n, kn(KE(n.jsDoc, (s) => s.tags), i)); + } + replaceRangeWithText(t, n, i) { + this.changes.push({ kind: 3, sourceFile: t, range: n, text: i }); + } + insertText(t, n, i) { + this.replaceRangeWithText(t, cp(n), i); + } + /** Prefer this over replacing a node with another that has a type annotation, as it avoids reformatting the other parts of the node. */ + tryInsertTypeAnnotation(t, n, i) { + let s; + if (Es(n)) { + if (s = Ya(n, 22, t), !s) { + if (!xo(n)) return !1; + s = Ca(n.parameters); + } + } else + s = (n.kind === 261 ? n.exclamationToken : n.questionToken) ?? n.name; + return this.insertNodeAt(t, s.end, i, { prefix: ": " }), !0; + } + tryInsertThisTypeAnnotation(t, n, i) { + const s = Ya(n, 21, t).getStart(t) + 1, o = n.parameters.length ? ", " : ""; + this.insertNodeAt(t, s, i, { prefix: "this: ", suffix: o }); + } + insertTypeParameters(t, n, i) { + const s = (Ya(n, 21, t) || Ca(n.parameters)).getStart(t); + this.insertNodesAt(t, s, i, { prefix: "<", suffix: ">", joiner: ", " }); + } + getOptionsForInsertNodeBefore(t, n, i) { + return Ti(t) || Hc(t) ? { suffix: i ? this.newLineCharacter + this.newLineCharacter : this.newLineCharacter } : ei(t) ? { suffix: ", " } : Ii(t) ? Ii(n) ? { suffix: ", " } : {} : ca(t) && qo(t.parent) || bm(t) ? { suffix: ", " } : Xu(t) ? { suffix: "," + (i ? this.newLineCharacter : " ") } : E.failBadSyntaxKind(t); + } + insertNodeAtConstructorStart(t, n, i) { + const s = Yc(n.body.statements); + !s || !n.body.multiLine ? this.replaceConstructorBody(t, n, [i, ...n.body.statements]) : this.insertNodeBefore(t, s, i); + } + insertNodeAtConstructorStartAfterSuperCall(t, n, i) { + const s = Nn(n.body.statements, (o) => Al(o) && oS(o.expression)); + !s || !n.body.multiLine ? this.replaceConstructorBody(t, n, [...n.body.statements, i]) : this.insertNodeAfter(t, s, i); + } + insertNodeAtConstructorEnd(t, n, i) { + const s = Do(n.body.statements); + !s || !n.body.multiLine ? this.replaceConstructorBody(t, n, [...n.body.statements, i]) : this.insertNodeAfter(t, s, i); + } + replaceConstructorBody(t, n, i) { + this.replaceNode(t, n.body, N.createBlock( + i, + /*multiLine*/ + !0 + )); + } + insertNodeAtEndOfScope(t, n, i) { + const s = XS(t, n.getLastToken(), {}); + this.insertNodeAt(t, s, i, { + prefix: Cu(t.text.charCodeAt(n.getLastToken().pos)) ? this.newLineCharacter : this.newLineCharacter + this.newLineCharacter, + suffix: this.newLineCharacter + }); + } + insertMemberAtStart(t, n, i) { + this.insertNodeAtStartWorker(t, n, i); + } + insertNodeAtObjectStart(t, n, i) { + this.insertNodeAtStartWorker(t, n, i); + } + insertNodeAtStartWorker(t, n, i) { + const s = this.guessIndentationFromExistingMembers(t, n) ?? this.computeIndentationForNewMember(t, n); + this.insertNodeAt(t, iG(n).pos, i, this.getInsertNodeAtStartInsertOptions(t, n, s)); + } + /** + * Tries to guess the indentation from the existing members of a class/interface/object. All members must be on + * new lines and must share the same indentation. + */ + guessIndentationFromExistingMembers(t, n) { + let i, s = n; + for (const o of iG(n)) { + if (M5(s, o, t)) + return; + const c = o.getStart(t), _ = nl.SmartIndenter.findFirstNonWhitespaceColumn(Hp(c, t), c, t, this.formatContext.options); + if (i === void 0) + i = _; + else if (_ !== i) + return; + s = o; + } + return i; + } + computeIndentationForNewMember(t, n) { + const i = n.getStart(t); + return nl.SmartIndenter.findFirstNonWhitespaceColumn(Hp(i, t), i, t, this.formatContext.options) + (this.formatContext.options.indentSize ?? 4); + } + getInsertNodeAtStartInsertOptions(t, n, i) { + const o = iG(n).length === 0, c = !this.classesWithNodesInsertedAtStart.has(Ma(n)); + c && this.classesWithNodesInsertedAtStart.set(Ma(n), { node: n, sourceFile: t }); + const _ = _a(n) && (!ap(t) || !o), u = _a(n) && ap(t) && o && !c; + return { + indentation: i, + prefix: (u ? "," : "") + this.newLineCharacter, + suffix: _ ? "," : Vl(n) && o ? ";" : "" + }; + } + insertNodeAfterComma(t, n, i) { + const s = this.insertNodeAfterWorker(t, this.nextCommaToken(t, n) || n, i); + this.insertNodeAt(t, s, i, this.getInsertNodeAfterOptions(t, n)); + } + insertNodeAfter(t, n, i) { + const s = this.insertNodeAfterWorker(t, n, i); + this.insertNodeAt(t, s, i, this.getInsertNodeAfterOptions(t, n)); + } + insertNodeAtEndOfList(t, n, i) { + this.insertNodeAt(t, n.end, i, { prefix: ", " }); + } + insertNodesAfter(t, n, i) { + const s = this.insertNodeAfterWorker(t, n, Ca(i)); + this.insertNodesAt(t, s, i, this.getInsertNodeAfterOptions(t, n)); + } + insertNodeAfterWorker(t, n, i) { + return pZe(n, i) && t.text.charCodeAt(n.end - 1) !== 59 && this.replaceRange(t, cp(n.end), N.createToken( + 27 + /* SemicolonToken */ + )), Ck(t, n, {}); + } + getInsertNodeAfterOptions(t, n) { + const i = this.getInsertNodeAfterOptionsWorker(n); + return { + ...i, + prefix: n.end === t.end && Ti(n) ? i.prefix ? ` +${i.prefix}` : ` +` : i.prefix + }; + } + getInsertNodeAfterOptionsWorker(t) { + switch (t.kind) { + case 264: + case 268: + return { prefix: this.newLineCharacter, suffix: this.newLineCharacter }; + case 261: + case 11: + case 80: + return { prefix: ", " }; + case 304: + return { suffix: "," + this.newLineCharacter }; + case 95: + return { prefix: " " }; + case 170: + return {}; + default: + return E.assert(Ti(t) || D7(t)), { suffix: this.newLineCharacter }; + } + } + insertName(t, n, i) { + if (E.assert(!n.name), n.kind === 220) { + const s = Ya(n, 39, t), o = Ya(n, 21, t); + o ? (this.insertNodesAt(t, o.getStart(t), [N.createToken( + 100 + /* FunctionKeyword */ + ), N.createIdentifier(i)], { joiner: " " }), Mh(this, t, s)) : (this.insertText(t, Ca(n.parameters).getStart(t), `function ${i}(`), this.replaceRange(t, s, N.createToken( + 22 + /* CloseParenToken */ + ))), n.body.kind !== 242 && (this.insertNodesAt(t, n.body.getStart(t), [N.createToken( + 19 + /* OpenBraceToken */ + ), N.createToken( + 107 + /* ReturnKeyword */ + )], { joiner: " ", suffix: " " }), this.insertNodesAt(t, n.body.end, [N.createToken( + 27 + /* SemicolonToken */ + ), N.createToken( + 20 + /* CloseBraceToken */ + )], { joiner: " " })); + } else { + const s = Ya(n, n.kind === 219 ? 100 : 86, t).end; + this.insertNodeAt(t, s, N.createIdentifier(i), { prefix: " " }); + } + } + insertExportModifier(t, n) { + this.insertText(t, n.getStart(t), "export "); + } + insertImportSpecifierAtIndex(t, n, i, s) { + const o = i.elements[s - 1]; + o ? this.insertNodeInListAfter(t, o, n) : this.insertNodeBefore( + t, + i.elements[0], + n, + !lp(i.elements[0].getStart(), i.parent.parent.getStart(), t) + ); + } + /** + * This function should be used to insert nodes in lists when nodes don't carry separators as the part of the node range, + * i.e. arguments in arguments lists, parameters in parameter lists etc. + * Note that separators are part of the node in statements and class elements. + */ + insertNodeInListAfter(t, n, i, s = nl.SmartIndenter.getContainingList(n, t)) { + if (!s) { + E.fail("node is not a list element"); + return; + } + const o = MC(s, n); + if (o < 0) + return; + const c = n.getEnd(); + if (o !== s.length - 1) { + const _ = vi(t, n.end); + if (_ && nG(n, _)) { + const u = s[o + 1], g = uwe(t.text, u.getFullStart()), m = `${qs(_.kind)}${t.text.substring(_.end, g)}`; + this.insertNodesAt(t, g, [i], { suffix: m }); + } + } else { + const _ = n.getStart(t), u = Hp(_, t); + let g, m = !1; + if (s.length === 1) + g = 28; + else { + const h = pl(n.pos, t); + g = nG(n, h) ? h.kind : 28, m = Hp(s[o - 1].getStart(t), t) !== u; + } + if ((rZe(t.text, n.end) || !lp(s.pos, s.end, t)) && (m = !0), m) { + this.replaceRange(t, cp(c), N.createToken(g)); + const h = nl.SmartIndenter.findFirstNonWhitespaceColumn(u, _, t, this.formatContext.options); + let S = oa( + t.text, + c, + /*stopAfterLineBreak*/ + !0, + /*stopAtComments*/ + !1 + ); + for (; S !== c && Cu(t.text.charCodeAt(S - 1)); ) + S--; + this.replaceRange(t, cp(S), i, { indentation: h, prefix: this.newLineCharacter }); + } else + this.replaceRange(t, cp(c), i, { prefix: `${qs(g)} ` }); + } + } + parenthesizeExpression(t, n) { + this.replaceRange(t, RJ(n), N.createParenthesizedExpression(n)); + } + finishClassesWithNodesInsertedAtStart() { + this.classesWithNodesInsertedAtStart.forEach(({ node: t, sourceFile: n }) => { + const [i, s] = cZe(t, n); + if (i !== void 0 && s !== void 0) { + const o = iG(t).length === 0, c = lp(i, s, n); + o && c && i !== s - 1 && this.deleteRange(n, cp(i, s - 1)), c && this.insertText(n, s - 1, this.newLineCharacter); + } + }); + } + finishDeleteDeclarations() { + const t = /* @__PURE__ */ new Set(); + for (const { sourceFile: n, node: i } of this.deletedNodes) + this.deletedNodes.some((s) => s.sourceFile === n && eae(s.node, i)) || (as(i) ? this.deleteRange(n, jJ(n, i)) : a_e.deleteDeclaration(this, t, n, i)); + t.forEach((n) => { + const i = n.getSourceFile(), s = nl.SmartIndenter.getContainingList(n, i); + if (n !== pa(s)) return; + const o = GI(s, (c) => !t.has(c), s.length - 2); + o !== -1 && this.deleteRange(i, { pos: s[o].end, end: i_e(i, s[o + 1]) }); + }); + } + /** + * Note: after calling this, the TextChanges object must be discarded! + * @param validate only for tests + * The reason we must validate as part of this method is that `getNonFormattedText` changes the node's positions, + * so we can only call this once and can't get the non-formatted text separately. + */ + getChanges(t) { + this.finishDeleteDeclarations(), this.finishClassesWithNodesInsertedAtStart(); + const n = sG.getTextChangesFromChanges(this.changes, this.newLineCharacter, this.formatContext, t); + return this.newFileChanges && this.newFileChanges.forEach((i, s) => { + n.push(sG.newFileChanges(s, i, this.newLineCharacter, this.formatContext)); + }), n; + } + createNewFile(t, n, i) { + this.insertStatementsInNewFile(n, i, t); + } + }; + function sZe(e) { + if (e.kind !== 220) + return e; + const t = e.parent.kind === 173 ? e.parent : e.parent.parent; + return t.jsDoc = e.jsDoc, t; + } + function aZe(e, t) { + if (e.kind === t.kind) + switch (e.kind) { + case 342: { + const n = e, i = t; + return Me(n.name) && Me(i.name) && n.name.escapedText === i.name.escapedText ? N.createJSDocParameterTag( + /*tagName*/ + void 0, + i.name, + /*isBracketed*/ + !1, + i.typeExpression, + i.isNameFirst, + n.comment + ) : void 0; + } + case 343: + return N.createJSDocReturnTag( + /*tagName*/ + void 0, + t.typeExpression, + e.comment + ); + case 345: + return N.createJSDocTypeTag( + /*tagName*/ + void 0, + t.typeExpression, + e.comment + ); + } + } + function i_e(e, t) { + return oa( + e.text, + XS(e, t, { + leadingTriviaOption: 1 + /* IncludeAll */ + }), + /*stopAfterLineBreak*/ + !1, + /*stopAtComments*/ + !0 + ); + } + function oZe(e, t, n, i) { + const s = i_e(e, i); + if (n === void 0 || lp(Ck(e, t, {}), s, e)) + return s; + const o = pl(i.getStart(e), e); + if (nG(t, o)) { + const c = pl(t.getStart(e), e); + if (nG(n, c)) { + const _ = oa( + e.text, + o.getEnd(), + /*stopAfterLineBreak*/ + !0, + /*stopAtComments*/ + !0 + ); + if (lp(c.getStart(e), o.getStart(e), e)) + return Cu(e.text.charCodeAt(_ - 1)) ? _ - 1 : _; + if (Cu(e.text.charCodeAt(_))) + return _; + } + } + return s; + } + function cZe(e, t) { + const n = Ya(e, 19, t), i = Ya(e, 20, t); + return [n?.end, i?.end]; + } + function iG(e) { + return _a(e) ? e.properties : e.members; + } + var sG; + ((e) => { + function t(_, u, g, m) { + return Fi(yC(_, (h) => h.sourceFile.path), (h) => { + const S = h[0].sourceFile, T = X_(h, (D, P) => D.range.pos - P.range.pos || D.range.end - P.range.end); + for (let D = 0; D < T.length - 1; D++) + E.assert(T[D].range.end <= T[D + 1].range.pos, "Changes overlap", () => `${JSON.stringify(T[D].range)} and ${JSON.stringify(T[D + 1].range)}`); + const k = Fi(T, (D) => { + const P = A0(D.range), A = D.kind === 1 ? xr(Vo(D.node)) ?? D.sourceFile : D.kind === 2 ? xr(Vo(D.nodes[0])) ?? D.sourceFile : D.sourceFile, O = s(D, A, S, u, g, m); + if (!(P.length === O.length && Lae(A.text, O, P.start))) + return qA(P, O); + }); + return k.length > 0 ? { fileName: S.fileName, textChanges: k } : void 0; + }); + } + e.getTextChangesFromChanges = t; + function n(_, u, g, m) { + const h = i(K5(_), u, g, m); + return { fileName: _, textChanges: [qA(Kl(0, 0), h)], isNewFile: !0 }; + } + e.newFileChanges = n; + function i(_, u, g, m) { + const h = ka(u, (k) => k.statements.map((D) => D === 4 ? "" : c(D, k.oldFile, g).text)).join(g), S = ek( + "any file name", + h, + { + languageVersion: 99, + jsDocParsingMode: 1 + /* ParseNone */ + }, + /*setParentNodes*/ + !0, + _ + ), T = nl.formatDocument(S, m); + return s_e(h, T) + g; + } + e.newFileChangesWorker = i; + function s(_, u, g, m, h, S) { + var T; + if (_.kind === 0) + return ""; + if (_.kind === 3) + return _.text; + const { options: k = {}, range: { pos: D } } = _, P = (F) => o(F, u, g, D, k, m, h, S), A = _.kind === 2 ? _.nodes.map((F) => bC(P(F), m)).join(((T = _.options) == null ? void 0 : T.joiner) || m) : P(_.node), O = k.indentation !== void 0 || Hp(D, u) === D ? A : A.replace(/^\s+/, ""); + return (k.prefix || "") + O + (!k.suffix || wo(O, k.suffix) ? "" : k.suffix); + } + function o(_, u, g, m, { indentation: h, prefix: S, delta: T }, k, D, P) { + const { node: A, text: O } = c(_, u, k); + P && P(A, O); + const F = G9(D, u), R = h !== void 0 ? h : nl.SmartIndenter.getIndentation(m, g, F, S === k || Hp(m, u) === m); + T === void 0 && (T = nl.SmartIndenter.shouldIndentChildNode(F, _) && F.indentSize || 0); + const B = { + text: O, + getLineAndCharacterOfPosition($) { + return js(this, $); + } + }, U = nl.formatNodeGivenIndentation(A, B, u.languageVariant, R, T, { ...D, options: F }); + return s_e(O, U); + } + function c(_, u, g) { + const m = _we(g), h = n8(g); + return Ky({ + newLine: h, + neverAsciiEscape: !0, + preserveSourceNewlines: !0, + terminateUnterminatedLiterals: !0 + }, m).writeNode(4, _, u, m), { text: m.getText(), node: aG(_) }; + } + e.getNonformattedText = c; + })(sG || (sG = {})); + function s_e(e, t) { + for (let n = t.length - 1; n >= 0; n--) { + const { span: i, newText: s } = t[n]; + e = `${e.substring(0, i.start)}${s}${e.substring(ec(i))}`; + } + return e; + } + function lZe(e) { + return oa(e, 0) === e.length; + } + var uZe = { + ...SA, + factory: NN( + SA.factory.flags | 1, + SA.factory.baseFactory + ) + }; + function aG(e) { + const t = br(e, aG, uZe, _Ze, aG), n = lo(t) ? t : Object.create(t); + return Ad(n, awe(e), owe(e)), n; + } + function _Ze(e, t, n, i, s) { + const o = Ar(e, t, n, i, s); + if (!o) + return o; + E.assert(e); + const c = o === e ? N.createNodeArray(o.slice(0)) : o; + return Ad(c, awe(e), owe(e)), c; + } + function _we(e) { + let t = 0; + const n = nN(e), i = (q) => { + q && t_e(q, t); + }, s = (q) => { + q && r_e(q, t); + }, o = (q) => { + q && t_e(q, t); + }, c = (q) => { + q && r_e(q, t); + }, _ = (q) => { + q && t_e(q, t); + }, u = (q) => { + q && r_e(q, t); + }; + function g(q, be) { + if (be || !lZe(q)) { + t = n.getTextPos(); + let je = 0; + for (; Cg(q.charCodeAt(q.length - je - 1)); ) + je++; + t -= je; + } + } + function m(q) { + n.write(q), g( + q, + /*force*/ + !1 + ); + } + function h(q) { + n.writeComment(q); + } + function S(q) { + n.writeKeyword(q), g( + q, + /*force*/ + !1 + ); + } + function T(q) { + n.writeOperator(q), g( + q, + /*force*/ + !1 + ); + } + function k(q) { + n.writePunctuation(q), g( + q, + /*force*/ + !1 + ); + } + function D(q) { + n.writeTrailingSemicolon(q), g( + q, + /*force*/ + !1 + ); + } + function P(q) { + n.writeParameter(q), g( + q, + /*force*/ + !1 + ); + } + function A(q) { + n.writeProperty(q), g( + q, + /*force*/ + !1 + ); + } + function O(q) { + n.writeSpace(q), g( + q, + /*force*/ + !1 + ); + } + function F(q) { + n.writeStringLiteral(q), g( + q, + /*force*/ + !1 + ); + } + function R(q, be) { + n.writeSymbol(q, be), g( + q, + /*force*/ + !1 + ); + } + function B(q) { + n.writeLine(q); + } + function U() { + n.increaseIndent(); + } + function $() { + n.decreaseIndent(); + } + function W() { + return n.getText(); + } + function _e(q) { + n.rawWrite(q), g( + q, + /*force*/ + !1 + ); + } + function K(q) { + n.writeLiteral(q), g( + q, + /*force*/ + !0 + ); + } + function V() { + return n.getTextPos(); + } + function ae() { + return n.getLine(); + } + function se() { + return n.getColumn(); + } + function ce() { + return n.getIndent(); + } + function fe() { + return n.isAtStartOfLine(); + } + function he() { + n.clear(), t = 0; + } + return { + onBeforeEmitNode: i, + onAfterEmitNode: s, + onBeforeEmitNodeArray: o, + onAfterEmitNodeArray: c, + onBeforeEmitToken: _, + onAfterEmitToken: u, + write: m, + writeComment: h, + writeKeyword: S, + writeOperator: T, + writePunctuation: k, + writeTrailingSemicolon: D, + writeParameter: P, + writeProperty: A, + writeSpace: O, + writeStringLiteral: F, + writeSymbol: R, + writeLine: B, + increaseIndent: U, + decreaseIndent: $, + getText: W, + rawWrite: _e, + writeLiteral: K, + getTextPos: V, + getLine: ae, + getColumn: se, + getIndent: ce, + isAtStartOfLine: fe, + hasTrailingComment: () => n.hasTrailingComment(), + hasTrailingWhitespace: () => n.hasTrailingWhitespace(), + clear: he + }; + } + function fZe(e) { + let t; + for (const g of e.statements) + if (cm(g)) + t = g; + else + break; + let n = 0; + const i = e.text; + if (t) + return n = t.end, u(), n; + const s = m7(i); + s !== void 0 && (n = s.length, u()); + const o = Eg(i, n); + if (!o) return n; + let c, _; + for (const g of o) { + if (g.kind === 3) { + if (U7(i, g.pos)) { + c = { range: g, pinnedOrTripleSlash: !0 }; + continue; + } + } else if (sB(i, g.pos, g.end)) { + c = { range: g, pinnedOrTripleSlash: !0 }; + continue; + } + if (c) { + if (c.pinnedOrTripleSlash) break; + const m = e.getLineAndCharacterOfPosition(g.pos).line, h = e.getLineAndCharacterOfPosition(c.range.end).line; + if (m >= h + 2) break; + } + if (e.statements.length) { + _ === void 0 && (_ = e.getLineAndCharacterOfPosition(e.statements[0].getStart()).line); + const m = e.getLineAndCharacterOfPosition(g.end).line; + if (_ < m + 2) break; + } + c = { range: g, pinnedOrTripleSlash: !1 }; + } + return c && (n = c.range.end, u()), n; + function u() { + if (n < i.length) { + const g = i.charCodeAt(n); + Cu(g) && (n++, n < i.length && g === 13 && i.charCodeAt(n) === 10 && n++); + } + } + } + function fwe(e, t) { + return !P0(e, t) && !_k(e, t) && !AV(e, t) && !aae(e, t); + } + function pZe(e, t) { + return ($u(e) || os(e)) && D7(t) && t.name.kind === 168 || m3(e) && m3(t); + } + var a_e; + ((e) => { + function t(o, c, _, u) { + switch (u.kind) { + case 170: { + const T = u.parent; + xo(T) && T.parameters.length === 1 && !Ya(T, 21, _) ? o.replaceNodeWithText(_, u, "()") : I8(o, c, _, u); + break; + } + case 273: + case 272: + const g = _.imports.length && u === Ca(_.imports).parent || u === Nn(_.statements, px); + Mh(o, _, u, { + leadingTriviaOption: g ? 0 : kf(u) ? 2 : 3 + /* StartLine */ + }); + break; + case 209: + const m = u.parent; + m.kind === 208 && u !== pa(m.elements) ? Mh(o, _, u) : I8(o, c, _, u); + break; + case 261: + s(o, c, _, u); + break; + case 169: + I8(o, c, _, u); + break; + case 277: + const S = u.parent; + S.elements.length === 1 ? i(o, _, S) : I8(o, c, _, u); + break; + case 275: + i(o, _, u); + break; + case 27: + Mh(o, _, u, { + trailingTriviaOption: 0 + /* Exclude */ + }); + break; + case 100: + Mh(o, _, u, { + leadingTriviaOption: 0 + /* Exclude */ + }); + break; + case 264: + case 263: + Mh(o, _, u, { + leadingTriviaOption: kf(u) ? 2 : 3 + /* StartLine */ + }); + break; + default: + u.parent ? ld(u.parent) && u.parent.name === u ? n(o, _, u.parent) : Ps(u.parent) && ms(u.parent.arguments, u) ? I8(o, c, _, u) : Mh(o, _, u) : Mh(o, _, u); + } + } + e.deleteDeclaration = t; + function n(o, c, _) { + if (!_.namedBindings) + Mh(o, c, _.parent); + else { + const u = _.name.getStart(c), g = vi(c, _.name.end); + if (g && g.kind === 28) { + const m = oa( + c.text, + g.end, + /*stopAfterLineBreak*/ + !1, + /*stopAtComments*/ + !0 + ); + o.deleteRange(c, { pos: u, end: m }); + } else + Mh(o, c, _.name); + } + } + function i(o, c, _) { + if (_.parent.name) { + const u = E.checkDefined(vi(c, _.pos - 1)); + o.deleteRange(c, { pos: u.getStart(c), end: _.end }); + } else { + const u = Q1( + _, + 273 + /* ImportDeclaration */ + ); + Mh(o, c, u); + } + } + function s(o, c, _, u) { + const { parent: g } = u; + if (g.kind === 300) { + o.deleteNodeRange(_, Ya(g, 21, _), Ya(g, 22, _)); + return; + } + if (g.declarations.length !== 1) { + I8(o, c, _, u); + return; + } + const m = g.parent; + switch (m.kind) { + case 251: + case 250: + o.replaceNode(_, u, N.createObjectLiteralExpression()); + break; + case 249: + Mh(o, _, g); + break; + case 244: + Mh(o, _, m, { + leadingTriviaOption: kf(m) ? 2 : 3 + /* StartLine */ + }); + break; + default: + E.assertNever(m); + } + } + })(a_e || (a_e = {})); + function Mh(e, t, n, i = { + leadingTriviaOption: 1 + /* IncludeAll */ + }) { + const s = XS(t, n, i), o = Ck(t, n, i); + e.deleteRange(t, { pos: s, end: o }); + } + function I8(e, t, n, i) { + const s = E.checkDefined(nl.SmartIndenter.getContainingList(i, n)), o = MC(s, i); + if (E.assert(o !== -1), s.length === 1) { + Mh(e, n, i); + return; + } + E.assert(!t.has(i), "Deleting a node twice"), t.add(i), e.deleteRange(n, { + pos: i_e(n, i), + end: o === s.length - 1 ? Ck(n, i, {}) : oZe(n, i, s[o - 1], s[o + 1]) + }); + } + var nl = {}; + Na(nl, { + FormattingContext: () => dwe, + FormattingRequestKind: () => pwe, + RuleAction: () => mwe, + RuleFlags: () => gwe, + SmartIndenter: () => wm, + anyContext: () => oG, + createTextRangeWithKind: () => _G, + formatDocument: () => iKe, + formatNodeGivenIndentation: () => _Ke, + formatOnClosingCurly: () => nKe, + formatOnEnter: () => eKe, + formatOnOpeningCurly: () => rKe, + formatOnSemicolon: () => tKe, + formatSelection: () => sKe, + getAllRules: () => hwe, + getFormatContext: () => HZe, + getFormattingScanner: () => o_e, + getIndentationString: () => S_e, + getRangeOfEnclosingComment: () => Wwe + }); + var pwe = /* @__PURE__ */ ((e) => (e[e.FormatDocument = 0] = "FormatDocument", e[e.FormatSelection = 1] = "FormatSelection", e[e.FormatOnEnter = 2] = "FormatOnEnter", e[e.FormatOnSemicolon = 3] = "FormatOnSemicolon", e[e.FormatOnOpeningCurlyBrace = 4] = "FormatOnOpeningCurlyBrace", e[e.FormatOnClosingCurlyBrace = 5] = "FormatOnClosingCurlyBrace", e))(pwe || {}), dwe = class { + constructor(e, t, n) { + this.sourceFile = e, this.formattingRequestKind = t, this.options = n; + } + updateContext(e, t, n, i, s) { + this.currentTokenSpan = E.checkDefined(e), this.currentTokenParent = E.checkDefined(t), this.nextTokenSpan = E.checkDefined(n), this.nextTokenParent = E.checkDefined(i), this.contextNode = E.checkDefined(s), this.contextNodeAllOnSameLine = void 0, this.nextNodeAllOnSameLine = void 0, this.tokensAreOnSameLine = void 0, this.contextNodeBlockIsOnOneLine = void 0, this.nextNodeBlockIsOnOneLine = void 0; + } + ContextNodeAllOnSameLine() { + return this.contextNodeAllOnSameLine === void 0 && (this.contextNodeAllOnSameLine = this.NodeIsOnOneLine(this.contextNode)), this.contextNodeAllOnSameLine; + } + NextNodeAllOnSameLine() { + return this.nextNodeAllOnSameLine === void 0 && (this.nextNodeAllOnSameLine = this.NodeIsOnOneLine(this.nextTokenParent)), this.nextNodeAllOnSameLine; + } + TokensAreOnSameLine() { + if (this.tokensAreOnSameLine === void 0) { + const e = this.sourceFile.getLineAndCharacterOfPosition(this.currentTokenSpan.pos).line, t = this.sourceFile.getLineAndCharacterOfPosition(this.nextTokenSpan.pos).line; + this.tokensAreOnSameLine = e === t; + } + return this.tokensAreOnSameLine; + } + ContextNodeBlockIsOnOneLine() { + return this.contextNodeBlockIsOnOneLine === void 0 && (this.contextNodeBlockIsOnOneLine = this.BlockIsOnOneLine(this.contextNode)), this.contextNodeBlockIsOnOneLine; + } + NextNodeBlockIsOnOneLine() { + return this.nextNodeBlockIsOnOneLine === void 0 && (this.nextNodeBlockIsOnOneLine = this.BlockIsOnOneLine(this.nextTokenParent)), this.nextNodeBlockIsOnOneLine; + } + NodeIsOnOneLine(e) { + const t = this.sourceFile.getLineAndCharacterOfPosition(e.getStart(this.sourceFile)).line, n = this.sourceFile.getLineAndCharacterOfPosition(e.getEnd()).line; + return t === n; + } + BlockIsOnOneLine(e) { + const t = Ya(e, 19, this.sourceFile), n = Ya(e, 20, this.sourceFile); + if (t && n) { + const i = this.sourceFile.getLineAndCharacterOfPosition(t.getEnd()).line, s = this.sourceFile.getLineAndCharacterOfPosition(n.getStart(this.sourceFile)).line; + return i === s; + } + return !1; + } + }, dZe = Dg( + 99, + /*skipTrivia*/ + !1, + 0 + /* Standard */ + ), mZe = Dg( + 99, + /*skipTrivia*/ + !1, + 1 + /* JSX */ + ); + function o_e(e, t, n, i, s) { + const o = t === 1 ? mZe : dZe; + o.setText(e), o.resetTokenState(n); + let c = !0, _, u, g, m, h; + const S = s({ + advance: T, + readTokenInfo: B, + readEOFTokenRange: $, + isOnToken: W, + isOnEOF: _e, + getCurrentLeadingTrivia: () => _, + lastTrailingTriviaWasNewLine: () => c, + skipToEndOf: V, + skipToStartOf: ae, + getTokenFullStart: () => h?.token.pos ?? o.getTokenStart(), + getStartPos: () => h?.token.pos ?? o.getTokenStart() + }); + return h = void 0, o.setText(void 0), S; + function T() { + h = void 0, o.getTokenFullStart() !== n ? c = !!u && pa(u).kind === 4 : o.scan(), _ = void 0, u = void 0; + let ce = o.getTokenFullStart(); + for (; ce < i; ) { + const fe = o.getToken(); + if (!XC(fe)) + break; + o.scan(); + const he = { + pos: ce, + end: o.getTokenFullStart(), + kind: fe + }; + ce = o.getTokenFullStart(), _ = Er(_, he); + } + g = o.getTokenFullStart(); + } + function k(se) { + switch (se.kind) { + case 34: + case 72: + case 73: + case 50: + case 49: + return !0; + } + return !1; + } + function D(se) { + if (se.parent) + switch (se.parent.kind) { + case 292: + case 287: + case 288: + case 286: + return k_(se.kind) || se.kind === 80; + } + return !1; + } + function P(se) { + return Bx(se) || Sm(se) && h?.token.kind === 12; + } + function A(se) { + return se.kind === 14; + } + function O(se) { + return se.kind === 17 || se.kind === 18; + } + function F(se) { + return se.parent && Tm(se.parent) && se.parent.initializer === se; + } + function R(se) { + return se === 44 || se === 69; + } + function B(se) { + E.assert(W()); + const ce = k(se) ? 1 : A(se) ? 2 : O(se) ? 3 : D(se) ? 4 : P(se) ? 5 : F(se) ? 6 : 0; + if (h && ce === m) + return K(h, se); + o.getTokenFullStart() !== g && (E.assert(h !== void 0), o.resetTokenState(g), o.scan()); + let fe = U(se, ce); + const he = _G( + o.getTokenFullStart(), + o.getTokenEnd(), + fe + ); + for (u && (u = void 0); o.getTokenFullStart() < i && (fe = o.scan(), !!XC(fe)); ) { + const q = _G( + o.getTokenFullStart(), + o.getTokenEnd(), + fe + ); + if (u || (u = []), u.push(q), fe === 4) { + o.scan(); + break; + } + } + return h = { leadingTrivia: _, trailingTrivia: u, token: he }, K(h, se); + } + function U(se, ce) { + const fe = o.getToken(); + switch (m = 0, ce) { + case 1: + if (fe === 32) { + m = 1; + const he = o.reScanGreaterToken(); + return E.assert(se.kind === he), he; + } + break; + case 2: + if (R(fe)) { + m = 2; + const he = o.reScanSlashToken(); + return E.assert(se.kind === he), he; + } + break; + case 3: + if (fe === 20) + return m = 3, o.reScanTemplateToken( + /*isTaggedTemplate*/ + !1 + ); + break; + case 4: + return m = 4, o.scanJsxIdentifier(); + case 5: + return m = 5, o.reScanJsxToken( + /*allowMultilineJsxText*/ + !1 + ); + case 6: + return m = 6, o.reScanJsxAttributeValue(); + case 0: + break; + default: + E.assertNever(ce); + } + return fe; + } + function $() { + return E.assert(_e()), _G( + o.getTokenFullStart(), + o.getTokenEnd(), + 1 + /* EndOfFileToken */ + ); + } + function W() { + const se = h ? h.token.kind : o.getToken(); + return se !== 1 && !XC(se); + } + function _e() { + return (h ? h.token.kind : o.getToken()) === 1; + } + function K(se, ce) { + return ix(ce) && se.token.kind !== ce.kind && (se.token.kind = ce.kind), se; + } + function V(se) { + o.resetTokenState(se.end), g = o.getTokenFullStart(), m = void 0, h = void 0, c = !1, _ = void 0, u = void 0; + } + function ae(se) { + o.resetTokenState(se.pos), g = o.getTokenFullStart(), m = void 0, h = void 0, c = !1, _ = void 0, u = void 0; + } + } + var oG = Ge, mwe = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.StopProcessingSpaceActions = 1] = "StopProcessingSpaceActions", e[e.StopProcessingTokenActions = 2] = "StopProcessingTokenActions", e[e.InsertSpace = 4] = "InsertSpace", e[e.InsertNewLine = 8] = "InsertNewLine", e[e.DeleteSpace = 16] = "DeleteSpace", e[e.DeleteToken = 32] = "DeleteToken", e[e.InsertTrailingSemicolon = 64] = "InsertTrailingSemicolon", e[e.StopAction = 3] = "StopAction", e[e.ModifySpaceAction = 28] = "ModifySpaceAction", e[e.ModifyTokenAction = 96] = "ModifyTokenAction", e))(mwe || {}), gwe = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.CanDeleteNewLines = 1] = "CanDeleteNewLines", e))(gwe || {}); + function hwe() { + const e = []; + for (let U = 0; U <= 166; U++) + U !== 1 && e.push(U); + function t(...U) { + return { tokens: e.filter(($) => !U.some((W) => W === $)), isSpecific: !1 }; + } + const n = { tokens: e, isSpecific: !1 }, i = Bw([ + ...e, + 3 + /* MultiLineCommentTrivia */ + ]), s = Bw([ + ...e, + 1 + /* EndOfFileToken */ + ]), o = vwe( + 83, + 166 + /* LastKeyword */ + ), c = vwe( + 30, + 79 + /* LastBinaryOperator */ + ), _ = [ + 103, + 104, + 165, + 130, + 142, + 152 + /* SatisfiesKeyword */ + ], u = [ + 46, + 47, + 55, + 54 + /* ExclamationToken */ + ], g = [ + 9, + 10, + 80, + 21, + 23, + 19, + 110, + 105 + /* NewKeyword */ + ], m = [ + 80, + 21, + 110, + 105 + /* NewKeyword */ + ], h = [ + 80, + 22, + 24, + 105 + /* NewKeyword */ + ], S = [ + 80, + 21, + 110, + 105 + /* NewKeyword */ + ], T = [ + 80, + 22, + 24, + 105 + /* NewKeyword */ + ], k = [ + 2, + 3 + /* MultiLineCommentTrivia */ + ], D = [80, ...JV], P = i, A = Bw([ + 80, + 32, + 3, + 86, + 95, + 102 + /* ImportKeyword */ + ]), O = Bw([ + 22, + 3, + 92, + 113, + 98, + 93, + 85 + /* CatchKeyword */ + ]), F = [ + // Leave comments alone + Wn( + "IgnoreBeforeComment", + n, + k, + oG, + 1 + /* StopProcessingSpaceActions */ + ), + Wn( + "IgnoreAfterLineComment", + 2, + n, + oG, + 1 + /* StopProcessingSpaceActions */ + ), + Wn( + "NotSpaceBeforeColon", + n, + 59, + [Oi, RL, Twe], + 16 + /* DeleteSpace */ + ), + Wn( + "SpaceAfterColon", + 59, + n, + [Oi, RL, IZe], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBeforeQuestionMark", + n, + 58, + [Oi, RL, Twe], + 16 + /* DeleteSpace */ + ), + // insert space after '?' only when it is used in conditional operator + Wn( + "SpaceAfterQuestionMarkInConditionalOperator", + 58, + n, + [Oi, vZe], + 4 + /* InsertSpace */ + ), + // in other cases there should be no space between '?' and next token + Wn( + "NoSpaceAfterQuestionMark", + 58, + n, + [Oi, yZe], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceBeforeDot", + n, + [ + 25, + 29 + /* QuestionDotToken */ + ], + [Oi, qZe], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceAfterDot", + [ + 25, + 29 + /* QuestionDotToken */ + ], + n, + [Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceBetweenImportParenInImportType", + 102, + 21, + [Oi, NZe], + 16 + /* DeleteSpace */ + ), + // Special handling of unary operators. + // Prefix operators generally shouldn't have a space between + // them and their target unary expression. + Wn( + "NoSpaceAfterUnaryPrefixOperator", + u, + g, + [Oi, RL], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceAfterUnaryPreincrementOperator", + 46, + m, + [Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceAfterUnaryPredecrementOperator", + 47, + S, + [Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceBeforeUnaryPostincrementOperator", + h, + 46, + [Oi, jwe], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceBeforeUnaryPostdecrementOperator", + T, + 47, + [Oi, jwe], + 16 + /* DeleteSpace */ + ), + // More unary operator special-casing. + // DevDiv 181814: Be careful when removing leading whitespace + // around unary operators. Examples: + // 1 - -2 --X--> 1--2 + // a + ++b --X--> a+++b + Wn( + "SpaceAfterPostincrementWhenFollowedByAdd", + 46, + 40, + [Oi, i1], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceAfterAddWhenFollowedByUnaryPlus", + 40, + 40, + [Oi, i1], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceAfterAddWhenFollowedByPreincrement", + 40, + 46, + [Oi, i1], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceAfterPostdecrementWhenFollowedBySubtract", + 47, + 41, + [Oi, i1], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceAfterSubtractWhenFollowedByUnaryMinus", + 41, + 41, + [Oi, i1], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceAfterSubtractWhenFollowedByPredecrement", + 41, + 47, + [Oi, i1], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceAfterCloseBrace", + 20, + [ + 28, + 27 + /* SemicolonToken */ + ], + [Oi], + 16 + /* DeleteSpace */ + ), + // For functions and control block place } on a new line [multi-line rule] + Wn( + "NewLineBeforeCloseBraceInBlockContext", + i, + 20, + [kwe], + 8 + /* InsertNewLine */ + ), + // Space/new line after }. + Wn( + "SpaceAfterCloseBrace", + 20, + t( + 22 + /* CloseParenToken */ + ), + [Oi, TZe], + 4 + /* InsertSpace */ + ), + // Special case for (}, else) and (}, while) since else & while tokens are not part of the tree which makes SpaceAfterCloseBrace rule not applied + // Also should not apply to }) + Wn( + "SpaceBetweenCloseBraceAndElse", + 20, + 93, + [Oi], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceBetweenCloseBraceAndWhile", + 20, + 117, + [Oi], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBetweenEmptyBraceBrackets", + 19, + 20, + [Oi, Nwe], + 16 + /* DeleteSpace */ + ), + // Add a space after control dec context if the next character is an open bracket ex: 'if (false)[a, b] = [1, 2];' -> 'if (false) [a, b] = [1, 2];' + Wn( + "SpaceAfterConditionalClosingParen", + 22, + 23, + [jL], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBetweenFunctionKeywordAndStar", + 100, + 42, + [Dwe], + 16 + /* DeleteSpace */ + ), + Wn( + "SpaceAfterStarInGeneratorDeclaration", + 42, + 80, + [Dwe], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceAfterFunctionInFuncDecl", + 100, + n, + [QS], + 4 + /* InsertSpace */ + ), + // Insert new line after { and before } in multi-line contexts. + Wn( + "NewLineAfterOpenBraceInBlockContext", + 19, + n, + [kwe], + 8 + /* InsertNewLine */ + ), + // For get/set members, we check for (identifier,identifier) since get/set don't have tokens and they are represented as just an identifier token. + // Though, we do extra check on the context to make sure we are dealing with get/set node. Example: + // get x() {} + // set x(val) {} + Wn( + "SpaceAfterGetSetInMember", + [ + 139, + 153 + /* SetKeyword */ + ], + 80, + [QS], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBetweenYieldKeywordAndStar", + 127, + 42, + [Oi, Rwe], + 16 + /* DeleteSpace */ + ), + Wn( + "SpaceBetweenYieldOrYieldStarAndOperand", + [ + 127, + 42 + /* AsteriskToken */ + ], + n, + [Oi, Rwe], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBetweenReturnAndSemicolon", + 107, + 27, + [Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "SpaceAfterCertainKeywords", + [ + 115, + 111, + 105, + 91, + 107, + 114, + 135 + /* AwaitKeyword */ + ], + n, + [Oi], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceAfterLetConstInVariableDeclaration", + [ + 121, + 87 + /* ConstKeyword */ + ], + n, + [Oi, LZe], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBeforeOpenParenInFuncCall", + n, + 21, + [Oi, CZe, EZe], + 16 + /* DeleteSpace */ + ), + // Special case for binary operators (that are keywords). For these we have to add a space and shouldn't follow any user options. + Wn( + "SpaceBeforeBinaryKeywordOperator", + n, + _, + [Oi, i1], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceAfterBinaryKeywordOperator", + _, + n, + [Oi, i1], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceAfterVoidOperator", + 116, + n, + [Oi, JZe], + 4 + /* InsertSpace */ + ), + // Async-await + Wn( + "SpaceBetweenAsyncAndOpenParen", + 134, + 21, + [PZe, Oi], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceBetweenAsyncAndFunctionKeyword", + 134, + [ + 100, + 80 + /* Identifier */ + ], + [Oi], + 4 + /* InsertSpace */ + ), + // Template string + Wn( + "NoSpaceBetweenTagAndTemplateString", + [ + 80, + 22 + /* CloseParenToken */ + ], + [ + 15, + 16 + /* TemplateHead */ + ], + [Oi], + 16 + /* DeleteSpace */ + ), + // JSX opening elements + Wn( + "SpaceBeforeJsxAttribute", + n, + 80, + [AZe, Oi], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceBeforeSlashInJsxOpeningElement", + n, + 44, + [Owe, Oi], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBeforeGreaterThanTokenInJsxOpeningElement", + 44, + 32, + [Owe, Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceBeforeEqualInJsxAttribute", + n, + 64, + [Iwe, Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceAfterEqualInJsxAttribute", + 64, + n, + [Iwe, Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceBeforeJsxNamespaceColon", + 80, + 59, + [Fwe], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceAfterJsxNamespaceColon", + 59, + 80, + [Fwe], + 16 + /* DeleteSpace */ + ), + // TypeScript-specific rules + // Use of module as a function call. e.g.: import m2 = module("m2"); + Wn( + "NoSpaceAfterModuleImport", + [ + 144, + 149 + /* RequireKeyword */ + ], + 21, + [Oi], + 16 + /* DeleteSpace */ + ), + // Add a space around certain TypeScript keywords + Wn( + "SpaceAfterCertainTypeScriptKeywords", + [ + 128, + 129, + 86, + 138, + 90, + 94, + 95, + 96, + 139, + 119, + 102, + 120, + 144, + 145, + 123, + 125, + 124, + 148, + 153, + 126, + 156, + 161, + 143, + 140 + /* InferKeyword */ + ], + n, + [Oi], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceBeforeCertainTypeScriptKeywords", + n, + [ + 96, + 119, + 161 + /* FromKeyword */ + ], + [Oi], + 4 + /* InsertSpace */ + ), + // Treat string literals in module names as identifiers, and add a space between the literal and the opening Brace braces, e.g.: module "m2" { + Wn( + "SpaceAfterModuleName", + 11, + 19, + [MZe], + 4 + /* InsertSpace */ + ), + // Lambda expressions + Wn( + "SpaceBeforeArrow", + n, + 39, + [Oi], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceAfterArrow", + 39, + n, + [Oi], + 4 + /* InsertSpace */ + ), + // Optional parameters and let args + Wn( + "NoSpaceAfterEllipsis", + 26, + 80, + [Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceAfterOptionalParameters", + 58, + [ + 22, + 28 + /* CommaToken */ + ], + [Oi, RL], + 16 + /* DeleteSpace */ + ), + // Remove spaces in empty interface literals. e.g.: x: {} + Wn( + "NoSpaceBetweenEmptyInterfaceBraceBrackets", + 19, + 20, + [Oi, RZe], + 16 + /* DeleteSpace */ + ), + // generics and type assertions + Wn( + "NoSpaceBeforeOpenAngularBracket", + D, + 30, + [Oi, BL], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceBetweenCloseParenAndAngularBracket", + 22, + 30, + [Oi, BL], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceAfterOpenAngularBracket", + 30, + n, + [Oi, BL], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceBeforeCloseAngularBracket", + n, + 32, + [Oi, BL], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceAfterCloseAngularBracket", + 32, + [ + 21, + 23, + 32, + 28 + /* CommaToken */ + ], + [ + Oi, + BL, + SZe, + /*To prevent an interference with the SpaceBeforeOpenParenInFuncDecl rule*/ + BZe + ], + 16 + /* DeleteSpace */ + ), + // decorators + Wn( + "SpaceBeforeAt", + [ + 22, + 80 + /* Identifier */ + ], + 60, + [Oi], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceAfterAt", + 60, + n, + [Oi], + 16 + /* DeleteSpace */ + ), + // Insert space after @ in decorator + Wn( + "SpaceAfterDecorator", + n, + [ + 128, + 80, + 95, + 90, + 86, + 126, + 125, + 123, + 124, + 139, + 153, + 23, + 42 + /* AsteriskToken */ + ], + [OZe], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBeforeNonNullAssertionOperator", + n, + 54, + [Oi, zZe], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceAfterNewKeywordOnConstructorSignature", + 105, + 21, + [Oi, jZe], + 16 + /* DeleteSpace */ + ), + Wn( + "SpaceLessThanAndNonJSXTypeAnnotation", + 30, + 30, + [Oi], + 4 + /* InsertSpace */ + ) + ], R = [ + // Treat constructor as an identifier in a function declaration, and remove spaces between constructor and following left parentheses + Wn( + "SpaceAfterConstructor", + 137, + 21, + [Jf("insertSpaceAfterConstructor"), Oi], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceAfterConstructor", + 137, + 21, + [Dm("insertSpaceAfterConstructor"), Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "SpaceAfterComma", + 28, + n, + [Jf("insertSpaceAfterCommaDelimiter"), Oi, d_e, DZe, wZe], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceAfterComma", + 28, + n, + [Dm("insertSpaceAfterCommaDelimiter"), Oi, d_e], + 16 + /* DeleteSpace */ + ), + // Insert space after function keyword for anonymous functions + Wn( + "SpaceAfterAnonymousFunctionKeyword", + [ + 100, + 42 + /* AsteriskToken */ + ], + 21, + [Jf("insertSpaceAfterFunctionKeywordForAnonymousFunctions"), QS], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceAfterAnonymousFunctionKeyword", + [ + 100, + 42 + /* AsteriskToken */ + ], + 21, + [Dm("insertSpaceAfterFunctionKeywordForAnonymousFunctions"), QS], + 16 + /* DeleteSpace */ + ), + // Insert space after keywords in control flow statements + Wn( + "SpaceAfterKeywordInControl", + o, + 21, + [Jf("insertSpaceAfterKeywordsInControlFlowStatements"), jL], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceAfterKeywordInControl", + o, + 21, + [Dm("insertSpaceAfterKeywordsInControlFlowStatements"), jL], + 16 + /* DeleteSpace */ + ), + // Insert space after opening and before closing nonempty parenthesis + Wn( + "SpaceAfterOpenParen", + 21, + n, + [Jf("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), Oi], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceBeforeCloseParen", + n, + 22, + [Jf("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), Oi], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceBetweenOpenParens", + 21, + 21, + [Jf("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), Oi], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBetweenParens", + 21, + 22, + [Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceAfterOpenParen", + 21, + n, + [Dm("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceBeforeCloseParen", + n, + 22, + [Dm("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), Oi], + 16 + /* DeleteSpace */ + ), + // Insert space after opening and before closing nonempty brackets + Wn( + "SpaceAfterOpenBracket", + 23, + n, + [Jf("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), Oi], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceBeforeCloseBracket", + n, + 24, + [Jf("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), Oi], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBetweenBrackets", + 23, + 24, + [Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceAfterOpenBracket", + 23, + n, + [Dm("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceBeforeCloseBracket", + n, + 24, + [Dm("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), Oi], + 16 + /* DeleteSpace */ + ), + // Insert a space after { and before } in single-line contexts, but remove space from empty object literals {}. + Wn( + "SpaceAfterOpenBrace", + 19, + n, + [Swe("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), xwe], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceBeforeCloseBrace", + n, + 20, + [Swe("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), xwe], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBetweenEmptyBraceBrackets", + 19, + 20, + [Oi, Nwe], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceAfterOpenBrace", + 19, + n, + [c_e("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceBeforeCloseBrace", + n, + 20, + [c_e("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), Oi], + 16 + /* DeleteSpace */ + ), + // Insert a space after opening and before closing empty brace brackets + Wn( + "SpaceBetweenEmptyBraceBrackets", + 19, + 20, + [Jf("insertSpaceAfterOpeningAndBeforeClosingEmptyBraces")], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBetweenEmptyBraceBrackets", + 19, + 20, + [c_e("insertSpaceAfterOpeningAndBeforeClosingEmptyBraces"), Oi], + 16 + /* DeleteSpace */ + ), + // Insert space after opening and before closing template string braces + Wn( + "SpaceAfterTemplateHeadAndMiddle", + [ + 16, + 17 + /* TemplateMiddle */ + ], + n, + [Jf("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), Awe], + 4, + 1 + /* CanDeleteNewLines */ + ), + Wn( + "SpaceBeforeTemplateMiddleAndTail", + n, + [ + 17, + 18 + /* TemplateTail */ + ], + [Jf("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), Oi], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceAfterTemplateHeadAndMiddle", + [ + 16, + 17 + /* TemplateMiddle */ + ], + n, + [Dm("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), Awe], + 16, + 1 + /* CanDeleteNewLines */ + ), + Wn( + "NoSpaceBeforeTemplateMiddleAndTail", + n, + [ + 17, + 18 + /* TemplateTail */ + ], + [Dm("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), Oi], + 16 + /* DeleteSpace */ + ), + // No space after { and before } in JSX expression + Wn( + "SpaceAfterOpenBraceInJsxExpression", + 19, + n, + [Jf("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), Oi, lG], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceBeforeCloseBraceInJsxExpression", + n, + 20, + [Jf("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), Oi, lG], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceAfterOpenBraceInJsxExpression", + 19, + n, + [Dm("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), Oi, lG], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceBeforeCloseBraceInJsxExpression", + n, + 20, + [Dm("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), Oi, lG], + 16 + /* DeleteSpace */ + ), + // Insert space after semicolon in for statement + Wn( + "SpaceAfterSemicolonInFor", + 27, + n, + [Jf("insertSpaceAfterSemicolonInForStatements"), Oi, u_e], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceAfterSemicolonInFor", + 27, + n, + [Dm("insertSpaceAfterSemicolonInForStatements"), Oi, u_e], + 16 + /* DeleteSpace */ + ), + // Insert space before and after binary operators + Wn( + "SpaceBeforeBinaryOperator", + n, + c, + [Jf("insertSpaceBeforeAndAfterBinaryOperators"), Oi, i1], + 4 + /* InsertSpace */ + ), + Wn( + "SpaceAfterBinaryOperator", + c, + n, + [Jf("insertSpaceBeforeAndAfterBinaryOperators"), Oi, i1], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBeforeBinaryOperator", + n, + c, + [Dm("insertSpaceBeforeAndAfterBinaryOperators"), Oi, i1], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceAfterBinaryOperator", + c, + n, + [Dm("insertSpaceBeforeAndAfterBinaryOperators"), Oi, i1], + 16 + /* DeleteSpace */ + ), + Wn( + "SpaceBeforeOpenParenInFuncDecl", + n, + 21, + [Jf("insertSpaceBeforeFunctionParenthesis"), Oi, QS], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBeforeOpenParenInFuncDecl", + n, + 21, + [Dm("insertSpaceBeforeFunctionParenthesis"), Oi, QS], + 16 + /* DeleteSpace */ + ), + // Open Brace braces after control block + Wn( + "NewLineBeforeOpenBraceInControl", + O, + 19, + [Jf("placeOpenBraceOnNewLineForControlBlocks"), jL, p_e], + 8, + 1 + /* CanDeleteNewLines */ + ), + // Open Brace braces after function + // TypeScript: Function can have return types, which can be made of tons of different token kinds + Wn( + "NewLineBeforeOpenBraceInFunction", + P, + 19, + [Jf("placeOpenBraceOnNewLineForFunctions"), QS, p_e], + 8, + 1 + /* CanDeleteNewLines */ + ), + // Open Brace braces after TypeScript module/class/interface + Wn( + "NewLineBeforeOpenBraceInTypeScriptDeclWithBlock", + A, + 19, + [Jf("placeOpenBraceOnNewLineForFunctions"), wwe, p_e], + 8, + 1 + /* CanDeleteNewLines */ + ), + Wn( + "SpaceAfterTypeAssertion", + 32, + n, + [Jf("insertSpaceAfterTypeAssertion"), Oi, g_e], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceAfterTypeAssertion", + 32, + n, + [Dm("insertSpaceAfterTypeAssertion"), Oi, g_e], + 16 + /* DeleteSpace */ + ), + Wn( + "SpaceBeforeTypeAnnotation", + n, + [ + 58, + 59 + /* ColonToken */ + ], + [Jf("insertSpaceBeforeTypeAnnotation"), Oi, __e], + 4 + /* InsertSpace */ + ), + Wn( + "NoSpaceBeforeTypeAnnotation", + n, + [ + 58, + 59 + /* ColonToken */ + ], + [Dm("insertSpaceBeforeTypeAnnotation"), Oi, __e], + 16 + /* DeleteSpace */ + ), + Wn( + "NoOptionalSemicolon", + 27, + s, + [bwe( + "semicolons", + "remove" + /* Remove */ + ), UZe], + 32 + /* DeleteToken */ + ), + Wn( + "OptionalSemicolon", + n, + s, + [bwe( + "semicolons", + "insert" + /* Insert */ + ), VZe], + 64 + /* InsertTrailingSemicolon */ + ) + ], B = [ + // Space after keyword but not before ; or : or ? + Wn( + "NoSpaceBeforeSemicolon", + n, + 27, + [Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "SpaceBeforeOpenBraceInControl", + O, + 19, + [l_e("placeOpenBraceOnNewLineForControlBlocks"), jL, m_e, f_e], + 4, + 1 + /* CanDeleteNewLines */ + ), + Wn( + "SpaceBeforeOpenBraceInFunction", + P, + 19, + [l_e("placeOpenBraceOnNewLineForFunctions"), QS, cG, m_e, f_e], + 4, + 1 + /* CanDeleteNewLines */ + ), + Wn( + "SpaceBeforeOpenBraceInTypeScriptDeclWithBlock", + A, + 19, + [l_e("placeOpenBraceOnNewLineForFunctions"), wwe, m_e, f_e], + 4, + 1 + /* CanDeleteNewLines */ + ), + Wn( + "NoSpaceBeforeComma", + n, + 28, + [Oi], + 16 + /* DeleteSpace */ + ), + // No space before and after indexer `x[]` + Wn( + "NoSpaceBeforeOpenBracket", + t( + 134, + 84 + /* CaseKeyword */ + ), + 23, + [Oi], + 16 + /* DeleteSpace */ + ), + Wn( + "NoSpaceAfterCloseBracket", + 24, + n, + [Oi, FZe], + 16 + /* DeleteSpace */ + ), + Wn( + "SpaceAfterSemicolon", + 27, + n, + [Oi], + 4 + /* InsertSpace */ + ), + // Remove extra space between for and await + Wn( + "SpaceBetweenForAndAwaitKeyword", + 99, + 135, + [Oi], + 4 + /* InsertSpace */ + ), + // Remove extra spaces between ... and type name in tuple spread + Wn( + "SpaceBetweenDotDotDotAndTypeName", + 26, + D, + [Oi], + 16 + /* DeleteSpace */ + ), + // Add a space between statements. All keywords except (do,else,case) has open/close parens after them. + // So, we have a rule to add a space for [),Any], [do,Any], [else,Any], and [case,Any] + Wn( + "SpaceBetweenStatements", + [ + 22, + 92, + 93, + 84 + /* CaseKeyword */ + ], + n, + [Oi, d_e, gZe], + 4 + /* InsertSpace */ + ), + // This low-pri rule takes care of "try {", "catch {" and "finally {" in case the rule SpaceBeforeOpenBraceInControl didn't execute on FormatOnEnter. + Wn( + "SpaceAfterTryCatchFinally", + [ + 113, + 85, + 98 + /* FinallyKeyword */ + ], + 19, + [Oi], + 4 + /* InsertSpace */ + ) + ]; + return [ + ...F, + ...R, + ...B + ]; + } + function Wn(e, t, n, i, s, o = 0) { + return { leftTokenRange: ywe(t), rightTokenRange: ywe(n), rule: { debugName: e, context: i, action: s, flags: o } }; + } + function Bw(e) { + return { tokens: e, isSpecific: !0 }; + } + function ywe(e) { + return typeof e == "number" ? Bw([e]) : as(e) ? Bw(e) : e; + } + function vwe(e, t, n = []) { + const i = []; + for (let s = e; s <= t; s++) + ms(n, s) || i.push(s); + return Bw(i); + } + function bwe(e, t) { + return (n) => n.options && n.options[e] === t; + } + function Jf(e) { + return (t) => t.options && eo(t.options, e) && !!t.options[e]; + } + function c_e(e) { + return (t) => t.options && eo(t.options, e) && !t.options[e]; + } + function Dm(e) { + return (t) => !t.options || !eo(t.options, e) || !t.options[e]; + } + function l_e(e) { + return (t) => !t.options || !eo(t.options, e) || !t.options[e] || t.TokensAreOnSameLine(); + } + function Swe(e) { + return (t) => !t.options || !eo(t.options, e) || !!t.options[e]; + } + function u_e(e) { + return e.contextNode.kind === 249; + } + function gZe(e) { + return !u_e(e); + } + function i1(e) { + switch (e.contextNode.kind) { + case 227: + return e.contextNode.operatorToken.kind !== 28; + case 228: + case 195: + case 235: + case 282: + case 277: + case 183: + case 193: + case 194: + case 239: + return !0; + // equals in binding elements: function foo([[x, y] = [1, 2]]) + case 209: + // equals in type X = ... + // falls through + case 266: + // equal in import a = module('a'); + // falls through + case 272: + // equal in export = 1 + // falls through + case 278: + // equal in let a = 0 + // falls through + case 261: + // equal in p = 0 + // falls through + case 170: + case 307: + case 173: + case 172: + return e.currentTokenSpan.kind === 64 || e.nextTokenSpan.kind === 64; + // "in" keyword in for (let x in []) { } + case 250: + // "in" keyword in [P in keyof T]: T[P] + // falls through + case 169: + return e.currentTokenSpan.kind === 103 || e.nextTokenSpan.kind === 103 || e.currentTokenSpan.kind === 64 || e.nextTokenSpan.kind === 64; + // Technically, "of" is not a binary operator, but format it the same way as "in" + case 251: + return e.currentTokenSpan.kind === 165 || e.nextTokenSpan.kind === 165; + } + return !1; + } + function RL(e) { + return !i1(e); + } + function Twe(e) { + return !__e(e); + } + function __e(e) { + const t = e.contextNode.kind; + return t === 173 || t === 172 || t === 170 || t === 261 || sx(t); + } + function hZe(e) { + return os(e.contextNode) && e.contextNode.questionToken; + } + function yZe(e) { + return !hZe(e); + } + function vZe(e) { + return e.contextNode.kind === 228 || e.contextNode.kind === 195; + } + function f_e(e) { + return e.TokensAreOnSameLine() || cG(e); + } + function xwe(e) { + return e.contextNode.kind === 207 || e.contextNode.kind === 201 || bZe(e); + } + function p_e(e) { + return cG(e) && !(e.NextNodeAllOnSameLine() || e.NextNodeBlockIsOnOneLine()); + } + function kwe(e) { + return Cwe(e) && !(e.ContextNodeAllOnSameLine() || e.ContextNodeBlockIsOnOneLine()); + } + function bZe(e) { + return Cwe(e) && (e.ContextNodeAllOnSameLine() || e.ContextNodeBlockIsOnOneLine()); + } + function Cwe(e) { + return Ewe(e.contextNode); + } + function cG(e) { + return Ewe(e.nextTokenParent); + } + function Ewe(e) { + if (Pwe(e)) + return !0; + switch (e.kind) { + case 242: + case 270: + case 211: + case 269: + return !0; + } + return !1; + } + function QS(e) { + switch (e.contextNode.kind) { + case 263: + case 175: + case 174: + // case SyntaxKind.MemberFunctionDeclaration: + // falls through + case 178: + case 179: + // case SyntaxKind.MethodSignature: + // falls through + case 180: + case 219: + case 177: + case 220: + // case SyntaxKind.ConstructorDeclaration: + // case SyntaxKind.SimpleArrowFunctionExpression: + // case SyntaxKind.ParenthesizedArrowFunctionExpression: + // falls through + case 265: + return !0; + } + return !1; + } + function SZe(e) { + return !QS(e); + } + function Dwe(e) { + return e.contextNode.kind === 263 || e.contextNode.kind === 219; + } + function wwe(e) { + return Pwe(e.contextNode); + } + function Pwe(e) { + switch (e.kind) { + case 264: + case 232: + case 265: + case 267: + case 188: + case 268: + case 279: + case 280: + case 273: + case 276: + return !0; + } + return !1; + } + function TZe(e) { + switch (e.currentTokenParent.kind) { + case 264: + case 268: + case 267: + case 300: + case 269: + case 256: + return !0; + case 242: { + const t = e.currentTokenParent.parent; + if (!t || t.kind !== 220 && t.kind !== 219) + return !0; + } + } + return !1; + } + function jL(e) { + switch (e.contextNode.kind) { + case 246: + case 256: + case 249: + case 250: + case 251: + case 248: + case 259: + case 247: + case 255: + // TODO + // case SyntaxKind.ElseClause: + // falls through + case 300: + return !0; + default: + return !1; + } + } + function Nwe(e) { + return e.contextNode.kind === 211; + } + function xZe(e) { + return e.contextNode.kind === 214; + } + function kZe(e) { + return e.contextNode.kind === 215; + } + function CZe(e) { + return xZe(e) || kZe(e); + } + function EZe(e) { + return e.currentTokenSpan.kind !== 28; + } + function DZe(e) { + return e.nextTokenSpan.kind !== 24; + } + function wZe(e) { + return e.nextTokenSpan.kind !== 22; + } + function PZe(e) { + return e.contextNode.kind === 220; + } + function NZe(e) { + return e.contextNode.kind === 206; + } + function Oi(e) { + return e.TokensAreOnSameLine() && e.contextNode.kind !== 12; + } + function Awe(e) { + return e.contextNode.kind !== 12; + } + function d_e(e) { + return e.contextNode.kind !== 285 && e.contextNode.kind !== 289; + } + function lG(e) { + return e.contextNode.kind === 295 || e.contextNode.kind === 294; + } + function AZe(e) { + return e.nextTokenParent.kind === 292 || e.nextTokenParent.kind === 296 && e.nextTokenParent.parent.kind === 292; + } + function Iwe(e) { + return e.contextNode.kind === 292; + } + function IZe(e) { + return e.nextTokenParent.kind !== 296; + } + function Fwe(e) { + return e.nextTokenParent.kind === 296; + } + function Owe(e) { + return e.contextNode.kind === 286; + } + function FZe(e) { + return !QS(e) && !cG(e); + } + function OZe(e) { + return e.TokensAreOnSameLine() && Ff(e.contextNode) && Lwe(e.currentTokenParent) && !Lwe(e.nextTokenParent); + } + function Lwe(e) { + for (; e && ut(e); ) + e = e.parent; + return e && e.kind === 171; + } + function LZe(e) { + return e.currentTokenParent.kind === 262 && e.currentTokenParent.getStart(e.sourceFile) === e.currentTokenSpan.pos; + } + function m_e(e) { + return e.formattingRequestKind !== 2; + } + function MZe(e) { + return e.contextNode.kind === 268; + } + function RZe(e) { + return e.contextNode.kind === 188; + } + function jZe(e) { + return e.contextNode.kind === 181; + } + function Mwe(e, t) { + if (e.kind !== 30 && e.kind !== 32) + return !1; + switch (t.kind) { + case 184: + case 217: + case 266: + case 264: + case 232: + case 265: + case 263: + case 219: + case 220: + case 175: + case 174: + case 180: + case 181: + case 214: + case 215: + case 234: + return !0; + default: + return !1; + } + } + function BL(e) { + return Mwe(e.currentTokenSpan, e.currentTokenParent) || Mwe(e.nextTokenSpan, e.nextTokenParent); + } + function g_e(e) { + return e.contextNode.kind === 217; + } + function BZe(e) { + return !g_e(e); + } + function JZe(e) { + return e.currentTokenSpan.kind === 116 && e.currentTokenParent.kind === 223; + } + function Rwe(e) { + return e.contextNode.kind === 230 && e.contextNode.expression !== void 0; + } + function zZe(e) { + return e.contextNode.kind === 236; + } + function jwe(e) { + return !WZe(e); + } + function WZe(e) { + switch (e.contextNode.kind) { + case 246: + case 249: + case 250: + case 251: + case 247: + case 248: + return !0; + default: + return !1; + } + } + function UZe(e) { + let t = e.nextTokenSpan.kind, n = e.nextTokenSpan.pos; + if (XC(t)) { + const o = e.nextTokenParent === e.currentTokenParent ? c2( + e.currentTokenParent, + dr(e.currentTokenParent, (c) => !c.parent), + e.sourceFile + ) : e.nextTokenParent.getFirstToken(e.sourceFile); + if (!o) + return !0; + t = o.kind, n = o.getStart(e.sourceFile); + } + const i = e.sourceFile.getLineAndCharacterOfPosition(e.currentTokenSpan.pos).line, s = e.sourceFile.getLineAndCharacterOfPosition(n).line; + return i === s ? t === 20 || t === 1 : t === 27 && e.currentTokenSpan.kind === 27 ? !0 : t === 241 || t === 27 ? !1 : e.contextNode.kind === 265 || e.contextNode.kind === 266 ? !$u(e.currentTokenParent) || !!e.currentTokenParent.type || t !== 21 : os(e.currentTokenParent) ? !e.currentTokenParent.initializer : e.currentTokenParent.kind !== 249 && e.currentTokenParent.kind !== 243 && e.currentTokenParent.kind !== 241 && t !== 23 && t !== 21 && t !== 40 && t !== 41 && t !== 44 && t !== 14 && t !== 28 && t !== 229 && t !== 16 && t !== 15 && t !== 25; + } + function VZe(e) { + return B9(e.currentTokenSpan.end, e.currentTokenParent, e.sourceFile); + } + function qZe(e) { + return !wn(e.contextNode) || !E_(e.contextNode.expression) || e.contextNode.expression.getText().includes("."); + } + function HZe(e, t) { + return { options: e, getRules: GZe(), host: t }; + } + var h_e; + function GZe() { + return h_e === void 0 && (h_e = XZe(hwe())), h_e; + } + function $Ze(e) { + let t = 0; + return e & 1 && (t |= 28), e & 2 && (t |= 96), e & 28 && (t |= 28), e & 96 && (t |= 96), t; + } + function XZe(e) { + const t = QZe(e); + return (n) => { + const i = t[Bwe(n.currentTokenSpan.kind, n.nextTokenSpan.kind)]; + if (i) { + const s = []; + let o = 0; + for (const c of i) { + const _ = ~$Ze(o); + c.action & _ && Ni(c.context, (u) => u(n)) && (s.push(c), o |= c.action); + } + if (s.length) + return s; + } + }; + } + function QZe(e) { + const t = new Array(y_e * y_e), n = new Array(t.length); + for (const i of e) { + const s = i.leftTokenRange.isSpecific && i.rightTokenRange.isSpecific; + for (const o of i.leftTokenRange.tokens) + for (const c of i.rightTokenRange.tokens) { + const _ = Bwe(o, c); + let u = t[_]; + u === void 0 && (u = t[_] = []), YZe(u, i.rule, s, n, _); + } + } + return t; + } + function Bwe(e, t) { + return E.assert(e <= 166 && t <= 166, "Must compute formatting context from tokens"), e * y_e + t; + } + var Jw = 5, uG = 31, y_e = 167, F8 = ((e) => (e[e.StopRulesSpecific = 0] = "StopRulesSpecific", e[e.StopRulesAny = Jw * 1] = "StopRulesAny", e[e.ContextRulesSpecific = Jw * 2] = "ContextRulesSpecific", e[e.ContextRulesAny = Jw * 3] = "ContextRulesAny", e[e.NoContextRulesSpecific = Jw * 4] = "NoContextRulesSpecific", e[e.NoContextRulesAny = Jw * 5] = "NoContextRulesAny", e))(F8 || {}); + function YZe(e, t, n, i, s) { + const o = t.action & 3 ? n ? 0 : F8.StopRulesAny : t.context !== oG ? n ? F8.ContextRulesSpecific : F8.ContextRulesAny : n ? F8.NoContextRulesSpecific : F8.NoContextRulesAny, c = i[s] || 0; + e.splice(ZZe(c, o), 0, t), i[s] = KZe(c, o); + } + function ZZe(e, t) { + let n = 0; + for (let i = 0; i <= t; i += Jw) + n += e & uG, e >>= Jw; + return n; + } + function KZe(e, t) { + const n = (e >> t & uG) + 1; + return E.assert((n & uG) === n, "Adding more rules into the sub-bucket than allowed. Maximum allowed is 32 rules."), e & ~(uG << t) | n << t; + } + function _G(e, t, n) { + const i = { pos: e, end: t, kind: n }; + return E.isDebugging && Object.defineProperty(i, "__debugKind", { + get: () => E.formatSyntaxKind(n) + }), i; + } + function eKe(e, t, n) { + const i = t.getLineAndCharacterOfPosition(e).line; + if (i === 0) + return []; + let s = v3(i, t); + for (; im(t.text.charCodeAt(s)); ) + s--; + Cu(t.text.charCodeAt(s)) && s--; + const o = { + // get start position for the previous line + pos: Ny(i - 1, t), + // end value is exclusive so add 1 to the result + end: s + 1 + }; + return JL( + o, + t, + n, + 2 + /* FormatOnEnter */ + ); + } + function tKe(e, t, n) { + const i = v_e(e, 27, t); + return Jwe( + b_e(i), + t, + n, + 3 + /* FormatOnSemicolon */ + ); + } + function rKe(e, t, n) { + const i = v_e(e, 19, t); + if (!i) + return []; + const s = i.parent, o = b_e(s), c = { + pos: Hp(o.getStart(t), t), + // TODO: GH#18217 + end: e + }; + return JL( + c, + t, + n, + 4 + /* FormatOnOpeningCurlyBrace */ + ); + } + function nKe(e, t, n) { + const i = v_e(e, 20, t); + return Jwe( + b_e(i), + t, + n, + 5 + /* FormatOnClosingCurlyBrace */ + ); + } + function iKe(e, t) { + const n = { + pos: 0, + end: e.text.length + }; + return JL( + n, + e, + t, + 0 + /* FormatDocument */ + ); + } + function sKe(e, t, n, i) { + const s = { + pos: Hp(e, n), + end: t + }; + return JL( + s, + n, + i, + 1 + /* FormatSelection */ + ); + } + function v_e(e, t, n) { + const i = pl(e, n); + return i && i.kind === t && e === i.getEnd() ? i : void 0; + } + function b_e(e) { + let t = e; + for (; t && t.parent && t.parent.end === e.end && !aKe(t.parent, t); ) + t = t.parent; + return t; + } + function aKe(e, t) { + switch (e.kind) { + case 264: + case 265: + return C_(e.members, t); + case 268: + const n = e.body; + return !!n && n.kind === 269 && C_(n.statements, t); + case 308: + case 242: + case 269: + return C_(e.statements, t); + case 300: + return C_(e.block.statements, t); + } + return !1; + } + function oKe(e, t) { + return n(t); + function n(i) { + const s = xs(i, (o) => pJ(o.getStart(t), o.end, e) && o); + if (s) { + const o = n(s); + if (o) + return o; + } + return i; + } + } + function cKe(e, t) { + if (!e.length) + return s; + const n = e.filter((o) => mw(t, o.start, o.start + o.length)).sort((o, c) => o.start - c.start); + if (!n.length) + return s; + let i = 0; + return (o) => { + for (; ; ) { + if (i >= n.length) + return !1; + const c = n[i]; + if (o.end <= c.start) + return !1; + if (v9(o.pos, o.end, c.start, c.start + c.length)) + return !0; + i++; + } + }; + function s() { + return !1; + } + } + function lKe(e, t, n) { + const i = e.getStart(n); + if (i === t.pos && e.end === t.end) + return i; + const s = pl(t.pos, n); + return !s || s.end >= t.pos ? e.pos : s.end; + } + function uKe(e, t, n) { + let i = -1, s; + for (; e; ) { + const o = n.getLineAndCharacterOfPosition(e.getStart(n)).line; + if (i !== -1 && o !== i) + break; + if (wm.shouldIndentChildNode(t, e, s, n)) + return t.indentSize; + i = o, s = e, e = e.parent; + } + return 0; + } + function _Ke(e, t, n, i, s, o) { + const c = { pos: e.pos, end: e.end }; + return o_e(t.text, n, c.pos, c.end, (_) => zwe( + c, + e, + i, + s, + _, + o, + 1, + (u) => !1, + // assume that node does not have any errors + t + )); + } + function Jwe(e, t, n, i) { + if (!e) + return []; + const s = { + pos: Hp(e.getStart(t), t), + end: e.end + }; + return JL(s, t, n, i); + } + function JL(e, t, n, i) { + const s = oKe(e, t); + return o_e( + t.text, + t.languageVariant, + lKe(s, e, t), + e.end, + (o) => zwe( + e, + s, + wm.getIndentationForNode(s, e, t, n.options), + uKe(s, n.options, t), + o, + n, + i, + cKe(t.parseDiagnostics, e), + t + ) + ); + } + function zwe(e, t, n, i, s, { options: o, getRules: c, host: _ }, u, g, m) { + var h; + const S = new dwe(m, u, o); + let T, k, D, P, A, O = -1; + const F = []; + if (s.advance(), s.isOnToken()) { + const ne = m.getLineAndCharacterOfPosition(t.getStart(m)).line; + let Se = ne; + Ff(t) && (Se = m.getLineAndCharacterOfPosition(aB(t, m)).line), _e(t, t, ne, Se, n, i); + } + const R = s.getCurrentLeadingTrivia(); + if (R) { + const ne = wm.nodeWillIndentChild( + o, + t, + /*child*/ + void 0, + m, + /*indentByDefault*/ + !1 + ) ? n + o.indentSize : n; + K( + R, + ne, + /*indentNextTokenOrTrivia*/ + !0, + (Se) => { + ae( + Se, + m.getLineAndCharacterOfPosition(Se.pos), + t, + t, + /*dynamicIndentation*/ + void 0 + ), ce( + Se.pos, + ne, + /*lineAdded*/ + !1 + ); + } + ), o.trimTrailingWhitespace !== !1 && me(R); + } + if (k && s.getTokenFullStart() >= e.end) { + const ne = s.isOnEOF() ? s.readEOFTokenRange() : s.isOnToken() ? s.readTokenInfo(t).token : void 0; + if (ne && ne.pos === T) { + const Se = ((h = pl(ne.end, m, t)) == null ? void 0 : h.parent) || D; + se( + ne, + m.getLineAndCharacterOfPosition(ne.pos).line, + Se, + k, + P, + D, + Se, + /*dynamicIndentation*/ + void 0 + ); + } + } + return F; + function B(ne, Se, ie, Ne, Ee) { + if (mw(Ne, ne, Se) || WA(Ne, ne, Se)) { + if (Ee !== -1) + return Ee; + } else { + const Ce = m.getLineAndCharacterOfPosition(ne).line, Ve = Hp(ne, m), St = wm.findFirstNonWhitespaceColumn(Ve, ne, m, o); + if (Ce !== ie || ne === St) { + const Bt = wm.getBaseIndentation(o); + return Bt > St ? Bt : St; + } + } + return -1; + } + function U(ne, Se, ie, Ne, Ee, Ce) { + const Ve = wm.shouldIndentChildNode(o, ne) ? o.indentSize : 0; + return Ce === Se ? { + indentation: Se === A ? O : Ee.getIndentation(), + delta: Math.min(o.indentSize, Ee.getDelta(ne) + Ve) + } : ie === -1 ? ne.kind === 21 && Se === A ? { indentation: O, delta: Ee.getDelta(ne) } : wm.childStartsOnTheSameLineWithElseInIfStatement(Ne, ne, Se, m) || wm.childIsUnindentedBranchOfConditionalExpression(Ne, ne, Se, m) || wm.argumentStartsOnSameLineAsPreviousArgument(Ne, ne, Se, m) ? { indentation: Ee.getIndentation(), delta: Ve } : { indentation: Ee.getIndentation() + Ee.getDelta(ne), delta: Ve } : { indentation: ie, delta: Ve }; + } + function $(ne) { + if (Vp(ne)) { + const Se = Nn(ne.modifiers, Zs, oc(ne.modifiers, ul)); + if (Se) return Se.kind; + } + switch (ne.kind) { + case 264: + return 86; + case 265: + return 120; + case 263: + return 100; + case 267: + return 267; + case 178: + return 139; + case 179: + return 153; + case 175: + if (ne.asteriskToken) + return 42; + // falls through + case 173: + case 170: + const Se = _s(ne); + if (Se) + return Se.kind; + } + } + function W(ne, Se, ie, Ne) { + return { + getIndentationForComment: (Ve, St, Bt) => { + switch (Ve) { + // preceding comment to the token that closes the indentation scope inherits the indentation from the scope + // .. { + // // comment + // } + case 20: + case 24: + case 22: + return ie + Ce(Bt); + } + return St !== -1 ? St : ie; + }, + // if list end token is LessThanToken '>' then its delta should be explicitly suppressed + // so that LessThanToken as a binary operator can still be indented. + // foo.then + // < + // number, + // string, + // >(); + // vs + // var a = xValue + // > yValue; + getIndentationForToken: (Ve, St, Bt, tr) => !tr && Ee(Ve, St, Bt) ? ie + Ce(Bt) : ie, + getIndentation: () => ie, + getDelta: Ce, + recomputeIndentation: (Ve, St) => { + wm.shouldIndentChildNode(o, St, ne, m) && (ie += Ve ? o.indentSize : -o.indentSize, Ne = wm.shouldIndentChildNode(o, ne) ? o.indentSize : 0); + } + }; + function Ee(Ve, St, Bt) { + switch (St) { + // open and close brace, 'else' and 'while' (in do statement) tokens has indentation of the parent + case 19: + case 20: + case 22: + case 93: + case 117: + case 60: + return !1; + case 44: + case 32: + switch (Bt.kind) { + case 287: + case 288: + case 286: + return !1; + } + break; + case 23: + case 24: + if (Bt.kind !== 201) + return !1; + break; + } + return Se !== Ve && !(Ff(ne) && St === $(ne)); + } + function Ce(Ve) { + return wm.nodeWillIndentChild( + o, + ne, + Ve, + m, + /*indentByDefault*/ + !0 + ) ? Ne : 0; + } + } + function _e(ne, Se, ie, Ne, Ee, Ce) { + if (!mw(e, ne.getStart(m), ne.getEnd())) + return; + const Ve = W(ne, ie, Ee, Ce); + let St = Se; + for (xs( + ne, + (st) => { + Bt( + st, + /*inheritedIndentation*/ + -1, + ne, + Ve, + ie, + Ne, + /*isListItem*/ + !1 + ); + }, + (st) => { + tr(st, ne, ie, Ve); + } + ); s.isOnToken() && s.getTokenFullStart() < e.end; ) { + const st = s.readTokenInfo(ne); + if (st.token.end > Math.min(ne.end, e.end)) + break; + Nr(st, ne, Ve, ne); + } + function Bt(st, Wt, Jr, ui, Ji, Dt, Mn, ai) { + if (E.assert(!lo(st)), lc(st) || $Z(Jr, st)) + return Wt; + const fi = st.getStart(m), pn = m.getLineAndCharacterOfPosition(fi).line; + let _i = pn; + Ff(st) && (_i = m.getLineAndCharacterOfPosition(aB(st, m)).line); + let Je = -1; + if (Mn && C_(e, Jr) && (Je = B(fi, st.end, Ji, e, Wt), Je !== -1 && (Wt = Je)), !mw(e, st.pos, st.end)) + return st.end < e.pos && s.skipToEndOf(st), Wt; + if (st.getFullWidth() === 0) + return Wt; + for (; s.isOnToken() && s.getTokenFullStart() < e.end; ) { + const qr = s.readTokenInfo(ne); + if (qr.token.end > e.end) + return Wt; + if (qr.token.end > fi) { + qr.token.pos > fi && s.skipToStartOf(st); + break; + } + Nr(qr, ne, ui, ne); + } + if (!s.isOnToken() || s.getTokenFullStart() >= e.end) + return Wt; + if (ix(st)) { + const qr = s.readTokenInfo(st); + if (st.kind !== 12) + return E.assert(qr.token.end === st.end, "Token end is child end"), Nr(qr, ne, ui, st), Wt; + } + const ft = st.kind === 171 ? pn : Dt, er = U(st, pn, Je, ne, ui, ft); + return _e(st, St, pn, _i, er.indentation, er.delta), St = ne, ai && Jr.kind === 210 && Wt === -1 && (Wt = er.indentation), Wt; + } + function tr(st, Wt, Jr, ui) { + E.assert(xb(st)), E.assert(!lo(st)); + const Ji = fKe(Wt, st); + let Dt = ui, Mn = Jr; + if (!mw(e, st.pos, st.end)) { + st.end < e.pos && s.skipToEndOf(st); + return; + } + if (Ji !== 0) + for (; s.isOnToken() && s.getTokenFullStart() < e.end; ) { + const pn = s.readTokenInfo(Wt); + if (pn.token.end > st.pos) + break; + if (pn.token.kind === Ji) { + Mn = m.getLineAndCharacterOfPosition(pn.token.pos).line, Nr(pn, Wt, ui, Wt); + let _i; + if (O !== -1) + _i = O; + else { + const Je = Hp(pn.token.pos, m); + _i = wm.findFirstNonWhitespaceColumn(Je, pn.token.pos, m, o); + } + Dt = W(Wt, Jr, _i, o.indentSize); + } else + Nr(pn, Wt, ui, Wt); + } + let ai = -1; + for (let pn = 0; pn < st.length; pn++) { + const _i = st[pn]; + ai = Bt( + _i, + ai, + ne, + Dt, + Mn, + Mn, + /*isListItem*/ + !0, + /*isFirstListItem*/ + pn === 0 + ); + } + const fi = pKe(Ji); + if (fi !== 0 && s.isOnToken() && s.getTokenFullStart() < e.end) { + let pn = s.readTokenInfo(Wt); + pn.token.kind === 28 && (Nr(pn, Wt, Dt, Wt), pn = s.isOnToken() ? s.readTokenInfo(Wt) : void 0), pn && pn.token.kind === fi && C_(Wt, pn.token) && Nr( + pn, + Wt, + Dt, + Wt, + /*isListEndToken*/ + !0 + ); + } + } + function Nr(st, Wt, Jr, ui, Ji) { + E.assert(C_(Wt, st.token)); + const Dt = s.lastTrailingTriviaWasNewLine(); + let Mn = !1; + st.leadingTrivia && V(st.leadingTrivia, Wt, St, Jr); + let ai = 0; + const fi = C_(e, st.token), pn = m.getLineAndCharacterOfPosition(st.token.pos); + if (fi) { + const _i = g(st.token), Je = k; + if (ai = ae(st.token, pn, Wt, St, Jr), !_i) + if (ai === 0) { + const ft = Je && m.getLineAndCharacterOfPosition(Je.end).line; + Mn = Dt && pn.line !== ft; + } else + Mn = ai === 1; + } + if (st.trailingTrivia && (T = pa(st.trailingTrivia).end, V(st.trailingTrivia, Wt, St, Jr)), Mn) { + const _i = fi && !g(st.token) ? Jr.getIndentationForToken(pn.line, st.token.kind, ui, !!Ji) : -1; + let Je = !0; + if (st.leadingTrivia) { + const ft = Jr.getIndentationForComment(st.token.kind, _i, ui); + Je = K(st.leadingTrivia, ft, Je, (er) => ce( + er.pos, + ft, + /*lineAdded*/ + !1 + )); + } + _i !== -1 && Je && (ce( + st.token.pos, + _i, + ai === 1 + /* LineAdded */ + ), A = pn.line, O = _i); + } + s.advance(), St = Wt; + } + } + function K(ne, Se, ie, Ne) { + for (const Ee of ne) { + const Ce = C_(e, Ee); + switch (Ee.kind) { + case 3: + Ce && q( + Ee, + Se, + /*firstLineIsIndented*/ + !ie + ), ie = !1; + break; + case 2: + ie && Ce && Ne(Ee), ie = !1; + break; + case 4: + ie = !0; + break; + } + } + return ie; + } + function V(ne, Se, ie, Ne) { + for (const Ee of ne) + if (E9(Ee.kind) && C_(e, Ee)) { + const Ce = m.getLineAndCharacterOfPosition(Ee.pos); + ae(Ee, Ce, Se, ie, Ne); + } + } + function ae(ne, Se, ie, Ne, Ee) { + const Ce = g(ne); + let Ve = 0; + if (!Ce) + if (k) + Ve = se(ne, Se.line, ie, k, P, D, Ne, Ee); + else { + const St = m.getLineAndCharacterOfPosition(e.pos); + be(St.line, Se.line); + } + return k = ne, T = ne.end, D = ie, P = Se.line, Ve; + } + function se(ne, Se, ie, Ne, Ee, Ce, Ve, St) { + S.updateContext(Ne, Ce, ne, ie, Ve); + const Bt = c(S); + let tr = S.options.trimTrailingWhitespace !== !1, Nr = 0; + return Bt ? YX(Bt, (st) => { + if (Nr = Ye(st, Ne, Ee, ne, Se), St) + switch (Nr) { + case 2: + ie.getStart(m) === ne.pos && St.recomputeIndentation( + /*lineAddedByFormatting*/ + !1, + Ve + ); + break; + case 1: + ie.getStart(m) === ne.pos && St.recomputeIndentation( + /*lineAddedByFormatting*/ + !0, + Ve + ); + break; + default: + E.assert( + Nr === 0 + /* None */ + ); + } + tr = tr && !(st.action & 16) && st.flags !== 1; + }) : tr = tr && ne.kind !== 1, Se !== Ee && tr && be(Ee, Se, Ne), Nr; + } + function ce(ne, Se, ie) { + const Ne = S_e(Se, o); + if (ie) + Te(ne, 0, Ne); + else { + const Ee = m.getLineAndCharacterOfPosition(ne), Ce = Ny(Ee.line, m); + (Se !== fe(Ce, Ee.character) || he(Ne, Ce)) && Te(Ce, Ee.character, Ne); + } + } + function fe(ne, Se) { + let ie = 0; + for (let Ne = 0; Ne < Se; Ne++) + m.text.charCodeAt(ne + Ne) === 9 ? ie += o.tabSize - ie % o.tabSize : ie++; + return ie; + } + function he(ne, Se) { + return ne !== m.text.substr(Se, ne.length); + } + function q(ne, Se, ie, Ne = !0) { + let Ee = m.getLineAndCharacterOfPosition(ne.pos).line; + const Ce = m.getLineAndCharacterOfPosition(ne.end).line; + if (Ee === Ce) { + ie || ce( + ne.pos, + Se, + /*lineAdded*/ + !1 + ); + return; + } + const Ve = []; + let St = ne.pos; + for (let Wt = Ee; Wt < Ce; Wt++) { + const Jr = v3(Wt, m); + Ve.push({ pos: St, end: Jr }), St = Ny(Wt + 1, m); + } + if (Ne && Ve.push({ pos: St, end: ne.end }), Ve.length === 0) return; + const Bt = Ny(Ee, m), tr = wm.findFirstNonWhitespaceCharacterAndColumn(Bt, Ve[0].pos, m, o); + let Nr = 0; + ie && (Nr = 1, Ee++); + const st = Se - tr.column; + for (let Wt = Nr; Wt < Ve.length; Wt++, Ee++) { + const Jr = Ny(Ee, m), ui = Wt === 0 ? tr : wm.findFirstNonWhitespaceCharacterAndColumn(Ve[Wt].pos, Ve[Wt].end, m, o), Ji = ui.column + st; + if (Ji > 0) { + const Dt = S_e(Ji, o); + Te(Jr, ui.character, Dt); + } else + pe(Jr, ui.character); + } + } + function be(ne, Se, ie) { + for (let Ne = ne; Ne < Se; Ne++) { + const Ee = Ny(Ne, m), Ce = v3(Ne, m); + if (ie && (E9(ie.kind) || OV(ie.kind)) && ie.pos <= Ce && ie.end > Ce) + continue; + const Ve = je(Ee, Ce); + Ve !== -1 && (E.assert(Ve === Ee || !im(m.text.charCodeAt(Ve - 1))), pe(Ve, Ce + 1 - Ve)); + } + } + function je(ne, Se) { + let ie = Se; + for (; ie >= ne && im(m.text.charCodeAt(ie)); ) + ie--; + return ie !== Se ? ie + 1 : -1; + } + function me(ne) { + let Se = k ? k.end : e.pos; + for (const ie of ne) + E9(ie.kind) && (Se < ie.pos && Z(Se, ie.pos - 1, k), Se = ie.end + 1); + Se < e.end && Z(Se, e.end, k); + } + function Z(ne, Se, ie) { + const Ne = m.getLineAndCharacterOfPosition(ne).line, Ee = m.getLineAndCharacterOfPosition(Se).line; + be(Ne, Ee + 1, ie); + } + function pe(ne, Se) { + Se && F.push(w9(ne, Se, "")); + } + function Te(ne, Se, ie) { + (Se || ie) && F.push(w9(ne, Se, ie)); + } + function Fe(ne, Se) { + F.push(w9(ne, 0, Se)); + } + function Ye(ne, Se, ie, Ne, Ee) { + const Ce = Ee !== ie; + switch (ne.action) { + case 1: + return 0; + case 16: + if (Se.end !== Ne.pos) + return pe(Se.end, Ne.pos - Se.end), Ce ? 2 : 0; + break; + case 32: + pe(Se.pos, Se.end - Se.pos); + break; + case 8: + if (ne.flags !== 1 && ie !== Ee) + return 0; + if (Ee - ie !== 1) + return Te(Se.end, Ne.pos - Se.end, Fh(_, o)), Ce ? 0 : 1; + break; + case 4: + if (ne.flags !== 1 && ie !== Ee) + return 0; + if (Ne.pos - Se.end !== 1 || m.text.charCodeAt(Se.end) !== 32) + return Te(Se.end, Ne.pos - Se.end, " "), Ce ? 2 : 0; + break; + case 64: + Fe(Se.end, ";"); + } + return 0; + } + } + function Wwe(e, t, n, i = vi(e, t)) { + const s = dr(i, Od); + if (s && (i = s.parent), i.getStart(e) <= t && t < i.getEnd()) + return; + n = n === null ? void 0 : n === void 0 ? pl(t, e) : n; + const c = n && Sy(e.text, n.end), _ = vB(i, e), u = Bi(c, _); + return u && Nn(u, (g) => zA(g, t) || // The end marker of a single-line comment does not include the newline character. + // With caret at `^`, in the following case, we are inside a comment (^ denotes the cursor position): + // + // // asdf ^\n + // + // But for closed multi-line comments, we don't want to be inside the comment in the following case: + // + // /* asdf */^ + // + // However, unterminated multi-line comments *do* contain their end. + // + // Internally, we represent the end of the comment at the newline and closing '/', respectively. + // + t === g.end && (g.kind === 2 || t === e.getFullWidth())); + } + function fKe(e, t) { + switch (e.kind) { + case 177: + case 263: + case 219: + case 175: + case 174: + case 220: + case 180: + case 181: + case 185: + case 186: + case 178: + case 179: + if (e.typeParameters === t) + return 30; + if (e.parameters === t) + return 21; + break; + case 214: + case 215: + if (e.typeArguments === t) + return 30; + if (e.arguments === t) + return 21; + break; + case 264: + case 232: + case 265: + case 266: + if (e.typeParameters === t) + return 30; + break; + case 184: + case 216: + case 187: + case 234: + case 206: + if (e.typeArguments === t) + return 30; + break; + case 188: + return 19; + } + return 0; + } + function pKe(e) { + switch (e) { + case 21: + return 22; + case 30: + return 32; + case 19: + return 20; + } + return 0; + } + var fG, O8, L8; + function S_e(e, t) { + if ((!fG || fG.tabSize !== t.tabSize || fG.indentSize !== t.indentSize) && (fG = { tabSize: t.tabSize, indentSize: t.indentSize }, O8 = L8 = void 0), t.convertTabsToSpaces) { + let i; + const s = Math.floor(e / t.indentSize), o = e % t.indentSize; + return L8 || (L8 = []), L8[s] === void 0 ? (i = HA(" ", t.indentSize * s), L8[s] = i) : i = L8[s], o ? i + HA(" ", o) : i; + } else { + const i = Math.floor(e / t.tabSize), s = e - i * t.tabSize; + let o; + return O8 || (O8 = []), O8[i] === void 0 ? O8[i] = o = HA(" ", i) : o = O8[i], s ? o + HA(" ", s) : o; + } + } + var wm; + ((e) => { + let t; + ((q) => { + q[q.Unknown = -1] = "Unknown"; + })(t || (t = {})); + function n(q, be, je, me = !1) { + if (q > be.text.length) + return _(je); + if (je.indentStyle === 0) + return 0; + const Z = pl( + q, + be, + /*startNode*/ + void 0, + /*excludeJsdoc*/ + !0 + ), pe = Wwe(be, q, Z || null); + if (pe && pe.kind === 3) + return i(be, q, je, pe); + if (!Z) + return _(je); + if (OV(Z.kind) && Z.getStart(be) <= q && q < Z.end) + return 0; + const Fe = be.getLineAndCharacterOfPosition(q).line, Ye = vi(be, q), ne = Ye.kind === 19 && Ye.parent.kind === 211; + if (je.indentStyle === 1 || ne) + return s(be, q, je); + if (Z.kind === 28 && Z.parent.kind !== 227) { + const ie = m(Z, be, je); + if (ie !== -1) + return ie; + } + const Se = R(q, Z.parent, be); + if (Se && !C_(Se, Z)) { + const Ne = [ + 219, + 220 + /* ArrowFunction */ + ].includes(Ye.parent.kind) ? 0 : je.indentSize; + return $(Se, be, je) + Ne; + } + return o(be, q, Z, Fe, me, je); + } + e.getIndentation = n; + function i(q, be, je, me) { + const Z = js(q, be).line - 1, pe = js(q, me.pos).line; + if (E.assert(pe >= 0), Z <= pe) + return ae(Ny(pe, q), be, q, je); + const Te = Ny(Z, q), { column: Fe, character: Ye } = V(Te, be, q, je); + return Fe === 0 ? Fe : q.text.charCodeAt(Te + Ye) === 42 ? Fe - 1 : Fe; + } + function s(q, be, je) { + let me = be; + for (; me > 0; ) { + const pe = q.text.charCodeAt(me); + if (!Cg(pe)) + break; + me--; + } + const Z = Hp(me, q); + return ae(Z, me, q, je); + } + function o(q, be, je, me, Z, pe) { + let Te, Fe = je; + for (; Fe; ) { + if (DV(Fe, be, q) && fe( + pe, + Fe, + Te, + q, + /*isNextChild*/ + !0 + )) { + const ne = k(Fe, q), Se = T(je, Fe, me, q), ie = Se !== 0 ? Z && Se === 2 ? pe.indentSize : 0 : me !== ne.line ? pe.indentSize : 0; + return u( + Fe, + ne, + /*ignoreActualIndentationRange*/ + void 0, + ie, + q, + /*isNextChild*/ + !0, + pe + ); + } + const Ye = W( + Fe, + q, + pe, + /*listIndentsChild*/ + !0 + ); + if (Ye !== -1) + return Ye; + Te = Fe, Fe = Fe.parent; + } + return _(pe); + } + function c(q, be, je, me) { + const Z = je.getLineAndCharacterOfPosition(q.getStart(je)); + return u( + q, + Z, + be, + /*indentationDelta*/ + 0, + je, + /*isNextChild*/ + !1, + me + ); + } + e.getIndentationForNode = c; + function _(q) { + return q.baseIndentSize || 0; + } + e.getBaseIndentation = _; + function u(q, be, je, me, Z, pe, Te) { + var Fe; + let Ye = q.parent; + for (; Ye; ) { + let ne = !0; + if (je) { + const Ee = q.getStart(Z); + ne = Ee < je.pos || Ee > je.end; + } + const Se = g(Ye, q, Z), ie = Se.line === be.line || P(Ye, q, be.line, Z); + if (ne) { + const Ee = (Fe = F(q, Z)) == null ? void 0 : Fe[0], Ce = !!Ee && k(Ee, Z).line > Se.line; + let Ve = W(q, Z, Te, Ce); + if (Ve !== -1 || (Ve = h(q, Ye, be, ie, Z, Te), Ve !== -1)) + return Ve + me; + } + fe(Te, Ye, q, Z, pe) && !ie && (me += Te.indentSize); + const Ne = D(Ye, q, be.line, Z); + q = Ye, Ye = q.parent, be = Ne ? Z.getLineAndCharacterOfPosition(q.getStart(Z)) : Se; + } + return me + _(Te); + } + function g(q, be, je) { + const me = F(be, je), Z = me ? me.pos : q.getStart(je); + return je.getLineAndCharacterOfPosition(Z); + } + function m(q, be, je) { + const me = tae(q); + return me && me.listItemIndex > 0 ? _e(me.list.getChildren(), me.listItemIndex - 1, be, je) : -1; + } + function h(q, be, je, me, Z, pe) { + return (Pl(q) || m3(q)) && (be.kind === 308 || !me) ? K(je, Z, pe) : -1; + } + let S; + ((q) => { + q[q.Unknown = 0] = "Unknown", q[q.OpenBrace = 1] = "OpenBrace", q[q.CloseBrace = 2] = "CloseBrace"; + })(S || (S = {})); + function T(q, be, je, me) { + const Z = c2(q, be, me); + if (!Z) + return 0; + if (Z.kind === 19) + return 1; + if (Z.kind === 20) { + const pe = k(Z, me).line; + return je === pe ? 2 : 0; + } + return 0; + } + function k(q, be) { + return be.getLineAndCharacterOfPosition(q.getStart(be)); + } + function D(q, be, je, me) { + if (!(Ps(q) && ms(q.arguments, be))) + return !1; + const Z = q.expression.getEnd(); + return js(me, Z).line === je; + } + e.isArgumentAndStartLineOverlapsExpressionBeingCalled = D; + function P(q, be, je, me) { + if (q.kind === 246 && q.elseStatement === be) { + const Z = Ya(q, 93, me); + return E.assert(Z !== void 0), k(Z, me).line === je; + } + return !1; + } + e.childStartsOnTheSameLineWithElseInIfStatement = P; + function A(q, be, je, me) { + if (ES(q) && (be === q.whenTrue || be === q.whenFalse)) { + const Z = js(me, q.condition.end).line; + if (be === q.whenTrue) + return je === Z; + { + const pe = k(q.whenTrue, me).line, Te = js(me, q.whenTrue.end).line; + return Z === pe && Te === je; + } + } + return !1; + } + e.childIsUnindentedBranchOfConditionalExpression = A; + function O(q, be, je, me) { + if (sm(q)) { + if (!q.arguments) return !1; + const Z = Nn(q.arguments, (Ye) => Ye.pos === be.pos); + if (!Z) return !1; + const pe = q.arguments.indexOf(Z); + if (pe === 0) return !1; + const Te = q.arguments[pe - 1], Fe = js(me, Te.getEnd()).line; + if (je === Fe) + return !0; + } + return !1; + } + e.argumentStartsOnSameLineAsPreviousArgument = O; + function F(q, be) { + return q.parent && B(q.getStart(be), q.getEnd(), q.parent, be); + } + e.getContainingList = F; + function R(q, be, je) { + return be && B(q, q, be, je); + } + function B(q, be, je, me) { + switch (je.kind) { + case 184: + return Z(je.typeArguments); + case 211: + return Z(je.properties); + case 210: + return Z(je.elements); + case 188: + return Z(je.members); + case 263: + case 219: + case 220: + case 175: + case 174: + case 180: + case 177: + case 186: + case 181: + return Z(je.typeParameters) || Z(je.parameters); + case 178: + return Z(je.parameters); + case 264: + case 232: + case 265: + case 266: + case 346: + return Z(je.typeParameters); + case 215: + case 214: + return Z(je.typeArguments) || Z(je.arguments); + case 262: + return Z(je.declarations); + case 276: + case 280: + return Z(je.elements); + case 207: + case 208: + return Z(je.elements); + } + function Z(pe) { + return pe && WA(U(je, pe, me), q, be) ? pe : void 0; + } + } + function U(q, be, je) { + const me = q.getChildren(je); + for (let Z = 1; Z < me.length - 1; Z++) + if (me[Z].pos === be.pos && me[Z].end === be.end) + return { pos: me[Z - 1].end, end: me[Z + 1].getStart(je) }; + return be; + } + function $(q, be, je) { + return q ? K(be.getLineAndCharacterOfPosition(q.pos), be, je) : -1; + } + function W(q, be, je, me) { + if (q.parent && q.parent.kind === 262) + return -1; + const Z = F(q, be); + if (Z) { + const pe = Z.indexOf(q); + if (pe !== -1) { + const Te = _e(Z, pe, be, je); + if (Te !== -1) + return Te; + } + return $(Z, be, je) + (me ? je.indentSize : 0); + } + return -1; + } + function _e(q, be, je, me) { + E.assert(be >= 0 && be < q.length); + const Z = q[be]; + let pe = k(Z, je); + for (let Te = be - 1; Te >= 0; Te--) { + if (q[Te].kind === 28) + continue; + if (je.getLineAndCharacterOfPosition(q[Te].end).line !== pe.line) + return K(pe, je, me); + pe = k(q[Te], je); + } + return -1; + } + function K(q, be, je) { + const me = be.getPositionOfLineAndCharacter(q.line, 0); + return ae(me, me + q.character, be, je); + } + function V(q, be, je, me) { + let Z = 0, pe = 0; + for (let Te = q; Te < be; Te++) { + const Fe = je.text.charCodeAt(Te); + if (!im(Fe)) + break; + Fe === 9 ? pe += me.tabSize + pe % me.tabSize : pe++, Z++; + } + return { column: pe, character: Z }; + } + e.findFirstNonWhitespaceCharacterAndColumn = V; + function ae(q, be, je, me) { + return V(q, be, je, me).column; + } + e.findFirstNonWhitespaceColumn = ae; + function se(q, be, je, me, Z) { + const pe = je ? je.kind : 0; + switch (be.kind) { + case 245: + case 264: + case 232: + case 265: + case 267: + case 266: + case 210: + case 242: + case 269: + case 211: + case 188: + case 201: + case 190: + case 218: + case 212: + case 214: + case 215: + case 244: + case 278: + case 254: + case 228: + case 208: + case 207: + case 287: + case 290: + case 286: + case 295: + case 174: + case 180: + case 181: + case 170: + case 185: + case 186: + case 197: + case 216: + case 224: + case 280: + case 276: + case 282: + case 277: + case 173: + case 297: + case 298: + return !0; + case 270: + return q.indentSwitchCase ?? !0; + case 261: + case 304: + case 227: + if (!q.indentMultiLineObjectLiteralBeginningOnBlankLine && me && pe === 211) + return he(me, je); + if (be.kind === 227 && me && je && pe === 285) { + const Te = me.getLineAndCharacterOfPosition(oa(me.text, be.pos)).line, Fe = me.getLineAndCharacterOfPosition(oa(me.text, je.pos)).line; + return Te !== Fe; + } + if (be.kind !== 227) + return !0; + break; + case 247: + case 248: + case 250: + case 251: + case 249: + case 246: + case 263: + case 219: + case 175: + case 177: + case 178: + case 179: + return pe !== 242; + case 220: + return me && pe === 218 ? he(me, je) : pe !== 242; + case 279: + return pe !== 280; + case 273: + return pe !== 274 || !!je.namedBindings && je.namedBindings.kind !== 276; + case 285: + return pe !== 288; + case 289: + return pe !== 291; + case 194: + case 193: + case 239: + if (pe === 188 || pe === 190 || pe === 201) + return !1; + break; + case 259: + if (pe === 242) + return !1; + break; + } + return Z; + } + e.nodeWillIndentChild = se; + function ce(q, be) { + switch (q) { + case 254: + case 258: + case 252: + case 253: + return be.kind !== 242; + default: + return !1; + } + } + function fe(q, be, je, me, Z = !1) { + return se( + q, + be, + je, + me, + /*indentByDefault*/ + !1 + ) && !(Z && je && ce(je.kind, be)); + } + e.shouldIndentChildNode = fe; + function he(q, be) { + const je = oa(q.text, be.pos), me = q.getLineAndCharacterOfPosition(je).line, Z = q.getLineAndCharacterOfPosition(be.end).line; + return me === Z; + } + })(wm || (wm = {})); + var pG = {}; + Na(pG, { + preparePasteEdits: () => dKe + }); + function dKe(e, t, n) { + let i = !1; + return t.forEach((s) => { + const o = dr( + vi(e, s.pos), + (c) => C_(c, s) + ); + o && xs(o, function c(_) { + var u; + if (!i) { + if (Me(_) && q6(s, _.getStart(e))) { + const g = n.resolveName( + _.text, + _, + -1, + /*excludeGlobals*/ + !1 + ); + if (g && g.declarations) { + for (const m of g.declarations) + if (Vq(m) || _.text && e.symbol && ((u = e.symbol.exports) != null && u.has(_.escapedText))) { + i = !0; + return; + } + } + } + _.forEachChild(c); + } + }); + }), i; + } + var dG = {}; + Na(dG, { + pasteEditsProvider: () => gKe + }); + var mKe = "providePostPasteEdits"; + function gKe(e, t, n, i, s, o, c, _) { + return { edits: cn.ChangeTracker.with({ host: s, formatContext: c, preferences: o }, (g) => hKe(e, t, n, i, s, o, c, _, g)), fixId: mKe }; + } + function hKe(e, t, n, i, s, o, c, _, u) { + let g; + t.length !== n.length && (g = t.length === 1 ? t[0] : t.join(Fh(c.host, c.options))); + const m = []; + let h = e.text; + for (let T = n.length - 1; T >= 0; T--) { + const { pos: k, end: D } = n[T]; + h = g ? h.slice(0, k) + g + h.slice(D) : h.slice(0, k) + t[T] + h.slice(D); + } + let S; + E.checkDefined(s.runWithTemporaryFileUpdate).call(s, e.fileName, h, (T, k, D) => { + if (S = Ou.createImportAdder(D, T, o, s), i?.range) { + E.assert(i.range.length === t.length), i.range.forEach((R) => { + const B = i.file.statements, U = oc(B, (W) => W.end > R.pos); + if (U === -1) return; + let $ = oc(B, (W) => W.end >= R.end, U); + $ !== -1 && R.end <= B[$].getStart() && $--, m.push(...B.slice(U, $ === -1 ? B.length : $ + 1)); + }), E.assertIsDefined(k, "no original program found"); + const P = k.getTypeChecker(), A = yKe(i), O = nL(i.file, m, P, joe(D, m, P), A), F = !gq(e.fileName, k, s, !!i.file.commonJsModuleIndicator); + Noe(i.file, O.targetFileImportsFromOldFile, u, F), Joe(i.file, O.oldImportsNeededByTargetFile, O.targetFileImportsFromOldFile, P, T, S); + } else { + const P = { + sourceFile: D, + program: k, + cancellationToken: _, + host: s, + preferences: o, + formatContext: c + }; + let A = 0; + n.forEach((O, F) => { + const R = O.end - O.pos, B = g ?? t[F], U = O.pos + A, $ = U + B.length, W = { pos: U, end: $ }; + A += B.length - R; + const _e = dr( + vi(P.sourceFile, W.pos), + (K) => C_(K, W) + ); + _e && xs(_e, function K(V) { + if (Me(V) && q6(W, V.getStart(D)) && !T?.getTypeChecker().resolveName( + V.text, + V, + -1, + /*excludeGlobals*/ + !1 + )) + return S.addImportForUnresolvedIdentifier( + P, + V, + /*useAutoImportProvider*/ + !0 + ); + V.forEachChild(K); + }); + }); + } + S.writeFixes(u, _f(i ? i.file : e, o)); + }), S.hasFixes() && n.forEach((T, k) => { + u.replaceRangeWithText( + e, + { pos: T.pos, end: T.end }, + g ?? t[k] + ); + }); + } + function yKe({ file: e, range: t }) { + const n = t[0].pos, i = t[t.length - 1].end, s = vi(e, n), o = gw(e, n) ?? vi(e, i); + return { + pos: Me(s) && n <= s.getStart(e) ? s.getFullStart() : n, + end: Me(o) && i === o.getEnd() ? cn.getAdjustedEndPosition(e, o, {}) : i + }; + } + var Uwe = {}; + Na(Uwe, { + ANONYMOUS: () => aq, + AccessFlags: () => KQ, + AssertionLevel: () => lQ, + AssignmentDeclarationKind: () => cY, + AssignmentKind: () => OK, + Associativity: () => WK, + BreakpointResolver: () => iH, + BuilderFileEmit: () => Rie, + BuilderProgramKind: () => qie, + BuilderState: () => Md, + CallHierarchy: () => hk, + CharacterCodes: () => vY, + CheckFlags: () => XQ, + CheckMode: () => PW, + ClassificationType: () => hV, + ClassificationTypeNames: () => Gse, + CommentDirectiveType: () => OQ, + Comparison: () => QX, + CompletionInfoFlags: () => Jse, + CompletionTriggerKind: () => mV, + Completions: () => Tk, + ContainerFlags: () => hne, + ContextFlags: () => zQ, + Debug: () => E, + DiagnosticCategory: () => n7, + Diagnostics: () => p, + DocumentHighlights: () => Z9, + ElementFlags: () => ZQ, + EmitFlags: () => fj, + EmitHint: () => xY, + EmitOnly: () => MQ, + EndOfLineState: () => Use, + ExitStatus: () => RQ, + ExportKind: () => Rae, + Extension: () => bY, + ExternalEmitHelpers: () => TY, + FileIncludeKind: () => rj, + FilePreprocessingDiagnosticsKind: () => LQ, + FileSystemEntryKind: () => IY, + FileWatcherEventKind: () => PY, + FindAllReferences: () => ko, + FlattenLevel: () => Bne, + FlowFlags: () => r7, + ForegroundColorEscapeSequences: () => Die, + FunctionFlags: () => JK, + GeneratedIdentifierFlags: () => tj, + GetLiteralTextFlags: () => YZ, + GoToDefinition: () => sE, + HighlightSpanKind: () => jse, + IdentifierNameMap: () => L6, + ImportKind: () => Mae, + ImportsNotUsedAsValues: () => dY, + IndentStyle: () => Bse, + IndexFlags: () => eY, + IndexKind: () => nY, + InferenceFlags: () => aY, + InferencePriority: () => sY, + InlayHintKind: () => Rse, + InlayHints: () => XH, + InternalEmitFlags: () => SY, + InternalNodeBuilderFlags: () => UQ, + InternalSymbolName: () => QQ, + IntersectionFlags: () => JQ, + InvalidatedProjectKind: () => dse, + JSDocParsingMode: () => wY, + JsDoc: () => Ev, + JsTyping: () => t1, + JsxEmit: () => pY, + JsxFlags: () => NQ, + JsxReferenceKind: () => tY, + LanguageFeatureMinimumTarget: () => El, + LanguageServiceMode: () => Lse, + LanguageVariant: () => hY, + LexicalEnvironmentFlags: () => CY, + ListFormat: () => EY, + LogLevel: () => vQ, + MapCode: () => QH, + MemberOverrideStatus: () => jQ, + ModifierFlags: () => KR, + ModuleDetectionKind: () => lY, + ModuleInstanceState: () => mne, + ModuleKind: () => TC, + ModuleResolutionKind: () => SC, + ModuleSpecifierEnding: () => jee, + NavigateTo: () => ooe, + NavigationBar: () => loe, + NewLineKind: () => mY, + NodeBuilderFlags: () => WQ, + NodeCheckFlags: () => sj, + NodeFactoryFlags: () => mte, + NodeFlags: () => ZR, + NodeResolutionFeatures: () => sne, + ObjectFlags: () => oj, + OperationCanceledException: () => lD, + OperatorPrecedence: () => UK, + OrganizeImports: () => Dv, + OrganizeImportsMode: () => dV, + OuterExpressionKinds: () => kY, + OutliningElementsCollector: () => ZH, + OutliningSpanKind: () => zse, + OutputFileType: () => Wse, + PackageJsonAutoImportPreference: () => Ose, + PackageJsonDependencyGroup: () => Fse, + PatternMatchKind: () => Cq, + PollingInterval: () => pj, + PollingWatchKind: () => fY, + PragmaKindFlags: () => DY, + PredicateSemantics: () => AQ, + PreparePasteEdits: () => pG, + PrivateIdentifierKind: () => Cte, + ProcessLevel: () => Une, + ProgramUpdateLevel: () => Tie, + QuotePreference: () => mae, + RegularExpressionFlags: () => IQ, + RelationComparisonResult: () => ej, + Rename: () => LL, + ScriptElementKind: () => qse, + ScriptElementKindModifier: () => Hse, + ScriptKind: () => lj, + ScriptSnapshot: () => u9, + ScriptTarget: () => gY, + SemanticClassificationFormat: () => Mse, + SemanticMeaning: () => $se, + SemicolonPreference: () => gV, + SignatureCheckMode: () => NW, + SignatureFlags: () => cj, + SignatureHelp: () => D8, + SignatureInfo: () => Mie, + SignatureKind: () => rY, + SmartSelectionRange: () => tG, + SnippetKind: () => _j, + StatisticType: () => xse, + StructureIsReused: () => nj, + SymbolAccessibility: () => HQ, + SymbolDisplay: () => O0, + SymbolDisplayPartKind: () => f9, + SymbolFlags: () => ij, + SymbolFormatFlags: () => qQ, + SyntaxKind: () => YR, + Ternary: () => oY, + ThrottledCancellationToken: () => hce, + TokenClass: () => Vse, + TokenFlags: () => FQ, + TransformFlags: () => uj, + TypeFacts: () => wW, + TypeFlags: () => aj, + TypeFormatFlags: () => VQ, + TypeMapKind: () => iY, + TypePredicateKind: () => GQ, + TypeReferenceSerializationKind: () => $Q, + UnionReduction: () => BQ, + UpToDateStatusType: () => ose, + VarianceFlags: () => YQ, + Version: () => xd, + VersionRange: () => t7, + WatchDirectoryFlags: () => yY, + WatchDirectoryKind: () => _Y, + WatchFileKind: () => uY, + WatchLogLevel: () => kie, + WatchType: () => Fl, + accessPrivateIdentifier: () => jne, + addEmitFlags: () => gm, + addEmitHelper: () => jx, + addEmitHelpers: () => Wg, + addInternalEmitFlags: () => bS, + addNodeFactoryPatcher: () => a0e, + addObjectAllocatorPatcher: () => Vhe, + addRange: () => In, + addRelatedInfo: () => zs, + addSyntheticLeadingComment: () => Uy, + addSyntheticTrailingComment: () => C4, + addToSeen: () => Jp, + advancedAsyncSuperHelper: () => bF, + affectsDeclarationPathOptionDeclarations: () => Nre, + affectsEmitOptionDeclarations: () => Pre, + allKeysStartWithDot: () => dO, + altDirectorySeparator: () => o7, + and: () => ZI, + append: () => Er, + appendIfUnique: () => dh, + arrayFrom: () => is, + arrayIsEqualTo: () => Tf, + arrayIsHomogeneous: () => Hee, + arrayOf: () => sQ, + arrayReverseIterator: () => NR, + arrayToMap: () => hC, + arrayToMultiMap: () => BP, + arrayToNumericMap: () => oQ, + assertType: () => bge, + assign: () => H2, + asyncSuperHelper: () => vF, + attachFileToDiagnostics: () => Px, + base64decode: () => uee, + base64encode: () => lee, + binarySearch: () => py, + binarySearchKey: () => $T, + bindSourceFile: () => yne, + breakIntoCharacterSpans: () => Kae, + breakIntoWordSpans: () => eoe, + buildLinkParts: () => xae, + buildOpts: () => tA, + buildOverload: () => Hwe, + bundlerModuleNameResolver: () => ane, + canBeConvertedToAsync: () => Aq, + canHaveDecorators: () => e2, + canHaveExportModifier: () => CN, + canHaveFlowNode: () => HC, + canHaveIllegalDecorators: () => jz, + canHaveIllegalModifiers: () => ure, + canHaveIllegalType: () => I0e, + canHaveIllegalTypeParameters: () => lre, + canHaveJSDoc: () => H3, + canHaveLocals: () => qm, + canHaveModifiers: () => Vp, + canHaveModuleSpecifier: () => AK, + canHaveSymbol: () => Ed, + canIncludeBindAndCheckDiagnostics: () => m4, + canJsonReportNoInputFiles: () => oA, + canProduceDiagnostics: () => gA, + canUsePropertyAccess: () => WJ, + canWatchAffectingLocation: () => Kie, + canWatchAtTypes: () => Zie, + canWatchDirectoryOrFile: () => AU, + canWatchDirectoryOrFilePath: () => AA, + cartesianProduct: () => hQ, + cast: () => Us, + chainBundle: () => Ld, + chainDiagnosticMessages: () => Ts, + changeAnyExtension: () => HP, + changeCompilerHostLikeToUseCache: () => ow, + changeExtension: () => S0, + changeFullExtension: () => u7, + changesAffectModuleResolution: () => R7, + changesAffectingProgramStructure: () => UZ, + characterCodeToRegularExpressionFlag: () => kj, + childIsDecorated: () => RD, + classElementOrClassElementParameterIsDecorated: () => xB, + classHasClassThisAssignment: () => qW, + classHasDeclaredOrExplicitlyAssignedName: () => HW, + classHasExplicitlyAssignedName: () => wO, + classOrConstructorParameterIsDecorated: () => g0, + classicNameResolver: () => pne, + classifier: () => Sce, + cleanExtendedConfigCache: () => OO, + clear: () => Ap, + clearMap: () => B_, + clearSharedExtendedConfigFileWatcher: () => aU, + climbPastPropertyAccess: () => m9, + clone: () => cQ, + cloneCompilerOptions: () => MV, + closeFileWatcher: () => od, + closeFileWatcherOf: () => gp, + codefix: () => Ou, + collapseTextChangeRangesAcrossMultipleVersions: () => tZ, + collectExternalModuleInfo: () => zW, + combine: () => GT, + combinePaths: () => On, + commandLineOptionOfCustomType: () => Fre, + commentPragmas: () => i7, + commonOptionsWithBuild: () => GF, + compact: () => RP, + compareBooleans: () => j1, + compareDataObjects: () => gJ, + compareDiagnostics: () => c4, + compareEmitHelpers: () => Dte, + compareNumberOfDirectorySeparators: () => SN, + comparePaths: () => gh, + comparePathsCaseInsensitive: () => Vge, + comparePathsCaseSensitive: () => Uge, + comparePatternKeys: () => SW, + compareProperties: () => pQ, + compareStringsCaseInsensitive: () => zP, + compareStringsCaseInsensitiveEslintCompatible: () => uQ, + compareStringsCaseSensitive: () => _u, + compareStringsCaseSensitiveUI: () => WP, + compareTextSpans: () => QI, + compareValues: () => ho, + compilerOptionsAffectDeclarationPath: () => Iee, + compilerOptionsAffectEmit: () => Aee, + compilerOptionsAffectSemanticDiagnostics: () => Nee, + compilerOptionsDidYouMeanDiagnostics: () => YF, + compilerOptionsIndicateEsModules: () => WV, + computeCommonSourceDirectoryOfFilenames: () => Cie, + computeLineAndCharacterOfPosition: () => CC, + computeLineOfPosition: () => dD, + computeLineStarts: () => nx, + computePositionOfLineAndCharacter: () => d7, + computeSignatureWithDiagnostics: () => CU, + computeSuggestionDiagnostics: () => wq, + computedOptions: () => l4, + concatenate: () => Bi, + concatenateDiagnosticMessageChains: () => xee, + consumesNodeCoreModules: () => U9, + contains: () => ms, + containsIgnoredPath: () => y4, + containsObjectRestOrSpread: () => YN, + containsParseError: () => fx, + containsPath: () => np, + convertCompilerOptionsForTelemetry: () => $re, + convertCompilerOptionsFromJson: () => zye, + convertJsonOption: () => LS, + convertToBase64: () => cee, + convertToJson: () => iA, + convertToObject: () => Wre, + convertToOptionsWithAbsolutePaths: () => tO, + convertToRelativePath: () => fD, + convertToTSConfig: () => iW, + convertTypeAcquisitionFromJson: () => Wye, + copyComments: () => VS, + copyEntries: () => j7, + copyLeadingComments: () => Y6, + copyProperties: () => RR, + copyTrailingAsLeadingComments: () => ZA, + copyTrailingComments: () => xw, + couldStartTrivia: () => zY, + countWhere: () => l0, + createAbstractBuilder: () => $ve, + createAccessorPropertyBackingField: () => zz, + createAccessorPropertyGetRedirector: () => yre, + createAccessorPropertySetRedirector: () => vre, + createBaseNodeFactory: () => ute, + createBinaryExpressionTrampoline: () => WF, + createBuilderProgram: () => EU, + createBuilderProgramUsingIncrementalBuildInfo: () => Xie, + createBuilderStatusReporter: () => r9, + createCacheableExportInfoMap: () => hq, + createCachedDirectoryStructureHost: () => IO, + createClassifier: () => k2e, + createCommentDirectivesMap: () => XZ, + createCompilerDiagnostic: () => Yo, + createCompilerDiagnosticForInvalidCustomType: () => Ore, + createCompilerDiagnosticFromMessageChain: () => z5, + createCompilerHost: () => Eie, + createCompilerHostFromProgramHost: () => HU, + createCompilerHostWorker: () => LO, + createDetachedDiagnostic: () => wx, + createDiagnosticCollection: () => ZD, + createDiagnosticForFileFromMessageChain: () => yB, + createDiagnosticForNode: () => sn, + createDiagnosticForNodeArray: () => jC, + createDiagnosticForNodeArrayFromMessageChain: () => k3, + createDiagnosticForNodeFromMessageChain: () => Fg, + createDiagnosticForNodeInSourceFile: () => sp, + createDiagnosticForRange: () => lK, + createDiagnosticMessageChainFromDiagnostic: () => cK, + createDiagnosticReporter: () => lk, + createDocumentPositionMapper: () => Fne, + createDocumentRegistry: () => Wae, + createDocumentRegistryInternal: () => Tq, + createEmitAndSemanticDiagnosticsBuilderProgram: () => NU, + createEmitHelperFactory: () => Ete, + createEmptyExports: () => UN, + createEvaluator: () => rte, + createExpressionForJsxElement: () => nre, + createExpressionForJsxFragment: () => ire, + createExpressionForObjectLiteralElementLike: () => sre, + createExpressionForPropertyName: () => Iz, + createExpressionFromEntityName: () => VN, + createExternalHelpersImportDeclarationIfNeeded: () => Lz, + createFileDiagnostic: () => ll, + createFileDiagnosticFromMessageChain: () => $7, + createFlowNode: () => tg, + createForOfBindingStatement: () => Az, + createFutureSourceFile: () => X9, + createGetCanonicalFileName: () => Zl, + createGetIsolatedDeclarationErrors: () => fie, + createGetSourceFile: () => _U, + createGetSymbolAccessibilityDiagnosticForNode: () => gv, + createGetSymbolAccessibilityDiagnosticForNodeName: () => _ie, + createGetSymbolWalker: () => vne, + createIncrementalCompilerHost: () => t9, + createIncrementalProgram: () => ase, + createJsxFactoryExpression: () => Nz, + createLanguageService: () => yce, + createLanguageServiceSourceFile: () => dL, + createMemberAccessForPropertyName: () => FS, + createModeAwareCache: () => N6, + createModeAwareCacheKey: () => H4, + createModeMismatchDetails: () => rB, + createModuleNotFoundChain: () => J7, + createModuleResolutionCache: () => A6, + createModuleResolutionLoader: () => hU, + createModuleResolutionLoaderUsingGlobalCache: () => nse, + createModuleSpecifierResolutionHost: () => bv, + createMultiMap: () => Fp, + createNameResolver: () => GJ, + createNodeConverters: () => pte, + createNodeFactory: () => NN, + createOptionNameMap: () => XF, + createOverload: () => mG, + createPackageJsonImportFilter: () => Z6, + createPackageJsonInfo: () => lq, + createParenthesizerRules: () => _te, + createPatternMatcher: () => Gae, + createPrinter: () => Ky, + createPrinterWithDefaults: () => bie, + createPrinterWithRemoveComments: () => i2, + createPrinterWithRemoveCommentsNeverAsciiEscape: () => Sie, + createPrinterWithRemoveCommentsOmitTrailingSemicolon: () => sU, + createProgram: () => wA, + createProgramDiagnostics: () => Oie, + createProgramHost: () => GU, + createPropertyNameNodeForIdentifierOrLiteral: () => kN, + createQueue: () => JP, + createRange: () => cp, + createRedirectedBuilderProgram: () => PU, + createResolutionCache: () => FU, + createRuntimeTypeSerializer: () => $ne, + createScanner: () => Dg, + createSemanticDiagnosticsBuilderProgram: () => Gve, + createSet: () => jR, + createSolutionBuilder: () => _se, + createSolutionBuilderHost: () => lse, + createSolutionBuilderWithWatch: () => fse, + createSolutionBuilderWithWatchHost: () => use, + createSortedArray: () => PR, + createSourceFile: () => ek, + createSourceMapGenerator: () => wne, + createSourceMapSource: () => u0e, + createSuperAccessVariableStatement: () => NO, + createSymbolTable: () => Bs, + createSymlinkCache: () => EJ, + createSyntacticTypeNodeBuilder: () => Nse, + createSystemWatchFunctions: () => FY, + createTextChange: () => qA, + createTextChangeFromStartLength: () => w9, + createTextChangeRange: () => r3, + createTextRangeFromNode: () => BV, + createTextRangeFromSpan: () => D9, + createTextSpan: () => Kl, + createTextSpanFromBounds: () => Nc, + createTextSpanFromNode: () => u_, + createTextSpanFromRange: () => A0, + createTextSpanFromStringLiteralLikeContent: () => jV, + createTextWriter: () => nN, + createTokenRange: () => _J, + createTypeChecker: () => Ene, + createTypeReferenceDirectiveResolutionCache: () => _O, + createTypeReferenceResolutionLoader: () => jO, + createWatchCompilerHost: () => ibe, + createWatchCompilerHostOfConfigFile: () => $U, + createWatchCompilerHostOfFilesAndCompilerOptions: () => XU, + createWatchFactory: () => qU, + createWatchHost: () => VU, + createWatchProgram: () => QU, + createWatchStatusReporter: () => OU, + createWriteFileMeasuringIO: () => fU, + declarationNameToString: () => co, + decodeMappings: () => jW, + decodedTextSpanIntersectsWith: () => t3, + deduplicate: () => hb, + defaultHoverMaximumTruncationLength: () => zZ, + defaultInitCompilerOptions: () => oye, + defaultMaximumTruncationLength: () => ND, + diagnosticCategoryName: () => $2, + diagnosticToString: () => l2, + diagnosticsEqualityComparer: () => W5, + directoryProbablyExists: () => Pd, + directorySeparator: () => So, + displayPart: () => W_, + displayPartsToString: () => _8, + disposeEmitNodes: () => iz, + documentSpansEqual: () => XV, + dumpTracingLegend: () => PQ, + elementAt: () => fy, + elideNodes: () => hre, + emitDetachedComments: () => ZK, + emitFiles: () => nU, + emitFilesAndReportErrors: () => YO, + emitFilesAndReportErrorsAndGetExitStatus: () => UU, + emitModuleKindIsNonNodeESM: () => hN, + emitNewLineBeforeLeadingCommentOfPosition: () => YK, + emitResolverSkipsTypeChecking: () => rU, + emitSkippedWithNoDiagnostics: () => bU, + emptyArray: () => Ge, + emptyFileSystemEntries: () => OJ, + emptyMap: () => SR, + emptyOptions: () => qp, + endsWith: () => wo, + ensurePathIsNonModuleName: () => X2, + ensureScriptKind: () => Z5, + ensureTrailingDirectorySeparator: () => gl, + entityNameToString: () => ef, + enumerateInsertsAndDeletes: () => e7, + equalOwnProperties: () => aQ, + equateStringsCaseInsensitive: () => hy, + equateStringsCaseSensitive: () => bb, + equateValues: () => gy, + escapeJsxAttributeString: () => GB, + escapeLeadingUnderscores: () => tc, + escapeNonAsciiString: () => S5, + escapeSnippetText: () => Vb, + escapeString: () => Ym, + escapeTemplateSubstitution: () => qB, + evaluatorResult: () => yl, + every: () => Ni, + exclusivelyPrefixedNodeCoreModules: () => pF, + executeCommandLine: () => Rbe, + expandPreOrPostfixIncrementOrDecrementExpression: () => RF, + explainFiles: () => jU, + explainIfFileIsRedirectAndImpliedFormat: () => BU, + exportAssignmentIsAlias: () => Q3, + expressionResultIsUnused: () => $ee, + extend: () => MR, + extensionFromPath: () => p4, + extensionIsTS: () => nF, + extensionsNotSupportingExtensionlessResolution: () => rF, + externalHelpersModuleNameText: () => Py, + factory: () => N, + fileExtensionIs: () => Xo, + fileExtensionIsOneOf: () => xc, + fileIncludeReasonToDiagnostics: () => WU, + fileShouldUseJavaScriptRequire: () => gq, + filter: () => kn, + filterMutate: () => kR, + filterSemanticDiagnostics: () => WO, + find: () => Nn, + findAncestor: () => dr, + findBestPatternMatch: () => VR, + findChildOfKind: () => Ya, + findComputedPropertyNameCacheAssignment: () => UF, + findConfigFile: () => lU, + findConstructorDeclaration: () => wN, + findContainingList: () => b9, + findDiagnosticForNode: () => Fae, + findFirstNonJsxWhitespaceToken: () => rae, + findIndex: () => oc, + findLast: () => gb, + findLastIndex: () => GI, + findListItemInfo: () => tae, + findModifier: () => $6, + findNextToken: () => c2, + findPackageJson: () => Iae, + findPackageJsons: () => cq, + findPrecedingMatchingToken: () => C9, + findPrecedingToken: () => pl, + findSuperStatementIndexPath: () => kO, + findTokenOnLeftOfPosition: () => gw, + findUseStrictPrologue: () => Oz, + first: () => Ca, + firstDefined: () => Lc, + firstDefinedIterator: () => MP, + firstIterator: () => IR, + firstOrOnly: () => fq, + firstOrUndefined: () => Yc, + firstOrUndefinedIterator: () => XI, + fixupCompilerOptions: () => Iq, + flatMap: () => ka, + flatMapIterator: () => CR, + flatMapToMutable: () => KE, + flatten: () => Ip, + flattenCommaList: () => bre, + flattenDestructuringAssignment: () => BS, + flattenDestructuringBinding: () => n2, + flattenDiagnosticMessageText: () => km, + forEach: () => lr, + forEachAncestor: () => VZ, + forEachAncestorDirectory: () => pD, + forEachAncestorDirectoryStoppingAtGlobalCache: () => eg, + forEachChild: () => xs, + forEachChildRecursively: () => Kx, + forEachDynamicImportOrRequireCall: () => dF, + forEachEmittedFile: () => ZW, + forEachEnclosingBlockScopeContainer: () => sK, + forEachEntry: () => hl, + forEachExternalModuleToImportFrom: () => vq, + forEachImportClauseDeclaration: () => IK, + forEachKey: () => Ag, + forEachLeadingCommentRange: () => XP, + forEachNameInAccessChainWalkingLeft: () => yee, + forEachNameOfDefaultExport: () => Y9, + forEachOptionsSyntaxByName: () => KJ, + forEachProjectReference: () => x4, + forEachPropertyAssignment: () => zC, + forEachResolvedProjectReference: () => YJ, + forEachReturnStatement: () => Fy, + forEachRight: () => YX, + forEachTrailingCommentRange: () => QP, + forEachTsConfigPropArray: () => P3, + forEachUnique: () => YV, + forEachYieldExpression: () => pK, + formatColorAndReset: () => s2, + formatDiagnostic: () => pU, + formatDiagnostics: () => Sve, + formatDiagnosticsWithColorAndContext: () => Nie, + formatGeneratedName: () => _v, + formatGeneratedNamePart: () => E6, + formatLocation: () => dU, + formatMessage: () => Nx, + formatStringFromArgs: () => jg, + formatting: () => nl, + generateDjb2Hash: () => uD, + generateTSConfig: () => Ure, + getAdjustedReferenceLocation: () => NV, + getAdjustedRenameLocation: () => T9, + getAliasDeclarationFromName: () => LB, + getAllAccessorDeclarations: () => Bb, + getAllDecoratorsOfClass: () => UW, + getAllDecoratorsOfClassElement: () => EO, + getAllJSDocTags: () => S7, + getAllJSDocTagsOfKind: () => phe, + getAllKeys: () => gge, + getAllProjectOutputs: () => AO, + getAllSuperTypeNodes: () => HD, + getAllowImportingTsExtensions: () => Cee, + getAllowJSCompilerOption: () => Jy, + getAllowSyntheticDefaultImports: () => Ax, + getAncestor: () => Q1, + getAnyExtensionFromPath: () => ex, + getAreDeclarationMapsEnabled: () => U5, + getAssignedExpandoInitializer: () => mx, + getAssignedName: () => y7, + getAssignmentDeclarationKind: () => Ac, + getAssignmentDeclarationPropertyAccessKind: () => z3, + getAssignmentTargetKind: () => Oy, + getAutomaticTypeDirectiveNames: () => lO, + getBaseFileName: () => Zc, + getBinaryOperatorPrecedence: () => eN, + getBuildInfo: () => iU, + getBuildInfoFileVersionMap: () => wU, + getBuildInfoText: () => yie, + getBuildOrderFromAnyBuildOrder: () => FA, + getBuilderCreationParameters: () => HO, + getBuilderFileEmit: () => e1, + getCanonicalDiagnostic: () => uK, + getCheckFlags: () => uc, + getClassExtendsHeritageElement: () => Lb, + getClassLikeDeclarationOfSymbol: () => Eh, + getCombinedLocalAndExportSymbolFlags: () => t6, + getCombinedModifierFlags: () => J1, + getCombinedNodeFlags: () => yh, + getCombinedNodeFlagsAlwaysIncludeJSDoc: () => Nj, + getCommentRange: () => hm, + getCommonSourceDirectory: () => aw, + getCommonSourceDirectoryOfConfig: () => JS, + getCompilerOptionValue: () => H5, + getConditions: () => Qy, + getConfigFileParsingDiagnostics: () => a2, + getConstantValue: () => yte, + getContainerFlags: () => xW, + getContainerNode: () => US, + getContainingClass: () => Wl, + getContainingClassExcludingClassDecorators: () => r5, + getContainingClassStaticBlock: () => SK, + getContainingFunction: () => Af, + getContainingFunctionDeclaration: () => bK, + getContainingFunctionOrClassStaticBlock: () => t5, + getContainingNodeArray: () => Xee, + getContainingObjectLiteralElement: () => f8, + getContextualTypeFromParent: () => R9, + getContextualTypeFromParentOrAncestorTypeNode: () => S9, + getDeclarationDiagnostics: () => pie, + getDeclarationEmitExtensionForPath: () => k5, + getDeclarationEmitOutputFilePath: () => GK, + getDeclarationEmitOutputFilePathWorker: () => x5, + getDeclarationFileExtension: () => qF, + getDeclarationFromName: () => qD, + getDeclarationModifierFlagsFromSymbol: () => up, + getDeclarationOfKind: () => Oo, + getDeclarationsOfKind: () => WZ, + getDeclaredExpandoInitializer: () => zD, + getDecorators: () => Ty, + getDefaultCompilerOptions: () => pL, + getDefaultFormatCodeSettings: () => _9, + getDefaultLibFileName: () => ZP, + getDefaultLibFilePath: () => vce, + getDefaultLikeExportInfo: () => Q9, + getDefaultLikeExportNameFromDeclaration: () => pq, + getDefaultResolutionModeForFileWorker: () => zO, + getDiagnosticText: () => D_, + getDiagnosticsWithinSpan: () => Oae, + getDirectoryPath: () => Hn, + getDirectoryToWatchFailedLookupLocation: () => IU, + getDirectoryToWatchFailedLookupLocationFromTypeRoot: () => tse, + getDocumentPositionMapper: () => Dq, + getDocumentSpansEqualityComparer: () => QV, + getESModuleInterop: () => mm, + getEditsForFileRename: () => Vae, + getEffectiveBaseTypeNode: () => wd, + getEffectiveConstraintOfTypeParameter: () => PC, + getEffectiveContainerForJSDocTemplateTag: () => d5, + getEffectiveImplementsTypeNodes: () => $C, + getEffectiveInitializer: () => j3, + getEffectiveJSDocHost: () => X1, + getEffectiveModifierFlags: () => pu, + getEffectiveModifierFlagsAlwaysIncludeJSDoc: () => ree, + getEffectiveModifierFlagsNoCache: () => nee, + getEffectiveReturnTypeNode: () => nf, + getEffectiveSetAccessorTypeAnnotationNode: () => tJ, + getEffectiveTypeAnnotationNode: () => Kc, + getEffectiveTypeParameterDeclarations: () => xy, + getEffectiveTypeRoots: () => q4, + getElementOrPropertyAccessArgumentExpressionOrName: () => p5, + getElementOrPropertyAccessName: () => Sh, + getElementsOfBindingOrAssignmentPattern: () => C6, + getEmitDeclarations: () => J_, + getEmitFlags: () => Ea, + getEmitHelpers: () => sz, + getEmitModuleDetectionKind: () => Eee, + getEmitModuleFormatOfFileWorker: () => uw, + getEmitModuleKind: () => Hu, + getEmitModuleResolutionKind: () => Pu, + getEmitScriptTarget: () => da, + getEmitStandardClassFields: () => kJ, + getEnclosingBlockScopeContainer: () => Dd, + getEnclosingContainer: () => G7, + getEncodedSemanticClassifications: () => bq, + getEncodedSyntacticClassifications: () => Sq, + getEndLinePosition: () => v3, + getEntityNameFromTypeNode: () => I3, + getEntrypointsFromPackageJsonInfo: () => yW, + getErrorCountForSummary: () => XO, + getErrorSpanForNode: () => aS, + getErrorSummaryText: () => MU, + getEscapedTextOfIdentifierOrLiteral: () => XD, + getEscapedTextOfJsxAttributeName: () => S4, + getEscapedTextOfJsxNamespacedName: () => Lx, + getExpandoInitializer: () => G1, + getExportAssignmentExpression: () => MB, + getExportInfoMap: () => i8, + getExportNeedsImportStarHelper: () => One, + getExpressionAssociativity: () => UB, + getExpressionPrecedence: () => YD, + getExternalHelpersModuleName: () => HN, + getExternalModuleImportEqualsDeclarationExpression: () => jD, + getExternalModuleName: () => hx, + getExternalModuleNameFromDeclaration: () => qK, + getExternalModuleNameFromPath: () => QB, + getExternalModuleNameLiteral: () => Zx, + getExternalModuleRequireArgument: () => CB, + getFallbackOptions: () => CA, + getFileEmitOutput: () => Lie, + getFileMatcherPatterns: () => Y5, + getFileNamesFromConfigSpecs: () => U4, + getFileWatcherEventKind: () => gj, + getFilesInErrorForSummary: () => QO, + getFirstConstructorWithBody: () => Mg, + getFirstIdentifier: () => i_, + getFirstNonSpaceCharacterPosition: () => Eae, + getFirstProjectOutput: () => tU, + getFixableErrorSpanExpression: () => uq, + getFormatCodeSettingsForWriting: () => G9, + getFullWidth: () => h3, + getFunctionFlags: () => Mc, + getHeritageClause: () => Y3, + getHostSignatureFromJSDoc: () => $1, + getIdentifierAutoGenerate: () => p0e, + getIdentifierGeneratedImportReference: () => kte, + getIdentifierTypeArguments: () => SS, + getImmediatelyInvokedFunctionExpression: () => q1, + getImpliedNodeFormatForEmitWorker: () => zS, + getImpliedNodeFormatForFile: () => DA, + getImpliedNodeFormatForFileWorker: () => JO, + getImportNeedsImportDefaultHelper: () => JW, + getImportNeedsImportStarHelper: () => TO, + getIndentString: () => T5, + getInferredLibraryNameResolveFrom: () => BO, + getInitializedVariables: () => s4, + getInitializerOfBinaryExpression: () => PB, + getInitializerOfBindingOrAssignmentElement: () => $N, + getInterfaceBaseTypeNodes: () => GD, + getInternalEmitFlags: () => sd, + getInvokedExpression: () => s5, + getIsFileExcluded: () => Bae, + getIsolatedModules: () => zp, + getJSDocAugmentsTag: () => _Z, + getJSDocClassTag: () => Fj, + getJSDocCommentRanges: () => bB, + getJSDocCommentsAndTags: () => NB, + getJSDocDeprecatedTag: () => Oj, + getJSDocDeprecatedTagNoCache: () => yZ, + getJSDocEnumTag: () => Lj, + getJSDocHost: () => Fb, + getJSDocImplementsTags: () => fZ, + getJSDocOverloadTags: () => IB, + getJSDocOverrideTagNoCache: () => hZ, + getJSDocParameterTags: () => wC, + getJSDocParameterTagsNoCache: () => oZ, + getJSDocPrivateTag: () => lhe, + getJSDocPrivateTagNoCache: () => dZ, + getJSDocProtectedTag: () => uhe, + getJSDocProtectedTagNoCache: () => mZ, + getJSDocPublicTag: () => che, + getJSDocPublicTagNoCache: () => pZ, + getJSDocReadonlyTag: () => _he, + getJSDocReadonlyTagNoCache: () => gZ, + getJSDocReturnTag: () => vZ, + getJSDocReturnType: () => i3, + getJSDocRoot: () => GC, + getJSDocSatisfiesExpressionType: () => VJ, + getJSDocSatisfiesTag: () => Mj, + getJSDocTags: () => W1, + getJSDocTemplateTag: () => fhe, + getJSDocThisTag: () => v7, + getJSDocType: () => f0, + getJSDocTypeAliasName: () => Rz, + getJSDocTypeAssertionType: () => x6, + getJSDocTypeParameterDeclarations: () => P5, + getJSDocTypeParameterTags: () => cZ, + getJSDocTypeParameterTagsNoCache: () => lZ, + getJSDocTypeTag: () => z1, + getJSXImplicitImportBase: () => yN, + getJSXRuntimeImport: () => $5, + getJSXTransformEnabled: () => G5, + getKeyForCompilerOptions: () => pW, + getLanguageVariant: () => fN, + getLastChild: () => hJ, + getLeadingCommentRanges: () => Eg, + getLeadingCommentRangesOfNode: () => vB, + getLeftmostAccessExpression: () => r6, + getLeftmostExpression: () => n6, + getLibFileNameFromLibReference: () => QJ, + getLibNameFromLibReference: () => XJ, + getLibraryNameFromLibFileName: () => yU, + getLineAndCharacterOfPosition: () => js, + getLineInfo: () => RW, + getLineOfLocalPosition: () => KD, + getLineStartPositionForPosition: () => Hp, + getLineStarts: () => kg, + getLinesBetweenPositionAndNextNonWhitespaceCharacter: () => mee, + getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter: () => dee, + getLinesBetweenPositions: () => mD, + getLinesBetweenRangeEndAndRangeStart: () => fJ, + getLinesBetweenRangeEndPositions: () => Whe, + getLiteralText: () => ZZ, + getLocalNameForExternalImport: () => k6, + getLocalSymbolForExportDefault: () => n4, + getLocaleSpecificMessage: () => Ss, + getLocaleTimeString: () => IA, + getMappedContextSpan: () => ZV, + getMappedDocumentSpan: () => O9, + getMappedLocation: () => bw, + getMatchedFileSpec: () => JU, + getMatchedIncludeSpec: () => zU, + getMeaningFromDeclaration: () => p9, + getMeaningFromLocation: () => WS, + getMembersOfDeclaration: () => dK, + getModeForFileReference: () => Aie, + getModeForResolutionAtIndex: () => Dve, + getModeForUsageLocation: () => gU, + getModifiedTime: () => KT, + getModifiers: () => Tb, + getModuleInstanceState: () => Ah, + getModuleNameStringLiteralAt: () => PA, + getModuleSpecifierEndingPreference: () => Bee, + getModuleSpecifierResolverHost: () => UV, + getNameForExportedSymbol: () => V9, + getNameFromImportAttribute: () => uF, + getNameFromIndexInfo: () => aK, + getNameFromPropertyName: () => GA, + getNameOfAccessExpression: () => vJ, + getNameOfCompilerOptionValue: () => eO, + getNameOfDeclaration: () => _s, + getNameOfExpando: () => EB, + getNameOfJSDocTypedef: () => aZ, + getNameOfScriptTarget: () => q5, + getNameOrArgument: () => J3, + getNameTable: () => nH, + getNamespaceDeclarationNode: () => qC, + getNewLineCharacter: () => v0, + getNewLineKind: () => n8, + getNewLineOrDefaultFromHost: () => Fh, + getNewTargetContainer: () => xK, + getNextJSDocCommentLocation: () => AB, + getNodeChildren: () => wz, + getNodeForGeneratedName: () => QN, + getNodeId: () => Ma, + getNodeKind: () => o2, + getNodeModifiers: () => hw, + getNodeModulePathParts: () => oF, + getNonAssignedNameOfDeclaration: () => h7, + getNonAssignmentOperatorForCompoundAssignment: () => K4, + getNonAugmentationDeclaration: () => fB, + getNonDecoratorTokenPosOfNode: () => aB, + getNonIncrementalBuildInfoRoots: () => Qie, + getNonModifierTokenPosOfNode: () => QZ, + getNormalizedAbsolutePath: () => Qi, + getNormalizedAbsolutePathWithoutRoot: () => bj, + getNormalizedPathComponents: () => l7, + getObjectFlags: () => Dn, + getOperatorAssociativity: () => VB, + getOperatorPrecedence: () => K3, + getOptionFromName: () => Kz, + getOptionsForLibraryResolution: () => dW, + getOptionsNameMap: () => w6, + getOptionsSyntaxByArrayElementValue: () => ZJ, + getOptionsSyntaxByValue: () => ote, + getOrCreateEmitNode: () => mu, + getOrUpdate: () => eD, + getOriginalNode: () => Vo, + getOriginalNodeId: () => l_, + getOutputDeclarationFileName: () => sw, + getOutputDeclarationFileNameWorker: () => KW, + getOutputExtension: () => TA, + getOutputFileNames: () => vve, + getOutputJSFileNameWorker: () => eU, + getOutputPathsFor: () => iw, + getOwnEmitOutputFilePath: () => HK, + getOwnKeys: () => rm, + getOwnValues: () => XT, + getPackageJsonTypesVersionsPaths: () => cO, + getPackageNameFromTypesPackageName: () => X4, + getPackageScopeForPath: () => $4, + getParameterSymbolFromJSDoc: () => G3, + getParentNodeInSpan: () => XA, + getParseTreeNode: () => vs, + getParsedCommandLineOfConfigFile: () => rA, + getPathComponents: () => fu, + getPathFromPathComponents: () => B1, + getPathUpdater: () => kq, + getPathsBasePath: () => C5, + getPatternFromSpec: () => PJ, + getPendingEmitKindWithSeen: () => qO, + getPositionOfLineAndCharacter: () => GP, + getPossibleGenericSignatures: () => IV, + getPossibleOriginalInputExtensionForExtension: () => YB, + getPossibleOriginalInputPathWithoutChangingExt: () => ZB, + getPossibleTypeArgumentsInfo: () => FV, + getPreEmitDiagnostics: () => bve, + getPrecedingNonSpaceCharacterPosition: () => L9, + getPrivateIdentifier: () => VW, + getProperties: () => WW, + getProperty: () => jP, + getPropertyAssignmentAliasLikeExpression: () => BK, + getPropertyNameForPropertyNameNode: () => dS, + getPropertyNameFromType: () => fp, + getPropertyNameOfBindingOrAssignmentElement: () => Mz, + getPropertySymbolFromBindingElement: () => F9, + getPropertySymbolsFromContextualType: () => mL, + getQuoteFromPreference: () => qV, + getQuotePreference: () => _f, + getRangesWhere: () => wR, + getRefactorContextSpan: () => pk, + getReferencedFileLocation: () => lw, + getRegexFromPattern: () => b0, + getRegularExpressionForWildcard: () => u4, + getRegularExpressionsForWildcards: () => X5, + getRelativePathFromDirectory: () => Nf, + getRelativePathFromFile: () => kC, + getRelativePathToDirectoryOrUrl: () => rx, + getRenameLocation: () => YA, + getReplacementSpanForContextToken: () => RV, + getResolutionDiagnostic: () => TU, + getResolutionModeOverride: () => R6, + getResolveJsonModule: () => zb, + getResolvePackageJsonExports: () => dN, + getResolvePackageJsonImports: () => mN, + getResolvedExternalModuleName: () => XB, + getResolvedModuleFromResolution: () => _x, + getResolvedTypeReferenceDirectiveFromResolution: () => B7, + getRestIndicatorOfBindingOrAssignmentElement: () => JF, + getRestParameterElementType: () => SB, + getRightMostAssignedExpression: () => B3, + getRootDeclaration: () => _m, + getRootDirectoryOfResolutionCache: () => rse, + getRootLength: () => kd, + getScriptKind: () => rq, + getScriptKindFromFileName: () => K5, + getScriptTargetFeatures: () => oB, + getSelectedEffectiveModifierFlags: () => xx, + getSelectedSyntacticModifierFlags: () => eee, + getSemanticClassifications: () => Jae, + getSemanticJsxChildren: () => QC, + getSetAccessorTypeAnnotationNode: () => XK, + getSetAccessorValueParameter: () => e4, + getSetExternalModuleIndicator: () => pN, + getShebang: () => m7, + getSingleVariableOfVariableStatement: () => bx, + getSnapshotText: () => fk, + getSnippetElement: () => az, + getSourceFileOfModule: () => y3, + getSourceFileOfNode: () => xr, + getSourceFilePathInNewDir: () => D5, + getSourceFileVersionAsHashFromText: () => ZO, + getSourceFilesToEmit: () => E5, + getSourceMapRange: () => x0, + getSourceMapper: () => roe, + getSourceTextOfNodeFromSourceFile: () => Db, + getSpanOfTokenAtPosition: () => om, + getSpellingSuggestion: () => Sb, + getStartPositionOfLine: () => Ny, + getStartPositionOfRange: () => i4, + getStartsOnNewLine: () => k4, + getStaticPropertiesAndClassStaticBlock: () => CO, + getStrictOptionValue: () => du, + getStringComparer: () => vC, + getSubPatternFromSpec: () => Q5, + getSuperCallFromStatement: () => xO, + getSuperContainer: () => N3, + getSupportedCodeFixes: () => tH, + getSupportedExtensions: () => _4, + getSupportedExtensionsWithJsonIfResolveJsonModule: () => bN, + getSwitchedType: () => sq, + getSymbolId: () => Xs, + getSymbolNameForPrivateIdentifier: () => Z3, + getSymbolTarget: () => nq, + getSyntacticClassifications: () => zae, + getSyntacticModifierFlags: () => h0, + getSyntacticModifierFlagsNoCache: () => iJ, + getSynthesizedDeepClone: () => qa, + getSynthesizedDeepCloneWithReplacements: () => PN, + getSynthesizedDeepClones: () => qb, + getSynthesizedDeepClonesWithReplacements: () => ez, + getSyntheticLeadingComments: () => l6, + getSyntheticTrailingComments: () => ON, + getTargetLabel: () => g9, + getTargetOfBindingOrAssignmentElement: () => $y, + getTemporaryModuleResolutionState: () => G4, + getTextOfConstantValue: () => KZ, + getTextOfIdentifierOrLiteral: () => op, + getTextOfJSDocComment: () => s3, + getTextOfJsxAttributeName: () => DN, + getTextOfJsxNamespacedName: () => T4, + getTextOfNode: () => Qo, + getTextOfNodeFromSourceText: () => ID, + getTextOfPropertyName: () => dx, + getThisContainer: () => qu, + getThisParameter: () => Rb, + getTokenAtPosition: () => vi, + getTokenPosOfNode: () => Ay, + getTokenSourceMapRange: () => _0e, + getTouchingPropertyName: () => w_, + getTouchingToken: () => H6, + getTrailingCommentRanges: () => Sy, + getTrailingSemicolonDeferringWriter: () => $B, + getTransformers: () => mie, + getTsBuildInfoEmitOutputFilePath: () => hv, + getTsConfigObjectLiteralExpression: () => MD, + getTsConfigPropArrayElementValue: () => e5, + getTypeAnnotationNode: () => QK, + getTypeArgumentOrTypeParameterList: () => lae, + getTypeKeywordOfTypeOnlyImport: () => $V, + getTypeNode: () => Tte, + getTypeNodeIfAccessible: () => Cw, + getTypeParameterFromJsDoc: () => FK, + getTypeParameterOwner: () => ihe, + getTypesPackageName: () => mO, + getUILocale: () => _Q, + getUniqueName: () => qS, + getUniqueSymbolId: () => Cae, + getUseDefineForClassFields: () => gN, + getWatchErrorSummaryDiagnosticMessage: () => LU, + getWatchFactory: () => cU, + group: () => yC, + groupBy: () => LR, + guessIndentation: () => BZ, + handleNoEmitOptions: () => SU, + handleWatchOptionsConfigDirTemplateSubstitution: () => rO, + hasAbstractModifier: () => Jb, + hasAccessorModifier: () => fm, + hasAmbientModifier: () => nJ, + hasChangesInResolutions: () => nB, + hasContextSensitiveParameters: () => aF, + hasDecorators: () => Ff, + hasDocComment: () => oae, + hasDynamicName: () => Th, + hasEffectiveModifier: () => sf, + hasEffectiveModifiers: () => rJ, + hasEffectiveReadonlyModifier: () => gS, + hasExtension: () => xC, + hasImplementationTSFileExtension: () => Ree, + hasIndexSignature: () => iq, + hasInferredType: () => fF, + hasInitializer: () => d0, + hasInvalidEscape: () => HB, + hasJSDocNodes: () => kf, + hasJSDocParameterTags: () => uZ, + hasJSFileExtension: () => Bg, + hasJsonModuleEmitEnabled: () => V5, + hasOnlyExpressionInitializer: () => iS, + hasOverrideModifier: () => N5, + hasPossibleExternalModuleReference: () => iK, + hasProperty: () => eo, + hasPropertyAccessExpressionWithName: () => BA, + hasQuestionToken: () => yx, + hasRecordedExternalHelpers: () => cre, + hasResolutionModeOverride: () => ete, + hasRestParameter: () => Zj, + hasScopeMarker: () => NZ, + hasStaticModifier: () => cl, + hasSyntacticModifier: () => Gn, + hasSyntacticModifiers: () => KK, + hasTSFileExtension: () => yS, + hasTabstop: () => Yee, + hasTrailingDirectorySeparator: () => vy, + hasType: () => O7, + hasTypeArguments: () => Ihe, + hasZeroOrOneAsteriskCharacter: () => CJ, + hostGetCanonicalFileName: () => xh, + hostUsesCaseSensitiveFileNames: () => mS, + idText: () => An, + identifierIsThisKeyword: () => eJ, + identifierToKeywordKind: () => Z2, + identity: () => go, + identitySourceMapConsumer: () => BW, + ignoreSourceNewlines: () => cz, + ignoredPaths: () => a7, + importFromModuleSpecifier: () => UD, + importSyntaxAffectsModuleResolution: () => xJ, + indexOfAnyCharCode: () => KX, + indexOfNode: () => MC, + indicesOf: () => $I, + inferredTypesContainingFile: () => cw, + injectClassNamedEvaluationHelperBlockIfMissing: () => PO, + injectClassThisAssignmentIfMissing: () => Wne, + insertImports: () => GV, + insertSorted: () => _y, + insertStatementAfterCustomPrologue: () => sS, + insertStatementAfterStandardPrologue: () => Che, + insertStatementsAfterCustomPrologue: () => iB, + insertStatementsAfterStandardPrologue: () => Ig, + intersperse: () => xR, + intrinsicTagNameToString: () => qJ, + introducesArgumentsExoticObject: () => hK, + inverseJsxOptionMap: () => eA, + isAbstractConstructorSymbol: () => gee, + isAbstractModifier: () => Ote, + isAccessExpression: () => To, + isAccessibilityModifier: () => LV, + isAccessor: () => Dy, + isAccessorModifier: () => dz, + isAliasableExpression: () => m5, + isAmbientModule: () => Vu, + isAmbientPropertyDeclaration: () => dB, + isAnyDirectorySeparator: () => hj, + isAnyImportOrBareOrAccessedRequire: () => rK, + isAnyImportOrReExport: () => T3, + isAnyImportOrRequireStatement: () => nK, + isAnyImportSyntax: () => px, + isAnySupportedFileExtension: () => r0e, + isApplicableVersionedTypesKey: () => uA, + isArgumentExpressionOfElementAccess: () => kV, + isArray: () => as, + isArrayBindingElement: () => w7, + isArrayBindingOrAssignmentElement: () => _3, + isArrayBindingOrAssignmentPattern: () => Hj, + isArrayBindingPattern: () => D0, + isArrayLiteralExpression: () => nu, + isArrayLiteralOrObjectLiteralDestructuringPattern: () => N0, + isArrayTypeNode: () => jN, + isArrowFunction: () => xo, + isAsExpression: () => d6, + isAssertClause: () => Wte, + isAssertEntry: () => T0e, + isAssertionExpression: () => Eb, + isAssertsKeyword: () => Ite, + isAssignmentDeclaration: () => JD, + isAssignmentExpression: () => Nl, + isAssignmentOperator: () => kh, + isAssignmentPattern: () => wD, + isAssignmentTarget: () => Ly, + isAsteriskToken: () => MN, + isAsyncFunction: () => $D, + isAsyncModifier: () => D4, + isAutoAccessorPropertyDeclaration: () => b_, + isAwaitExpression: () => Hy, + isAwaitKeyword: () => pz, + isBigIntLiteral: () => u6, + isBinaryExpression: () => _n, + isBinaryLogicalOperator: () => iN, + isBinaryOperatorToken: () => gre, + isBindableObjectDefinePropertyCall: () => uS, + isBindableStaticAccessExpression: () => Ib, + isBindableStaticElementAccessExpression: () => f5, + isBindableStaticNameExpression: () => _S, + isBindingElement: () => ya, + isBindingElementOfBareOrAccessedRequire: () => EK, + isBindingName: () => rS, + isBindingOrAssignmentElement: () => EZ, + isBindingOrAssignmentPattern: () => l3, + isBindingPattern: () => ws, + isBlock: () => Ns, + isBlockLike: () => dk, + isBlockOrCatchScoped: () => cB, + isBlockScope: () => mB, + isBlockScopedContainerTopLevel: () => tK, + isBooleanLiteral: () => DD, + isBreakOrContinueStatement: () => xD, + isBreakStatement: () => v0e, + isBuildCommand: () => kse, + isBuildInfoFile: () => gie, + isBuilderProgram: () => RU, + isBundle: () => Hte, + isCallChain: () => K2, + isCallExpression: () => Ps, + isCallExpressionTarget: () => yV, + isCallLikeExpression: () => Cb, + isCallLikeOrFunctionLikeExpression: () => Gj, + isCallOrNewExpression: () => sm, + isCallOrNewExpressionTarget: () => vV, + isCallSignatureDeclaration: () => Ux, + isCallToHelper: () => E4, + isCaseBlock: () => O4, + isCaseClause: () => y6, + isCaseKeyword: () => Mte, + isCaseOrDefaultClause: () => I7, + isCatchClause: () => Zb, + isCatchClauseVariableDeclaration: () => Qee, + isCatchClauseVariableDeclarationOrBindingElement: () => lB, + isCheckJsEnabledForFile: () => d4, + isCircularBuildOrder: () => uk, + isClassDeclaration: () => tl, + isClassElement: () => Hc, + isClassExpression: () => Rc, + isClassInstanceProperty: () => kZ, + isClassLike: () => $n, + isClassMemberModifier: () => Uj, + isClassNamedEvaluationHelperBlock: () => ok, + isClassOrTypeElement: () => D7, + isClassStaticBlockDeclaration: () => kc, + isClassThisAssignmentBlock: () => tw, + isColonToken: () => Nte, + isCommaExpression: () => qN, + isCommaListExpression: () => I4, + isCommaSequence: () => B4, + isCommaToken: () => Pte, + isComment: () => E9, + isCommonJsExportPropertyAssignment: () => Z7, + isCommonJsExportedExpression: () => mK, + isCompoundAssignment: () => Z4, + isComputedNonLiteralName: () => x3, + isComputedPropertyName: () => Gs, + isConciseBody: () => N7, + isConditionalExpression: () => ES, + isConditionalTypeNode: () => Gb, + isConstAssertion: () => HJ, + isConstTypeReference: () => nd, + isConstructSignatureDeclaration: () => N4, + isConstructorDeclaration: () => nc, + isConstructorTypeNode: () => _6, + isContextualKeyword: () => h5, + isContinueStatement: () => y0e, + isCustomPrologue: () => w3, + isDebuggerStatement: () => b0e, + isDeclaration: () => Pl, + isDeclarationBindingElement: () => c3, + isDeclarationFileName: () => Il, + isDeclarationName: () => Qm, + isDeclarationNameOfEnumOrNamespace: () => dJ, + isDeclarationReadonly: () => C3, + isDeclarationStatement: () => OZ, + isDeclarationWithTypeParameterChildren: () => hB, + isDeclarationWithTypeParameters: () => gB, + isDecorator: () => ul, + isDecoratorTarget: () => Qse, + isDefaultClause: () => L4, + isDefaultImport: () => fS, + isDefaultModifier: () => kF, + isDefaultedExpandoInitializer: () => DK, + isDeleteExpression: () => jte, + isDeleteTarget: () => OB, + isDeprecatedDeclaration: () => q9, + isDestructuringAssignment: () => y0, + isDiskPathRoot: () => yj, + isDoStatement: () => h0e, + isDocumentRegistryEntry: () => s8, + isDotDotDotToken: () => TF, + isDottedName: () => aN, + isDynamicName: () => v5, + isEffectiveExternalModule: () => RC, + isEffectiveStrictModeSourceFile: () => pB, + isElementAccessChain: () => Rj, + isElementAccessExpression: () => uo, + isEmittedFileOfProgram: () => xie, + isEmptyArrayLiteral: () => oee, + isEmptyBindingElement: () => nZ, + isEmptyBindingPattern: () => rZ, + isEmptyObjectLiteral: () => lJ, + isEmptyStatement: () => hz, + isEmptyStringLiteral: () => kB, + isEntityName: () => r_, + isEntityNameExpression: () => to, + isEnumConst: () => V1, + isEnumDeclaration: () => ov, + isEnumMember: () => Ph, + isEqualityOperatorKind: () => j9, + isEqualsGreaterThanToken: () => Ate, + isExclamationToken: () => RN, + isExcludedFile: () => qre, + isExclusivelyTypeOnlyImportOrExport: () => mU, + isExpandoPropertyDeclaration: () => Mx, + isExportAssignment: () => Mo, + isExportDeclaration: () => Bc, + isExportModifier: () => zx, + isExportName: () => jF, + isExportNamespaceAsDefaultDeclaration: () => V7, + isExportOrDefaultModifier: () => XN, + isExportSpecifier: () => Nu, + isExportsIdentifier: () => lS, + isExportsOrModuleExportsOrAlias: () => t2, + isExpression: () => ut, + isExpressionNode: () => Xm, + isExpressionOfExternalModuleImportEqualsDeclaration: () => Kse, + isExpressionOfOptionalChainRoot: () => x7, + isExpressionStatement: () => Al, + isExpressionWithTypeArguments: () => Dh, + isExpressionWithTypeArgumentsInClassExtendsClause: () => I5, + isExternalModule: () => fl, + isExternalModuleAugmentation: () => Pb, + isExternalModuleImportEqualsDeclaration: () => H1, + isExternalModuleIndicator: () => p3, + isExternalModuleNameRelative: () => Dl, + isExternalModuleReference: () => wh, + isExternalModuleSymbol: () => lx, + isExternalOrCommonJsModule: () => tf, + isFileLevelReservedGeneratedIdentifier: () => o3, + isFileLevelUniqueName: () => W7, + isFileProbablyExternalModule: () => ZN, + isFirstDeclarationOfSymbolParameter: () => KV, + isFixablePromiseHandler: () => Nq, + isForInOrOfStatement: () => nS, + isForInStatement: () => PF, + isForInitializer: () => ip, + isForOfStatement: () => JN, + isForStatement: () => av, + isFullSourceFile: () => Og, + isFunctionBlock: () => Nb, + isFunctionBody: () => Xj, + isFunctionDeclaration: () => Cc, + isFunctionExpression: () => yo, + isFunctionExpressionOrArrowFunction: () => zy, + isFunctionLike: () => Es, + isFunctionLikeDeclaration: () => io, + isFunctionLikeKind: () => sx, + isFunctionLikeOrClassStaticBlockDeclaration: () => IC, + isFunctionOrConstructorTypeNode: () => CZ, + isFunctionOrModuleBlock: () => Vj, + isFunctionSymbol: () => NK, + isFunctionTypeNode: () => Zm, + isGeneratedIdentifier: () => Bo, + isGeneratedPrivateIdentifier: () => tS, + isGetAccessor: () => Pg, + isGetAccessorDeclaration: () => pp, + isGetOrSetAccessorDeclaration: () => a3, + isGlobalScopeAugmentation: () => $m, + isGlobalSourceFile: () => m0, + isGrammarError: () => $Z, + isHeritageClause: () => cf, + isHoistedFunction: () => Q7, + isHoistedVariableStatement: () => Y7, + isIdentifier: () => Me, + isIdentifierANonContextualKeyword: () => BB, + isIdentifierName: () => jK, + isIdentifierOrThisTypeNode: () => fre, + isIdentifierPart: () => hh, + isIdentifierStart: () => Vm, + isIdentifierText: () => R_, + isIdentifierTypePredicate: () => yK, + isIdentifierTypeReference: () => qee, + isIfStatement: () => sv, + isIgnoredFileFromWildCardWatching: () => kA, + isImplicitGlob: () => wJ, + isImportAttribute: () => Ute, + isImportAttributeName: () => xZ, + isImportAttributes: () => PS, + isImportCall: () => T_, + isImportClause: () => ld, + isImportDeclaration: () => qo, + isImportEqualsDeclaration: () => _l, + isImportKeyword: () => P4, + isImportMeta: () => JC, + isImportOrExportSpecifier: () => Cy, + isImportOrExportSpecifierName: () => kae, + isImportSpecifier: () => Xu, + isImportTypeAssertionContainer: () => S0e, + isImportTypeNode: () => ym, + isImportable: () => yq, + isInComment: () => P0, + isInCompoundLikeAssignment: () => FB, + isInExpressionContext: () => a5, + isInJSDoc: () => BD, + isInJSFile: () => an, + isInJSXText: () => aae, + isInJsonFile: () => c5, + isInNonReferenceComment: () => fae, + isInReferenceComment: () => _ae, + isInRightSideOfInternalImportEqualsDeclaration: () => d9, + isInString: () => _k, + isInTemplateString: () => AV, + isInTopLevelContext: () => n5, + isInTypeQuery: () => Tx, + isIncrementalBuildInfo: () => NA, + isIncrementalBundleEmitBuildInfo: () => Vie, + isIncrementalCompilation: () => Wb, + isIndexSignatureDeclaration: () => qy, + isIndexedAccessTypeNode: () => $b, + isInferTypeNode: () => xS, + isInfinityOrNaNString: () => v4, + isInitializedProperty: () => dA, + isInitializedVariable: () => _N, + isInsideJsxElement: () => k9, + isInsideJsxElementOrAttribute: () => sae, + isInsideNodeModules: () => e8, + isInsideTemplateLiteral: () => VA, + isInstanceOfExpression: () => F5, + isInstantiatedModule: () => IW, + isInterfaceDeclaration: () => Vl, + isInternalDeclaration: () => JZ, + isInternalModuleImportEqualsDeclaration: () => cS, + isInternalName: () => Fz, + isIntersectionTypeNode: () => Hx, + isIntrinsicJsxName: () => YC, + isIterationStatement: () => wy, + isJSDoc: () => Od, + isJSDocAllType: () => Xte, + isJSDocAugmentsTag: () => Yx, + isJSDocAuthorTag: () => E0e, + isJSDocCallbackTag: () => Sz, + isJSDocClassTag: () => Yte, + isJSDocCommentContainingNode: () => F7, + isJSDocConstructSignature: () => vx, + isJSDocDeprecatedTag: () => Ez, + isJSDocEnumTag: () => WN, + isJSDocFunctionType: () => b6, + isJSDocImplementsTag: () => LF, + isJSDocImportTag: () => xm, + isJSDocIndexSignature: () => u5, + isJSDocLikeText: () => Wz, + isJSDocLink: () => Gte, + isJSDocLinkCode: () => $te, + isJSDocLinkLike: () => cx, + isJSDocLinkPlain: () => k0e, + isJSDocMemberName: () => uv, + isJSDocNameReference: () => M4, + isJSDocNamepathType: () => C0e, + isJSDocNamespaceBody: () => yhe, + isJSDocNode: () => FC, + isJSDocNonNullableType: () => AF, + isJSDocNullableType: () => v6, + isJSDocOptionalParameter: () => cF, + isJSDocOptionalType: () => bz, + isJSDocOverloadTag: () => S6, + isJSDocOverrideTag: () => FF, + isJSDocParameterTag: () => Lf, + isJSDocPrivateTag: () => xz, + isJSDocPropertyLikeTag: () => kD, + isJSDocPropertyTag: () => Zte, + isJSDocProtectedTag: () => kz, + isJSDocPublicTag: () => Tz, + isJSDocReadonlyTag: () => Cz, + isJSDocReturnTag: () => OF, + isJSDocSatisfiesExpression: () => UJ, + isJSDocSatisfiesTag: () => MF, + isJSDocSeeTag: () => D0e, + isJSDocSignature: () => w0, + isJSDocTag: () => OC, + isJSDocTemplateTag: () => Up, + isJSDocThisTag: () => Dz, + isJSDocThrowsTag: () => P0e, + isJSDocTypeAlias: () => jp, + isJSDocTypeAssertion: () => Kb, + isJSDocTypeExpression: () => lv, + isJSDocTypeLiteral: () => AS, + isJSDocTypeTag: () => R4, + isJSDocTypedefTag: () => IS, + isJSDocUnknownTag: () => w0e, + isJSDocUnknownType: () => Qte, + isJSDocVariadicType: () => IF, + isJSXTagName: () => UC, + isJsonEqual: () => iF, + isJsonSourceFile: () => ap, + isJsxAttribute: () => Tm, + isJsxAttributeLike: () => A7, + isJsxAttributeName: () => Kee, + isJsxAttributes: () => Yb, + isJsxCallLike: () => jZ, + isJsxChild: () => g3, + isJsxClosingElement: () => Qb, + isJsxClosingFragment: () => qte, + isJsxElement: () => Sm, + isJsxExpression: () => h6, + isJsxFragment: () => cv, + isJsxNamespacedName: () => Fd, + isJsxOpeningElement: () => Id, + isJsxOpeningFragment: () => ud, + isJsxOpeningLikeElement: () => wu, + isJsxOpeningLikeElementTagName: () => Yse, + isJsxSelfClosingElement: () => NS, + isJsxSpreadAttribute: () => Qx, + isJsxTagNameExpression: () => PD, + isJsxText: () => Bx, + isJumpStatementTarget: () => JA, + isKeyword: () => k_, + isKeywordOrPunctuation: () => g5, + isKnownSymbol: () => QD, + isLabelName: () => TV, + isLabelOfLabeledStatement: () => SV, + isLabeledStatement: () => Gy, + isLateVisibilityPaintedStatement: () => H7, + isLeftHandSideExpression: () => S_, + isLet: () => X7, + isLineBreak: () => Cu, + isLiteralComputedPropertyDeclarationName: () => X3, + isLiteralExpression: () => eS, + isLiteralExpressionOfObject: () => zj, + isLiteralImportTypeNode: () => bh, + isLiteralKind: () => CD, + isLiteralNameOfPropertyDeclarationOrIndexAccess: () => h9, + isLiteralTypeLiteral: () => PZ, + isLiteralTypeNode: () => E0, + isLocalName: () => Nh, + isLogicalOperator: () => iee, + isLogicalOrCoalescingAssignmentExpression: () => sJ, + isLogicalOrCoalescingAssignmentOperator: () => t4, + isLogicalOrCoalescingBinaryExpression: () => sN, + isLogicalOrCoalescingBinaryOperator: () => A5, + isMappedTypeNode: () => CS, + isMemberName: () => wg, + isMetaProperty: () => DS, + isMethodDeclaration: () => rc, + isMethodOrAccessor: () => ax, + isMethodSignature: () => cd, + isMinusToken: () => fz, + isMissingDeclaration: () => x0e, + isMissingPackageJsonInfo: () => rne, + isModifier: () => Zs, + isModifierKind: () => Ey, + isModifierLike: () => Jo, + isModuleAugmentationExternal: () => _B, + isModuleBlock: () => vm, + isModuleBody: () => AZ, + isModuleDeclaration: () => jc, + isModuleExportName: () => NF, + isModuleExportsAccessExpression: () => Lg, + isModuleIdentifier: () => DB, + isModuleName: () => mre, + isModuleOrEnumDeclaration: () => d3, + isModuleReference: () => MZ, + isModuleSpecifierLike: () => I9, + isModuleWithStringLiteralName: () => q7, + isNameOfFunctionDeclaration: () => EV, + isNameOfModuleDeclaration: () => CV, + isNamedDeclaration: () => wl, + isNamedEvaluation: () => rf, + isNamedEvaluationSource: () => JB, + isNamedExportBindings: () => Bj, + isNamedExports: () => mp, + isNamedImportBindings: () => Qj, + isNamedImports: () => bm, + isNamedImportsOrExports: () => B5, + isNamedTupleMember: () => f6, + isNamespaceBody: () => hhe, + isNamespaceExport: () => Km, + isNamespaceExportDeclaration: () => zN, + isNamespaceImport: () => Ug, + isNamespaceReexportDeclaration: () => CK, + isNewExpression: () => Xb, + isNewExpressionTarget: () => dw, + isNewScopeNode: () => ate, + isNoSubstitutionTemplateLiteral: () => TS, + isNodeArray: () => xb, + isNodeArrayMultiLine: () => pee, + isNodeDescendantOf: () => Ob, + isNodeKind: () => C7, + isNodeLikeSystem: () => GR, + isNodeModulesDirectory: () => _7, + isNodeWithPossibleHoistedDeclaration: () => MK, + isNonContextualKeyword: () => jB, + isNonGlobalAmbientModule: () => uB, + isNonNullAccess: () => Zee, + isNonNullChain: () => k7, + isNonNullExpression: () => $x, + isNonStaticMethodOrAccessorWithPrivateName: () => Lne, + isNotEmittedStatement: () => Vte, + isNullishCoalesce: () => jj, + isNumber: () => dy, + isNumericLiteral: () => E_, + isNumericLiteralName: () => zg, + isObjectBindingElementWithoutPropertyName: () => $A, + isObjectBindingOrAssignmentElement: () => u3, + isObjectBindingOrAssignmentPattern: () => qj, + isObjectBindingPattern: () => Of, + isObjectLiteralElement: () => Yj, + isObjectLiteralElementLike: () => vh, + isObjectLiteralExpression: () => _a, + isObjectLiteralMethod: () => Rp, + isObjectLiteralOrClassExpressionMethodOrAccessor: () => K7, + isObjectTypeDeclaration: () => Dx, + isOmittedExpression: () => vl, + isOptionalChain: () => Eu, + isOptionalChainRoot: () => SD, + isOptionalDeclaration: () => Ox, + isOptionalJSDocPropertyLikeTag: () => EN, + isOptionalTypeNode: () => CF, + isOuterExpression: () => BF, + isOutermostOptionalChain: () => TD, + isOverrideModifier: () => Lte, + isPackageJsonInfo: () => uO, + isPackedArrayLiteral: () => zJ, + isParameter: () => Ii, + isParameterPropertyDeclaration: () => K_, + isParameterPropertyModifier: () => ED, + isParenthesizedExpression: () => o_, + isParenthesizedTypeNode: () => kS, + isParseTreeNode: () => bD, + isPartOfParameterDeclaration: () => Y1, + isPartOfTypeNode: () => lm, + isPartOfTypeOnlyImportOrExportDeclaration: () => TZ, + isPartOfTypeQuery: () => o5, + isPartiallyEmittedExpression: () => Bte, + isPatternMatch: () => YI, + isPinnedComment: () => U7, + isPlainJsFile: () => AD, + isPlusToken: () => _z, + isPossiblyTypeArgumentPosition: () => UA, + isPostfixUnaryExpression: () => gz, + isPrefixUnaryExpression: () => iv, + isPrimitiveLiteralValue: () => _F, + isPrivateIdentifier: () => Ai, + isPrivateIdentifierClassElementDeclaration: () => Du, + isPrivateIdentifierPropertyAccessExpression: () => AC, + isPrivateIdentifierSymbol: () => zK, + isProgramUptoDate: () => vU, + isPrologueDirective: () => cm, + isPropertyAccessChain: () => T7, + isPropertyAccessEntityNameExpression: () => oN, + isPropertyAccessExpression: () => wn, + isPropertyAccessOrQualifiedName: () => f3, + isPropertyAccessOrQualifiedNameOrImportTypeNode: () => DZ, + isPropertyAssignment: () => rl, + isPropertyDeclaration: () => os, + isPropertyName: () => qc, + isPropertyNameLiteral: () => um, + isPropertySignature: () => $u, + isPrototypeAccess: () => jy, + isPrototypePropertyAssignment: () => W3, + isPunctuation: () => RB, + isPushOrUnshiftIdentifier: () => zB, + isQualifiedName: () => s_, + isQuestionDotToken: () => xF, + isQuestionOrExclamationToken: () => _re, + isQuestionOrPlusOrMinusToken: () => dre, + isQuestionToken: () => Vy, + isReadonlyKeyword: () => Fte, + isReadonlyKeywordOrPlusOrMinusToken: () => pre, + isRecognizedTripleSlashComment: () => sB, + isReferenceFileLocation: () => j6, + isReferencedFile: () => yv, + isRegularExpressionLiteral: () => lz, + isRequireCall: () => x_, + isRequireVariableStatement: () => M3, + isRestParameter: () => Hm, + isRestTypeNode: () => EF, + isReturnStatement: () => Cf, + isReturnStatementWithFixablePromiseHandler: () => K9, + isRightSideOfAccessExpression: () => cJ, + isRightSideOfInstanceofExpression: () => aee, + isRightSideOfPropertyAccess: () => U6, + isRightSideOfQualifiedName: () => Zse, + isRightSideOfQualifiedNameOrPropertyAccess: () => r4, + isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName: () => see, + isRootedDiskPath: () => Z_, + isSameEntityName: () => VC, + isSatisfiesExpression: () => m6, + isSemicolonClassElement: () => Jte, + isSetAccessor: () => am, + isSetAccessorDeclaration: () => z_, + isShiftOperatorOrHigher: () => Bz, + isShorthandAmbientModuleSymbol: () => S3, + isShorthandPropertyAssignment: () => gu, + isSideEffectImport: () => $J, + isSignedNumericLiteral: () => y5, + isSimpleCopiableExpression: () => r2, + isSimpleInlineableExpression: () => rg, + isSimpleParameterList: () => mA, + isSingleOrDoubleQuote: () => R3, + isSolutionConfig: () => cW, + isSourceElement: () => tte, + isSourceFile: () => Di, + isSourceFileFromLibrary: () => K6, + isSourceFileJS: () => n_, + isSourceFileNotJson: () => l5, + isSourceMapping: () => Ine, + isSpecialPropertyDeclaration: () => PK, + isSpreadAssignment: () => Vg, + isSpreadElement: () => dp, + isStatement: () => Ti, + isStatementButNotDeclaration: () => m3, + isStatementOrBlock: () => LZ, + isStatementWithLocals: () => GZ, + isStatic: () => Js, + isStaticModifier: () => Wx, + isString: () => gs, + isStringANonContextualKeyword: () => Sx, + isStringAndEmptyAnonymousObjectIntersection: () => uae, + isStringDoubleQuoted: () => _5, + isStringLiteral: () => ca, + isStringLiteralLike: () => ja, + isStringLiteralOrJsxExpression: () => RZ, + isStringLiteralOrTemplate: () => wae, + isStringOrNumericLiteralLike: () => If, + isStringOrRegularExpressionOrTemplateLiteral: () => OV, + isStringTextContainingNode: () => Wj, + isSuperCall: () => oS, + isSuperKeyword: () => w4, + isSuperProperty: () => j_, + isSupportedSourceFileName: () => FJ, + isSwitchStatement: () => F4, + isSyntaxList: () => T6, + isSyntheticExpression: () => g0e, + isSyntheticReference: () => Xx, + isTagName: () => xV, + isTaggedTemplateExpression: () => nv, + isTaggedTemplateTag: () => Xse, + isTemplateExpression: () => wF, + isTemplateHead: () => Jx, + isTemplateLiteral: () => ox, + isTemplateLiteralKind: () => ky, + isTemplateLiteralToken: () => bZ, + isTemplateLiteralTypeNode: () => Rte, + isTemplateLiteralTypeSpan: () => mz, + isTemplateMiddle: () => uz, + isTemplateMiddleOrTemplateTail: () => E7, + isTemplateSpan: () => g6, + isTemplateTail: () => SF, + isTextWhiteSpaceLike: () => gae, + isThis: () => V6, + isThisContainerOrFunctionBlock: () => TK, + isThisIdentifier: () => Ry, + isThisInTypeQuery: () => jb, + isThisInitializedDeclaration: () => i5, + isThisInitializedObjectBindingExpression: () => kK, + isThisProperty: () => A3, + isThisTypeNode: () => A4, + isThisTypeParameter: () => b4, + isThisTypePredicate: () => vK, + isThrowStatement: () => vz, + isToken: () => ix, + isTokenKind: () => Jj, + isTraceEnabled: () => Xy, + isTransientSymbol: () => Ng, + isTrivia: () => XC, + isTryStatement: () => wS, + isTupleTypeNode: () => qx, + isTypeAlias: () => q3, + isTypeAliasDeclaration: () => Wp, + isTypeAssertionExpression: () => DF, + isTypeDeclaration: () => Fx, + isTypeElement: () => kb, + isTypeKeyword: () => yw, + isTypeKeywordTokenOrIdentifier: () => P9, + isTypeLiteralNode: () => a_, + isTypeNode: () => li, + isTypeNodeKind: () => yJ, + isTypeOfExpression: () => p6, + isTypeOnlyExportDeclaration: () => SZ, + isTypeOnlyImportDeclaration: () => NC, + isTypeOnlyImportOrExportDeclaration: () => p0, + isTypeOperatorNode: () => rv, + isTypeParameterDeclaration: () => Lo, + isTypePredicateNode: () => Vx, + isTypeQueryNode: () => Hb, + isTypeReferenceNode: () => of, + isTypeReferenceType: () => L7, + isTypeUsableAsPropertyName: () => _p, + isUMDExportSymbol: () => j5, + isUnaryExpression: () => $j, + isUnaryExpressionWithWrite: () => wZ, + isUnicodeIdentifierStart: () => p7, + isUnionTypeNode: () => C0, + isUrl: () => LY, + isValidBigIntString: () => sF, + isValidESSymbolDeclaration: () => gK, + isValidTypeOnlyAliasUseSite: () => K1, + isValueSignatureDeclaration: () => pS, + isVarAwaitUsing: () => E3, + isVarConst: () => BC, + isVarConstLike: () => fK, + isVarUsing: () => D3, + isVariableDeclaration: () => ei, + isVariableDeclarationInVariableStatement: () => LD, + isVariableDeclarationInitializedToBareOrAccessedRequire: () => Ab, + isVariableDeclarationInitializedToRequire: () => L3, + isVariableDeclarationList: () => Ul, + isVariableLike: () => OD, + isVariableStatement: () => Ic, + isVoidExpression: () => Gx, + isWatchSet: () => mJ, + isWhileStatement: () => yz, + isWhiteSpaceLike: () => Cg, + isWhiteSpaceSingleLine: () => im, + isWithStatement: () => zte, + isWriteAccess: () => Ex, + isWriteOnlyAccess: () => R5, + isYieldExpression: () => BN, + jsxModeNeedsExplicitImport: () => mq, + keywordPart: () => ff, + last: () => pa, + lastOrUndefined: () => Do, + length: () => wr, + libMap: () => Gz, + libs: () => HF, + lineBreakPart: () => Q6, + loadModuleFromGlobalCache: () => dne, + loadWithModeAwareCache: () => EA, + makeIdentifierFromModuleName: () => eK, + makeImport: () => r1, + makeStringLiteral: () => vw, + mangleScopedPackageName: () => F6, + map: () => hr, + mapAllOrFail: () => ER, + mapDefined: () => Fi, + mapDefinedIterator: () => uy, + mapEntries: () => rQ, + mapIterator: () => ZE, + mapOneOrMany: () => _q, + mapToDisplayParts: () => n1, + matchFiles: () => NJ, + matchPatternOrExact: () => LJ, + matchedText: () => gQ, + matchesExclude: () => sO, + matchesExcludeWorker: () => aO, + maxBy: () => BR, + maybeBind: () => Os, + maybeSetLocalizedDiagnosticMessages: () => Tee, + memoize: () => Uu, + memoizeOne: () => nm, + min: () => JR, + minAndMax: () => Wee, + missingFileModifiedTime: () => Y_, + modifierToFlag: () => kx, + modifiersToFlags: () => pm, + moduleExportNameIsDefault: () => Gm, + moduleExportNameTextEscaped: () => wb, + moduleExportNameTextUnescaped: () => Iy, + moduleOptionDeclaration: () => Dre, + moduleResolutionIsEqualTo: () => qZ, + moduleResolutionNameAndModeGetter: () => RO, + moduleResolutionOptionDeclarations: () => Xz, + moduleResolutionSupportsPackageJsonExportsAndImports: () => i6, + moduleResolutionUsesNodeModules: () => N9, + moduleSpecifierToValidIdentifier: () => r8, + moduleSpecifiers: () => Ih, + moduleSupportsImportAttributes: () => Pee, + moduleSymbolToValidIdentifier: () => t8, + moveEmitHelpers: () => bte, + moveRangeEnd: () => L5, + moveRangePastDecorators: () => Ch, + moveRangePastModifiers: () => dm, + moveRangePos: () => Z1, + moveSyntheticComments: () => hte, + mutateMap: () => o4, + mutateMapSkippingNewValues: () => Rg, + needsParentheses: () => M9, + needsScopeMarker: () => P7, + newCaseClauseTracker: () => $9, + newPrivateEnvironment: () => Rne, + noEmitNotification: () => vA, + noEmitSubstitution: () => nw, + noTransformers: () => die, + noTruncationMaximumTruncationLength: () => eB, + nodeCanBeDecorated: () => F3, + nodeCoreModules: () => c6, + nodeHasName: () => n3, + nodeIsDecorated: () => WC, + nodeIsMissing: () => lc, + nodeIsPresent: () => Mp, + nodeIsSynthesized: () => lo, + nodeModuleNameResolver: () => one, + nodeModulesPathPart: () => qg, + nodeNextJsonConfigResolver: () => cne, + nodeOrChildIsDecorated: () => O3, + nodeOverlapsWithStartEnd: () => y9, + nodePosToString: () => She, + nodeSeenTracker: () => G6, + nodeStartsNewLexicalEnvironment: () => WB, + noop: () => Ha, + noopFileWatcher: () => z6, + normalizePath: () => Hs, + normalizeSlashes: () => zl, + normalizeSpans: () => Pj, + not: () => KI, + notImplemented: () => Vs, + notImplementedResolver: () => vie, + nullNodeConverters: () => dte, + nullParenthesizerRules: () => fte, + nullTransformationContext: () => SA, + objectAllocator: () => tu, + operatorPart: () => Sw, + optionDeclarations: () => _d, + optionMapToObject: () => KF, + optionsAffectingProgramStructure: () => Are, + optionsForBuild: () => Yz, + optionsForWatch: () => rk, + optionsHaveChanges: () => ux, + or: () => Q_, + orderedRemoveItem: () => rD, + orderedRemoveItemAt: () => yy, + packageIdToPackageName: () => z7, + packageIdToString: () => U1, + parameterIsThisKeyword: () => My, + parameterNamePart: () => yae, + parseBaseNodeFactory: () => Sre, + parseBigInt: () => Vee, + parseBuildCommand: () => Bre, + parseCommandLine: () => Rre, + parseCommandLineWorker: () => Zz, + parseConfigFileTextToJson: () => eW, + parseConfigFileWithSystem: () => ise, + parseConfigHostFromCompilerHostLike: () => UO, + parseCustomTypeOption: () => QF, + parseIsolatedEntityName: () => tk, + parseIsolatedJSDocComment: () => xre, + parseJSDocTypeExpressionForTests: () => K0e, + parseJsonConfigFileContent: () => Pye, + parseJsonSourceFileConfigFileContent: () => sA, + parseJsonText: () => KN, + parseListTypeOption: () => Lre, + parseNodeFactory: () => fv, + parseNodeModuleFromPath: () => lA, + parsePackageName: () => pO, + parsePseudoBigInt: () => g4, + parseValidBigInt: () => BJ, + pasteEdits: () => dG, + patchWriteFileEnsuringDirectory: () => OY, + pathContainsNodeModules: () => Yy, + pathIsAbsolute: () => _D, + pathIsBareSpecifier: () => vj, + pathIsRelative: () => xf, + patternText: () => mQ, + performIncrementalCompilation: () => sse, + performance: () => kQ, + positionBelongsToNode: () => DV, + positionIsASICandidate: () => B9, + positionIsSynthesized: () => Nd, + positionsAreOnSameLine: () => lp, + preProcessFile: () => j2e, + probablyUsesSemicolons: () => KA, + processCommentPragmas: () => qz, + processPragmasIntoFields: () => Hz, + processTaggedTemplateExpression: () => GW, + programContainsEsModules: () => dae, + programContainsModules: () => pae, + projectReferenceIsEqualTo: () => tB, + propertyNamePart: () => vae, + pseudoBigIntToString: () => Ub, + punctuationPart: () => Fu, + pushIfUnique: () => tp, + quote: () => kw, + quotePreferenceFromString: () => VV, + rangeContainsPosition: () => q6, + rangeContainsPositionExclusive: () => zA, + rangeContainsRange: () => C_, + rangeContainsRangeExclusive: () => eae, + rangeContainsStartEnd: () => WA, + rangeEndIsOnSameLineAsRangeStart: () => uN, + rangeEndPositionsAreOnSameLine: () => _ee, + rangeEquals: () => AR, + rangeIsOnSingleLine: () => hS, + rangeOfNode: () => RJ, + rangeOfTypeParameters: () => jJ, + rangeOverlapsWithStartEnd: () => mw, + rangeStartIsOnSameLineAsRangeEnd: () => fee, + rangeStartPositionsAreOnSameLine: () => M5, + readBuilderProgram: () => e9, + readConfigFile: () => nA, + readJson: () => e6, + readJsonConfigFile: () => Jre, + readJsonOrUndefined: () => uJ, + reduceEachLeadingCommentRange: () => UY, + reduceEachTrailingCommentRange: () => VY, + reduceLeft: () => Wu, + reduceLeftIterator: () => ZX, + reducePathComponents: () => tx, + refactor: () => gk, + regExpEscape: () => Qhe, + regularExpressionFlagToCharacterCode: () => Xge, + relativeComplement: () => nQ, + removeAllComments: () => IN, + removeEmitHelper: () => f0e, + removeExtension: () => TN, + removeFileExtension: () => Gu, + removeIgnoredPath: () => GO, + removeMinAndVersionNumbers: () => UR, + removePrefix: () => nD, + removeSuffix: () => bC, + removeTrailingDirectorySeparator: () => _0, + repeatString: () => HA, + replaceElement: () => OR, + replaceFirstStar: () => vS, + resolutionExtensionIsTSOrJson: () => f4, + resolveConfigFileProjectName: () => YU, + resolveJSModule: () => ine, + resolveLibrary: () => fO, + resolveModuleName: () => MS, + resolveModuleNameFromCache: () => s1e, + resolvePackageNameToPackageJson: () => fW, + resolvePath: () => by, + resolveProjectReferencePath: () => ck, + resolveTripleslashReference: () => uU, + resolveTypeReferenceDirective: () => ene, + resolvingEmptyArray: () => Kj, + returnFalse: () => mh, + returnNoopFileWatcher: () => _w, + returnTrue: () => yb, + returnUndefined: () => vb, + returnsPromise: () => Pq, + rewriteModuleSpecifier: () => sk, + sameFlatMap: () => eQ, + sameMap: () => Qc, + sameMapping: () => X1e, + scanTokenAtPosition: () => _K, + scanner: () => ql, + semanticDiagnosticsOptionDeclarations: () => wre, + serializeCompilerOptions: () => sW, + server: () => Gwe, + servicesVersion: () => DTe, + setCommentRange: () => el, + setConfigFileInOptions: () => aW, + setConstantValue: () => vte, + setEmitFlags: () => un, + setGetSourceFileAsHashVersioned: () => KO, + setIdentifierAutoGenerate: () => LN, + setIdentifierGeneratedImportReference: () => xte, + setIdentifierTypeArguments: () => k0, + setInternalEmitFlags: () => FN, + setLocalizedDiagnosticMessages: () => See, + setNodeChildren: () => Kte, + setNodeFlags: () => Gee, + setObjectAllocator: () => bee, + setOriginalNode: () => Cn, + setParent: () => za, + setParentRecursive: () => ev, + setPrivateIdentifier: () => jS, + setSnippetElement: () => oz, + setSourceMapRange: () => ha, + setStackTraceLimit: () => Ige, + setStartsOnNewLine: () => hF, + setSyntheticLeadingComments: () => tv, + setSyntheticTrailingComments: () => Rx, + setSys: () => jge, + setSysLog: () => AY, + setTextRange: () => ct, + setTextRangeEnd: () => o6, + setTextRangePos: () => h4, + setTextRangePosEnd: () => Ad, + setTextRangePosWidth: () => JJ, + setTokenSourceMapRange: () => gte, + setTypeNode: () => Ste, + setUILocale: () => fQ, + setValueDeclaration: () => WD, + shouldAllowImportingTsExtension: () => O6, + shouldPreserveConstEnums: () => By, + shouldRewriteModuleSpecifier: () => V3, + shouldUseUriStyleNodeCoreModules: () => H9, + showModuleSpecifier: () => hee, + signatureHasRestParameter: () => Iu, + signatureToDisplayParts: () => tq, + single: () => FR, + singleElementArray: () => ZT, + singleIterator: () => tQ, + singleOrMany: () => Wm, + singleOrUndefined: () => xg, + skipAlias: () => eu, + skipConstraint: () => zV, + skipOuterExpressions: () => hc, + skipParentheses: () => Ba, + skipPartiallyEmittedExpressions: () => id, + skipTrivia: () => oa, + skipTypeChecking: () => a6, + skipTypeCheckingIgnoringNoCheck: () => Uee, + skipTypeParentheses: () => VD, + skipWhile: () => yQ, + sliceAfter: () => MJ, + some: () => ot, + sortAndDeduplicate: () => tD, + sortAndDeduplicateDiagnostics: () => DC, + sourceFileAffectingCompilerOptions: () => Qz, + sourceFileMayBeEmitted: () => Mb, + sourceMapCommentRegExp: () => LW, + sourceMapCommentRegExpDontCareLineStart: () => Pne, + spacePart: () => fc, + spanMap: () => DR, + startEndContainsRange: () => pJ, + startEndOverlapsWithStartEnd: () => v9, + startOnNewLine: () => Au, + startTracing: () => wQ, + startsWith: () => Ui, + startsWithDirectory: () => Tj, + startsWithUnderscore: () => dq, + startsWithUseStrict: () => are, + stringContainsAt: () => Lae, + stringToToken: () => Q2, + stripQuotes: () => Bp, + supportedDeclarationExtensions: () => tF, + supportedJSExtensionsFlat: () => s6, + supportedLocaleDirectories: () => sZ, + supportedTSExtensionsFlat: () => AJ, + supportedTSImplementationExtensions: () => vN, + suppressLeadingAndTrailingTrivia: () => af, + suppressLeadingTrivia: () => tz, + suppressTrailingTrivia: () => cte, + symbolEscapedNameNoDefault: () => A9, + symbolName: () => cc, + symbolNameNoDefault: () => HV, + symbolToDisplayParts: () => Tw, + sys: () => ml, + sysLog: () => qP, + tagNamesAreEquivalent: () => dv, + takeWhile: () => HR, + targetOptionDeclaration: () => $z, + targetToLibMap: () => qY, + testFormatSettings: () => a2e, + textChangeRangeIsUnchanged: () => eZ, + textChangeRangeNewSpan: () => vD, + textChanges: () => cn, + textOrKeywordPart: () => eq, + textPart: () => Bf, + textRangeContainsPositionInclusive: () => KP, + textRangeContainsTextSpan: () => $Y, + textRangeIntersectsWithTextSpan: () => ZY, + textSpanContainsPosition: () => Dj, + textSpanContainsTextRange: () => wj, + textSpanContainsTextSpan: () => GY, + textSpanEnd: () => ec, + textSpanIntersection: () => KY, + textSpanIntersectsWith: () => e3, + textSpanIntersectsWithPosition: () => YY, + textSpanIntersectsWithTextSpan: () => QY, + textSpanIsEmpty: () => HY, + textSpanOverlap: () => XY, + textSpanOverlapsWith: () => nhe, + textSpansEqual: () => X6, + textToKeywordObj: () => f7, + timestamp: () => ao, + toArray: () => QT, + toBuilderFileEmit: () => Gie, + toBuilderStateFileInfoForMultiEmit: () => Hie, + toEditorSettings: () => u8, + toFileNameLowerCase: () => my, + toPath: () => oo, + toProgramEmitPending: () => $ie, + toSorted: () => X_, + tokenIsIdentifierOrKeyword: () => v_, + tokenIsIdentifierOrKeywordOrGreaterThan: () => RY, + tokenToString: () => qs, + trace: () => ts, + tracing: () => on, + tracingEnabled: () => VP, + transferSourceFileChildren: () => ere, + transform: () => RTe, + transformClassFields: () => Gne, + transformDeclarations: () => YW, + transformECMAScriptModule: () => QW, + transformES2015: () => oie, + transformES2016: () => aie, + transformES2017: () => Yne, + transformES2018: () => Zne, + transformES2019: () => Kne, + transformES2020: () => eie, + transformES2021: () => tie, + transformESDecorators: () => Qne, + transformESNext: () => rie, + transformGenerators: () => cie, + transformImpliedNodeFormatDependentModule: () => uie, + transformJsx: () => sie, + transformLegacyDecorators: () => Xne, + transformModule: () => XW, + transformNamedEvaluation: () => lf, + transformNodes: () => bA, + transformSystemModule: () => lie, + transformTypeScript: () => Hne, + transpile: () => G2e, + transpileDeclaration: () => q2e, + transpileModule: () => ioe, + transpileOptionValueCompilerOptions: () => Ire, + tryAddToSet: () => u0, + tryAndIgnoreErrors: () => W9, + tryCast: () => Bn, + tryDirectoryExists: () => z9, + tryExtractTSExtension: () => O5, + tryFileExists: () => Ew, + tryGetClassExtendingExpressionWithTypeArguments: () => aJ, + tryGetClassImplementingOrExtendingExpressionWithTypeArguments: () => oJ, + tryGetDirectories: () => J9, + tryGetExtensionFromPath: () => Jg, + tryGetImportFromModuleSpecifier: () => U3, + tryGetJSDocSatisfiesTypeNode: () => lF, + tryGetModuleNameFromFile: () => GN, + tryGetModuleSpecifierFromDeclaration: () => gx, + tryGetNativePerformanceHooks: () => xQ, + tryGetPropertyAccessOrIdentifierToString: () => cN, + tryGetPropertyNameOfBindingOrAssignmentElement: () => zF, + tryGetSourceMappingURL: () => Nne, + tryGetTextOfPropertyName: () => FD, + tryParseJson: () => lN, + tryParsePattern: () => Ix, + tryParsePatterns: () => xN, + tryParseRawSourceMap: () => Ane, + tryReadDirectory: () => oq, + tryReadFile: () => W4, + tryRemoveDirectoryPrefix: () => DJ, + tryRemoveExtension: () => zee, + tryRemovePrefix: () => qR, + tryRemoveSuffix: () => dQ, + tscBuildOption: () => OS, + typeAcquisitionDeclarations: () => $F, + typeAliasNamePart: () => bae, + typeDirectiveIsEqualTo: () => HZ, + typeKeywords: () => JV, + typeParameterNamePart: () => Sae, + typeToDisplayParts: () => QA, + unchangedPollThresholds: () => s7, + unchangedTextChangeRange: () => g7, + unescapeLeadingUnderscores: () => Si, + unmangleScopedPackageName: () => _A, + unorderedRemoveItem: () => YT, + unprefixedNodeCoreModules: () => ste, + unreachableCodeIsError: () => Dee, + unsetNodeChildren: () => Pz, + unusedLabelIsError: () => wee, + unwrapInnermostStatementOfLabel: () => TB, + unwrapParenthesizedExpression: () => nte, + updateErrorForNoInputFiles: () => iO, + updateLanguageServiceSourceFile: () => rH, + updateMissingFilePathsWatch: () => oU, + updateResolutionField: () => P6, + updateSharedExtendedConfigFileWatcher: () => FO, + updateSourceFile: () => Uz, + updateWatchingWildcardDirectories: () => xA, + usingSingleLineStringWriter: () => LC, + utf16EncodeAsString: () => yD, + validateLocaleAndSetLanguage: () => Aj, + version: () => ep, + versionMajorMinor: () => q2, + visitArray: () => Q4, + visitCommaListElements: () => SO, + visitEachChild: () => br, + visitFunctionBody: () => jf, + visitIterationBody: () => c_, + visitLexicalEnvironment: () => OW, + visitNode: () => Qe, + visitNodes: () => Ar, + visitParameterList: () => _c, + walkUpBindingElementsAndPatterns: () => Y2, + walkUpOuterExpressions: () => ore, + walkUpParenthesizedExpressions: () => ad, + walkUpParenthesizedTypes: () => $3, + walkUpParenthesizedTypesAndGetParentAndChild: () => RK, + whitespaceOrMapCommentRegExp: () => MW, + writeCommentRange: () => KC, + writeFile: () => w5, + writeFileEnsuringDirectories: () => KB, + zipWith: () => TR + }); + var Vwe; + function vKe() { + return Vwe ?? (Vwe = new xd(ep)); + } + function qwe(e, t, n, i, s) { + let o = t ? "DeprecationError: " : "DeprecationWarning: "; + return o += `'${e}' `, o += i ? `has been deprecated since v${i}` : "is deprecated", o += t ? " and can no longer be used." : n ? ` and will no longer be usable after v${n}.` : ".", o += s ? ` ${jg(s, [e])}` : "", o; + } + function bKe(e, t, n, i) { + const s = qwe( + e, + /*error*/ + !0, + t, + n, + i + ); + return () => { + throw new TypeError(s); + }; + } + function SKe(e, t, n, i) { + let s = !1; + return () => { + s || (E.log.warn(qwe( + e, + /*error*/ + !1, + t, + n, + i + )), s = !0); + }; + } + function TKe(e, t = {}) { + const n = typeof t.typeScriptVersion == "string" ? new xd(t.typeScriptVersion) : t.typeScriptVersion ?? vKe(), i = typeof t.errorAfter == "string" ? new xd(t.errorAfter) : t.errorAfter, s = typeof t.warnAfter == "string" ? new xd(t.warnAfter) : t.warnAfter, o = typeof t.since == "string" ? new xd(t.since) : t.since ?? s, c = t.error || i && n.compareTo(i) >= 0, _ = !s || n.compareTo(s) >= 0; + return c ? bKe(e, i, o, t.message) : _ ? SKe(e, i, o, t.message) : Ha; + } + function xKe(e, t) { + return function() { + return e(), t.apply(this, arguments); + }; + } + function kKe(e, t) { + const n = TKe(t?.name ?? E.getFunctionName(e), t); + return xKe(n, e); + } + function mG(e, t, n, i) { + if (Object.defineProperty(o, "name", { ...Object.getOwnPropertyDescriptor(o, "name"), value: e }), i) + for (const c of Object.keys(i)) { + const _ = +c; + !isNaN(_) && eo(t, `${_}`) && (t[_] = kKe(t[_], { ...i[_], name: e })); + } + const s = CKe(t, n); + return o; + function o(...c) { + const _ = s(c), u = _ !== void 0 ? t[_] : void 0; + if (typeof u == "function") + return u(...c); + throw new TypeError("Invalid arguments"); + } + } + function CKe(e, t) { + return (n) => { + for (let i = 0; eo(e, `${i}`) && eo(t, `${i}`); i++) { + const s = t[i]; + if (s(n)) + return i; + } + }; + } + function Hwe(e) { + return { + overload: (t) => ({ + bind: (n) => ({ + finish: () => mG(e, t, n), + deprecate: (i) => ({ + finish: () => mG(e, t, n, i) + }) + }) + }) + }; + } + var Gwe = {}; + Na(Gwe, { + ActionInvalidate: () => c9, + ActionPackageInstalled: () => l9, + ActionSet: () => o9, + ActionWatchTypingLocations: () => RA, + Arguments: () => pV, + AutoImportProviderProject: () => H_e, + AuxiliaryProject: () => V_e, + CharRangeSection: () => yfe, + CloseFileWatcherEvent: () => wG, + CommandNames: () => CPe, + ConfigFileDiagEvent: () => xG, + ConfiguredProject: () => G_e, + ConfiguredProjectLoadKind: () => K_e, + CreateDirectoryWatcherEvent: () => DG, + CreateFileWatcherEvent: () => EG, + Errors: () => Rh, + EventBeginInstallTypes: () => _V, + EventEndInstallTypes: () => fV, + EventInitializationFailed: () => Ase, + EventTypesRegistry: () => uV, + ExternalProject: () => hG, + GcTimer: () => I_e, + InferredProject: () => U_e, + LargeFileReferencedEvent: () => TG, + LineIndex: () => W8, + LineLeaf: () => VL, + LineNode: () => fE, + LogLevel: () => x_e, + Msg: () => k_e, + OpenFileInfoTelemetryEvent: () => $_e, + Project: () => Ek, + ProjectInfoTelemetryEvent: () => CG, + ProjectKind: () => Ww, + ProjectLanguageServiceStateEvent: () => kG, + ProjectLoadingFinishEvent: () => SG, + ProjectLoadingStartEvent: () => bG, + ProjectService: () => cfe, + ProjectsUpdatedInBackgroundEvent: () => zL, + ScriptInfo: () => M_e, + ScriptVersionCache: () => JG, + Session: () => FPe, + TextStorage: () => L_e, + ThrottledOperations: () => A_e, + TypingsInstallerAdapter: () => BPe, + allFilesAreJsOrDts: () => J_e, + allRootFilesAreJsOrDts: () => B_e, + asNormalizedPath: () => Ywe, + convertCompilerOptions: () => WL, + convertFormatOptions: () => lE, + convertScriptKindName: () => NG, + convertTypeAcquisition: () => Q_e, + convertUserPreferences: () => Y_e, + convertWatchOptions: () => J8, + countEachFileTypes: () => M8, + createInstallTypingsRequest: () => C_e, + createModuleSpecifierCache: () => _fe, + createNormalizedPathMap: () => Zwe, + createPackageJsonCache: () => ffe, + createSortedArray: () => N_e, + emptyArray: () => bl, + findArgument: () => Zbe, + formatDiagnosticToProtocol: () => z8, + formatMessage: () => pfe, + getBaseConfigFileName: () => gG, + getDetailWatchInfo: () => OG, + getLocationInNewDocument: () => hfe, + hasArgument: () => Ybe, + hasNoTypeScriptSource: () => z_e, + indent: () => pw, + isBackgroundProject: () => j8, + isConfigFile: () => lfe, + isConfiguredProject: () => L0, + isDynamicFileName: () => zw, + isExternalProject: () => R8, + isInferredProject: () => cE, + isInferredProjectName: () => E_e, + isProjectDeferredClose: () => B8, + makeAutoImportProviderProjectName: () => w_e, + makeAuxiliaryProjectName: () => P_e, + makeInferredProjectName: () => D_e, + maxFileSize: () => vG, + maxProgramSizeForNonTsFiles: () => yG, + normalizedPathToPath: () => oE, + nowString: () => Kbe, + nullCancellationToken: () => TPe, + nullTypingsInstaller: () => UL, + protocol: () => F_e, + scriptInfoIsContainedByBackgroundProject: () => R_e, + scriptInfoIsContainedByDeferredClosedProject: () => j_e, + stringifyIndented: () => vv, + toEvent: () => dfe, + toNormalizedPath: () => ro, + tryConvertScriptKindName: () => PG, + typingsInstaller: () => T_e, + updateProjectIfDirty: () => Gp + }); + var T_e = {}; + Na(T_e, { + TypingsInstaller: () => wKe, + getNpmCommandForInstallation: () => Xwe, + installNpmPackages: () => DKe, + typingsName: () => Qwe + }); + var EKe = { + isEnabled: () => !1, + writeLine: Ha + }; + function $we(e, t, n, i) { + try { + const s = MS(t, On(e, "index.d.ts"), { + moduleResolution: 2 + /* Node10 */ + }, n); + return s.resolvedModule && s.resolvedModule.resolvedFileName; + } catch (s) { + i.isEnabled() && i.writeLine(`Failed to resolve ${t} in folder '${e}': ${s.message}`); + return; + } + } + function DKe(e, t, n, i) { + let s = !1; + for (let o = n.length; o > 0; ) { + const c = Xwe(e, t, n, o); + o = c.remaining, s = i(c.command) || s; + } + return s; + } + function Xwe(e, t, n, i) { + const s = n.length - i; + let o, c = i; + for (; o = `${e} install --ignore-scripts ${(c === n.length ? n : n.slice(s, s + c)).join(" ")} --save-dev --user-agent="typesInstaller/${t}"`, !(o.length < 8e3); ) + c = c - Math.floor(c / 2); + return { command: o, remaining: i - c }; + } + var wKe = class { + constructor(e, t, n, i, s, o = EKe) { + this.installTypingHost = e, this.globalCachePath = t, this.safeListPath = n, this.typesMapLocation = i, this.throttleLimit = s, this.log = o, this.packageNameToTypingLocation = /* @__PURE__ */ new Map(), this.missingTypingsSet = /* @__PURE__ */ new Set(), this.knownCachesSet = /* @__PURE__ */ new Set(), this.projectWatchers = /* @__PURE__ */ new Map(), this.pendingRunRequests = [], this.installRunCount = 1, this.inFlightRequestCount = 0, this.latestDistTag = "latest", this.log.isEnabled() && this.log.writeLine(`Global cache location '${t}', safe file path '${n}', types map path ${i}`), this.processCacheLocation(this.globalCachePath); + } + /** @internal */ + handleRequest(e) { + switch (e.kind) { + case "discover": + this.install(e); + break; + case "closeProject": + this.closeProject(e); + break; + case "typesRegistry": { + const t = {}; + this.typesRegistry.forEach((i, s) => { + t[s] = i; + }); + const n = { kind: uV, typesRegistry: t }; + this.sendResponse(n); + break; + } + case "installPackage": { + this.installPackage(e); + break; + } + default: + E.assertNever(e); + } + } + closeProject(e) { + this.closeWatchers(e.projectName); + } + closeWatchers(e) { + if (this.log.isEnabled() && this.log.writeLine(`Closing file watchers for project '${e}'`), !this.projectWatchers.get(e)) { + this.log.isEnabled() && this.log.writeLine(`No watchers are registered for project '${e}'`); + return; + } + this.projectWatchers.delete(e), this.sendResponse({ kind: RA, projectName: e, files: [] }), this.log.isEnabled() && this.log.writeLine(`Closing file watchers for project '${e}' - done.`); + } + install(e) { + this.log.isEnabled() && this.log.writeLine(`Got install request${vv(e)}`), e.cachePath && (this.log.isEnabled() && this.log.writeLine(`Request specifies cache path '${e.cachePath}', loading cached information...`), this.processCacheLocation(e.cachePath)), this.safeList === void 0 && this.initializeSafeList(); + const t = t1.discoverTypings( + this.installTypingHost, + this.log.isEnabled() ? (n) => this.log.writeLine(n) : void 0, + e.fileNames, + e.projectRootPath, + this.safeList, + this.packageNameToTypingLocation, + e.typeAcquisition, + e.unresolvedImports, + this.typesRegistry, + e.compilerOptions + ); + this.watchFiles(e.projectName, t.filesToWatch), t.newTypingNames.length ? this.installTypings(e, e.cachePath || this.globalCachePath, t.cachedTypingPaths, t.newTypingNames) : (this.sendResponse(this.createSetTypings(e, t.cachedTypingPaths)), this.log.isEnabled() && this.log.writeLine("No new typings were requested as a result of typings discovery")); + } + /** @internal */ + installPackage(e) { + const { fileName: t, packageName: n, projectName: i, projectRootPath: s, id: o } = e, c = pD(Hn(t), (_) => { + if (this.installTypingHost.fileExists(On(_, "package.json"))) + return _; + }) || s; + if (c) + this.installWorker(-1, [n], c, (_) => { + const u = _ ? `Package ${n} installed.` : `There was an error installing ${n}.`, g = { + kind: l9, + projectName: i, + id: o, + success: _, + message: u + }; + this.sendResponse(g); + }); + else { + const _ = { + kind: l9, + projectName: i, + id: o, + success: !1, + message: "Could not determine a project root path." + }; + this.sendResponse(_); + } + } + initializeSafeList() { + if (this.typesMapLocation) { + const e = t1.loadTypesMap(this.installTypingHost, this.typesMapLocation); + if (e) { + this.log.writeLine(`Loaded safelist from types map file '${this.typesMapLocation}'`), this.safeList = e; + return; + } + this.log.writeLine(`Failed to load safelist from types map file '${this.typesMapLocation}'`); + } + this.safeList = t1.loadSafeList(this.installTypingHost, this.safeListPath); + } + processCacheLocation(e) { + if (this.log.isEnabled() && this.log.writeLine(`Processing cache location '${e}'`), this.knownCachesSet.has(e)) { + this.log.isEnabled() && this.log.writeLine("Cache location was already processed..."); + return; + } + const t = On(e, "package.json"), n = On(e, "package-lock.json"); + if (this.log.isEnabled() && this.log.writeLine(`Trying to find '${t}'...`), this.installTypingHost.fileExists(t) && this.installTypingHost.fileExists(n)) { + const i = JSON.parse(this.installTypingHost.readFile(t)), s = JSON.parse(this.installTypingHost.readFile(n)); + if (this.log.isEnabled() && (this.log.writeLine(`Loaded content of '${t}':${vv(i)}`), this.log.writeLine(`Loaded content of '${n}':${vv(s)}`)), i.devDependencies && (s.packages || s.dependencies)) + for (const o in i.devDependencies) { + if (s.packages && !eo(s.packages, `node_modules/${o}`) || s.dependencies && !eo(s.dependencies, o)) + continue; + const c = Zc(o); + if (!c) + continue; + const _ = $we(e, c, this.installTypingHost, this.log); + if (!_) { + this.missingTypingsSet.add(c); + continue; + } + const u = this.packageNameToTypingLocation.get(c); + if (u) { + if (u.typingLocation === _) + continue; + this.log.isEnabled() && this.log.writeLine(`New typing for package ${c} from '${_}' conflicts with existing typing file '${u}'`); + } + this.log.isEnabled() && this.log.writeLine(`Adding entry into typings cache: '${c}' => '${_}'`); + const g = s.packages && jP(s.packages, `node_modules/${o}`) || jP(s.dependencies, o), m = g && g.version; + if (!m) + continue; + const h = { typingLocation: _, version: new xd(m) }; + this.packageNameToTypingLocation.set(c, h); + } + } + this.log.isEnabled() && this.log.writeLine(`Finished processing cache location '${e}'`), this.knownCachesSet.add(e); + } + filterTypings(e) { + return Fi(e, (t) => { + const n = F6(t); + if (this.missingTypingsSet.has(n)) { + this.log.isEnabled() && this.log.writeLine(`'${t}':: '${n}' is in missingTypingsSet - skipping...`); + return; + } + const i = t1.validatePackageName(t); + if (i !== t1.NameValidationResult.Ok) { + this.missingTypingsSet.add(n), this.log.isEnabled() && this.log.writeLine(t1.renderPackageNameValidationFailure(i, t)); + return; + } + if (!this.typesRegistry.has(n)) { + this.log.isEnabled() && this.log.writeLine(`'${t}':: Entry for package '${n}' does not exist in local types registry - skipping...`); + return; + } + if (this.packageNameToTypingLocation.get(n) && t1.isTypingUpToDate(this.packageNameToTypingLocation.get(n), this.typesRegistry.get(n))) { + this.log.isEnabled() && this.log.writeLine(`'${t}':: '${n}' already has an up-to-date typing - skipping...`); + return; + } + return n; + }); + } + ensurePackageDirectoryExists(e) { + const t = On(e, "package.json"); + this.log.isEnabled() && this.log.writeLine(`Npm config file: ${t}`), this.installTypingHost.fileExists(t) || (this.log.isEnabled() && this.log.writeLine(`Npm config file: '${t}' is missing, creating new one...`), this.ensureDirectoryExists(e, this.installTypingHost), this.installTypingHost.writeFile(t, '{ "private": true }')); + } + installTypings(e, t, n, i) { + this.log.isEnabled() && this.log.writeLine(`Installing typings ${JSON.stringify(i)}`); + const s = this.filterTypings(i); + if (s.length === 0) { + this.log.isEnabled() && this.log.writeLine("All typings are known to be missing or invalid - no need to install more typings"), this.sendResponse(this.createSetTypings(e, n)); + return; + } + this.ensurePackageDirectoryExists(t); + const o = this.installRunCount; + this.installRunCount++, this.sendResponse({ + kind: _V, + eventId: o, + typingsInstallerVersion: ep, + projectName: e.projectName + }); + const c = s.map(Qwe); + this.installTypingsAsync(o, c, t, (_) => { + try { + if (!_) { + this.log.isEnabled() && this.log.writeLine(`install request failed, marking packages as missing to prevent repeated requests: ${JSON.stringify(s)}`); + for (const g of s) + this.missingTypingsSet.add(g); + return; + } + this.log.isEnabled() && this.log.writeLine(`Installed typings ${JSON.stringify(c)}`); + const u = []; + for (const g of s) { + const m = $we(t, g, this.installTypingHost, this.log); + if (!m) { + this.missingTypingsSet.add(g); + continue; + } + const h = this.typesRegistry.get(g), S = new xd(h[`ts${q2}`] || h[this.latestDistTag]), T = { typingLocation: m, version: S }; + this.packageNameToTypingLocation.set(g, T), u.push(m); + } + this.log.isEnabled() && this.log.writeLine(`Installed typing files ${JSON.stringify(u)}`), this.sendResponse(this.createSetTypings(e, n.concat(u))); + } finally { + const u = { + kind: fV, + eventId: o, + projectName: e.projectName, + packagesToInstall: c, + installSuccess: _, + typingsInstallerVersion: ep + }; + this.sendResponse(u); + } + }); + } + ensureDirectoryExists(e, t) { + const n = Hn(e); + t.directoryExists(n) || this.ensureDirectoryExists(n, t), t.directoryExists(e) || t.createDirectory(e); + } + watchFiles(e, t) { + if (!t.length) { + this.closeWatchers(e); + return; + } + const n = this.projectWatchers.get(e), i = new Set(t); + !n || Ag(i, (s) => !n.has(s)) || Ag(n, (s) => !i.has(s)) ? (this.projectWatchers.set(e, i), this.sendResponse({ kind: RA, projectName: e, files: t })) : this.sendResponse({ kind: RA, projectName: e, files: void 0 }); + } + createSetTypings(e, t) { + return { + projectName: e.projectName, + typeAcquisition: e.typeAcquisition, + compilerOptions: e.compilerOptions, + typings: t, + unresolvedImports: e.unresolvedImports, + kind: o9 + }; + } + installTypingsAsync(e, t, n, i) { + this.pendingRunRequests.unshift({ requestId: e, packageNames: t, cwd: n, onRequestCompleted: i }), this.executeWithThrottling(); + } + executeWithThrottling() { + for (; this.inFlightRequestCount < this.throttleLimit && this.pendingRunRequests.length; ) { + this.inFlightRequestCount++; + const e = this.pendingRunRequests.pop(); + this.installWorker(e.requestId, e.packageNames, e.cwd, (t) => { + this.inFlightRequestCount--, e.onRequestCompleted(t), this.executeWithThrottling(); + }); + } + } + }; + function Qwe(e) { + return `@types/${e}@ts${q2}`; + } + var x_e = /* @__PURE__ */ ((e) => (e[e.terse = 0] = "terse", e[e.normal = 1] = "normal", e[e.requestTime = 2] = "requestTime", e[e.verbose = 3] = "verbose", e))(x_e || {}), bl = N_e(), k_e = /* @__PURE__ */ ((e) => (e.Err = "Err", e.Info = "Info", e.Perf = "Perf", e))(k_e || {}); + function C_e(e, t, n, i) { + return { + projectName: e.getProjectName(), + fileNames: e.getFileNames( + /*excludeFilesFromExternalLibraries*/ + !0, + /*excludeConfigFiles*/ + !0 + ).concat(e.getExcludedFiles()), + compilerOptions: e.getCompilationSettings(), + typeAcquisition: t, + unresolvedImports: n, + projectRootPath: e.getCurrentDirectory(), + cachePath: i, + kind: "discover" + }; + } + var Rh; + ((e) => { + function t() { + throw new Error("No Project."); + } + e.ThrowNoProject = t; + function n() { + throw new Error("The project's language service is disabled."); + } + e.ThrowProjectLanguageServiceDisabled = n; + function i(s, o) { + throw new Error(`Project '${o.getProjectName()}' does not contain document '${s}'`); + } + e.ThrowProjectDoesNotContainDocument = i; + })(Rh || (Rh = {})); + function ro(e) { + return Hs(e); + } + function oE(e, t, n) { + const i = Z_(e) ? e : Qi(e, t); + return n(i); + } + function Ywe(e) { + return e; + } + function Zwe() { + const e = /* @__PURE__ */ new Map(); + return { + get(t) { + return e.get(t); + }, + set(t, n) { + e.set(t, n); + }, + contains(t) { + return e.has(t); + }, + remove(t) { + e.delete(t); + } + }; + } + function E_e(e) { + return /dev\/null\/inferredProject\d+\*/.test(e); + } + function D_e(e) { + return `/dev/null/inferredProject${e}*`; + } + function w_e(e) { + return `/dev/null/autoImportProviderProject${e}*`; + } + function P_e(e) { + return `/dev/null/auxiliaryProject${e}*`; + } + function N_e() { + return []; + } + var A_e = class z5e { + constructor(t, n) { + this.host = t, this.pendingTimeouts = /* @__PURE__ */ new Map(), this.logger = n.hasLevel( + 3 + /* verbose */ + ) ? n : void 0; + } + /** + * Wait `number` milliseconds and then invoke `cb`. If, while waiting, schedule + * is called again with the same `operationId`, cancel this operation in favor + * of the new one. (Note that the amount of time the canceled operation had been + * waiting does not affect the amount of time that the new operation waits.) + */ + schedule(t, n, i) { + const s = this.pendingTimeouts.get(t); + s && this.host.clearTimeout(s), this.pendingTimeouts.set(t, this.host.setTimeout(z5e.run, n, t, this, i)), this.logger && this.logger.info(`Scheduled: ${t}${s ? ", Cancelled earlier one" : ""}`); + } + cancel(t) { + const n = this.pendingTimeouts.get(t); + return n ? (this.host.clearTimeout(n), this.pendingTimeouts.delete(t)) : !1; + } + static run(t, n, i) { + n.pendingTimeouts.delete(t), n.logger && n.logger.info(`Running: ${t}`), i(); + } + }, I_e = class W5e { + constructor(t, n, i) { + this.host = t, this.delay = n, this.logger = i; + } + scheduleCollect() { + !this.host.gc || this.timerId !== void 0 || (this.timerId = this.host.setTimeout(W5e.run, this.delay, this)); + } + static run(t) { + t.timerId = void 0; + const n = t.logger.hasLevel( + 2 + /* requestTime */ + ), i = n && t.host.getMemoryUsage(); + if (t.host.gc(), n) { + const s = t.host.getMemoryUsage(); + t.logger.perftrc(`GC::before ${i}, after ${s}`); + } + } + }; + function gG(e) { + const t = Zc(e); + return t === "tsconfig.json" || t === "jsconfig.json" ? t : void 0; + } + var F_e = {}; + Na(F_e, { + ClassificationType: () => hV, + CommandTypes: () => O_e, + CompletionTriggerKind: () => mV, + IndentStyle: () => rPe, + JsxEmit: () => nPe, + ModuleKind: () => iPe, + ModuleResolutionKind: () => sPe, + NewLineKind: () => aPe, + OrganizeImportsMode: () => dV, + PollingWatchKind: () => tPe, + ScriptTarget: () => oPe, + SemicolonPreference: () => gV, + WatchDirectoryKind: () => ePe, + WatchFileKind: () => Kwe + }); + var O_e = /* @__PURE__ */ ((e) => (e.JsxClosingTag = "jsxClosingTag", e.LinkedEditingRange = "linkedEditingRange", e.Brace = "brace", e.BraceFull = "brace-full", e.BraceCompletion = "braceCompletion", e.GetSpanOfEnclosingComment = "getSpanOfEnclosingComment", e.Change = "change", e.Close = "close", e.Completions = "completions", e.CompletionInfo = "completionInfo", e.CompletionsFull = "completions-full", e.CompletionDetails = "completionEntryDetails", e.CompletionDetailsFull = "completionEntryDetails-full", e.CompileOnSaveAffectedFileList = "compileOnSaveAffectedFileList", e.CompileOnSaveEmitFile = "compileOnSaveEmitFile", e.Configure = "configure", e.Definition = "definition", e.DefinitionFull = "definition-full", e.DefinitionAndBoundSpan = "definitionAndBoundSpan", e.DefinitionAndBoundSpanFull = "definitionAndBoundSpan-full", e.Implementation = "implementation", e.ImplementationFull = "implementation-full", e.EmitOutput = "emit-output", e.Exit = "exit", e.FileReferences = "fileReferences", e.FileReferencesFull = "fileReferences-full", e.Format = "format", e.Formatonkey = "formatonkey", e.FormatFull = "format-full", e.FormatonkeyFull = "formatonkey-full", e.FormatRangeFull = "formatRange-full", e.Geterr = "geterr", e.GeterrForProject = "geterrForProject", e.SemanticDiagnosticsSync = "semanticDiagnosticsSync", e.SyntacticDiagnosticsSync = "syntacticDiagnosticsSync", e.SuggestionDiagnosticsSync = "suggestionDiagnosticsSync", e.NavBar = "navbar", e.NavBarFull = "navbar-full", e.Navto = "navto", e.NavtoFull = "navto-full", e.NavTree = "navtree", e.NavTreeFull = "navtree-full", e.DocumentHighlights = "documentHighlights", e.DocumentHighlightsFull = "documentHighlights-full", e.Open = "open", e.Quickinfo = "quickinfo", e.QuickinfoFull = "quickinfo-full", e.References = "references", e.ReferencesFull = "references-full", e.Reload = "reload", e.Rename = "rename", e.RenameInfoFull = "rename-full", e.RenameLocationsFull = "renameLocations-full", e.Saveto = "saveto", e.SignatureHelp = "signatureHelp", e.SignatureHelpFull = "signatureHelp-full", e.FindSourceDefinition = "findSourceDefinition", e.Status = "status", e.TypeDefinition = "typeDefinition", e.ProjectInfo = "projectInfo", e.ReloadProjects = "reloadProjects", e.Unknown = "unknown", e.OpenExternalProject = "openExternalProject", e.OpenExternalProjects = "openExternalProjects", e.CloseExternalProject = "closeExternalProject", e.SynchronizeProjectList = "synchronizeProjectList", e.ApplyChangedToOpenFiles = "applyChangedToOpenFiles", e.UpdateOpen = "updateOpen", e.EncodedSyntacticClassificationsFull = "encodedSyntacticClassifications-full", e.EncodedSemanticClassificationsFull = "encodedSemanticClassifications-full", e.Cleanup = "cleanup", e.GetOutliningSpans = "getOutliningSpans", e.GetOutliningSpansFull = "outliningSpans", e.TodoComments = "todoComments", e.Indentation = "indentation", e.DocCommentTemplate = "docCommentTemplate", e.CompilerOptionsDiagnosticsFull = "compilerOptionsDiagnostics-full", e.NameOrDottedNameSpan = "nameOrDottedNameSpan", e.BreakpointStatement = "breakpointStatement", e.CompilerOptionsForInferredProjects = "compilerOptionsForInferredProjects", e.GetCodeFixes = "getCodeFixes", e.GetCodeFixesFull = "getCodeFixes-full", e.GetCombinedCodeFix = "getCombinedCodeFix", e.GetCombinedCodeFixFull = "getCombinedCodeFix-full", e.ApplyCodeActionCommand = "applyCodeActionCommand", e.GetSupportedCodeFixes = "getSupportedCodeFixes", e.GetApplicableRefactors = "getApplicableRefactors", e.GetEditsForRefactor = "getEditsForRefactor", e.GetMoveToRefactoringFileSuggestions = "getMoveToRefactoringFileSuggestions", e.PreparePasteEdits = "preparePasteEdits", e.GetPasteEdits = "getPasteEdits", e.GetEditsForRefactorFull = "getEditsForRefactor-full", e.OrganizeImports = "organizeImports", e.OrganizeImportsFull = "organizeImports-full", e.GetEditsForFileRename = "getEditsForFileRename", e.GetEditsForFileRenameFull = "getEditsForFileRename-full", e.ConfigurePlugin = "configurePlugin", e.SelectionRange = "selectionRange", e.SelectionRangeFull = "selectionRange-full", e.ToggleLineComment = "toggleLineComment", e.ToggleLineCommentFull = "toggleLineComment-full", e.ToggleMultilineComment = "toggleMultilineComment", e.ToggleMultilineCommentFull = "toggleMultilineComment-full", e.CommentSelection = "commentSelection", e.CommentSelectionFull = "commentSelection-full", e.UncommentSelection = "uncommentSelection", e.UncommentSelectionFull = "uncommentSelection-full", e.PrepareCallHierarchy = "prepareCallHierarchy", e.ProvideCallHierarchyIncomingCalls = "provideCallHierarchyIncomingCalls", e.ProvideCallHierarchyOutgoingCalls = "provideCallHierarchyOutgoingCalls", e.ProvideInlayHints = "provideInlayHints", e.WatchChange = "watchChange", e.MapCode = "mapCode", e.CopilotRelated = "copilotRelated", e))(O_e || {}), Kwe = /* @__PURE__ */ ((e) => (e.FixedPollingInterval = "FixedPollingInterval", e.PriorityPollingInterval = "PriorityPollingInterval", e.DynamicPriorityPolling = "DynamicPriorityPolling", e.FixedChunkSizePolling = "FixedChunkSizePolling", e.UseFsEvents = "UseFsEvents", e.UseFsEventsOnParentDirectory = "UseFsEventsOnParentDirectory", e))(Kwe || {}), ePe = /* @__PURE__ */ ((e) => (e.UseFsEvents = "UseFsEvents", e.FixedPollingInterval = "FixedPollingInterval", e.DynamicPriorityPolling = "DynamicPriorityPolling", e.FixedChunkSizePolling = "FixedChunkSizePolling", e))(ePe || {}), tPe = /* @__PURE__ */ ((e) => (e.FixedInterval = "FixedInterval", e.PriorityInterval = "PriorityInterval", e.DynamicPriority = "DynamicPriority", e.FixedChunkSize = "FixedChunkSize", e))(tPe || {}), rPe = /* @__PURE__ */ ((e) => (e.None = "None", e.Block = "Block", e.Smart = "Smart", e))(rPe || {}), nPe = /* @__PURE__ */ ((e) => (e.None = "none", e.Preserve = "preserve", e.ReactNative = "react-native", e.React = "react", e.ReactJSX = "react-jsx", e.ReactJSXDev = "react-jsxdev", e))(nPe || {}), iPe = /* @__PURE__ */ ((e) => (e.None = "none", e.CommonJS = "commonjs", e.AMD = "amd", e.UMD = "umd", e.System = "system", e.ES6 = "es6", e.ES2015 = "es2015", e.ES2020 = "es2020", e.ES2022 = "es2022", e.ESNext = "esnext", e.Node16 = "node16", e.Node18 = "node18", e.Node20 = "node20", e.NodeNext = "nodenext", e.Preserve = "preserve", e))(iPe || {}), sPe = /* @__PURE__ */ ((e) => (e.Classic = "classic", e.Node = "node", e.NodeJs = "node", e.Node10 = "node10", e.Node16 = "node16", e.NodeNext = "nodenext", e.Bundler = "bundler", e))(sPe || {}), aPe = /* @__PURE__ */ ((e) => (e.Crlf = "Crlf", e.Lf = "Lf", e))(aPe || {}), oPe = /* @__PURE__ */ ((e) => (e.ES3 = "es3", e.ES5 = "es5", e.ES6 = "es6", e.ES2015 = "es2015", e.ES2016 = "es2016", e.ES2017 = "es2017", e.ES2018 = "es2018", e.ES2019 = "es2019", e.ES2020 = "es2020", e.ES2021 = "es2021", e.ES2022 = "es2022", e.ES2023 = "es2023", e.ES2024 = "es2024", e.ESNext = "esnext", e.JSON = "json", e.Latest = "esnext", e))(oPe || {}), L_e = class { + constructor(e, t, n) { + this.host = e, this.info = t, this.isOpen = !1, this.ownFileText = !1, this.pendingReloadFromDisk = !1, this.version = n || 0; + } + getVersion() { + return this.svc ? `SVC-${this.version}-${this.svc.getSnapshotVersion()}` : `Text-${this.version}`; + } + hasScriptVersionCache_TestOnly() { + return this.svc !== void 0; + } + resetSourceMapInfo() { + this.info.sourceFileLike = void 0, this.info.closeSourceMapFileWatcher(), this.info.sourceMapFilePath = void 0, this.info.declarationInfoPath = void 0, this.info.sourceInfos = void 0, this.info.documentPositionMapper = void 0; + } + /** Public for testing */ + useText(e) { + this.svc = void 0, this.text = e, this.textSnapshot = void 0, this.lineMap = void 0, this.fileSize = void 0, this.resetSourceMapInfo(), this.version++; + } + edit(e, t, n) { + this.switchToScriptVersionCache().edit(e, t - e, n), this.ownFileText = !1, this.text = void 0, this.textSnapshot = void 0, this.lineMap = void 0, this.fileSize = void 0, this.resetSourceMapInfo(); + } + /** + * Set the contents as newText + * returns true if text changed + */ + reload(e) { + return E.assert(e !== void 0), this.pendingReloadFromDisk = !1, !this.text && this.svc && (this.text = fk(this.svc.getSnapshot())), this.text !== e ? (this.useText(e), this.ownFileText = !1, !0) : !1; + } + /** + * Reads the contents from tempFile(if supplied) or own file and sets it as contents + * returns true if text changed + */ + reloadWithFileText(e) { + const { text: t, fileSize: n } = e || !this.info.isDynamicOrHasMixedContent() ? this.getFileTextAndSize(e) : { text: "", fileSize: void 0 }, i = this.reload(t); + return this.fileSize = n, this.ownFileText = !e || e === this.info.fileName, this.ownFileText && this.info.mTime === Y_.getTime() && (this.info.mTime = (this.host.getModifiedTime(this.info.fileName) || Y_).getTime()), i; + } + /** + * Schedule reload from the disk if its not already scheduled and its not own text + * returns true when scheduling reload + */ + scheduleReloadIfNeeded() { + return !this.pendingReloadFromDisk && !this.ownFileText ? this.pendingReloadFromDisk = !0 : !1; + } + delayReloadFromFileIntoText() { + this.pendingReloadFromDisk = !0; + } + /** + * For telemetry purposes, we would like to be able to report the size of the file. + * However, we do not want telemetry to require extra file I/O so we report a size + * that may be stale (e.g. may not reflect change made on disk since the last reload). + * NB: Will read from disk if the file contents have never been loaded because + * telemetry falsely indicating size 0 would be counter-productive. + */ + getTelemetryFileSize() { + return this.fileSize ? this.fileSize : this.text ? this.text.length : this.svc ? this.svc.getSnapshot().getLength() : this.getSnapshot().getLength(); + } + getSnapshot() { + var e; + return ((e = this.tryUseScriptVersionCache()) == null ? void 0 : e.getSnapshot()) || (this.textSnapshot ?? (this.textSnapshot = u9.fromString(E.checkDefined(this.text)))); + } + getAbsolutePositionAndLineText(e) { + const t = this.tryUseScriptVersionCache(); + if (t) return t.getAbsolutePositionAndLineText(e); + const n = this.getLineMap(); + return e <= n.length ? { + absolutePosition: n[e - 1], + lineText: this.text.substring(n[e - 1], n[e]) + } : { + absolutePosition: this.text.length, + lineText: void 0 + }; + } + /** + * @param line 0 based index + */ + lineToTextSpan(e) { + const t = this.tryUseScriptVersionCache(); + if (t) return t.lineToTextSpan(e); + const n = this.getLineMap(), i = n[e], s = e + 1 < n.length ? n[e + 1] : this.text.length; + return Nc(i, s); + } + /** + * @param line 1 based index + * @param offset 1 based index + */ + lineOffsetToPosition(e, t, n) { + const i = this.tryUseScriptVersionCache(); + return i ? i.lineOffsetToPosition(e, t) : d7(this.getLineMap(), e - 1, t - 1, this.text, n); + } + positionToLineOffset(e) { + const t = this.tryUseScriptVersionCache(); + if (t) return t.positionToLineOffset(e); + const { line: n, character: i } = CC(this.getLineMap(), e); + return { line: n + 1, offset: i + 1 }; + } + getFileTextAndSize(e) { + let t; + const n = e || this.info.fileName, i = () => t === void 0 ? t = this.host.readFile(n) || "" : t; + if (!yS(this.info.fileName)) { + const s = this.host.getFileSize ? this.host.getFileSize(n) : i().length; + if (s > vG) + return E.assert(!!this.info.containingProjects.length), this.info.containingProjects[0].projectService.logger.info(`Skipped loading contents of large file ${n} for info ${this.info.fileName}: fileSize: ${s}`), this.info.containingProjects[0].projectService.sendLargeFileReferencedEvent(n, s), { text: "", fileSize: s }; + } + return { text: i() }; + } + /** @internal */ + switchToScriptVersionCache() { + return (!this.svc || this.pendingReloadFromDisk) && (this.svc = JG.fromString(this.getOrLoadText()), this.textSnapshot = void 0, this.version++), this.svc; + } + tryUseScriptVersionCache() { + return (!this.svc || this.pendingReloadFromDisk) && this.getOrLoadText(), this.isOpen ? (!this.svc && !this.textSnapshot && (this.svc = JG.fromString(E.checkDefined(this.text)), this.textSnapshot = void 0), this.svc) : this.svc; + } + getOrLoadText() { + return (this.text === void 0 || this.pendingReloadFromDisk) && (E.assert(!this.svc || this.pendingReloadFromDisk, "ScriptVersionCache should not be set when reloading from disk"), this.reloadWithFileText()), this.text; + } + getLineMap() { + return E.assert(!this.svc, "ScriptVersionCache should not be set"), this.lineMap || (this.lineMap = nx(E.checkDefined(this.text))); + } + getLineInfo() { + const e = this.tryUseScriptVersionCache(); + if (e) + return { + getLineCount: () => e.getLineCount(), + getLineText: (n) => e.getAbsolutePositionAndLineText(n + 1).lineText + }; + const t = this.getLineMap(); + return RW(this.text, t); + } + }; + function zw(e) { + return e[0] === "^" || (e.includes("walkThroughSnippet:/") || e.includes("untitled:/")) && Zc(e)[0] === "^" || e.includes(":^") && !e.includes(So); + } + var M_e = class { + constructor(e, t, n, i, s, o) { + this.host = e, this.fileName = t, this.scriptKind = n, this.hasMixedContent = i, this.path = s, this.containingProjects = [], this.isDynamic = zw(t), this.textStorage = new L_e(e, this, o), (i || this.isDynamic) && (this.realpath = this.path), this.scriptKind = n || K5(t); + } + /** @internal */ + isDynamicOrHasMixedContent() { + return this.hasMixedContent || this.isDynamic; + } + isScriptOpen() { + return this.textStorage.isOpen; + } + open(e) { + this.textStorage.isOpen = !0, e !== void 0 && this.textStorage.reload(e) && this.markContainingProjectsAsDirty(); + } + close(e = !0) { + this.textStorage.isOpen = !1, e && this.textStorage.scheduleReloadIfNeeded() && this.markContainingProjectsAsDirty(); + } + getSnapshot() { + return this.textStorage.getSnapshot(); + } + ensureRealPath() { + if (this.realpath === void 0 && (this.realpath = this.path, this.host.realpath)) { + E.assert(!!this.containingProjects.length); + const e = this.containingProjects[0], t = this.host.realpath(this.path); + t && (this.realpath = e.toPath(t), this.realpath !== this.path && e.projectService.realpathToScriptInfos.add(this.realpath, this)); + } + } + /** @internal */ + getRealpathIfDifferent() { + return this.realpath && this.realpath !== this.path ? this.realpath : void 0; + } + /** + * @internal + * Does not compute realpath; uses precomputed result. Use `ensureRealPath` + * first if a definite result is needed. + */ + isSymlink() { + return this.realpath && this.realpath !== this.path; + } + getFormatCodeSettings() { + return this.formatSettings; + } + getPreferences() { + return this.preferences; + } + attachToProject(e) { + const t = !this.isAttached(e); + return t && (this.containingProjects.push(e), e.getCompilerOptions().preserveSymlinks || this.ensureRealPath(), e.onFileAddedOrRemoved(this.isSymlink())), t; + } + isAttached(e) { + switch (this.containingProjects.length) { + case 0: + return !1; + case 1: + return this.containingProjects[0] === e; + case 2: + return this.containingProjects[0] === e || this.containingProjects[1] === e; + default: + return ms(this.containingProjects, e); + } + } + detachFromProject(e) { + switch (this.containingProjects.length) { + case 0: + return; + case 1: + this.containingProjects[0] === e && (e.onFileAddedOrRemoved(this.isSymlink()), this.containingProjects.pop()); + break; + case 2: + this.containingProjects[0] === e ? (e.onFileAddedOrRemoved(this.isSymlink()), this.containingProjects[0] = this.containingProjects.pop()) : this.containingProjects[1] === e && (e.onFileAddedOrRemoved(this.isSymlink()), this.containingProjects.pop()); + break; + default: + rD(this.containingProjects, e) && e.onFileAddedOrRemoved(this.isSymlink()); + break; + } + } + detachAllProjects() { + for (const e of this.containingProjects) { + L0(e) && e.getCachedDirectoryStructureHost().addOrDeleteFile( + this.fileName, + this.path, + 2 + /* Deleted */ + ); + const t = e.getRootFilesMap().get(this.path); + e.removeFile( + this, + /*fileExists*/ + !1, + /*detachFromProject*/ + !1 + ), e.onFileAddedOrRemoved(this.isSymlink()), t && !cE(e) && e.addMissingFileRoot(t.fileName); + } + Ap(this.containingProjects); + } + getDefaultProject() { + switch (this.containingProjects.length) { + case 0: + return Rh.ThrowNoProject(); + case 1: + return B8(this.containingProjects[0]) || j8(this.containingProjects[0]) ? Rh.ThrowNoProject() : this.containingProjects[0]; + default: + let e, t, n, i; + for (let s = 0; s < this.containingProjects.length; s++) { + const o = this.containingProjects[s]; + if (L0(o)) { + if (o.deferredClose) continue; + if (!o.isSourceOfProjectReferenceRedirect(this.fileName)) { + if (i === void 0 && s !== this.containingProjects.length - 1 && (i = o.projectService.findDefaultConfiguredProject(this) || !1), i === o) return o; + n || (n = o); + } + e || (e = o); + } else { + if (R8(o)) + return o; + !t && cE(o) && (t = o); + } + } + return (i || n || e || t) ?? Rh.ThrowNoProject(); + } + } + registerFileUpdate() { + for (const e of this.containingProjects) + e.registerFileUpdate(this.path); + } + setOptions(e, t) { + e && (this.formatSettings ? this.formatSettings = { ...this.formatSettings, ...e } : (this.formatSettings = _9(this.host.newLine), H2(this.formatSettings, e))), t && (this.preferences || (this.preferences = qp), this.preferences = { ...this.preferences, ...t }); + } + getLatestVersion() { + return this.textStorage.getSnapshot(), this.textStorage.getVersion(); + } + saveTo(e) { + this.host.writeFile(e, fk(this.textStorage.getSnapshot())); + } + /** @internal */ + delayReloadNonMixedContentFile() { + E.assert(!this.isDynamicOrHasMixedContent()), this.textStorage.delayReloadFromFileIntoText(), this.markContainingProjectsAsDirty(); + } + reloadFromFile(e) { + return this.textStorage.reloadWithFileText(e) ? (this.markContainingProjectsAsDirty(), !0) : !1; + } + editContent(e, t, n) { + this.textStorage.edit(e, t, n), this.markContainingProjectsAsDirty(); + } + markContainingProjectsAsDirty() { + for (const e of this.containingProjects) + e.markFileAsDirty(this.path); + } + isOrphan() { + return this.deferredDelete || !lr(this.containingProjects, (e) => !e.isOrphan()); + } + /** + * @param line 1 based index + */ + lineToTextSpan(e) { + return this.textStorage.lineToTextSpan(e); + } + // eslint-disable-line @typescript-eslint/unified-signatures + lineOffsetToPosition(e, t, n) { + return this.textStorage.lineOffsetToPosition(e, t, n); + } + positionToLineOffset(e) { + PKe(e); + const t = this.textStorage.positionToLineOffset(e); + return NKe(t), t; + } + isJavaScript() { + return this.scriptKind === 1 || this.scriptKind === 2; + } + /** @internal */ + closeSourceMapFileWatcher() { + this.sourceMapFilePath && !gs(this.sourceMapFilePath) && (gp(this.sourceMapFilePath), this.sourceMapFilePath = void 0); + } + }; + function PKe(e) { + E.assert(typeof e == "number", `Expected position ${e} to be a number.`), E.assert(e >= 0, "Expected position to be non-negative."); + } + function NKe(e) { + E.assert(typeof e.line == "number", `Expected line ${e.line} to be a number.`), E.assert(typeof e.offset == "number", `Expected offset ${e.offset} to be a number.`), E.assert(e.line > 0, `Expected line to be non-${e.line === 0 ? "zero" : "negative"}`), E.assert(e.offset > 0, `Expected offset to be non-${e.offset === 0 ? "zero" : "negative"}`); + } + function R_e(e) { + return ot( + e.containingProjects, + j8 + ); + } + function j_e(e) { + return ot( + e.containingProjects, + B8 + ); + } + var Ww = /* @__PURE__ */ ((e) => (e[e.Inferred = 0] = "Inferred", e[e.Configured = 1] = "Configured", e[e.External = 2] = "External", e[e.AutoImportProvider = 3] = "AutoImportProvider", e[e.Auxiliary = 4] = "Auxiliary", e))(Ww || {}); + function M8(e, t = !1) { + const n = { + js: 0, + jsSize: 0, + jsx: 0, + jsxSize: 0, + ts: 0, + tsSize: 0, + tsx: 0, + tsxSize: 0, + dts: 0, + dtsSize: 0, + deferred: 0, + deferredSize: 0 + }; + for (const i of e) { + const s = t ? i.textStorage.getTelemetryFileSize() : 0; + switch (i.scriptKind) { + case 1: + n.js += 1, n.jsSize += s; + break; + case 2: + n.jsx += 1, n.jsxSize += s; + break; + case 3: + Il(i.fileName) ? (n.dts += 1, n.dtsSize += s) : (n.ts += 1, n.tsSize += s); + break; + case 4: + n.tsx += 1, n.tsxSize += s; + break; + case 7: + n.deferred += 1, n.deferredSize += s; + break; + } + } + return n; + } + function AKe(e) { + const t = M8(e.getScriptInfos()); + return t.js > 0 && t.ts === 0 && t.tsx === 0; + } + function B_e(e) { + const t = M8(e.getRootScriptInfos()); + return t.ts === 0 && t.tsx === 0; + } + function J_e(e) { + const t = M8(e.getScriptInfos()); + return t.ts === 0 && t.tsx === 0; + } + function z_e(e) { + return !e.some((t) => Xo( + t, + ".ts" + /* Ts */ + ) && !Il(t) || Xo( + t, + ".tsx" + /* Tsx */ + )); + } + function W_e(e) { + return e.generatedFilePath !== void 0; + } + function cPe(e, t) { + if (e === t || (e || bl).length === 0 && (t || bl).length === 0) + return !0; + const n = /* @__PURE__ */ new Map(); + let i = 0; + for (const s of e) + n.get(s) !== !0 && (n.set(s, !0), i++); + for (const s of t) { + const o = n.get(s); + if (o === void 0) + return !1; + o === !0 && (n.set(s, !1), i--); + } + return i === 0; + } + function IKe(e, t) { + return e.enable !== t.enable || !cPe(e.include, t.include) || !cPe(e.exclude, t.exclude); + } + function FKe(e, t) { + return Jy(e) !== Jy(t); + } + function OKe(e, t) { + return e === t ? !1 : !Tf(e, t); + } + var Ek = class U5e { + /** @internal */ + constructor(t, n, i, s, o, c, _, u, g, m) { + switch (this.projectKind = n, this.projectService = i, this.compilerOptions = c, this.compileOnSaveEnabled = _, this.watchOptions = u, this.rootFilesMap = /* @__PURE__ */ new Map(), this.plugins = [], this.cachedUnresolvedImportsPerFile = /* @__PURE__ */ new Map(), this.hasAddedorRemovedFiles = !1, this.hasAddedOrRemovedSymlinks = !1, this.lastReportedVersion = 0, this.projectProgramVersion = 0, this.projectStateVersion = 0, this.initialLoadPending = !1, this.dirty = !1, this.typingFiles = bl, this.moduleSpecifierCache = _fe(this), this.createHash = Os(this.projectService.host, this.projectService.host.createHash), this.globalCacheResolutionModuleName = t1.nonRelativeModuleNameForTypingCache, this.updateFromProjectInProgress = !1, i.logger.info(`Creating ${Ww[n]}Project: ${t}, currentDirectory: ${m}`), this.projectName = t, this.directoryStructureHost = g, this.currentDirectory = this.projectService.getNormalizedAbsolutePath(m), this.getCanonicalFileName = this.projectService.toCanonicalFileName, this.jsDocParsingMode = this.projectService.jsDocParsingMode, this.cancellationToken = new hce(this.projectService.cancellationToken, this.projectService.throttleWaitMilliseconds), this.compilerOptions ? (s || Jy(this.compilerOptions) || this.projectService.hasDeferredExtension()) && (this.compilerOptions.allowNonTsExtensions = !0) : (this.compilerOptions = pL(), this.compilerOptions.allowNonTsExtensions = !0, this.compilerOptions.allowJs = !0), i.serverMode) { + case 0: + this.languageServiceEnabled = !0; + break; + case 1: + this.languageServiceEnabled = !0, this.compilerOptions.noResolve = !0, this.compilerOptions.types = []; + break; + case 2: + this.languageServiceEnabled = !1, this.compilerOptions.noResolve = !0, this.compilerOptions.types = []; + break; + default: + E.assertNever(i.serverMode); + } + this.setInternalCompilerOptionsForEmittingJsFiles(); + const h = this.projectService.host; + this.projectService.logger.loggingEnabled() ? this.trace = (S) => this.writeLog(S) : h.trace && (this.trace = (S) => h.trace(S)), this.realpath = Os(h, h.realpath), this.preferNonRecursiveWatch = this.projectService.canUseWatchEvents || h.preferNonRecursiveWatch, this.resolutionCache = FU( + this, + this.currentDirectory, + /*logChangesWhenResolvingModule*/ + !0 + ), this.languageService = yce( + this, + this.projectService.documentRegistry, + this.projectService.serverMode + ), o && this.disableLanguageService(o), this.markAsDirty(), j8(this) || (this.projectService.pendingEnsureProjectForOpenFiles = !0), this.projectService.onProjectCreation(this); + } + /** @internal */ + getRedirectFromSourceFile(t) { + } + isNonTsProject() { + return Gp(this), J_e(this); + } + isJsOnlyProject() { + return Gp(this), AKe(this); + } + static resolveModule(t, n, i, s) { + return U5e.importServicePluginSync({ name: t }, [n], i, s).resolvedModule; + } + /** @internal */ + static importServicePluginSync(t, n, i, s) { + E.assertIsDefined(i.require); + let o, c; + for (const _ of n) { + const u = zl(i.resolvePath(On(_, "node_modules"))); + s(`Loading ${t.name} from ${_} (resolved to ${u})`); + const g = i.require(u, t.name); + if (!g.error) { + c = g.module; + break; + } + const m = g.error.stack || g.error.message || JSON.stringify(g.error); + (o ?? (o = [])).push(`Failed to load module '${t.name}' from ${u}: ${m}`); + } + return { pluginConfigEntry: t, resolvedModule: c, errorLogs: o }; + } + /** @internal */ + static async importServicePluginAsync(t, n, i, s) { + E.assertIsDefined(i.importPlugin); + let o, c; + for (const _ of n) { + const u = On(_, "node_modules"); + s(`Dynamically importing ${t.name} from ${_} (resolved to ${u})`); + let g; + try { + g = await i.importPlugin(u, t.name); + } catch (h) { + g = { module: void 0, error: h }; + } + if (!g.error) { + c = g.module; + break; + } + const m = g.error.stack || g.error.message || JSON.stringify(g.error); + (o ?? (o = [])).push(`Failed to dynamically import module '${t.name}' from ${u}: ${m}`); + } + return { pluginConfigEntry: t, resolvedModule: c, errorLogs: o }; + } + isKnownTypesPackageName(t) { + return this.projectService.typingsInstaller.isKnownTypesPackageName(t); + } + installPackage(t) { + return this.projectService.typingsInstaller.installPackage({ ...t, projectName: this.projectName, projectRootPath: this.toPath(this.currentDirectory) }); + } + /** @internal */ + getGlobalTypingsCacheLocation() { + return this.getTypeAcquisition().enable ? this.projectService.typingsInstaller.globalTypingsCacheLocation : void 0; + } + /** @internal */ + getSymlinkCache() { + return this.symlinks || (this.symlinks = EJ(this.getCurrentDirectory(), this.getCanonicalFileName)), this.program && !this.symlinks.hasProcessedResolutions() && this.symlinks.setSymlinksFromResolutions( + this.program.forEachResolvedModule, + this.program.forEachResolvedTypeReferenceDirective, + this.program.getAutomaticTypeDirectiveResolutions() + ), this.symlinks; + } + // Method of LanguageServiceHost + getCompilationSettings() { + return this.compilerOptions; + } + // Method to support public API + getCompilerOptions() { + return this.getCompilationSettings(); + } + getNewLine() { + return this.projectService.host.newLine; + } + getProjectVersion() { + return this.projectStateVersion.toString(); + } + getProjectReferences() { + } + getScriptFileNames() { + if (!this.rootFilesMap.size) + return Ge; + let t; + return this.rootFilesMap.forEach((n) => { + (this.languageServiceEnabled || n.info && n.info.isScriptOpen()) && (t || (t = [])).push(n.fileName); + }), In(t, this.typingFiles) || Ge; + } + getOrCreateScriptInfoAndAttachToProject(t) { + const n = this.projectService.getOrCreateScriptInfoNotOpenedByClient( + t, + this.currentDirectory, + this.directoryStructureHost, + /*deferredDeleteOk*/ + !1 + ); + if (n) { + const i = this.rootFilesMap.get(n.path); + i && i.info !== n && (i.info = n), n.attachToProject(this); + } + return n; + } + getScriptKind(t) { + const n = this.projectService.getScriptInfoForPath(this.toPath(t)); + return n && n.scriptKind; + } + getScriptVersion(t) { + const n = this.projectService.getOrCreateScriptInfoNotOpenedByClient( + t, + this.currentDirectory, + this.directoryStructureHost, + /*deferredDeleteOk*/ + !1 + ); + return n && n.getLatestVersion(); + } + getScriptSnapshot(t) { + const n = this.getOrCreateScriptInfoAndAttachToProject(t); + if (n) + return n.getSnapshot(); + } + getCancellationToken() { + return this.cancellationToken; + } + getCurrentDirectory() { + return this.currentDirectory; + } + getDefaultLibFileName() { + const t = Hn(Hs(this.projectService.getExecutingFilePath())); + return On(t, ZP(this.compilerOptions)); + } + useCaseSensitiveFileNames() { + return this.projectService.host.useCaseSensitiveFileNames; + } + readDirectory(t, n, i, s, o) { + return this.directoryStructureHost.readDirectory(t, n, i, s, o); + } + readFile(t) { + return this.projectService.host.readFile(t); + } + writeFile(t, n) { + return this.projectService.host.writeFile(t, n); + } + fileExists(t) { + const n = this.toPath(t); + return !!this.projectService.getScriptInfoForPath(n) || !this.isWatchedMissingFile(n) && this.directoryStructureHost.fileExists(t); + } + /** @internal */ + resolveModuleNameLiterals(t, n, i, s, o, c) { + return this.resolutionCache.resolveModuleNameLiterals(t, n, i, s, o, c); + } + /** @internal */ + getModuleResolutionCache() { + return this.resolutionCache.getModuleResolutionCache(); + } + /** @internal */ + resolveTypeReferenceDirectiveReferences(t, n, i, s, o, c) { + return this.resolutionCache.resolveTypeReferenceDirectiveReferences( + t, + n, + i, + s, + o, + c + ); + } + /** @internal */ + resolveLibrary(t, n, i, s) { + return this.resolutionCache.resolveLibrary(t, n, i, s); + } + directoryExists(t) { + return this.directoryStructureHost.directoryExists(t); + } + getDirectories(t) { + return this.directoryStructureHost.getDirectories(t); + } + /** @internal */ + getCachedDirectoryStructureHost() { + } + /** @internal */ + toPath(t) { + return oo(t, this.currentDirectory, this.projectService.toCanonicalFileName); + } + /** @internal */ + watchDirectoryOfFailedLookupLocation(t, n, i) { + return this.projectService.watchFactory.watchDirectory( + t, + n, + i, + this.projectService.getWatchOptions(this), + Fl.FailedLookupLocations, + this + ); + } + /** @internal */ + watchAffectingFileLocation(t, n) { + return this.projectService.watchFactory.watchFile( + t, + n, + 2e3, + this.projectService.getWatchOptions(this), + Fl.AffectingFileLocation, + this + ); + } + /** @internal */ + clearInvalidateResolutionOfFailedLookupTimer() { + return this.projectService.throttledOperations.cancel(`${this.getProjectName()}FailedLookupInvalidation`); + } + /** @internal */ + scheduleInvalidateResolutionsOfFailedLookupLocations() { + this.projectService.throttledOperations.schedule( + `${this.getProjectName()}FailedLookupInvalidation`, + /*delay*/ + 1e3, + () => { + this.resolutionCache.invalidateResolutionsOfFailedLookupLocations() && this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this); + } + ); + } + /** @internal */ + invalidateResolutionsOfFailedLookupLocations() { + this.clearInvalidateResolutionOfFailedLookupTimer() && this.resolutionCache.invalidateResolutionsOfFailedLookupLocations() && (this.markAsDirty(), this.projectService.delayEnsureProjectForOpenFiles()); + } + /** @internal */ + onInvalidatedResolution() { + this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this); + } + /** @internal */ + watchTypeRootsDirectory(t, n, i) { + return this.projectService.watchFactory.watchDirectory( + t, + n, + i, + this.projectService.getWatchOptions(this), + Fl.TypeRoots, + this + ); + } + /** @internal */ + hasChangedAutomaticTypeDirectiveNames() { + return this.resolutionCache.hasChangedAutomaticTypeDirectiveNames(); + } + /** @internal */ + onChangedAutomaticTypeDirectiveNames() { + this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this); + } + /** @internal */ + fileIsOpen(t) { + return this.projectService.openFiles.has(t); + } + /** @internal */ + writeLog(t) { + this.projectService.logger.info(t); + } + log(t) { + this.writeLog(t); + } + error(t) { + this.projectService.logger.msg( + t, + "Err" + /* Err */ + ); + } + setInternalCompilerOptionsForEmittingJsFiles() { + (this.projectKind === 0 || this.projectKind === 2) && (this.compilerOptions.noEmitForJsFiles = !0); + } + /** + * Get the errors that dont have any file name associated + */ + getGlobalProjectErrors() { + return kn(this.projectErrors, (t) => !t.file) || bl; + } + /** + * Get all the project errors + */ + getAllProjectErrors() { + return this.projectErrors || bl; + } + setProjectErrors(t) { + this.projectErrors = t; + } + getLanguageService(t = !0) { + return t && Gp(this), this.languageService; + } + /** @internal */ + getSourceMapper() { + return this.getLanguageService().getSourceMapper(); + } + /** @internal */ + clearSourceMapperCache() { + this.languageService.clearSourceMapperCache(); + } + /** @internal */ + getDocumentPositionMapper(t, n) { + return this.projectService.getDocumentPositionMapper(this, t, n); + } + /** @internal */ + getSourceFileLike(t) { + return this.projectService.getSourceFileLike(t, this); + } + /** @internal */ + shouldEmitFile(t) { + return t && !t.isDynamicOrHasMixedContent() && !this.program.isSourceOfProjectReferenceRedirect(t.path); + } + getCompileOnSaveAffectedFileList(t) { + return this.languageServiceEnabled ? (Gp(this), this.builderState = Md.create( + this.program, + this.builderState, + /*disableUseFileVersionAsSignature*/ + !0 + ), Fi( + Md.getFilesAffectedBy( + this.builderState, + this.program, + t.path, + this.cancellationToken, + this.projectService.host + ), + (n) => this.shouldEmitFile(this.projectService.getScriptInfoForPath(n.path)) ? n.fileName : void 0 + )) : []; + } + /** + * Returns true if emit was conducted + */ + emitFile(t, n) { + if (!this.languageServiceEnabled || !this.shouldEmitFile(t)) + return { emitSkipped: !0, diagnostics: bl }; + const { emitSkipped: i, diagnostics: s, outputFiles: o } = this.getLanguageService().getEmitOutput(t.fileName); + if (!i) { + for (const c of o) { + const _ = Qi(c.name, this.currentDirectory); + n(_, c.text, c.writeByteOrderMark); + } + if (this.builderState && J_(this.compilerOptions)) { + const c = o.filter((_) => Il(_.name)); + if (c.length === 1) { + const _ = this.program.getSourceFile(t.fileName), u = this.projectService.host.createHash ? this.projectService.host.createHash(c[0].text) : uD(c[0].text); + Md.updateSignatureOfFile(this.builderState, u, _.resolvedPath); + } + } + } + return { emitSkipped: i, diagnostics: s }; + } + enableLanguageService() { + this.languageServiceEnabled || this.projectService.serverMode === 2 || (this.languageServiceEnabled = !0, this.lastFileExceededProgramSize = void 0, this.projectService.onUpdateLanguageServiceStateForProject( + this, + /*languageServiceEnabled*/ + !0 + )); + } + /** @internal */ + cleanupProgram() { + if (this.program) { + for (const t of this.program.getSourceFiles()) + this.detachScriptInfoIfNotRoot(t.fileName); + this.program.forEachResolvedProjectReference((t) => this.detachScriptInfoFromProject(t.sourceFile.fileName)), this.program = void 0; + } + } + disableLanguageService(t) { + this.languageServiceEnabled && (E.assert( + this.projectService.serverMode !== 2 + /* Syntactic */ + ), this.languageService.cleanupSemanticCache(), this.languageServiceEnabled = !1, this.cleanupProgram(), this.lastFileExceededProgramSize = t, this.builderState = void 0, this.autoImportProviderHost && this.autoImportProviderHost.close(), this.autoImportProviderHost = void 0, this.resolutionCache.closeTypeRootsWatch(), this.clearGeneratedFileWatch(), this.projectService.verifyDocumentRegistry(), this.projectService.onUpdateLanguageServiceStateForProject( + this, + /*languageServiceEnabled*/ + !1 + )); + } + getProjectName() { + return this.projectName; + } + removeLocalTypingsFromTypeAcquisition(t) { + return !t.enable || !t.include ? t : { ...t, include: this.removeExistingTypings(t.include) }; + } + getExternalFiles(t) { + return X_(ka(this.plugins, (n) => { + if (typeof n.module.getExternalFiles == "function") + try { + return n.module.getExternalFiles( + this, + t || 0 + /* Update */ + ); + } catch (i) { + this.projectService.logger.info(`A plugin threw an exception in getExternalFiles: ${i}`), i.stack && this.projectService.logger.info(i.stack); + } + })); + } + getSourceFile(t) { + if (this.program) + return this.program.getSourceFileByPath(t); + } + /** @internal */ + getSourceFileOrConfigFile(t) { + const n = this.program.getCompilerOptions(); + return t === n.configFilePath ? n.configFile : this.getSourceFile(t); + } + close() { + var t; + this.typingsCache && this.projectService.typingsInstaller.onProjectClosed(this), this.typingsCache = void 0, this.closeWatchingTypingLocations(), this.cleanupProgram(), lr(this.externalFiles, (n) => this.detachScriptInfoIfNotRoot(n)), this.rootFilesMap.forEach((n) => { + var i; + return (i = n.info) == null ? void 0 : i.detachFromProject(this); + }), this.projectService.pendingEnsureProjectForOpenFiles = !0, this.rootFilesMap = void 0, this.externalFiles = void 0, this.program = void 0, this.builderState = void 0, this.resolutionCache.clear(), this.resolutionCache = void 0, this.cachedUnresolvedImportsPerFile = void 0, (t = this.packageJsonWatches) == null || t.forEach((n) => { + n.projects.delete(this), n.close(); + }), this.packageJsonWatches = void 0, this.moduleSpecifierCache.clear(), this.moduleSpecifierCache = void 0, this.directoryStructureHost = void 0, this.exportMapCache = void 0, this.projectErrors = void 0, this.plugins.length = 0, this.missingFilesMap && (B_(this.missingFilesMap, od), this.missingFilesMap = void 0), this.clearGeneratedFileWatch(), this.clearInvalidateResolutionOfFailedLookupTimer(), this.autoImportProviderHost && this.autoImportProviderHost.close(), this.autoImportProviderHost = void 0, this.noDtsResolutionProject && this.noDtsResolutionProject.close(), this.noDtsResolutionProject = void 0, this.languageService.dispose(), this.languageService = void 0; + } + detachScriptInfoIfNotRoot(t) { + const n = this.projectService.getScriptInfo(t); + n && !this.isRoot(n) && n.detachFromProject(this); + } + isClosed() { + return this.rootFilesMap === void 0; + } + hasRoots() { + var t; + return !!((t = this.rootFilesMap) != null && t.size); + } + /** @internal */ + isOrphan() { + return !1; + } + getRootFiles() { + return this.rootFilesMap && is(uy(this.rootFilesMap.values(), (t) => { + var n; + return (n = t.info) == null ? void 0 : n.fileName; + })); + } + /** @internal */ + getRootFilesMap() { + return this.rootFilesMap; + } + getRootScriptInfos() { + return is(uy(this.rootFilesMap.values(), (t) => t.info)); + } + getScriptInfos() { + return this.languageServiceEnabled ? hr(this.program.getSourceFiles(), (t) => { + const n = this.projectService.getScriptInfoForPath(t.resolvedPath); + return E.assert(!!n, "getScriptInfo", () => `scriptInfo for a file '${t.fileName}' Path: '${t.path}' / '${t.resolvedPath}' is missing.`), n; + }) : this.getRootScriptInfos(); + } + getExcludedFiles() { + return bl; + } + getFileNames(t, n) { + if (!this.program) + return []; + if (!this.languageServiceEnabled) { + let s = this.getRootFiles(); + if (this.compilerOptions) { + const o = vce(this.compilerOptions); + o && (s || (s = [])).push(o); + } + return s; + } + const i = []; + for (const s of this.program.getSourceFiles()) + t && this.program.isSourceFileFromExternalLibrary(s) || i.push(s.fileName); + if (!n) { + const s = this.program.getCompilerOptions().configFile; + if (s && (i.push(s.fileName), s.extendedSourceFiles)) + for (const o of s.extendedSourceFiles) + i.push(o); + } + return i; + } + /** @internal */ + getFileNamesWithRedirectInfo(t) { + return this.getFileNames().map((n) => ({ + fileName: n, + isSourceOfProjectReferenceRedirect: t && this.isSourceOfProjectReferenceRedirect(n) + })); + } + hasConfigFile(t) { + if (this.program && this.languageServiceEnabled) { + const n = this.program.getCompilerOptions().configFile; + if (n) { + if (t === n.fileName) + return !0; + if (n.extendedSourceFiles) { + for (const i of n.extendedSourceFiles) + if (t === i) + return !0; + } + } + } + return !1; + } + containsScriptInfo(t) { + if (this.isRoot(t)) return !0; + if (!this.program) return !1; + const n = this.program.getSourceFileByPath(t.path); + return !!n && n.resolvedPath === t.path; + } + containsFile(t, n) { + const i = this.projectService.getScriptInfoForNormalizedPath(t); + return i && (i.isScriptOpen() || !n) ? this.containsScriptInfo(i) : !1; + } + isRoot(t) { + var n, i; + return ((i = (n = this.rootFilesMap) == null ? void 0 : n.get(t.path)) == null ? void 0 : i.info) === t; + } + // add a root file to project + addRoot(t, n) { + E.assert(!this.isRoot(t)), this.rootFilesMap.set(t.path, { fileName: n || t.fileName, info: t }), t.attachToProject(this), this.markAsDirty(); + } + // add a root file that doesnt exist on host + addMissingFileRoot(t) { + const n = this.projectService.toPath(t); + this.rootFilesMap.set(n, { fileName: t }), this.markAsDirty(); + } + removeFile(t, n, i) { + this.isRoot(t) && this.removeRoot(t), n ? this.resolutionCache.removeResolutionsOfFile(t.path) : this.resolutionCache.invalidateResolutionOfFile(t.path), this.cachedUnresolvedImportsPerFile.delete(t.path), i && t.detachFromProject(this), this.markAsDirty(); + } + registerFileUpdate(t) { + (this.updatedFileNames || (this.updatedFileNames = /* @__PURE__ */ new Set())).add(t); + } + /** @internal */ + markFileAsDirty(t) { + this.markAsDirty(), this.exportMapCache && !this.exportMapCache.isEmpty() && (this.changedFilesForExportMapCache || (this.changedFilesForExportMapCache = /* @__PURE__ */ new Set())).add(t); + } + /** @internal */ + markAsDirty() { + this.dirty || (this.projectStateVersion++, this.dirty = !0); + } + /** @internal */ + markAutoImportProviderAsDirty() { + var t; + this.autoImportProviderHost || (this.autoImportProviderHost = void 0), (t = this.autoImportProviderHost) == null || t.markAsDirty(); + } + /** @internal */ + onAutoImportProviderSettingsChanged() { + this.markAutoImportProviderAsDirty(); + } + /** @internal */ + onPackageJsonChange() { + this.moduleSpecifierCache.clear(), this.markAutoImportProviderAsDirty(); + } + /** @internal */ + onFileAddedOrRemoved(t) { + this.hasAddedorRemovedFiles = !0, t && (this.hasAddedOrRemovedSymlinks = !0); + } + /** @internal */ + onDiscoveredSymlink() { + this.hasAddedOrRemovedSymlinks = !0; + } + /** @internal */ + onReleaseOldSourceFile(t, n, i, s) { + (!s || t.resolvedPath === t.path && s.resolvedPath !== t.path) && this.detachScriptInfoFromProject(t.fileName, i); + } + /** @internal */ + updateFromProject() { + Gp(this); + } + /** + * Updates set of files that contribute to this project + * @returns: true if set of files in the project stays the same and false - otherwise. + */ + updateGraph() { + var t, n; + (t = on) == null || t.push(on.Phase.Session, "updateGraph", { name: this.projectName, kind: Ww[this.projectKind] }), this.resolutionCache.startRecordingFilesWithChangedResolutions(); + const i = this.updateGraphWorker(), s = this.hasAddedorRemovedFiles; + this.hasAddedorRemovedFiles = !1, this.hasAddedOrRemovedSymlinks = !1; + const o = this.resolutionCache.finishRecordingFilesWithChangedResolutions() || bl; + for (const _ of o) + this.cachedUnresolvedImportsPerFile.delete(_); + this.languageServiceEnabled && this.projectService.serverMode === 0 && !this.isOrphan() ? ((i || o.length) && (this.lastCachedUnresolvedImportsList = LKe(this.program, this.cachedUnresolvedImportsPerFile)), this.enqueueInstallTypingsForProject(s)) : this.lastCachedUnresolvedImportsList = void 0; + const c = this.projectProgramVersion === 0 && i; + return i && this.projectProgramVersion++, s && this.markAutoImportProviderAsDirty(), c && this.getPackageJsonAutoImportProvider(), (n = on) == null || n.pop(), !i; + } + /** @internal */ + enqueueInstallTypingsForProject(t) { + const n = this.getTypeAcquisition(); + if (!n || !n.enable || this.projectService.typingsInstaller === UL) + return; + const i = this.typingsCache; + (t || !i || IKe(n, i.typeAcquisition) || FKe(this.getCompilationSettings(), i.compilerOptions) || OKe(this.lastCachedUnresolvedImportsList, i.unresolvedImports)) && (this.typingsCache = { + compilerOptions: this.getCompilationSettings(), + typeAcquisition: n, + unresolvedImports: this.lastCachedUnresolvedImportsList + }, this.projectService.typingsInstaller.enqueueInstallTypingsRequest(this, n, this.lastCachedUnresolvedImportsList)); + } + /** @internal */ + updateTypingFiles(t, n, i, s) { + this.typingsCache = { + compilerOptions: t, + typeAcquisition: n, + unresolvedImports: i + }; + const o = !n || !n.enable ? bl : X_(s); + e7( + o, + this.typingFiles, + vC(!this.useCaseSensitiveFileNames()), + /*inserted*/ + Ha, + (c) => this.detachScriptInfoFromProject(c) + ) && (this.typingFiles = o, this.resolutionCache.setFilesWithInvalidatedNonRelativeUnresolvedImports(this.cachedUnresolvedImportsPerFile), this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this)); + } + closeWatchingTypingLocations() { + this.typingWatchers && B_(this.typingWatchers, od), this.typingWatchers = void 0; + } + onTypingInstallerWatchInvoke() { + this.typingWatchers.isInvoked = !0, this.projectService.updateTypingsForProject({ projectName: this.getProjectName(), kind: c9 }); + } + /** @internal */ + watchTypingLocations(t) { + if (!t) { + this.typingWatchers.isInvoked = !1; + return; + } + if (!t.length) { + this.closeWatchingTypingLocations(); + return; + } + const n = new Map(this.typingWatchers); + this.typingWatchers || (this.typingWatchers = /* @__PURE__ */ new Map()), this.typingWatchers.isInvoked = !1; + const i = (s, o) => { + const c = this.toPath(s); + if (n.delete(c), !this.typingWatchers.has(c)) { + const _ = o === "FileWatcher" ? Fl.TypingInstallerLocationFile : Fl.TypingInstallerLocationDirectory; + this.typingWatchers.set( + c, + AA(c) ? o === "FileWatcher" ? this.projectService.watchFactory.watchFile( + s, + () => this.typingWatchers.isInvoked ? this.writeLog("TypingWatchers already invoked") : this.onTypingInstallerWatchInvoke(), + 2e3, + this.projectService.getWatchOptions(this), + _, + this + ) : this.projectService.watchFactory.watchDirectory( + s, + (u) => { + if (this.typingWatchers.isInvoked) return this.writeLog("TypingWatchers already invoked"); + if (!Xo( + u, + ".json" + /* Json */ + )) return this.writeLog("Ignoring files that are not *.json"); + if (gh(u, On(this.projectService.typingsInstaller.globalTypingsCacheLocation, "package.json"), !this.useCaseSensitiveFileNames())) return this.writeLog("Ignoring package.json change at global typings location"); + this.onTypingInstallerWatchInvoke(); + }, + 1, + this.projectService.getWatchOptions(this), + _, + this + ) : (this.writeLog(`Skipping watcher creation at ${s}:: ${OG(_, this)}`), z6) + ); + } + }; + for (const s of t) { + const o = Zc(s); + if (o === "package.json" || o === "bower.json") { + i( + s, + "FileWatcher" + /* FileWatcher */ + ); + continue; + } + if (np(this.currentDirectory, s, this.currentDirectory, !this.useCaseSensitiveFileNames())) { + const c = s.indexOf(So, this.currentDirectory.length + 1); + i( + c !== -1 ? s.substr(0, c) : s, + "DirectoryWatcher" + /* DirectoryWatcher */ + ); + continue; + } + if (np(this.projectService.typingsInstaller.globalTypingsCacheLocation, s, this.currentDirectory, !this.useCaseSensitiveFileNames())) { + i( + this.projectService.typingsInstaller.globalTypingsCacheLocation, + "DirectoryWatcher" + /* DirectoryWatcher */ + ); + continue; + } + i( + s, + "DirectoryWatcher" + /* DirectoryWatcher */ + ); + } + n.forEach((s, o) => { + s.close(), this.typingWatchers.delete(o); + }); + } + /** @internal */ + getCurrentProgram() { + return this.program; + } + removeExistingTypings(t) { + if (!t.length) return t; + const n = lO(this.getCompilerOptions(), this); + return kn(t, (i) => !n.includes(i)); + } + updateGraphWorker() { + var t, n; + const i = this.languageService.getCurrentProgram(); + E.assert(i === this.program), E.assert(!this.isClosed(), "Called update graph worker of closed project"), this.writeLog(`Starting updateGraphWorker: Project: ${this.getProjectName()}`); + const s = ao(), { hasInvalidatedResolutions: o, hasInvalidatedLibResolutions: c } = this.resolutionCache.createHasInvalidatedResolutions(mh, mh); + this.hasInvalidatedResolutions = o, this.hasInvalidatedLibResolutions = c, this.resolutionCache.startCachingPerDirectoryResolution(), this.dirty = !1, this.updateFromProjectInProgress = !0, this.program = this.languageService.getProgram(), this.updateFromProjectInProgress = !1, (t = on) == null || t.push(on.Phase.Session, "finishCachingPerDirectoryResolution"), this.resolutionCache.finishCachingPerDirectoryResolution(this.program, i), (n = on) == null || n.pop(), E.assert(i === void 0 || this.program !== void 0); + let _ = !1; + if (this.program && (!i || this.program !== i && this.program.structureIsReused !== 2)) { + if (_ = !0, this.rootFilesMap.forEach((m, h) => { + var S; + const T = this.program.getSourceFileByPath(h), k = m.info; + !T || ((S = m.info) == null ? void 0 : S.path) === T.resolvedPath || (m.info = this.projectService.getScriptInfo(T.fileName), E.assert(m.info.isAttached(this)), k?.detachFromProject(this)); + }), oU( + this.program, + this.missingFilesMap || (this.missingFilesMap = /* @__PURE__ */ new Map()), + // Watch the missing files + (m, h) => this.addMissingFileWatcher(m, h) + ), this.generatedFilesMap) { + const m = this.compilerOptions.outFile; + W_e(this.generatedFilesMap) ? (!m || !this.isValidGeneratedFileWatcher( + Gu(m) + ".d.ts", + this.generatedFilesMap + )) && this.clearGeneratedFileWatch() : m ? this.clearGeneratedFileWatch() : this.generatedFilesMap.forEach((h, S) => { + const T = this.program.getSourceFileByPath(S); + (!T || T.resolvedPath !== S || !this.isValidGeneratedFileWatcher( + x5(T.fileName, this.compilerOptions, this.program), + h + )) && (gp(h), this.generatedFilesMap.delete(S)); + }); + } + this.languageServiceEnabled && this.projectService.serverMode === 0 && this.resolutionCache.updateTypeRootsWatch(); + } + this.projectService.verifyProgram(this), this.exportMapCache && !this.exportMapCache.isEmpty() && (this.exportMapCache.releaseSymbols(), this.hasAddedorRemovedFiles || i && !this.program.structureIsReused ? this.exportMapCache.clear() : this.changedFilesForExportMapCache && i && this.program && Ag(this.changedFilesForExportMapCache, (m) => { + const h = i.getSourceFileByPath(m), S = this.program.getSourceFileByPath(m); + return !h || !S ? (this.exportMapCache.clear(), !0) : this.exportMapCache.onFileChanged(h, S, !!this.getTypeAcquisition().enable); + })), this.changedFilesForExportMapCache && this.changedFilesForExportMapCache.clear(), (this.hasAddedOrRemovedSymlinks || this.program && !this.program.structureIsReused && this.getCompilerOptions().preserveSymlinks) && (this.symlinks = void 0, this.moduleSpecifierCache.clear()); + const u = this.externalFiles || bl; + this.externalFiles = this.getExternalFiles(), e7( + this.externalFiles, + u, + vC(!this.useCaseSensitiveFileNames()), + // Ensure a ScriptInfo is created for new external files. This is performed indirectly + // by the host for files in the program when the program is retrieved above but + // the program doesn't contain external files so this must be done explicitly. + (m) => { + const h = this.projectService.getOrCreateScriptInfoNotOpenedByClient( + m, + this.currentDirectory, + this.directoryStructureHost, + /*deferredDeleteOk*/ + !1 + ); + h?.attachToProject(this); + }, + (m) => this.detachScriptInfoFromProject(m) + ); + const g = ao() - s; + return this.sendPerformanceEvent("UpdateGraph", g), this.writeLog(`Finishing updateGraphWorker: Project: ${this.getProjectName()} projectStateVersion: ${this.projectStateVersion} projectProgramVersion: ${this.projectProgramVersion} structureChanged: ${_}${this.program ? ` structureIsReused:: ${nj[this.program.structureIsReused]}` : ""} Elapsed: ${g}ms`), this.projectService.logger.isTestLogger ? this.program !== i ? this.print( + /*writeProjectFileNames*/ + !0, + this.hasAddedorRemovedFiles, + /*writeFileVersionAndText*/ + !0 + ) : this.writeLog("Same program as before") : this.hasAddedorRemovedFiles ? this.print( + /*writeProjectFileNames*/ + !0, + /*writeFileExplaination*/ + !0, + /*writeFileVersionAndText*/ + !1 + ) : this.program !== i && this.writeLog("Different program with same set of files"), this.projectService.verifyDocumentRegistry(), _; + } + /** @internal */ + sendPerformanceEvent(t, n) { + this.projectService.sendPerformanceEvent(t, n); + } + detachScriptInfoFromProject(t, n) { + const i = this.projectService.getScriptInfo(t); + i && (i.detachFromProject(this), n || this.resolutionCache.removeResolutionsOfFile(i.path)); + } + addMissingFileWatcher(t, n) { + var i; + if (L0(this)) { + const o = this.projectService.configFileExistenceInfoCache.get(t); + if ((i = o?.config) != null && i.projects.has(this.canonicalConfigFilePath)) return z6; + } + const s = this.projectService.watchFactory.watchFile( + Qi(n, this.currentDirectory), + (o, c) => { + L0(this) && this.getCachedDirectoryStructureHost().addOrDeleteFile(o, t, c), c === 0 && this.missingFilesMap.has(t) && (this.missingFilesMap.delete(t), s.close(), this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this)); + }, + 500, + this.projectService.getWatchOptions(this), + Fl.MissingFile, + this + ); + return s; + } + isWatchedMissingFile(t) { + return !!this.missingFilesMap && this.missingFilesMap.has(t); + } + /** @internal */ + addGeneratedFileWatch(t, n) { + if (this.compilerOptions.outFile) + this.generatedFilesMap || (this.generatedFilesMap = this.createGeneratedFileWatcher(t)); + else { + const i = this.toPath(n); + if (this.generatedFilesMap) { + if (W_e(this.generatedFilesMap)) { + E.fail(`${this.projectName} Expected to not have --out watcher for generated file with options: ${JSON.stringify(this.compilerOptions)}`); + return; + } + if (this.generatedFilesMap.has(i)) return; + } else + this.generatedFilesMap = /* @__PURE__ */ new Map(); + this.generatedFilesMap.set(i, this.createGeneratedFileWatcher(t)); + } + } + createGeneratedFileWatcher(t) { + return { + generatedFilePath: this.toPath(t), + watcher: this.projectService.watchFactory.watchFile( + t, + () => { + this.clearSourceMapperCache(), this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this); + }, + 2e3, + this.projectService.getWatchOptions(this), + Fl.MissingGeneratedFile, + this + ) + }; + } + isValidGeneratedFileWatcher(t, n) { + return this.toPath(t) === n.generatedFilePath; + } + clearGeneratedFileWatch() { + this.generatedFilesMap && (W_e(this.generatedFilesMap) ? gp(this.generatedFilesMap) : B_(this.generatedFilesMap, gp), this.generatedFilesMap = void 0); + } + getScriptInfoForNormalizedPath(t) { + const n = this.projectService.getScriptInfoForPath(this.toPath(t)); + return n && !n.isAttached(this) ? Rh.ThrowProjectDoesNotContainDocument(t, this) : n; + } + getScriptInfo(t) { + return this.projectService.getScriptInfo(t); + } + filesToString(t) { + return this.filesToStringWorker( + t, + /*writeFileExplaination*/ + !0, + /*writeFileVersionAndText*/ + !1 + ); + } + filesToStringWorker(t, n, i) { + if (this.initialLoadPending) return ` Files (0) InitialLoadPending +`; + if (!this.program) return ` Files (0) NoProgram +`; + const s = this.program.getSourceFiles(); + let o = ` Files (${s.length}) +`; + if (t) { + for (const c of s) + o += ` ${c.fileName}${i ? ` ${c.version} ${JSON.stringify(c.text)}` : ""} +`; + n && (o += ` + +`, jU(this.program, (c) => o += ` ${c} +`)); + } + return o; + } + /** @internal */ + print(t, n, i) { + var s; + this.writeLog(`Project '${this.projectName}' (${Ww[this.projectKind]})`), this.writeLog(this.filesToStringWorker( + t && this.projectService.logger.hasLevel( + 3 + /* verbose */ + ), + n && this.projectService.logger.hasLevel( + 3 + /* verbose */ + ), + i && this.projectService.logger.hasLevel( + 3 + /* verbose */ + ) + )), this.writeLog("-----------------------------------------------"), this.autoImportProviderHost && this.autoImportProviderHost.print( + /*writeProjectFileNames*/ + !1, + /*writeFileExplaination*/ + !1, + /*writeFileVersionAndText*/ + !1 + ), (s = this.noDtsResolutionProject) == null || s.print( + /*writeProjectFileNames*/ + !1, + /*writeFileExplaination*/ + !1, + /*writeFileVersionAndText*/ + !1 + ); + } + setCompilerOptions(t) { + var n; + if (t) { + t.allowNonTsExtensions = !0; + const i = this.compilerOptions; + this.compilerOptions = t, this.setInternalCompilerOptionsForEmittingJsFiles(), (n = this.noDtsResolutionProject) == null || n.setCompilerOptions(this.getCompilerOptionsForNoDtsResolutionProject()), R7(i, t) && (this.cachedUnresolvedImportsPerFile.clear(), this.lastCachedUnresolvedImportsList = void 0, this.resolutionCache.onChangesAffectModuleResolution(), this.moduleSpecifierCache.clear()), this.markAsDirty(); + } + } + /** @internal */ + setWatchOptions(t) { + this.watchOptions = t; + } + /** @internal */ + getWatchOptions() { + return this.watchOptions; + } + setTypeAcquisition(t) { + t && (this.typeAcquisition = this.removeLocalTypingsFromTypeAcquisition(t)); + } + getTypeAcquisition() { + return this.typeAcquisition || {}; + } + /** @internal */ + getChangesSinceVersion(t, n) { + var i, s; + const o = n ? (u) => is(u.entries(), ([g, m]) => ({ + fileName: g, + isSourceOfProjectReferenceRedirect: m + })) : (u) => is(u.keys()); + this.initialLoadPending || Gp(this); + const c = { + projectName: this.getProjectName(), + version: this.projectProgramVersion, + isInferred: cE(this), + options: this.getCompilationSettings(), + languageServiceDisabled: !this.languageServiceEnabled, + lastFileExceededProgramSize: this.lastFileExceededProgramSize + }, _ = this.updatedFileNames; + if (this.updatedFileNames = void 0, this.lastReportedFileNames && t === this.lastReportedVersion) { + if (this.projectProgramVersion === this.lastReportedVersion && !_) + return { info: c, projectErrors: this.getGlobalProjectErrors() }; + const u = this.lastReportedFileNames, g = ((i = this.externalFiles) == null ? void 0 : i.map((D) => ({ + fileName: ro(D), + isSourceOfProjectReferenceRedirect: !1 + }))) || bl, m = hC( + this.getFileNamesWithRedirectInfo(!!n).concat(g), + (D) => D.fileName, + (D) => D.isSourceOfProjectReferenceRedirect + ), h = /* @__PURE__ */ new Map(), S = /* @__PURE__ */ new Map(), T = _ ? is(_.keys()) : [], k = []; + return hl(m, (D, P) => { + u.has(P) ? n && D !== u.get(P) && k.push({ + fileName: P, + isSourceOfProjectReferenceRedirect: D + }) : h.set(P, D); + }), hl(u, (D, P) => { + m.has(P) || S.set(P, D); + }), this.lastReportedFileNames = m, this.lastReportedVersion = this.projectProgramVersion, { + info: c, + changes: { + added: o(h), + removed: o(S), + updated: n ? T.map((D) => ({ + fileName: D, + isSourceOfProjectReferenceRedirect: this.isSourceOfProjectReferenceRedirect(D) + })) : T, + updatedRedirects: n ? k : void 0 + }, + projectErrors: this.getGlobalProjectErrors() + }; + } else { + const u = this.getFileNamesWithRedirectInfo(!!n), g = ((s = this.externalFiles) == null ? void 0 : s.map((h) => ({ + fileName: ro(h), + isSourceOfProjectReferenceRedirect: !1 + }))) || bl, m = u.concat(g); + return this.lastReportedFileNames = hC( + m, + (h) => h.fileName, + (h) => h.isSourceOfProjectReferenceRedirect + ), this.lastReportedVersion = this.projectProgramVersion, { + info: c, + files: n ? m : m.map((h) => h.fileName), + projectErrors: this.getGlobalProjectErrors() + }; + } + } + // remove a root file from project + removeRoot(t) { + this.rootFilesMap.delete(t.path); + } + /** @internal */ + isSourceOfProjectReferenceRedirect(t) { + return !!this.program && this.program.isSourceOfProjectReferenceRedirect(t); + } + /** @internal */ + getGlobalPluginSearchPaths() { + return [ + ...this.projectService.pluginProbeLocations, + // ../../.. to walk from X/node_modules/typescript/lib/tsserver.js to X/node_modules/ + On(this.projectService.getExecutingFilePath(), "../../..") + ]; + } + enableGlobalPlugins(t) { + if (!this.projectService.globalPlugins.length) return; + const n = this.projectService.host; + if (!n.require && !n.importPlugin) { + this.projectService.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded"); + return; + } + const i = this.getGlobalPluginSearchPaths(); + for (const s of this.projectService.globalPlugins) + s && (t.plugins && t.plugins.some((o) => o.name === s) || (this.projectService.logger.info(`Loading global plugin ${s}`), this.enablePlugin({ name: s, global: !0 }, i))); + } + enablePlugin(t, n) { + this.projectService.requestEnablePlugin(this, t, n); + } + /** @internal */ + enableProxy(t, n) { + try { + if (typeof t != "function") { + this.projectService.logger.info(`Skipped loading plugin ${n.name} because it did not expose a proper factory function`); + return; + } + const i = { + config: n, + project: this, + languageService: this.languageService, + languageServiceHost: this, + serverHost: this.projectService.host, + session: this.projectService.session + }, s = t({ typescript: Uwe }), o = s.create(i); + for (const c of Object.keys(this.languageService)) + c in o || (this.projectService.logger.info(`Plugin activation warning: Missing proxied method ${c} in created LS. Patching.`), o[c] = this.languageService[c]); + this.projectService.logger.info("Plugin validation succeeded"), this.languageService = o, this.plugins.push({ name: n.name, module: s }); + } catch (i) { + this.projectService.logger.info(`Plugin activation failed: ${i}`); + } + } + /** @internal */ + onPluginConfigurationChanged(t, n) { + this.plugins.filter((i) => i.name === t).forEach((i) => { + i.module.onConfigurationChanged && i.module.onConfigurationChanged(n); + }); + } + /** Starts a new check for diagnostics. Call this if some file has updated that would cause diagnostics to be changed. */ + refreshDiagnostics() { + this.projectService.sendProjectsUpdatedInBackgroundEvent(); + } + /** @internal */ + getPackageJsonsVisibleToFile(t, n) { + return this.projectService.serverMode !== 0 ? bl : this.projectService.getPackageJsonsVisibleToFile(t, this, n); + } + /** @internal */ + getNearestAncestorDirectoryWithPackageJson(t) { + return this.projectService.getNearestAncestorDirectoryWithPackageJson(t, this); + } + /** @internal */ + getPackageJsonsForAutoImport(t) { + return this.getPackageJsonsVisibleToFile(On(this.currentDirectory, cw), t); + } + /** @internal */ + getPackageJsonCache() { + return this.projectService.packageJsonCache; + } + /** @internal */ + getCachedExportInfoMap() { + return this.exportMapCache || (this.exportMapCache = hq(this)); + } + /** @internal */ + clearCachedExportInfoMap() { + var t; + (t = this.exportMapCache) == null || t.clear(); + } + /** @internal */ + getModuleSpecifierCache() { + return this.moduleSpecifierCache; + } + /** @internal */ + includePackageJsonAutoImports() { + return this.projectService.includePackageJsonAutoImports() === 0 || !this.languageServiceEnabled || e8(this.currentDirectory) || !this.isDefaultProjectForOpenFiles() ? 0 : this.projectService.includePackageJsonAutoImports(); + } + /** @internal */ + getHostForAutoImportProvider() { + var t, n; + return this.program ? { + fileExists: this.program.fileExists, + directoryExists: this.program.directoryExists, + realpath: this.program.realpath || ((t = this.projectService.host.realpath) == null ? void 0 : t.bind(this.projectService.host)), + getCurrentDirectory: this.getCurrentDirectory.bind(this), + readFile: this.projectService.host.readFile.bind(this.projectService.host), + getDirectories: this.projectService.host.getDirectories.bind(this.projectService.host), + trace: (n = this.projectService.host.trace) == null ? void 0 : n.bind(this.projectService.host), + useCaseSensitiveFileNames: this.program.useCaseSensitiveFileNames(), + readDirectory: this.projectService.host.readDirectory.bind(this.projectService.host) + } : this.projectService.host; + } + /** @internal */ + getPackageJsonAutoImportProvider() { + var t, n, i; + if (this.autoImportProviderHost === !1) + return; + if (this.projectService.serverMode !== 0) { + this.autoImportProviderHost = !1; + return; + } + if (this.autoImportProviderHost) { + if (Gp(this.autoImportProviderHost), this.autoImportProviderHost.isEmpty()) { + this.autoImportProviderHost.close(), this.autoImportProviderHost = void 0; + return; + } + return this.autoImportProviderHost.getCurrentProgram(); + } + const s = this.includePackageJsonAutoImports(); + if (s) { + (t = on) == null || t.push(on.Phase.Session, "getPackageJsonAutoImportProvider"); + const o = ao(); + if (this.autoImportProviderHost = H_e.create( + s, + this, + this.getHostForAutoImportProvider() + ) ?? !1, this.autoImportProviderHost) + return Gp(this.autoImportProviderHost), this.sendPerformanceEvent("CreatePackageJsonAutoImportProvider", ao() - o), (n = on) == null || n.pop(), this.autoImportProviderHost.getCurrentProgram(); + (i = on) == null || i.pop(); + } + } + isDefaultProjectForOpenFiles() { + return !!hl( + this.projectService.openFiles, + (t, n) => this.projectService.tryGetDefaultProjectForFile(this.projectService.getScriptInfoForPath(n)) === this + ); + } + /** @internal */ + watchNodeModulesForPackageJsonChanges(t) { + return this.projectService.watchPackageJsonsInNodeModules(t, this); + } + /** @internal */ + getIncompleteCompletionsCache() { + return this.projectService.getIncompleteCompletionsCache(); + } + /** @internal */ + getNoDtsResolutionProject(t) { + return E.assert( + this.projectService.serverMode === 0 + /* Semantic */ + ), this.noDtsResolutionProject ?? (this.noDtsResolutionProject = new V_e(this)), this.noDtsResolutionProject.rootFile !== t && (this.projectService.setFileNamesOfAutoImportProviderOrAuxillaryProject( + this.noDtsResolutionProject, + [t] + ), this.noDtsResolutionProject.rootFile = t), this.noDtsResolutionProject; + } + /** @internal */ + runWithTemporaryFileUpdate(t, n, i) { + var s, o, c, _; + const u = this.program, g = E.checkDefined((s = this.program) == null ? void 0 : s.getSourceFile(t), "Expected file to be part of program"), m = E.checkDefined(g.getFullText()); + (o = this.getScriptInfo(t)) == null || o.editContent(0, m.length, n), this.updateGraph(); + try { + i(this.program, u, (c = this.program) == null ? void 0 : c.getSourceFile(t)); + } finally { + (_ = this.getScriptInfo(t)) == null || _.editContent(0, n.length, m); + } + } + /** @internal */ + getCompilerOptionsForNoDtsResolutionProject() { + return { + ...this.getCompilerOptions(), + noDtsResolution: !0, + allowJs: !0, + maxNodeModuleJsDepth: 3, + diagnostics: !1, + skipLibCheck: !0, + sourceMap: !1, + types: Ge, + lib: Ge, + noLib: !0 + }; + } + }; + function LKe(e, t) { + var n, i; + const s = e.getSourceFiles(); + (n = on) == null || n.push(on.Phase.Session, "getUnresolvedImports", { count: s.length }); + const o = e.getTypeChecker().getAmbientModules().map((_) => Bp(_.getName())), c = tD(ka(s, (_) => MKe( + e, + _, + o, + t + ))); + return (i = on) == null || i.pop(), c; + } + function MKe(e, t, n, i) { + return eD(i, t.path, () => { + let s; + return e.forEachResolvedModule(({ resolvedModule: o }, c) => { + (!o || !f4(o.extension)) && !Dl(c) && !n.some((_) => _ === c) && (s = Er(s, pO(c).packageName)); + }, t), s || bl; + }); + } + var U_e = class extends Ek { + /** @internal */ + constructor(e, t, n, i, s, o) { + super( + e.newInferredProjectName(), + 0, + e, + /*hasExplicitListOfFiles*/ + !1, + /*lastFileExceededProgramSize*/ + void 0, + t, + /*compileOnSaveEnabled*/ + !1, + n, + e.host, + s + ), this._isJsInferredProject = !1, this.typeAcquisition = o, this.projectRootPath = i && e.toCanonicalFileName(i), !i && !e.useSingleInferredProject && (this.canonicalCurrentDirectory = e.toCanonicalFileName(this.currentDirectory)), this.enableGlobalPlugins(this.getCompilerOptions()); + } + toggleJsInferredProject(e) { + e !== this._isJsInferredProject && (this._isJsInferredProject = e, this.setCompilerOptions()); + } + setCompilerOptions(e) { + if (!e && !this.getCompilationSettings()) + return; + const t = MV(e || this.getCompilationSettings()); + this._isJsInferredProject && typeof t.maxNodeModuleJsDepth != "number" ? t.maxNodeModuleJsDepth = 2 : this._isJsInferredProject || (t.maxNodeModuleJsDepth = void 0), t.allowJs = !0, super.setCompilerOptions(t); + } + addRoot(e) { + E.assert(e.isScriptOpen()), this.projectService.startWatchingConfigFilesForInferredProjectRoot(e), !this._isJsInferredProject && e.isJavaScript() ? this.toggleJsInferredProject( + /*isJsInferredProject*/ + !0 + ) : this.isOrphan() && this._isJsInferredProject && !e.isJavaScript() && this.toggleJsInferredProject( + /*isJsInferredProject*/ + !1 + ), super.addRoot(e); + } + removeRoot(e) { + this.projectService.stopWatchingConfigFilesForScriptInfo(e), super.removeRoot(e), !this.isOrphan() && this._isJsInferredProject && e.isJavaScript() && Ni(this.getRootScriptInfos(), (t) => !t.isJavaScript()) && this.toggleJsInferredProject( + /*isJsInferredProject*/ + !1 + ); + } + /** @internal */ + isOrphan() { + return !this.hasRoots(); + } + isProjectWithSingleRoot() { + return !this.projectRootPath && !this.projectService.useSingleInferredProject || this.getRootScriptInfos().length === 1; + } + close() { + lr(this.getRootScriptInfos(), (e) => this.projectService.stopWatchingConfigFilesForScriptInfo(e)), super.close(); + } + getTypeAcquisition() { + return this.typeAcquisition || { + enable: B_e(this), + include: Ge, + exclude: Ge + }; + } + }, V_e = class extends Ek { + constructor(e) { + super( + e.projectService.newAuxiliaryProjectName(), + 4, + e.projectService, + /*hasExplicitListOfFiles*/ + !1, + /*lastFileExceededProgramSize*/ + void 0, + e.getCompilerOptionsForNoDtsResolutionProject(), + /*compileOnSaveEnabled*/ + !1, + /*watchOptions*/ + void 0, + e.projectService.host, + e.currentDirectory + ); + } + isOrphan() { + return !0; + } + scheduleInvalidateResolutionsOfFailedLookupLocations() { + } + }, q_e = class _ge extends Ek { + /** @internal */ + constructor(t, n, i) { + super( + t.projectService.newAutoImportProviderProjectName(), + 3, + t.projectService, + /*hasExplicitListOfFiles*/ + !1, + /*lastFileExceededProgramSize*/ + void 0, + i, + /*compileOnSaveEnabled*/ + !1, + t.getWatchOptions(), + t.projectService.host, + t.currentDirectory + ), this.hostProject = t, this.rootFileNames = n, this.useSourceOfProjectReferenceRedirect = Os(this.hostProject, this.hostProject.useSourceOfProjectReferenceRedirect), this.getParsedCommandLine = Os(this.hostProject, this.hostProject.getParsedCommandLine); + } + /** @internal */ + static getRootFileNames(t, n, i, s) { + var o, c; + if (!t) + return Ge; + const _ = n.getCurrentProgram(); + if (!_) + return Ge; + const u = ao(); + let g, m; + const h = On(n.currentDirectory, cw), S = n.getPackageJsonsForAutoImport(On(n.currentDirectory, h)); + for (const R of S) + (o = R.dependencies) == null || o.forEach((B, U) => A(U)), (c = R.peerDependencies) == null || c.forEach((B, U) => A(U)); + let T = 0; + if (g) { + const R = n.getSymlinkCache(); + for (const B of is(g.keys())) { + if (t === 2 && T >= this.maxDependencies) + return n.log(`AutoImportProviderProject: attempted to add more than ${this.maxDependencies} dependencies. Aborting.`), Ge; + const U = fW( + B, + n.currentDirectory, + s, + i, + _.getModuleResolutionCache() + ); + if (U) { + const W = O(U, _, R); + if (W) { + T += P(W); + continue; + } + } + if (!lr([n.currentDirectory, n.getGlobalTypingsCacheLocation()], (W) => { + if (W) { + const _e = fW( + `@types/${B}`, + W, + s, + i, + _.getModuleResolutionCache() + ); + if (_e) { + const K = O(_e, _, R); + return T += P(K), !0; + } + } + }) && U && s.allowJs && s.maxNodeModuleJsDepth) { + const W = O( + U, + _, + R, + /*resolveJs*/ + !0 + ); + T += P(W); + } + } + } + const k = _.getResolvedProjectReferences(); + let D = 0; + return k?.length && n.projectService.getHostPreferences().includeCompletionsForModuleExports && k.forEach((R) => { + if (R?.commandLine.options.outFile) + D += P(F([ + S0(R.commandLine.options.outFile, ".d.ts") + ])); + else if (R) { + const B = Uu( + () => JS( + R.commandLine, + !n.useCaseSensitiveFileNames() + ) + ); + D += P(F(Fi( + R.commandLine.fileNames, + (U) => !Il(U) && !Xo( + U, + ".json" + /* Json */ + ) && !_.getSourceFile(U) ? sw( + U, + R.commandLine, + !n.useCaseSensitiveFileNames(), + B + ) : void 0 + ))); + } + }), m?.size && n.log(`AutoImportProviderProject: found ${m.size} root files in ${T} dependencies ${D} referenced projects in ${ao() - u} ms`), m ? is(m.values()) : Ge; + function P(R) { + return R?.length ? (m ?? (m = /* @__PURE__ */ new Set()), R.forEach((B) => m.add(B)), 1) : 0; + } + function A(R) { + Ui(R, "@types/") || (g || (g = /* @__PURE__ */ new Set())).add(R); + } + function O(R, B, U, $) { + var W; + const _e = yW( + R, + s, + i, + B.getModuleResolutionCache(), + $ + ); + if (_e) { + const K = (W = i.realpath) == null ? void 0 : W.call(i, R.packageDirectory), V = K ? n.toPath(K) : void 0, ae = V && V !== n.toPath(R.packageDirectory); + return ae && U.setSymlinkedDirectory(R.packageDirectory, { + real: gl(K), + realPath: gl(V) + }), F(_e, ae ? (se) => se.replace(R.packageDirectory, K) : void 0); + } + } + function F(R, B) { + return Fi(R, (U) => { + const $ = B ? B(U) : U; + if (!_.getSourceFile($) && !(B && _.getSourceFile(U))) + return $; + }); + } + } + /** @internal */ + static create(t, n, i) { + if (t === 0) + return; + const s = { + ...n.getCompilerOptions(), + ...this.compilerOptionsOverrides + }, o = this.getRootFileNames(t, n, i, s); + if (o.length) + return new _ge(n, o, s); + } + /** @internal */ + isEmpty() { + return !ot(this.rootFileNames); + } + /** @internal */ + isOrphan() { + return !0; + } + updateGraph() { + let t = this.rootFileNames; + t || (t = _ge.getRootFileNames( + this.hostProject.includePackageJsonAutoImports(), + this.hostProject, + this.hostProject.getHostForAutoImportProvider(), + this.getCompilationSettings() + )), this.projectService.setFileNamesOfAutoImportProviderOrAuxillaryProject(this, t), this.rootFileNames = t; + const n = this.getCurrentProgram(), i = super.updateGraph(); + return n && n !== this.getCurrentProgram() && this.hostProject.clearCachedExportInfoMap(), i; + } + /** @internal */ + scheduleInvalidateResolutionsOfFailedLookupLocations() { + } + hasRoots() { + var t; + return !!((t = this.rootFileNames) != null && t.length); + } + /** @internal */ + markAsDirty() { + this.rootFileNames = void 0, super.markAsDirty(); + } + getScriptFileNames() { + return this.rootFileNames || Ge; + } + getLanguageService() { + throw new Error("AutoImportProviderProject language service should never be used. To get the program, use `project.getCurrentProgram()`."); + } + /** @internal */ + onAutoImportProviderSettingsChanged() { + throw new Error("AutoImportProviderProject is an auto import provider; use `markAsDirty()` instead."); + } + /** @internal */ + onPackageJsonChange() { + throw new Error("package.json changes should be notified on an AutoImportProvider's host project"); + } + getHostForAutoImportProvider() { + throw new Error("AutoImportProviderProject cannot provide its own host; use `hostProject.getModuleResolutionHostForAutomImportProvider()` instead."); + } + getProjectReferences() { + return this.hostProject.getProjectReferences(); + } + /** @internal */ + includePackageJsonAutoImports() { + return 0; + } + /** @internal */ + getSymlinkCache() { + return this.hostProject.getSymlinkCache(); + } + /** @internal */ + getModuleResolutionCache() { + var t; + return (t = this.hostProject.getCurrentProgram()) == null ? void 0 : t.getModuleResolutionCache(); + } + }; + q_e.maxDependencies = 10, q_e.compilerOptionsOverrides = { + diagnostics: !1, + skipLibCheck: !0, + sourceMap: !1, + types: Ge, + lib: Ge, + noLib: !0 + }; + var H_e = q_e, G_e = class extends Ek { + /** @internal */ + constructor(e, t, n, i, s) { + super( + e, + 1, + n, + /*hasExplicitListOfFiles*/ + !1, + /*lastFileExceededProgramSize*/ + void 0, + /*compilerOptions*/ + {}, + /*compileOnSaveEnabled*/ + !1, + /*watchOptions*/ + void 0, + i, + Hn(e) + ), this.canonicalConfigFilePath = t, this.openFileWatchTriggered = /* @__PURE__ */ new Map(), this.initialLoadPending = !0, this.sendLoadingProjectFinish = !1, this.pendingUpdateLevel = 2, this.pendingUpdateReason = s; + } + /** @internal */ + setCompilerHost(e) { + this.compilerHost = e; + } + /** @internal */ + getCompilerHost() { + return this.compilerHost; + } + /** @internal */ + useSourceOfProjectReferenceRedirect() { + return this.languageServiceEnabled; + } + /** @internal */ + getParsedCommandLine(e) { + const t = ro(e), n = this.projectService.toCanonicalFileName(t); + let i = this.projectService.configFileExistenceInfoCache.get(n); + return i || this.projectService.configFileExistenceInfoCache.set(n, i = { exists: this.projectService.host.fileExists(t) }), this.projectService.ensureParsedConfigUptoDate(t, n, i, this), this.languageServiceEnabled && this.projectService.serverMode === 0 && this.projectService.watchWildcards(t, i, this), i.exists ? i.config.parsedCommandLine : void 0; + } + /** @internal */ + onReleaseParsedCommandLine(e) { + this.releaseParsedConfig(this.projectService.toCanonicalFileName(ro(e))); + } + releaseParsedConfig(e) { + this.projectService.stopWatchingWildCards(e, this), this.projectService.releaseParsedConfig(e, this); + } + /** + * If the project has reload from disk pending, it reloads (and then updates graph as part of that) instead of just updating the graph + * @returns: true if set of files in the project stays the same and false - otherwise. + */ + updateGraph() { + if (this.deferredClose) return !1; + const e = this.dirty; + this.initialLoadPending = !1; + const t = this.pendingUpdateLevel; + this.pendingUpdateLevel = 0; + let n; + switch (t) { + case 1: + this.openFileWatchTriggered.clear(), n = this.projectService.reloadFileNamesOfConfiguredProject(this); + break; + case 2: + this.openFileWatchTriggered.clear(); + const i = E.checkDefined(this.pendingUpdateReason); + this.projectService.reloadConfiguredProject(this, i), n = !0; + break; + default: + n = super.updateGraph(); + } + return this.compilerHost = void 0, this.projectService.sendProjectLoadingFinishEvent(this), this.projectService.sendProjectTelemetry(this), t === 2 || // Already sent event through reload + n && // Not new program + (!e || !this.triggerFileForConfigFileDiag || this.getCurrentProgram().structureIsReused === 2) ? this.triggerFileForConfigFileDiag = void 0 : this.triggerFileForConfigFileDiag || this.projectService.sendConfigFileDiagEvent( + this, + /*triggerFile*/ + void 0, + /*force*/ + !1 + ), n; + } + /** @internal */ + getCachedDirectoryStructureHost() { + return this.directoryStructureHost; + } + getConfigFilePath() { + return this.getProjectName(); + } + getProjectReferences() { + return this.projectReferences; + } + updateReferences(e) { + this.projectReferences = e, this.potentialProjectReferences = void 0; + } + /** @internal */ + setPotentialProjectReference(e) { + E.assert(this.initialLoadPending), (this.potentialProjectReferences || (this.potentialProjectReferences = /* @__PURE__ */ new Set())).add(e); + } + /** @internal */ + getRedirectFromSourceFile(e) { + const t = this.getCurrentProgram(); + return t && t.getRedirectFromSourceFile(e); + } + /** @internal */ + forEachResolvedProjectReference(e) { + var t; + return (t = this.getCurrentProgram()) == null ? void 0 : t.forEachResolvedProjectReference(e); + } + /** @internal */ + enablePluginsWithOptions(e) { + var t; + if (this.plugins.length = 0, !((t = e.plugins) != null && t.length) && !this.projectService.globalPlugins.length) return; + const n = this.projectService.host; + if (!n.require && !n.importPlugin) { + this.projectService.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded"); + return; + } + const i = this.getGlobalPluginSearchPaths(); + if (this.projectService.allowLocalPluginLoads) { + const s = Hn(this.canonicalConfigFilePath); + this.projectService.logger.info(`Local plugin loading enabled; adding ${s} to search paths`), i.unshift(s); + } + if (e.plugins) + for (const s of e.plugins) + this.enablePlugin(s, i); + return this.enableGlobalPlugins(e); + } + /** + * Get the errors that dont have any file name associated + */ + getGlobalProjectErrors() { + return kn(this.projectErrors, (e) => !e.file) || bl; + } + /** + * Get all the project errors + */ + getAllProjectErrors() { + return this.projectErrors || bl; + } + setProjectErrors(e) { + this.projectErrors = e; + } + close() { + this.projectService.configFileExistenceInfoCache.forEach((e, t) => this.releaseParsedConfig(t)), this.projectErrors = void 0, this.openFileWatchTriggered.clear(), this.compilerHost = void 0, super.close(); + } + /** @internal */ + markAsDirty() { + this.deferredClose || super.markAsDirty(); + } + /** @internal */ + isOrphan() { + return !!this.deferredClose; + } + getEffectiveTypeRoots() { + return q4(this.getCompilationSettings(), this) || []; + } + /** @internal */ + updateErrorOnNoInputFiles(e) { + this.parsedCommandLine = e, iO( + e.fileNames, + this.getConfigFilePath(), + this.getCompilerOptions().configFile.configFileSpecs, + this.projectErrors, + oA(e.raw) + ); + } + }, hG = class extends Ek { + /** @internal */ + constructor(e, t, n, i, s, o, c) { + super( + e, + 2, + t, + /*hasExplicitListOfFiles*/ + !0, + i, + n, + s, + c, + t.host, + Hn(o || zl(e)) + ), this.externalProjectName = e, this.compileOnSaveEnabled = s, this.excludedFiles = [], this.enableGlobalPlugins(this.getCompilerOptions()); + } + updateGraph() { + const e = super.updateGraph(); + return this.projectService.sendProjectTelemetry(this), e; + } + getExcludedFiles() { + return this.excludedFiles; + } + }; + function cE(e) { + return e.projectKind === 0; + } + function L0(e) { + return e.projectKind === 1; + } + function R8(e) { + return e.projectKind === 2; + } + function j8(e) { + return e.projectKind === 3 || e.projectKind === 4; + } + function B8(e) { + return L0(e) && !!e.deferredClose; + } + var yG = 20 * 1024 * 1024, vG = 4 * 1024 * 1024, zL = "projectsUpdatedInBackground", bG = "projectLoadingStart", SG = "projectLoadingFinish", TG = "largeFileReferenced", xG = "configFileDiag", kG = "projectLanguageServiceState", CG = "projectInfo", $_e = "openFileInfo", EG = "createFileWatcher", DG = "createDirectoryWatcher", wG = "closeFileWatcher", lPe = "*ensureProjectForOpenFiles*"; + function uPe(e) { + const t = /* @__PURE__ */ new Map(); + for (const n of e) + if (typeof n.type == "object") { + const i = n.type; + i.forEach((s) => { + E.assert(typeof s == "number"); + }), t.set(n.name, i); + } + return t; + } + var RKe = uPe(_d), jKe = uPe(rk), BKe = new Map(Object.entries({ + none: 0, + block: 1, + smart: 2 + /* Smart */ + })), X_e = { + jquery: { + // jquery files can have names like "jquery-1.10.2.min.js" (or "jquery.intellisense.js") + match: /jquery(-[\d.]+)?(\.intellisense)?(\.min)?\.js$/i, + types: ["jquery"] + }, + WinJS: { + // e.g. c:/temp/UWApp1/lib/winjs-4.0.1/js/base.js + match: /^(.*\/winjs-[.\d]+)\/js\/base\.js$/i, + // If the winjs/base.js file is found.. + exclude: [["^", 1, "/.*"]], + // ..then exclude all files under the winjs folder + types: ["winjs"] + // And fetch the @types package for WinJS + }, + Kendo: { + // e.g. /Kendo3/wwwroot/lib/kendo/kendo.all.min.js + match: /^(.*\/kendo(-ui)?)\/kendo\.all(\.min)?\.js$/i, + exclude: [["^", 1, "/.*"]], + types: ["kendo-ui"] + }, + "Office Nuget": { + // e.g. /scripts/Office/1/excel-15.debug.js + match: /^(.*\/office\/1)\/excel-\d+\.debug\.js$/i, + // Office NuGet package is installed under a "1/office" folder + exclude: [["^", 1, "/.*"]], + // Exclude that whole folder if the file indicated above is found in it + types: ["office"] + // @types package to fetch instead + }, + References: { + match: /^(.*\/_references\.js)$/i, + exclude: [["^", 1, "$"]] + } + }; + function lE(e) { + return gs(e.indentStyle) && (e.indentStyle = BKe.get(e.indentStyle.toLowerCase()), E.assert(e.indentStyle !== void 0)), e; + } + function WL(e) { + return RKe.forEach((t, n) => { + const i = e[n]; + gs(i) && (e[n] = t.get(i.toLowerCase())); + }), e; + } + function J8(e, t) { + let n, i; + return rk.forEach((s) => { + const o = e[s.name]; + if (o === void 0) return; + const c = jKe.get(s.name); + (n || (n = {}))[s.name] = c ? gs(o) ? c.get(o.toLowerCase()) : o : LS(s, o, t || "", i || (i = [])); + }), n && { watchOptions: n, errors: i }; + } + function Q_e(e) { + let t; + return $F.forEach((n) => { + const i = e[n.name]; + i !== void 0 && ((t || (t = {}))[n.name] = i); + }), t; + } + function PG(e) { + return gs(e) ? NG(e) : e; + } + function NG(e) { + switch (e) { + case "JS": + return 1; + case "JSX": + return 2; + case "TS": + return 3; + case "TSX": + return 4; + default: + return 0; + } + } + function Y_e(e) { + const { lazyConfiguredProjectsFromExternalProject: t, ...n } = e; + return n; + } + var AG = { + getFileName: (e) => e, + getScriptKind: (e, t) => { + let n; + if (t) { + const i = ex(e); + i && ot(t, (s) => s.extension === i ? (n = s.scriptKind, !0) : !1); + } + return n; + }, + hasMixedContent: (e, t) => ot(t, (n) => n.isMixedContent && Xo(e, n.extension)) + }, IG = { + getFileName: (e) => e.fileName, + getScriptKind: (e) => PG(e.scriptKind), + // TODO: GH#18217 + hasMixedContent: (e) => !!e.hasMixedContent + }; + function _Pe(e, t) { + for (const n of t) + if (n.getProjectName() === e) + return n; + } + var UL = { + isKnownTypesPackageName: mh, + // Should never be called because we never provide a types registry. + installPackage: Vs, + enqueueInstallTypingsRequest: Ha, + attach: Ha, + onProjectClosed: Ha, + globalTypingsCacheLocation: void 0 + // TODO: GH#18217 + }, Z_e = { close: Ha }; + function fPe(e, t) { + if (!t) return; + const n = t.get(e.path); + if (n !== void 0) + return FG(e) ? n && !gs(n) ? ( + // Map with fileName as key + n.get(e.fileName) + ) : void 0 : gs(n) || !n ? n : ( + // direct result + n.get( + /*key*/ + !1 + ) + ); + } + function pPe(e) { + return !!e.containingProjects; + } + function FG(e) { + return !!e.configFileInfo; + } + var K_e = /* @__PURE__ */ ((e) => (e[e.FindOptimized = 0] = "FindOptimized", e[e.Find = 1] = "Find", e[e.CreateReplayOptimized = 2] = "CreateReplayOptimized", e[e.CreateReplay = 3] = "CreateReplay", e[e.CreateOptimized = 4] = "CreateOptimized", e[e.Create = 5] = "Create", e[e.ReloadOptimized = 6] = "ReloadOptimized", e[e.Reload = 7] = "Reload", e))(K_e || {}); + function dPe(e) { + return e - 1; + } + function mPe(e, t, n, i, s, o, c, _, u) { + for (var g; ; ) { + if (t.parsedCommandLine && (_ && !t.parsedCommandLine.options.composite || // Currently disableSolutionSearching is shared for finding solution/project when + // - loading solution for find all references + // - trying to find default project + t.parsedCommandLine.options.disableSolutionSearching)) return; + const m = t.projectService.getConfigFileNameForFile( + { + fileName: t.getConfigFilePath(), + path: e.path, + configFileInfo: !0, + isForDefaultProject: !_ + }, + i <= 3 + /* CreateReplay */ + ); + if (!m) return; + const h = t.projectService.findCreateOrReloadConfiguredProject( + m, + i, + s, + o, + _ ? void 0 : e.fileName, + // Config Diag event for project if its for default project + c, + _, + // Delay load if we are searching for solution + u + ); + if (!h) return; + !h.project.parsedCommandLine && ((g = t.parsedCommandLine) != null && g.options.composite) && h.project.setPotentialProjectReference(t.canonicalConfigFilePath); + const S = n(h); + if (S) return S; + t = h.project; + } + } + function gPe(e, t, n, i, s, o, c, _) { + const u = t.options.disableReferencedProjectLoad ? 0 : i; + let g; + return lr( + t.projectReferences, + (m) => { + var h; + const S = ro(ck(m)), T = e.projectService.toCanonicalFileName(S), k = _?.get(T); + if (k !== void 0 && k >= u) return; + const D = e.projectService.configFileExistenceInfoCache.get(T); + let P = u === 0 ? D?.exists || (h = e.resolvedChildConfigs) != null && h.has(T) ? D.config.parsedCommandLine : void 0 : e.getParsedCommandLine(S); + if (P && u !== i && u > 2 && (P = e.getParsedCommandLine(S)), !P) return; + const A = e.projectService.findConfiguredProjectByProjectName(S, o); + if (!(u === 2 && !D && !A)) { + switch (u) { + case 6: + A && A.projectService.reloadConfiguredProjectOptimized(A, s, c); + // falls through + case 4: + (e.resolvedChildConfigs ?? (e.resolvedChildConfigs = /* @__PURE__ */ new Set())).add(T); + // falls through + case 2: + case 0: + if (A || u !== 0) { + const O = n( + D ?? e.projectService.configFileExistenceInfoCache.get(T), + A, + S, + s, + e, + T + ); + if (O) return O; + } + break; + default: + E.assertNever(u); + } + (_ ?? (_ = /* @__PURE__ */ new Map())).set(T, u), (g ?? (g = [])).push(P); + } + } + ) || lr( + g, + (m) => m.projectReferences && gPe( + e, + m, + n, + u, + s, + o, + c, + _ + ) + ); + } + function efe(e, t, n, i, s) { + let o = !1, c; + switch (t) { + case 2: + case 3: + ife(e) && (c = e.projectService.configFileExistenceInfoCache.get(e.canonicalConfigFilePath)); + break; + case 4: + if (c = nfe(e), c) break; + // falls through + case 5: + o = zKe(e, n); + break; + case 6: + if (e.projectService.reloadConfiguredProjectOptimized(e, i, s), c = nfe(e), c) break; + // falls through + case 7: + o = e.projectService.reloadConfiguredProjectClearingSemanticCache( + e, + i, + s + ); + break; + case 0: + case 1: + break; + default: + E.assertNever(t); + } + return { project: e, sentConfigFileDiag: o, configFileExistenceInfo: c, reason: i }; + } + function hPe(e, t) { + return e.initialLoadPending ? (e.potentialProjectReferences && Ag(e.potentialProjectReferences, t)) ?? (e.resolvedChildConfigs && Ag(e.resolvedChildConfigs, t)) : void 0; + } + function JKe(e, t, n, i) { + return e.getCurrentProgram() ? e.forEachResolvedProjectReference(t) : e.initialLoadPending ? hPe(e, i) : lr(e.getProjectReferences(), n); + } + function tfe(e, t, n) { + const i = n && e.projectService.configuredProjects.get(n); + return i && t(i); + } + function yPe(e, t) { + return JKe( + e, + (n) => tfe(e, t, n.sourceFile.path), + (n) => tfe(e, t, e.toPath(ck(n))), + (n) => tfe(e, t, n) + ); + } + function OG(e, t) { + return `${gs(t) ? `Config: ${t} ` : t ? `Project: ${t.getProjectName()} ` : ""}WatchType: ${e}`; + } + function rfe(e) { + return !e.isScriptOpen() && e.mTime !== void 0; + } + function Gp(e) { + return e.invalidateResolutionsOfFailedLookupLocations(), e.dirty && !e.updateGraph(); + } + function vPe(e, t, n) { + if (!n && (e.invalidateResolutionsOfFailedLookupLocations(), !e.dirty)) + return !1; + e.triggerFileForConfigFileDiag = t; + const i = e.pendingUpdateLevel; + if (e.updateGraph(), !e.triggerFileForConfigFileDiag && !n) return i === 2; + const s = e.projectService.sendConfigFileDiagEvent(e, t, n); + return e.triggerFileForConfigFileDiag = void 0, s; + } + function zKe(e, t) { + if (t) { + if (vPe( + e, + t, + /*isReload*/ + !1 + )) return !0; + } else + Gp(e); + return !1; + } + function nfe(e) { + const t = ro(e.getConfigFilePath()), n = e.projectService.ensureParsedConfigUptoDate( + t, + e.canonicalConfigFilePath, + e.projectService.configFileExistenceInfoCache.get(e.canonicalConfigFilePath), + e + ), i = n.config.parsedCommandLine; + if (e.parsedCommandLine = i, e.resolvedChildConfigs = void 0, e.updateReferences(i.projectReferences), ife(e)) return n; + } + function ife(e) { + return !!e.parsedCommandLine && (!!e.parsedCommandLine.options.composite || // If solution, no need to load it to determine if file belongs to it + !!cW(e.parsedCommandLine)); + } + function WKe(e) { + return ife(e) ? e.projectService.configFileExistenceInfoCache.get(e.canonicalConfigFilePath) : void 0; + } + function UKe(e) { + return `Creating possible configured project for ${e.fileName} to open`; + } + function LG(e) { + return `User requested reload projects: ${e}`; + } + function sfe(e) { + L0(e) && (e.projectOptions = !0); + } + function afe(e) { + let t = 1; + return () => e(t++); + } + function ofe() { + return { idToCallbacks: /* @__PURE__ */ new Map(), pathToId: /* @__PURE__ */ new Map() }; + } + function bPe(e, t) { + return !!t && !!e.eventHandler && !!e.session; + } + function VKe(e, t) { + if (!bPe(e, t)) return; + const n = ofe(), i = ofe(), s = ofe(); + let o = 1; + return e.session.addProtocolHandler("watchChange", (T) => (g(T.arguments), { responseRequired: !1 })), { + watchFile: c, + watchDirectory: _, + getCurrentDirectory: () => e.host.getCurrentDirectory(), + useCaseSensitiveFileNames: e.host.useCaseSensitiveFileNames + }; + function c(T, k) { + return u( + n, + T, + k, + (D) => ({ eventName: EG, data: { id: D, path: T } }) + ); + } + function _(T, k, D) { + return u( + D ? s : i, + T, + k, + (P) => ({ + eventName: DG, + data: { + id: P, + path: T, + recursive: !!D, + // Special case node_modules as we watch it for changes to closed script infos as well + ignoreUpdate: T.endsWith("/node_modules") ? void 0 : !0 + } + }) + ); + } + function u({ pathToId: T, idToCallbacks: k }, D, P, A) { + const O = e.toPath(D); + let F = T.get(O); + F || T.set(O, F = o++); + let R = k.get(F); + return R || (k.set(F, R = /* @__PURE__ */ new Set()), e.eventHandler(A(F))), R.add(P), { + close() { + const B = k.get(F); + B?.delete(P) && (B.size || (k.delete(F), T.delete(O), e.eventHandler({ eventName: wG, data: { id: F } }))); + } + }; + } + function g(T) { + as(T) ? T.forEach(m) : m(T); + } + function m({ id: T, created: k, deleted: D, updated: P }) { + h( + T, + k, + 0 + /* Created */ + ), h( + T, + D, + 2 + /* Deleted */ + ), h( + T, + P, + 1 + /* Changed */ + ); + } + function h(T, k, D) { + k?.length && (S(n, T, k, (P, A) => P(A, D)), S(i, T, k, (P, A) => P(A)), S(s, T, k, (P, A) => P(A))); + } + function S(T, k, D, P) { + var A; + (A = T.idToCallbacks.get(k)) == null || A.forEach((O) => { + D.forEach((F) => P(O, zl(F))); + }); + } + } + var SPe = class fge { + constructor(t) { + this.filenameToScriptInfo = /* @__PURE__ */ new Map(), this.nodeModulesWatchers = /* @__PURE__ */ new Map(), this.filenameToScriptInfoVersion = /* @__PURE__ */ new Map(), this.allJsFilesForOpenFileTelemetry = /* @__PURE__ */ new Set(), this.externalProjectToConfiguredProjectMap = /* @__PURE__ */ new Map(), this.externalProjects = [], this.inferredProjects = [], this.configuredProjects = /* @__PURE__ */ new Map(), this.newInferredProjectName = afe(D_e), this.newAutoImportProviderProjectName = afe(w_e), this.newAuxiliaryProjectName = afe(P_e), this.openFiles = /* @__PURE__ */ new Map(), this.configFileForOpenFiles = /* @__PURE__ */ new Map(), this.rootOfInferredProjects = /* @__PURE__ */ new Set(), this.openFilesWithNonRootedDiskPath = /* @__PURE__ */ new Map(), this.compilerOptionsForInferredProjectsPerProjectRoot = /* @__PURE__ */ new Map(), this.watchOptionsForInferredProjectsPerProjectRoot = /* @__PURE__ */ new Map(), this.typeAcquisitionForInferredProjectsPerProjectRoot = /* @__PURE__ */ new Map(), this.projectToSizeMap = /* @__PURE__ */ new Map(), this.configFileExistenceInfoCache = /* @__PURE__ */ new Map(), this.safelist = X_e, this.legacySafelist = /* @__PURE__ */ new Map(), this.pendingProjectUpdates = /* @__PURE__ */ new Map(), this.pendingEnsureProjectForOpenFiles = !1, this.seenProjects = /* @__PURE__ */ new Map(), this.sharedExtendedConfigFileWatchers = /* @__PURE__ */ new Map(), this.extendedConfigCache = /* @__PURE__ */ new Map(), this.baseline = Ha, this.verifyDocumentRegistry = Ha, this.verifyProgram = Ha, this.onProjectCreation = Ha; + var n; + this.host = t.host, this.logger = t.logger, this.cancellationToken = t.cancellationToken, this.useSingleInferredProject = t.useSingleInferredProject, this.useInferredProjectPerProjectRoot = t.useInferredProjectPerProjectRoot, this.typingsInstaller = t.typingsInstaller || UL, this.throttleWaitMilliseconds = t.throttleWaitMilliseconds, this.eventHandler = t.eventHandler, this.suppressDiagnosticEvents = t.suppressDiagnosticEvents, this.globalPlugins = t.globalPlugins || bl, this.pluginProbeLocations = t.pluginProbeLocations || bl, this.allowLocalPluginLoads = !!t.allowLocalPluginLoads, this.typesMapLocation = t.typesMapLocation === void 0 ? On(Hn(this.getExecutingFilePath()), "typesMap.json") : t.typesMapLocation, this.session = t.session, this.jsDocParsingMode = t.jsDocParsingMode, t.serverMode !== void 0 ? this.serverMode = t.serverMode : this.serverMode = 0, this.host.realpath && (this.realpathToScriptInfos = Fp()), this.currentDirectory = ro(this.host.getCurrentDirectory()), this.toCanonicalFileName = Zl(this.host.useCaseSensitiveFileNames), this.globalCacheLocationDirectoryPath = this.typingsInstaller.globalTypingsCacheLocation ? gl(this.toPath(this.typingsInstaller.globalTypingsCacheLocation)) : void 0, this.throttledOperations = new A_e(this.host, this.logger), this.logger.info(`currentDirectory:: ${this.host.getCurrentDirectory()} useCaseSensitiveFileNames:: ${this.host.useCaseSensitiveFileNames}`), this.logger.info(`libs Location:: ${Hn(this.host.getExecutingFilePath())}`), this.logger.info(`globalTypingsCacheLocation:: ${this.typingsInstaller.globalTypingsCacheLocation}`), this.typesMapLocation ? this.loadTypesMap() : this.logger.info("No types map provided; using the default"), this.typingsInstaller.attach(this), this.hostConfiguration = { + formatCodeOptions: _9(this.host.newLine), + preferences: qp, + hostInfo: "Unknown host", + extraFileExtensions: [] + }, this.documentRegistry = Tq( + this.host.useCaseSensitiveFileNames, + this.currentDirectory, + this.jsDocParsingMode, + this + ); + const i = this.logger.hasLevel( + 3 + /* verbose */ + ) ? 2 : this.logger.loggingEnabled() ? 1 : 0, s = i !== 0 ? (o) => this.logger.info(o) : Ha; + this.packageJsonCache = ffe(this), this.watchFactory = this.serverMode !== 0 ? { + watchFile: _w, + watchDirectory: _w + } : cU( + VKe(this, t.canUseWatchEvents) || this.host, + i, + s, + OG + ), this.canUseWatchEvents = bPe(this, t.canUseWatchEvents), (n = t.incrementalVerifier) == null || n.call(t, this); + } + toPath(t) { + return oo(t, this.currentDirectory, this.toCanonicalFileName); + } + /** @internal */ + getExecutingFilePath() { + return this.getNormalizedAbsolutePath(this.host.getExecutingFilePath()); + } + /** @internal */ + getNormalizedAbsolutePath(t) { + return Qi(t, this.host.getCurrentDirectory()); + } + /** @internal */ + setDocument(t, n, i) { + const s = E.checkDefined(this.getScriptInfoForPath(n)); + s.cacheSourceFile = { key: t, sourceFile: i }; + } + /** @internal */ + getDocument(t, n) { + const i = this.getScriptInfoForPath(n); + return i && i.cacheSourceFile && i.cacheSourceFile.key === t ? i.cacheSourceFile.sourceFile : void 0; + } + /** @internal */ + ensureInferredProjectsUpToDate_TestOnly() { + this.ensureProjectStructuresUptoDate(); + } + /** @internal */ + getCompilerOptionsForInferredProjects() { + return this.compilerOptionsForInferredProjects; + } + /** @internal */ + onUpdateLanguageServiceStateForProject(t, n) { + if (!this.eventHandler) + return; + const i = { + eventName: kG, + data: { project: t, languageServiceEnabled: n } + }; + this.eventHandler(i); + } + loadTypesMap() { + try { + const t = this.host.readFile(this.typesMapLocation); + if (t === void 0) { + this.logger.info(`Provided types map file "${this.typesMapLocation}" doesn't exist`); + return; + } + const n = JSON.parse(t); + for (const i of Object.keys(n.typesMap)) + n.typesMap[i].match = new RegExp(n.typesMap[i].match, "i"); + this.safelist = n.typesMap; + for (const i in n.simpleMap) + eo(n.simpleMap, i) && this.legacySafelist.set(i, n.simpleMap[i].toLowerCase()); + } catch (t) { + this.logger.info(`Error loading types map: ${t}`), this.safelist = X_e, this.legacySafelist.clear(); + } + } + // eslint-disable-line @typescript-eslint/unified-signatures + updateTypingsForProject(t) { + const n = this.findProject(t.projectName); + if (n) + switch (t.kind) { + case o9: + n.updateTypingFiles( + t.compilerOptions, + t.typeAcquisition, + t.unresolvedImports, + t.typings + ); + return; + case c9: + n.enqueueInstallTypingsForProject( + /*forceRefresh*/ + !0 + ); + return; + } + } + /** @internal */ + watchTypingLocations(t) { + var n; + (n = this.findProject(t.projectName)) == null || n.watchTypingLocations(t.files); + } + /** @internal */ + delayEnsureProjectForOpenFiles() { + this.openFiles.size && (this.pendingEnsureProjectForOpenFiles = !0, this.throttledOperations.schedule( + lPe, + /*delay*/ + 2500, + () => { + this.pendingProjectUpdates.size !== 0 ? this.delayEnsureProjectForOpenFiles() : this.pendingEnsureProjectForOpenFiles && (this.ensureProjectForOpenFiles(), this.sendProjectsUpdatedInBackgroundEvent()); + } + )); + } + delayUpdateProjectGraph(t) { + if (B8(t) || (t.markAsDirty(), j8(t))) return; + const n = t.getProjectName(); + this.pendingProjectUpdates.set(n, t), this.throttledOperations.schedule( + n, + /*delay*/ + 250, + () => { + this.pendingProjectUpdates.delete(n) && Gp(t); + } + ); + } + /** @internal */ + hasPendingProjectUpdate(t) { + return this.pendingProjectUpdates.has(t.getProjectName()); + } + /** @internal */ + sendProjectsUpdatedInBackgroundEvent() { + if (!this.eventHandler) + return; + const t = { + eventName: zL, + data: { + openFiles: is(this.openFiles.keys(), (n) => this.getScriptInfoForPath(n).fileName) + } + }; + this.eventHandler(t); + } + /** @internal */ + sendLargeFileReferencedEvent(t, n) { + if (!this.eventHandler) + return; + const i = { + eventName: TG, + data: { file: t, fileSize: n, maxFileSize: vG } + }; + this.eventHandler(i); + } + /** @internal */ + sendProjectLoadingStartEvent(t, n) { + if (!this.eventHandler) + return; + t.sendLoadingProjectFinish = !0; + const i = { + eventName: bG, + data: { project: t, reason: n } + }; + this.eventHandler(i); + } + /** @internal */ + sendProjectLoadingFinishEvent(t) { + if (!this.eventHandler || !t.sendLoadingProjectFinish) + return; + t.sendLoadingProjectFinish = !1; + const n = { + eventName: SG, + data: { project: t } + }; + this.eventHandler(n); + } + /** @internal */ + sendPerformanceEvent(t, n) { + this.performanceEventHandler && this.performanceEventHandler({ kind: t, durationMs: n }); + } + /** @internal */ + delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(t) { + this.delayUpdateProjectGraph(t), this.delayEnsureProjectForOpenFiles(); + } + delayUpdateProjectGraphs(t, n) { + if (t.length) { + for (const i of t) + n && i.clearSourceMapperCache(), this.delayUpdateProjectGraph(i); + this.delayEnsureProjectForOpenFiles(); + } + } + setCompilerOptionsForInferredProjects(t, n) { + E.assert(n === void 0 || this.useInferredProjectPerProjectRoot, "Setting compiler options per project root path is only supported when useInferredProjectPerProjectRoot is enabled"); + const i = WL(t), s = J8(t, n), o = Q_e(t); + i.allowNonTsExtensions = !0; + const c = n && this.toCanonicalFileName(n); + c ? (this.compilerOptionsForInferredProjectsPerProjectRoot.set(c, i), this.watchOptionsForInferredProjectsPerProjectRoot.set(c, s || !1), this.typeAcquisitionForInferredProjectsPerProjectRoot.set(c, o)) : (this.compilerOptionsForInferredProjects = i, this.watchOptionsForInferredProjects = s, this.typeAcquisitionForInferredProjects = o); + for (const _ of this.inferredProjects) + (c ? _.projectRootPath === c : !_.projectRootPath || !this.compilerOptionsForInferredProjectsPerProjectRoot.has(_.projectRootPath)) && (_.setCompilerOptions(i), _.setTypeAcquisition(o), _.setWatchOptions(s?.watchOptions), _.setProjectErrors(s?.errors), _.compileOnSaveEnabled = i.compileOnSave, _.markAsDirty(), this.delayUpdateProjectGraph(_)); + this.delayEnsureProjectForOpenFiles(); + } + findProject(t) { + if (t !== void 0) + return E_e(t) ? _Pe(t, this.inferredProjects) : this.findExternalProjectByProjectName(t) || this.findConfiguredProjectByProjectName(ro(t)); + } + /** @internal */ + forEachProject(t) { + this.externalProjects.forEach(t), this.configuredProjects.forEach(t), this.inferredProjects.forEach(t); + } + /** @internal */ + forEachEnabledProject(t) { + this.forEachProject((n) => { + !n.isOrphan() && n.languageServiceEnabled && t(n); + }); + } + getDefaultProjectForFile(t, n) { + return n ? this.ensureDefaultProjectForFile(t) : this.tryGetDefaultProjectForFile(t); + } + /** @internal */ + tryGetDefaultProjectForFile(t) { + const n = gs(t) ? this.getScriptInfoForNormalizedPath(t) : t; + return n && !n.isOrphan() ? n.getDefaultProject() : void 0; + } + /** + * If there is default project calculation pending for this file, + * then it completes that calculation so that correct default project is used for the project + */ + tryGetDefaultProjectForEnsuringConfiguredProjectForFile(t) { + var n; + const i = gs(t) ? this.getScriptInfoForNormalizedPath(t) : t; + if (i) + return (n = this.pendingOpenFileProjectUpdates) != null && n.delete(i.path) && (this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo( + i, + 5 + /* Create */ + ), i.isOrphan() && this.assignOrphanScriptInfoToInferredProject(i, this.openFiles.get(i.path))), this.tryGetDefaultProjectForFile(i); + } + /** @internal */ + ensureDefaultProjectForFile(t) { + return this.tryGetDefaultProjectForEnsuringConfiguredProjectForFile(t) || this.doEnsureDefaultProjectForFile(t); + } + doEnsureDefaultProjectForFile(t) { + this.ensureProjectStructuresUptoDate(); + const n = gs(t) ? this.getScriptInfoForNormalizedPath(t) : t; + return n ? n.getDefaultProject() : (this.logErrorForScriptInfoNotFound(gs(t) ? t : t.fileName), Rh.ThrowNoProject()); + } + getScriptInfoEnsuringProjectsUptoDate(t) { + return this.ensureProjectStructuresUptoDate(), this.getScriptInfo(t); + } + /** + * Ensures the project structures are upto date + * This means, + * - we go through all the projects and update them if they are dirty + * - if updates reflect some change in structure or there was pending request to ensure projects for open files + * ensure that each open script info has project + */ + ensureProjectStructuresUptoDate() { + let t = this.pendingEnsureProjectForOpenFiles; + this.pendingProjectUpdates.clear(); + const n = (i) => { + t = Gp(i) || t; + }; + this.externalProjects.forEach(n), this.configuredProjects.forEach(n), this.inferredProjects.forEach(n), t && this.ensureProjectForOpenFiles(); + } + getFormatCodeOptions(t) { + const n = this.getScriptInfoForNormalizedPath(t); + return n && n.getFormatCodeSettings() || this.hostConfiguration.formatCodeOptions; + } + getPreferences(t) { + const n = this.getScriptInfoForNormalizedPath(t); + return { ...this.hostConfiguration.preferences, ...n && n.getPreferences() }; + } + getHostFormatCodeOptions() { + return this.hostConfiguration.formatCodeOptions; + } + getHostPreferences() { + return this.hostConfiguration.preferences; + } + onSourceFileChanged(t, n) { + E.assert(!t.isScriptOpen()), n === 2 ? this.handleDeletedFile( + t, + /*deferredDelete*/ + !0 + ) : (t.deferredDelete && (t.deferredDelete = void 0), t.delayReloadNonMixedContentFile(), this.delayUpdateProjectGraphs( + t.containingProjects, + /*clearSourceMapperCache*/ + !1 + ), this.handleSourceMapProjects(t)); + } + handleSourceMapProjects(t) { + if (t.sourceMapFilePath) + if (gs(t.sourceMapFilePath)) { + const n = this.getScriptInfoForPath(t.sourceMapFilePath); + this.delayUpdateSourceInfoProjects(n?.sourceInfos); + } else + this.delayUpdateSourceInfoProjects(t.sourceMapFilePath.sourceInfos); + this.delayUpdateSourceInfoProjects(t.sourceInfos), t.declarationInfoPath && this.delayUpdateProjectsOfScriptInfoPath(t.declarationInfoPath); + } + delayUpdateSourceInfoProjects(t) { + t && t.forEach((n, i) => this.delayUpdateProjectsOfScriptInfoPath(i)); + } + delayUpdateProjectsOfScriptInfoPath(t) { + const n = this.getScriptInfoForPath(t); + n && this.delayUpdateProjectGraphs( + n.containingProjects, + /*clearSourceMapperCache*/ + !0 + ); + } + handleDeletedFile(t, n) { + E.assert(!t.isScriptOpen()), this.delayUpdateProjectGraphs( + t.containingProjects, + /*clearSourceMapperCache*/ + !1 + ), this.handleSourceMapProjects(t), t.detachAllProjects(), n ? (t.delayReloadNonMixedContentFile(), t.deferredDelete = !0) : this.deleteScriptInfo(t); + } + /** + * This is to watch whenever files are added or removed to the wildcard directories + */ + watchWildcardDirectory(t, n, i, s) { + let o = this.watchFactory.watchDirectory( + t, + (_) => this.onWildCardDirectoryWatcherInvoke( + t, + i, + s, + c, + _ + ), + n, + this.getWatchOptionsFromProjectWatchOptions(s.parsedCommandLine.watchOptions, Hn(i)), + Fl.WildcardDirectory, + i + ); + const c = { + packageJsonWatches: void 0, + close() { + var _; + o && (o.close(), o = void 0, (_ = c.packageJsonWatches) == null || _.forEach((u) => { + u.projects.delete(c), u.close(); + }), c.packageJsonWatches = void 0); + } + }; + return c; + } + onWildCardDirectoryWatcherInvoke(t, n, i, s, o) { + const c = this.toPath(o), _ = i.cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(o, c); + if (Zc(c) === "package.json" && !e8(c) && (_ && _.fileExists || !_ && this.host.fileExists(o))) { + const g = this.getNormalizedAbsolutePath(o); + this.logger.info(`Config: ${n} Detected new package.json: ${g}`), this.packageJsonCache.addOrUpdate(g, c), this.watchPackageJsonFile(g, c, s); + } + _?.fileExists || this.sendSourceFileChange(c); + const u = this.findConfiguredProjectByProjectName(n); + kA({ + watchedDirPath: this.toPath(t), + fileOrDirectory: o, + fileOrDirectoryPath: c, + configFileName: n, + extraFileExtensions: this.hostConfiguration.extraFileExtensions, + currentDirectory: this.currentDirectory, + options: i.parsedCommandLine.options, + program: u?.getCurrentProgram() || i.parsedCommandLine.fileNames, + useCaseSensitiveFileNames: this.host.useCaseSensitiveFileNames, + writeLog: (g) => this.logger.info(g), + toPath: (g) => this.toPath(g), + getScriptKind: u ? (g) => u.getScriptKind(g) : void 0 + }) || (i.updateLevel !== 2 && (i.updateLevel = 1), i.projects.forEach((g, m) => { + var h; + if (!g) return; + const S = this.getConfiguredProjectByCanonicalConfigFilePath(m); + if (!S) return; + if (u !== S && this.getHostPreferences().includeCompletionsForModuleExports) { + const k = this.toPath(n); + Nn((h = S.getCurrentProgram()) == null ? void 0 : h.getResolvedProjectReferences(), (D) => D?.sourceFile.path === k) && S.markAutoImportProviderAsDirty(); + } + const T = u === S ? 1 : 0; + if (!(S.pendingUpdateLevel > T)) + if (this.openFiles.has(c)) + if (E.checkDefined(this.getScriptInfoForPath(c)).isAttached(S)) { + const D = Math.max( + T, + S.openFileWatchTriggered.get(c) || 0 + /* Update */ + ); + S.openFileWatchTriggered.set(c, D); + } else + S.pendingUpdateLevel = T, this.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(S); + else + S.pendingUpdateLevel = T, this.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(S); + })); + } + delayUpdateProjectsFromParsedConfigOnConfigFileChange(t, n) { + const i = this.configFileExistenceInfoCache.get(t); + if (!i?.config) return !1; + let s = !1; + return i.config.updateLevel = 2, i.config.cachedDirectoryStructureHost.clearCache(), i.config.projects.forEach((o, c) => { + var _, u, g; + const m = this.getConfiguredProjectByCanonicalConfigFilePath(c); + if (m) + if (s = !0, c === t) { + if (m.initialLoadPending) return; + m.pendingUpdateLevel = 2, m.pendingUpdateReason = n, this.delayUpdateProjectGraph(m), m.markAutoImportProviderAsDirty(); + } else { + if (m.initialLoadPending) { + (u = (_ = this.configFileExistenceInfoCache.get(c)) == null ? void 0 : _.openFilesImpactedByConfigFile) == null || u.forEach((S) => { + var T; + (T = this.pendingOpenFileProjectUpdates) != null && T.has(S) || (this.pendingOpenFileProjectUpdates ?? (this.pendingOpenFileProjectUpdates = /* @__PURE__ */ new Map())).set( + S, + this.configFileForOpenFiles.get(S) + ); + }); + return; + } + const h = this.toPath(t); + m.resolutionCache.removeResolutionsFromProjectReferenceRedirects(h), this.delayUpdateProjectGraph(m), this.getHostPreferences().includeCompletionsForModuleExports && Nn((g = m.getCurrentProgram()) == null ? void 0 : g.getResolvedProjectReferences(), (S) => S?.sourceFile.path === h) && m.markAutoImportProviderAsDirty(); + } + }), s; + } + onConfigFileChanged(t, n, i) { + const s = this.configFileExistenceInfoCache.get(n), o = this.getConfiguredProjectByCanonicalConfigFilePath(n), c = o?.deferredClose; + i === 2 ? (s.exists = !1, o && (o.deferredClose = !0)) : (s.exists = !0, c && (o.deferredClose = void 0, o.markAsDirty())), this.delayUpdateProjectsFromParsedConfigOnConfigFileChange( + n, + "Change in config file detected" + ), this.openFiles.forEach((_, u) => { + var g, m; + const h = this.configFileForOpenFiles.get(u); + if (!((g = s.openFilesImpactedByConfigFile) != null && g.has(u))) return; + this.configFileForOpenFiles.delete(u); + const S = this.getScriptInfoForPath(u); + this.getConfigFileNameForFile( + S, + /*findFromCacheOnly*/ + !1 + ) && ((m = this.pendingOpenFileProjectUpdates) != null && m.has(u) || (this.pendingOpenFileProjectUpdates ?? (this.pendingOpenFileProjectUpdates = /* @__PURE__ */ new Map())).set(u, h)); + }), this.delayEnsureProjectForOpenFiles(); + } + removeProject(t) { + switch (this.logger.info("`remove Project::"), t.print( + /*writeProjectFileNames*/ + !0, + /*writeFileExplaination*/ + !0, + /*writeFileVersionAndText*/ + !1 + ), t.close(), E.shouldAssert( + 1 + /* Normal */ + ) && this.filenameToScriptInfo.forEach( + (n) => E.assert( + !n.isAttached(t), + "Found script Info still attached to project", + () => `${t.projectName}: ScriptInfos still attached: ${JSON.stringify( + is( + uy( + this.filenameToScriptInfo.values(), + (i) => i.isAttached(t) ? { + fileName: i.fileName, + projects: i.containingProjects.map((s) => s.projectName), + hasMixedContent: i.hasMixedContent + } : void 0 + ) + ), + /*replacer*/ + void 0, + " " + )}` + ) + ), this.pendingProjectUpdates.delete(t.getProjectName()), t.projectKind) { + case 2: + YT(this.externalProjects, t), this.projectToSizeMap.delete(t.getProjectName()); + break; + case 1: + this.configuredProjects.delete(t.canonicalConfigFilePath), this.projectToSizeMap.delete(t.canonicalConfigFilePath); + break; + case 0: + YT(this.inferredProjects, t); + break; + } + } + /** @internal */ + assignOrphanScriptInfoToInferredProject(t, n) { + E.assert(t.isOrphan()); + const i = this.getOrCreateInferredProjectForProjectRootPathIfEnabled(t, n) || this.getOrCreateSingleInferredProjectIfEnabled() || this.getOrCreateSingleInferredWithoutProjectRoot( + t.isDynamic ? n || this.currentDirectory : Hn( + Z_(t.fileName) ? t.fileName : Qi( + t.fileName, + n ? this.getNormalizedAbsolutePath(n) : this.currentDirectory + ) + ) + ); + if (i.addRoot(t), t.containingProjects[0] !== i && (rD(t.containingProjects, i), t.containingProjects.unshift(i)), i.updateGraph(), !this.useSingleInferredProject && !i.projectRootPath) + for (const s of this.inferredProjects) { + if (s === i || s.isOrphan()) + continue; + const o = s.getRootScriptInfos(); + E.assert(o.length === 1 || !!s.projectRootPath), o.length === 1 && lr(o[0].containingProjects, (c) => c !== o[0].containingProjects[0] && !c.isOrphan()) && s.removeFile( + o[0], + /*fileExists*/ + !0, + /*detachFromProject*/ + !0 + ); + } + return i; + } + assignOrphanScriptInfosToInferredProject() { + this.openFiles.forEach((t, n) => { + const i = this.getScriptInfoForPath(n); + i.isOrphan() && this.assignOrphanScriptInfoToInferredProject(i, t); + }); + } + /** + * Remove this file from the set of open, non-configured files. + * @param info The file that has been closed or newly configured + */ + closeOpenFile(t, n) { + var i; + const s = t.isDynamic ? !1 : this.host.fileExists(t.fileName); + t.close(s), this.stopWatchingConfigFilesForScriptInfo(t); + const o = this.toCanonicalFileName(t.fileName); + this.openFilesWithNonRootedDiskPath.get(o) === t && this.openFilesWithNonRootedDiskPath.delete(o); + let c = !1; + for (const _ of t.containingProjects) { + if (L0(_)) { + t.hasMixedContent && t.registerFileUpdate(); + const u = _.openFileWatchTriggered.get(t.path); + u !== void 0 && (_.openFileWatchTriggered.delete(t.path), _.pendingUpdateLevel < u && (_.pendingUpdateLevel = u, _.markFileAsDirty(t.path))); + } else cE(_) && _.isRoot(t) && (_.isProjectWithSingleRoot() && (c = !0), _.removeFile( + t, + s, + /*detachFromProject*/ + !0 + )); + _.languageServiceEnabled || _.markAsDirty(); + } + return this.openFiles.delete(t.path), this.configFileForOpenFiles.delete(t.path), (i = this.pendingOpenFileProjectUpdates) == null || i.delete(t.path), E.assert(!this.rootOfInferredProjects.has(t)), !n && c && this.assignOrphanScriptInfosToInferredProject(), s ? this.watchClosedScriptInfo(t) : this.handleDeletedFile( + t, + /*deferredDelete*/ + !1 + ), c; + } + deleteScriptInfo(t) { + E.assert(!t.isScriptOpen()), this.filenameToScriptInfo.delete(t.path), this.filenameToScriptInfoVersion.set(t.path, t.textStorage.version), this.stopWatchingScriptInfo(t); + const n = t.getRealpathIfDifferent(); + n && this.realpathToScriptInfos.remove(n, t), t.closeSourceMapFileWatcher(); + } + configFileExists(t, n, i) { + const s = this.configFileExistenceInfoCache.get(n); + let o; + if (this.openFiles.has(i.path) && (!FG(i) || i.isForDefaultProject) && (s ? (s.openFilesImpactedByConfigFile ?? (s.openFilesImpactedByConfigFile = /* @__PURE__ */ new Set())).add(i.path) : (o = /* @__PURE__ */ new Set()).add(i.path)), s) return s.exists; + const c = this.host.fileExists(t); + return this.configFileExistenceInfoCache.set(n, { exists: c, openFilesImpactedByConfigFile: o }), c; + } + createConfigFileWatcherForParsedConfig(t, n, i) { + var s, o; + const c = this.configFileExistenceInfoCache.get(n); + (!c.watcher || c.watcher === Z_e) && (c.watcher = this.watchFactory.watchFile( + t, + (_, u) => this.onConfigFileChanged(t, n, u), + 2e3, + this.getWatchOptionsFromProjectWatchOptions((o = (s = c?.config) == null ? void 0 : s.parsedCommandLine) == null ? void 0 : o.watchOptions, Hn(t)), + Fl.ConfigFile, + i + )), this.ensureConfigFileWatcherForProject(c, i); + } + ensureConfigFileWatcherForProject(t, n) { + const i = t.config.projects; + i.set(n.canonicalConfigFilePath, i.get(n.canonicalConfigFilePath) || !1); + } + /** @internal */ + releaseParsedConfig(t, n) { + var i, s, o; + const c = this.configFileExistenceInfoCache.get(t); + (i = c.config) != null && i.projects.delete(n.canonicalConfigFilePath) && ((s = c.config) != null && s.projects.size || (c.config = void 0, aU(t, this.sharedExtendedConfigFileWatchers), E.checkDefined(c.watcher), (o = c.openFilesImpactedByConfigFile) != null && o.size ? c.inferredProjectRoots ? AA(Hn(t)) || (c.watcher.close(), c.watcher = Z_e) : (c.watcher.close(), c.watcher = void 0) : (c.watcher.close(), this.configFileExistenceInfoCache.delete(t)))); + } + /** + * This is called on file close or when its removed from inferred project as root, + * so that we handle the watches and inferred project root data + * @internal + */ + stopWatchingConfigFilesForScriptInfo(t) { + if (this.serverMode !== 0) return; + const n = this.rootOfInferredProjects.delete(t), i = t.isScriptOpen(); + i && !n || this.forEachConfigFileLocation(t, (s) => { + var o, c, _; + const u = this.configFileExistenceInfoCache.get(s); + if (u) { + if (i) { + if (!((o = u?.openFilesImpactedByConfigFile) != null && o.has(t.path))) return; + } else if (!((c = u.openFilesImpactedByConfigFile) != null && c.delete(t.path))) return; + n && (u.inferredProjectRoots--, u.watcher && !u.config && !u.inferredProjectRoots && (u.watcher.close(), u.watcher = void 0)), !((_ = u.openFilesImpactedByConfigFile) != null && _.size) && !u.config && (E.assert(!u.watcher), this.configFileExistenceInfoCache.delete(s)); + } + }); + } + /** + * This is called by inferred project whenever script info is added as a root + * + * @internal + */ + startWatchingConfigFilesForInferredProjectRoot(t) { + this.serverMode === 0 && (E.assert(t.isScriptOpen()), this.rootOfInferredProjects.add(t), this.forEachConfigFileLocation(t, (n, i) => { + let s = this.configFileExistenceInfoCache.get(n); + s ? s.inferredProjectRoots = (s.inferredProjectRoots ?? 0) + 1 : (s = { exists: this.host.fileExists(i), inferredProjectRoots: 1 }, this.configFileExistenceInfoCache.set(n, s)), (s.openFilesImpactedByConfigFile ?? (s.openFilesImpactedByConfigFile = /* @__PURE__ */ new Set())).add(t.path), s.watcher || (s.watcher = AA(Hn(n)) ? this.watchFactory.watchFile( + i, + (o, c) => this.onConfigFileChanged(i, n, c), + 2e3, + this.hostConfiguration.watchOptions, + Fl.ConfigFileForInferredRoot + ) : Z_e); + })); + } + /** + * This function tries to search for a tsconfig.json for the given file. + * This is different from the method the compiler uses because + * the compiler can assume it will always start searching in the + * current directory (the directory in which tsc was invoked). + * The server must start searching from the directory containing + * the newly opened file. + */ + forEachConfigFileLocation(t, n) { + if (this.serverMode !== 0) + return; + E.assert(!pPe(t) || this.openFiles.has(t.path)); + const i = this.openFiles.get(t.path); + if (E.checkDefined(this.getScriptInfo(t.path)).isDynamic) return; + let o = Hn(t.fileName); + const c = () => np(i, o, this.currentDirectory, !this.host.useCaseSensitiveFileNames), _ = !i || !c(); + let u = !0, g = !0; + FG(t) && (wo(t.fileName, "tsconfig.json") ? u = !1 : u = g = !1); + do { + const m = oE(o, this.currentDirectory, this.toCanonicalFileName); + if (u) { + const S = On(o, "tsconfig.json"); + if (n(On(m, "tsconfig.json"), S)) return S; + } + if (g) { + const S = On(o, "jsconfig.json"); + if (n(On(m, "jsconfig.json"), S)) return S; + } + if (_7(m)) + break; + const h = Hn(o); + if (h === o) break; + o = h, u = g = !0; + } while (_ || c()); + } + /** @internal */ + findDefaultConfiguredProject(t) { + var n; + return (n = this.findDefaultConfiguredProjectWorker( + t, + 1 + /* Find */ + )) == null ? void 0 : n.defaultProject; + } + /** @internal */ + findDefaultConfiguredProjectWorker(t, n) { + return t.isScriptOpen() ? this.tryFindDefaultConfiguredProjectForOpenScriptInfo( + t, + n + ) : void 0; + } + /** Get cached configFileName for scriptInfo or ancestor of open script info */ + getConfigFileNameForFileFromCache(t, n) { + if (n) { + const i = fPe(t, this.pendingOpenFileProjectUpdates); + if (i !== void 0) return i; + } + return fPe(t, this.configFileForOpenFiles); + } + /** Caches the configFilename for script info or ancestor of open script info */ + setConfigFileNameForFileInCache(t, n) { + if (!this.openFiles.has(t.path)) return; + const i = n || !1; + if (!FG(t)) + this.configFileForOpenFiles.set(t.path, i); + else { + let s = this.configFileForOpenFiles.get(t.path); + (!s || gs(s)) && this.configFileForOpenFiles.set( + t.path, + s = (/* @__PURE__ */ new Map()).set(!1, s) + ), s.set(t.fileName, i); + } + } + /** + * This function tries to search for a tsconfig.json for the given file. + * This is different from the method the compiler uses because + * the compiler can assume it will always start searching in the + * current directory (the directory in which tsc was invoked). + * The server must start searching from the directory containing + * the newly opened file. + * If script info is passed in, it is asserted to be open script info + * otherwise just file name + * when findFromCacheOnly is true only looked up in cache instead of hitting disk to figure things out + * @internal + */ + getConfigFileNameForFile(t, n) { + const i = this.getConfigFileNameForFileFromCache(t, n); + if (i !== void 0) return i || void 0; + if (n) return; + const s = this.forEachConfigFileLocation(t, (o, c) => this.configFileExists(c, o, t)); + return this.logger.info(`getConfigFileNameForFile:: File: ${t.fileName} ProjectRootPath: ${this.openFiles.get(t.path)}:: Result: ${s}`), this.setConfigFileNameForFileInCache(t, s), s; + } + printProjects() { + this.logger.hasLevel( + 1 + /* normal */ + ) && (this.logger.startGroup(), this.externalProjects.forEach(ufe), this.configuredProjects.forEach(ufe), this.inferredProjects.forEach(ufe), this.logger.info("Open files: "), this.openFiles.forEach((t, n) => { + const i = this.getScriptInfoForPath(n); + this.logger.info(` FileName: ${i.fileName} ProjectRootPath: ${t}`), this.logger.info(` Projects: ${i.containingProjects.map((s) => s.getProjectName())}`); + }), this.logger.endGroup()); + } + /** @internal */ + findConfiguredProjectByProjectName(t, n) { + const i = this.toCanonicalFileName(t), s = this.getConfiguredProjectByCanonicalConfigFilePath(i); + return n ? s : s?.deferredClose ? void 0 : s; + } + getConfiguredProjectByCanonicalConfigFilePath(t) { + return this.configuredProjects.get(t); + } + findExternalProjectByProjectName(t) { + return _Pe(t, this.externalProjects); + } + /** Get a filename if the language service exceeds the maximum allowed program size; otherwise returns undefined. */ + getFilenameForExceededTotalSizeLimitForNonTsFiles(t, n, i, s) { + if (n && n.disableSizeLimit || !this.host.getFileSize) + return; + let o = yG; + this.projectToSizeMap.set(t, 0), this.projectToSizeMap.forEach((_) => o -= _ || 0); + let c = 0; + for (const _ of i) { + const u = s.getFileName(_); + if (!yS(u) && (c += this.host.getFileSize(u), c > yG || c > o)) { + const g = i.map((m) => s.getFileName(m)).filter((m) => !yS(m)).map((m) => ({ name: m, size: this.host.getFileSize(m) })).sort((m, h) => h.size - m.size).slice(0, 5); + return this.logger.info(`Non TS file size exceeded limit (${c}). Largest files: ${g.map((m) => `${m.name}:${m.size}`).join(", ")}`), u; + } + } + this.projectToSizeMap.set(t, c); + } + createExternalProject(t, n, i, s, o) { + const c = WL(i), _ = J8(i, Hn(zl(t))), u = new hG( + t, + this, + c, + /*lastFileExceededProgramSize*/ + this.getFilenameForExceededTotalSizeLimitForNonTsFiles(t, c, n, IG), + i.compileOnSave === void 0 ? !0 : i.compileOnSave, + /*projectFilePath*/ + void 0, + _?.watchOptions + ); + return u.setProjectErrors(_?.errors), u.excludedFiles = o, this.addFilesToNonInferredProject(u, n, IG, s), this.externalProjects.push(u), u; + } + /** @internal */ + sendProjectTelemetry(t) { + if (this.seenProjects.has(t.projectName)) { + sfe(t); + return; + } + if (this.seenProjects.set(t.projectName, !0), !this.eventHandler || !this.host.createSHA256Hash) { + sfe(t); + return; + } + const n = L0(t) ? t.projectOptions : void 0; + sfe(t); + const i = { + projectId: this.host.createSHA256Hash(t.projectName), + fileStats: M8( + t.getScriptInfos(), + /*includeSizes*/ + !0 + ), + compilerOptions: $re(t.getCompilationSettings()), + typeAcquisition: o(t.getTypeAcquisition()), + extends: n && n.configHasExtendsProperty, + files: n && n.configHasFilesProperty, + include: n && n.configHasIncludeProperty, + exclude: n && n.configHasExcludeProperty, + compileOnSave: t.compileOnSaveEnabled, + configFileName: s(), + projectType: t instanceof hG ? "external" : "configured", + languageServiceEnabled: t.languageServiceEnabled, + version: ep + }; + this.eventHandler({ eventName: CG, data: i }); + function s() { + return L0(t) && gG(t.getConfigFilePath()) || "other"; + } + function o({ enable: c, include: _, exclude: u }) { + return { + enable: c, + include: _ !== void 0 && _.length !== 0, + exclude: u !== void 0 && u.length !== 0 + }; + } + } + addFilesToNonInferredProject(t, n, i, s) { + this.updateNonInferredProjectFiles(t, n, i), t.setTypeAcquisition(s), t.markAsDirty(); + } + /** @internal */ + createConfiguredProject(t, n) { + var i; + (i = on) == null || i.instant(on.Phase.Session, "createConfiguredProject", { configFilePath: t }); + const s = this.toCanonicalFileName(t); + let o = this.configFileExistenceInfoCache.get(s); + o ? o.exists = !0 : this.configFileExistenceInfoCache.set(s, o = { exists: !0 }), o.config || (o.config = { + cachedDirectoryStructureHost: IO(this.host, this.host.getCurrentDirectory(), this.host.useCaseSensitiveFileNames), + projects: /* @__PURE__ */ new Map(), + updateLevel: 2 + /* Full */ + }); + const c = new G_e( + t, + s, + this, + o.config.cachedDirectoryStructureHost, + n + ); + return E.assert(!this.configuredProjects.has(s)), this.configuredProjects.set(s, c), this.createConfigFileWatcherForParsedConfig(t, s, c), c; + } + /** + * Read the config file of the project, and update the project root file names. + */ + loadConfiguredProject(t, n) { + var i, s; + (i = on) == null || i.push(on.Phase.Session, "loadConfiguredProject", { configFilePath: t.canonicalConfigFilePath }), this.sendProjectLoadingStartEvent(t, n); + const o = ro(t.getConfigFilePath()), c = this.ensureParsedConfigUptoDate( + o, + t.canonicalConfigFilePath, + this.configFileExistenceInfoCache.get(t.canonicalConfigFilePath), + t + ), _ = c.config.parsedCommandLine; + E.assert(!!_.fileNames); + const u = _.options; + t.projectOptions || (t.projectOptions = { + configHasExtendsProperty: _.raw.extends !== void 0, + configHasFilesProperty: _.raw.files !== void 0, + configHasIncludeProperty: _.raw.include !== void 0, + configHasExcludeProperty: _.raw.exclude !== void 0 + }), t.parsedCommandLine = _, t.setProjectErrors(_.options.configFile.parseDiagnostics), t.updateReferences(_.projectReferences); + const g = this.getFilenameForExceededTotalSizeLimitForNonTsFiles(t.canonicalConfigFilePath, u, _.fileNames, AG); + g ? (t.disableLanguageService(g), this.configFileExistenceInfoCache.forEach((h, S) => this.stopWatchingWildCards(S, t))) : (t.setCompilerOptions(u), t.setWatchOptions(_.watchOptions), t.enableLanguageService(), this.watchWildcards(o, c, t)), t.enablePluginsWithOptions(u); + const m = _.fileNames.concat(t.getExternalFiles( + 2 + /* Full */ + )); + this.updateRootAndOptionsOfNonInferredProject(t, m, AG, u, _.typeAcquisition, _.compileOnSave, _.watchOptions), (s = on) == null || s.pop(); + } + /** @internal */ + ensureParsedConfigUptoDate(t, n, i, s) { + var o, c, _; + if (i.config && (i.config.updateLevel === 1 && this.reloadFileNamesOfParsedConfig(t, i.config), !i.config.updateLevel)) + return this.ensureConfigFileWatcherForProject(i, s), i; + if (!i.exists && i.config) + return i.config.updateLevel = void 0, this.ensureConfigFileWatcherForProject(i, s), i; + const u = ((o = i.config) == null ? void 0 : o.cachedDirectoryStructureHost) || IO(this.host, this.host.getCurrentDirectory(), this.host.useCaseSensitiveFileNames), g = W4(t, (D) => this.host.readFile(D)), m = KN(t, gs(g) ? g : ""), h = m.parseDiagnostics; + gs(g) || h.push(g); + const S = Hn(t), T = sA( + m, + u, + S, + /*existingOptions*/ + void 0, + t, + /*resolutionStack*/ + void 0, + this.hostConfiguration.extraFileExtensions, + this.extendedConfigCache + ); + T.errors.length && h.push(...T.errors), this.logger.info(`Config: ${t} : ${JSON.stringify( + { + rootNames: T.fileNames, + options: T.options, + watchOptions: T.watchOptions, + projectReferences: T.projectReferences + }, + /*replacer*/ + void 0, + " " + )}`); + const k = (c = i.config) == null ? void 0 : c.parsedCommandLine; + return i.config ? (i.config.parsedCommandLine = T, i.config.watchedDirectoriesStale = !0, i.config.updateLevel = void 0) : i.config = { parsedCommandLine: T, cachedDirectoryStructureHost: u, projects: /* @__PURE__ */ new Map() }, !k && !iF( + // Old options + this.getWatchOptionsFromProjectWatchOptions( + /*projectOptions*/ + void 0, + S + ), + // New options + this.getWatchOptionsFromProjectWatchOptions(T.watchOptions, S) + ) && ((_ = i.watcher) == null || _.close(), i.watcher = void 0), this.createConfigFileWatcherForParsedConfig(t, n, s), FO( + n, + T.options, + this.sharedExtendedConfigFileWatchers, + (D, P) => this.watchFactory.watchFile( + D, + () => { + var A; + OO(this.extendedConfigCache, P, (F) => this.toPath(F)); + let O = !1; + (A = this.sharedExtendedConfigFileWatchers.get(P)) == null || A.projects.forEach((F) => { + O = this.delayUpdateProjectsFromParsedConfigOnConfigFileChange(F, `Change in extended config file ${D} detected`) || O; + }), O && this.delayEnsureProjectForOpenFiles(); + }, + 2e3, + this.hostConfiguration.watchOptions, + Fl.ExtendedConfigFile, + t + ), + (D) => this.toPath(D) + ), i; + } + /** @internal */ + watchWildcards(t, { exists: n, config: i }, s) { + if (i.projects.set(s.canonicalConfigFilePath, !0), n) { + if (i.watchedDirectories && !i.watchedDirectoriesStale) return; + i.watchedDirectoriesStale = !1, xA( + i.watchedDirectories || (i.watchedDirectories = /* @__PURE__ */ new Map()), + i.parsedCommandLine.wildcardDirectories, + // Create new directory watcher + (o, c) => this.watchWildcardDirectory(o, c, t, i) + ); + } else { + if (i.watchedDirectoriesStale = !1, !i.watchedDirectories) return; + B_(i.watchedDirectories, gp), i.watchedDirectories = void 0; + } + } + /** @internal */ + stopWatchingWildCards(t, n) { + const i = this.configFileExistenceInfoCache.get(t); + !i.config || !i.config.projects.get(n.canonicalConfigFilePath) || (i.config.projects.set(n.canonicalConfigFilePath, !1), !hl(i.config.projects, go) && (i.config.watchedDirectories && (B_(i.config.watchedDirectories, gp), i.config.watchedDirectories = void 0), i.config.watchedDirectoriesStale = void 0)); + } + updateNonInferredProjectFiles(t, n, i) { + var s; + const o = t.getRootFilesMap(), c = /* @__PURE__ */ new Map(); + for (const _ of n) { + const u = i.getFileName(_), g = ro(u), m = zw(g); + let h; + if (!m && !t.fileExists(u)) { + h = oE(g, this.currentDirectory, this.toCanonicalFileName); + const S = o.get(h); + S ? (((s = S.info) == null ? void 0 : s.path) === h && (t.removeFile( + S.info, + /*fileExists*/ + !1, + /*detachFromProject*/ + !0 + ), S.info = void 0), S.fileName = g) : o.set(h, { fileName: g }); + } else { + const S = i.getScriptKind(_, this.hostConfiguration.extraFileExtensions), T = i.hasMixedContent(_, this.hostConfiguration.extraFileExtensions), k = E.checkDefined(this.getOrCreateScriptInfoNotOpenedByClientForNormalizedPath( + g, + t.currentDirectory, + S, + T, + t.directoryStructureHost, + /*deferredDeleteOk*/ + !1 + )); + h = k.path; + const D = o.get(h); + !D || D.info !== k ? (t.addRoot(k, g), k.isScriptOpen() && this.removeRootOfInferredProjectIfNowPartOfOtherProject(k)) : D.fileName = g; + } + c.set(h, !0); + } + o.size > c.size && o.forEach((_, u) => { + c.has(u) || (_.info ? t.removeFile( + _.info, + t.fileExists(_.info.fileName), + /*detachFromProject*/ + !0 + ) : o.delete(u)); + }); + } + updateRootAndOptionsOfNonInferredProject(t, n, i, s, o, c, _) { + t.setCompilerOptions(s), t.setWatchOptions(_), c !== void 0 && (t.compileOnSaveEnabled = c), this.addFilesToNonInferredProject(t, n, i, o); + } + /** + * Reload the file names from config file specs and update the project graph + * + * @internal + */ + reloadFileNamesOfConfiguredProject(t) { + const n = this.reloadFileNamesOfParsedConfig(t.getConfigFilePath(), this.configFileExistenceInfoCache.get(t.canonicalConfigFilePath).config); + return t.updateErrorOnNoInputFiles(n), this.updateNonInferredProjectFiles( + t, + n.fileNames.concat(t.getExternalFiles( + 1 + /* RootNamesAndUpdate */ + )), + AG + ), t.markAsDirty(), t.updateGraph(); + } + reloadFileNamesOfParsedConfig(t, n) { + if (n.updateLevel === void 0) return n.parsedCommandLine; + E.assert( + n.updateLevel === 1 + /* RootNamesAndUpdate */ + ); + const i = n.parsedCommandLine.options.configFile.configFileSpecs, s = U4( + i, + Hn(t), + n.parsedCommandLine.options, + n.cachedDirectoryStructureHost, + this.hostConfiguration.extraFileExtensions + ); + return n.parsedCommandLine = { ...n.parsedCommandLine, fileNames: s }, n.updateLevel = void 0, n.parsedCommandLine; + } + /** @internal */ + setFileNamesOfAutoImportProviderOrAuxillaryProject(t, n) { + this.updateNonInferredProjectFiles(t, n, AG); + } + /** @internal */ + reloadConfiguredProjectOptimized(t, n, i) { + i.has(t) || (i.set( + t, + 6 + /* ReloadOptimized */ + ), t.initialLoadPending || this.setProjectForReload(t, 2, n)); + } + /** @internal */ + reloadConfiguredProjectClearingSemanticCache(t, n, i) { + return i.get(t) === 7 ? !1 : (i.set( + t, + 7 + /* Reload */ + ), this.clearSemanticCache(t), this.reloadConfiguredProject(t, LG(n)), !0); + } + setProjectForReload(t, n, i) { + n === 2 && this.clearSemanticCache(t), t.pendingUpdateReason = i && LG(i), t.pendingUpdateLevel = n; + } + /** + * Read the config file of the project again by clearing the cache and update the project graph + * + * @internal + */ + reloadConfiguredProject(t, n) { + t.initialLoadPending = !1, this.setProjectForReload( + t, + 0 + /* Update */ + ), this.loadConfiguredProject(t, n), vPe( + t, + t.triggerFileForConfigFileDiag ?? t.getConfigFilePath(), + /*isReload*/ + !0 + ); + } + clearSemanticCache(t) { + t.originalConfiguredProjects = void 0, t.resolutionCache.clear(), t.getLanguageService( + /*ensureSynchronized*/ + !1 + ).cleanupSemanticCache(), t.cleanupProgram(), t.markAsDirty(); + } + /** @internal */ + sendConfigFileDiagEvent(t, n, i) { + if (!this.eventHandler || this.suppressDiagnosticEvents) return !1; + const s = t.getLanguageService().getCompilerOptionsDiagnostics(); + return s.push(...t.getAllProjectErrors()), !i && s.length === (t.configDiagDiagnosticsReported ?? 0) ? !1 : (t.configDiagDiagnosticsReported = s.length, this.eventHandler( + { + eventName: xG, + data: { configFileName: t.getConfigFilePath(), diagnostics: s, triggerFile: n ?? t.getConfigFilePath() } + } + ), !0); + } + getOrCreateInferredProjectForProjectRootPathIfEnabled(t, n) { + if (!this.useInferredProjectPerProjectRoot || // Its a dynamic info opened without project root + t.isDynamic && n === void 0) + return; + if (n) { + const s = this.toCanonicalFileName(n); + for (const o of this.inferredProjects) + if (o.projectRootPath === s) + return o; + return this.createInferredProject( + n, + /*isSingleInferredProject*/ + !1, + n + ); + } + let i; + for (const s of this.inferredProjects) + s.projectRootPath && np(s.projectRootPath, t.path, this.host.getCurrentDirectory(), !this.host.useCaseSensitiveFileNames) && (i && i.projectRootPath.length > s.projectRootPath.length || (i = s)); + return i; + } + getOrCreateSingleInferredProjectIfEnabled() { + if (this.useSingleInferredProject) + return this.inferredProjects.length > 0 && this.inferredProjects[0].projectRootPath === void 0 ? this.inferredProjects[0] : this.createInferredProject( + this.currentDirectory, + /*isSingleInferredProject*/ + !0, + /*projectRootPath*/ + void 0 + ); + } + getOrCreateSingleInferredWithoutProjectRoot(t) { + E.assert(!this.useSingleInferredProject); + const n = this.toCanonicalFileName(this.getNormalizedAbsolutePath(t)); + for (const i of this.inferredProjects) + if (!i.projectRootPath && i.isOrphan() && i.canonicalCurrentDirectory === n) + return i; + return this.createInferredProject( + t, + /*isSingleInferredProject*/ + !1, + /*projectRootPath*/ + void 0 + ); + } + createInferredProject(t, n, i) { + const s = i && this.compilerOptionsForInferredProjectsPerProjectRoot.get(i) || this.compilerOptionsForInferredProjects; + let o, c; + i && (o = this.watchOptionsForInferredProjectsPerProjectRoot.get(i), c = this.typeAcquisitionForInferredProjectsPerProjectRoot.get(i)), o === void 0 && (o = this.watchOptionsForInferredProjects), c === void 0 && (c = this.typeAcquisitionForInferredProjects), o = o || void 0; + const _ = new U_e( + this, + s, + o?.watchOptions, + i, + t, + c + ); + return _.setProjectErrors(o?.errors), n ? this.inferredProjects.unshift(_) : this.inferredProjects.push(_), _; + } + /** @internal */ + getOrCreateScriptInfoNotOpenedByClient(t, n, i, s) { + return this.getOrCreateScriptInfoNotOpenedByClientForNormalizedPath( + ro(t), + n, + /*scriptKind*/ + void 0, + /*hasMixedContent*/ + void 0, + i, + s + ); + } + getScriptInfo(t) { + return this.getScriptInfoForNormalizedPath(ro(t)); + } + /** @internal */ + getScriptInfoOrConfig(t) { + const n = ro(t), i = this.getScriptInfoForNormalizedPath(n); + if (i) return i; + const s = this.configuredProjects.get(this.toPath(t)); + return s && s.getCompilerOptions().configFile; + } + /** @internal */ + logErrorForScriptInfoNotFound(t) { + const n = is( + uy( + this.filenameToScriptInfo.entries(), + (i) => i[1].deferredDelete ? void 0 : i + ), + ([i, s]) => ({ path: i, fileName: s.fileName }) + ); + this.logger.msg( + `Could not find file ${JSON.stringify(t)}. +All files are: ${JSON.stringify(n)}`, + "Err" + /* Err */ + ); + } + /** + * Returns the projects that contain script info through SymLink + * Note that this does not return projects in info.containingProjects + * + * @internal + */ + getSymlinkedProjects(t) { + let n; + if (this.realpathToScriptInfos) { + const s = t.getRealpathIfDifferent(); + s && lr(this.realpathToScriptInfos.get(s), i), lr(this.realpathToScriptInfos.get(t.path), i); + } + return n; + function i(s) { + if (s !== t) + for (const o of s.containingProjects) + o.languageServiceEnabled && !o.isOrphan() && !o.getCompilerOptions().preserveSymlinks && !t.isAttached(o) && (n ? hl(n, (c, _) => _ === s.path ? !1 : ms(c, o)) || n.add(s.path, o) : (n = Fp(), n.add(s.path, o))); + } + } + watchClosedScriptInfo(t) { + if (E.assert(!t.fileWatcher), !t.isDynamicOrHasMixedContent() && (!this.globalCacheLocationDirectoryPath || !Ui(t.path, this.globalCacheLocationDirectoryPath))) { + const n = t.fileName.indexOf("/node_modules/"); + !this.host.getModifiedTime || n === -1 ? t.fileWatcher = this.watchFactory.watchFile( + t.fileName, + (i, s) => this.onSourceFileChanged(t, s), + 500, + this.hostConfiguration.watchOptions, + Fl.ClosedScriptInfo + ) : (t.mTime = this.getModifiedTime(t), t.fileWatcher = this.watchClosedScriptInfoInNodeModules(t.fileName.substring(0, n))); + } + } + createNodeModulesWatcher(t, n) { + let i = this.watchFactory.watchDirectory( + t, + (o) => { + var c; + const _ = GO(this.toPath(o)); + if (!_) return; + const u = Zc(_); + if ((c = s.affectedModuleSpecifierCacheProjects) != null && c.size && (u === "package.json" || u === "node_modules") && s.affectedModuleSpecifierCacheProjects.forEach((g) => { + var m; + (m = g.getModuleSpecifierCache()) == null || m.clear(); + }), s.refreshScriptInfoRefCount) + if (n === _) + this.refreshScriptInfosInDirectory(n); + else { + const g = this.filenameToScriptInfo.get(_); + g ? rfe(g) && this.refreshScriptInfo(g) : xC(_) || this.refreshScriptInfosInDirectory(_); + } + }, + 1, + this.hostConfiguration.watchOptions, + Fl.NodeModules + ); + const s = { + refreshScriptInfoRefCount: 0, + affectedModuleSpecifierCacheProjects: void 0, + close: () => { + var o; + i && !s.refreshScriptInfoRefCount && !((o = s.affectedModuleSpecifierCacheProjects) != null && o.size) && (i.close(), i = void 0, this.nodeModulesWatchers.delete(n)); + } + }; + return this.nodeModulesWatchers.set(n, s), s; + } + /** @internal */ + watchPackageJsonsInNodeModules(t, n) { + var i; + const s = this.toPath(t), o = this.nodeModulesWatchers.get(s) || this.createNodeModulesWatcher(t, s); + return E.assert(!((i = o.affectedModuleSpecifierCacheProjects) != null && i.has(n))), (o.affectedModuleSpecifierCacheProjects || (o.affectedModuleSpecifierCacheProjects = /* @__PURE__ */ new Set())).add(n), { + close: () => { + var c; + (c = o.affectedModuleSpecifierCacheProjects) == null || c.delete(n), o.close(); + } + }; + } + watchClosedScriptInfoInNodeModules(t) { + const n = t + "/node_modules", i = this.toPath(n), s = this.nodeModulesWatchers.get(i) || this.createNodeModulesWatcher(n, i); + return s.refreshScriptInfoRefCount++, { + close: () => { + s.refreshScriptInfoRefCount--, s.close(); + } + }; + } + getModifiedTime(t) { + return (this.host.getModifiedTime(t.fileName) || Y_).getTime(); + } + refreshScriptInfo(t) { + const n = this.getModifiedTime(t); + if (n !== t.mTime) { + const i = gj(t.mTime, n); + t.mTime = n, this.onSourceFileChanged(t, i); + } + } + refreshScriptInfosInDirectory(t) { + t = t + So, this.filenameToScriptInfo.forEach((n) => { + rfe(n) && Ui(n.path, t) && this.refreshScriptInfo(n); + }); + } + stopWatchingScriptInfo(t) { + t.fileWatcher && (t.fileWatcher.close(), t.fileWatcher = void 0); + } + getOrCreateScriptInfoNotOpenedByClientForNormalizedPath(t, n, i, s, o, c) { + if (Z_(t) || zw(t)) + return this.getOrCreateScriptInfoWorker( + t, + n, + /*openedByClient*/ + !1, + /*fileContent*/ + void 0, + i, + !!s, + o, + c + ); + const _ = this.openFilesWithNonRootedDiskPath.get(this.toCanonicalFileName(t)); + if (_) + return _; + } + getOrCreateScriptInfoForNormalizedPath(t, n, i, s, o, c) { + return this.getOrCreateScriptInfoWorker( + t, + this.currentDirectory, + n, + i, + s, + !!o, + c, + /*deferredDeleteOk*/ + !1 + ); + } + getOrCreateScriptInfoWorker(t, n, i, s, o, c, _, u) { + E.assert(s === void 0 || i, "ScriptInfo needs to be opened by client to be able to set its user defined content"); + const g = oE(t, n, this.toCanonicalFileName); + let m = this.filenameToScriptInfo.get(g); + if (m) { + if (m.deferredDelete) { + if (E.assert(!m.isDynamic), !i && !(_ || this.host).fileExists(t)) + return u ? m : void 0; + m.deferredDelete = void 0; + } + } else { + const h = zw(t); + if (E.assert(Z_(t) || h || i, "", () => `${JSON.stringify({ fileName: t, currentDirectory: n, hostCurrentDirectory: this.currentDirectory, openKeys: is(this.openFilesWithNonRootedDiskPath.keys()) })} +Script info with non-dynamic relative file name can only be open script info or in context of host currentDirectory`), E.assert(!Z_(t) || this.currentDirectory === n || !this.openFilesWithNonRootedDiskPath.has(this.toCanonicalFileName(t)), "", () => `${JSON.stringify({ fileName: t, currentDirectory: n, hostCurrentDirectory: this.currentDirectory, openKeys: is(this.openFilesWithNonRootedDiskPath.keys()) })} +Open script files with non rooted disk path opened with current directory context cannot have same canonical names`), E.assert(!h || this.currentDirectory === n || this.useInferredProjectPerProjectRoot, "", () => `${JSON.stringify({ fileName: t, currentDirectory: n, hostCurrentDirectory: this.currentDirectory, openKeys: is(this.openFilesWithNonRootedDiskPath.keys()) })} +Dynamic files must always be opened with service's current directory or service should support inferred project per projectRootPath.`), !i && !h && !(_ || this.host).fileExists(t)) + return; + m = new M_e(this.host, t, o, c, g, this.filenameToScriptInfoVersion.get(g)), this.filenameToScriptInfo.set(m.path, m), this.filenameToScriptInfoVersion.delete(m.path), i ? !Z_(t) && (!h || this.currentDirectory !== n) && this.openFilesWithNonRootedDiskPath.set(this.toCanonicalFileName(t), m) : this.watchClosedScriptInfo(m); + } + return i && (this.stopWatchingScriptInfo(m), m.open(s), c && m.registerFileUpdate()), m; + } + /** + * This gets the script info for the normalized path. If the path is not rooted disk path then the open script info with project root context is preferred + */ + getScriptInfoForNormalizedPath(t) { + return !Z_(t) && this.openFilesWithNonRootedDiskPath.get(this.toCanonicalFileName(t)) || this.getScriptInfoForPath(oE(t, this.currentDirectory, this.toCanonicalFileName)); + } + getScriptInfoForPath(t) { + const n = this.filenameToScriptInfo.get(t); + return !n || !n.deferredDelete ? n : void 0; + } + /** @internal */ + getDocumentPositionMapper(t, n, i) { + const s = this.getOrCreateScriptInfoNotOpenedByClient( + n, + t.currentDirectory, + this.host, + /*deferredDeleteOk*/ + !1 + ); + if (!s) { + i && t.addGeneratedFileWatch(n, i); + return; + } + if (s.getSnapshot(), gs(s.sourceMapFilePath)) { + const g = this.getScriptInfoForPath(s.sourceMapFilePath); + if (g && (g.getSnapshot(), g.documentPositionMapper !== void 0)) + return g.sourceInfos = this.addSourceInfoToSourceMap(i, t, g.sourceInfos), g.documentPositionMapper ? g.documentPositionMapper : void 0; + s.sourceMapFilePath = void 0; + } else if (s.sourceMapFilePath) { + s.sourceMapFilePath.sourceInfos = this.addSourceInfoToSourceMap(i, t, s.sourceMapFilePath.sourceInfos); + return; + } else if (s.sourceMapFilePath !== void 0) + return; + let o, c = (g, m) => { + const h = this.getOrCreateScriptInfoNotOpenedByClient( + g, + t.currentDirectory, + this.host, + /*deferredDeleteOk*/ + !0 + ); + if (o = h || m, !h || h.deferredDelete) return; + const S = h.getSnapshot(); + return h.documentPositionMapper !== void 0 ? h.documentPositionMapper : fk(S); + }; + const _ = t.projectName, u = Dq( + { getCanonicalFileName: this.toCanonicalFileName, log: (g) => this.logger.info(g), getSourceFileLike: (g) => this.getSourceFileLike(g, _, s) }, + s.fileName, + s.textStorage.getLineInfo(), + c + ); + return c = void 0, o ? gs(o) ? s.sourceMapFilePath = { + watcher: this.addMissingSourceMapFile( + t.currentDirectory === this.currentDirectory ? o : Qi(o, t.currentDirectory), + s.path + ), + sourceInfos: this.addSourceInfoToSourceMap(i, t) + } : (s.sourceMapFilePath = o.path, o.declarationInfoPath = s.path, o.deferredDelete || (o.documentPositionMapper = u || !1), o.sourceInfos = this.addSourceInfoToSourceMap(i, t, o.sourceInfos)) : s.sourceMapFilePath = !1, u; + } + addSourceInfoToSourceMap(t, n, i) { + if (t) { + const s = this.getOrCreateScriptInfoNotOpenedByClient( + t, + n.currentDirectory, + n.directoryStructureHost, + /*deferredDeleteOk*/ + !1 + ); + (i || (i = /* @__PURE__ */ new Set())).add(s.path); + } + return i; + } + addMissingSourceMapFile(t, n) { + return this.watchFactory.watchFile( + t, + () => { + const s = this.getScriptInfoForPath(n); + s && s.sourceMapFilePath && !gs(s.sourceMapFilePath) && (this.delayUpdateProjectGraphs( + s.containingProjects, + /*clearSourceMapperCache*/ + !0 + ), this.delayUpdateSourceInfoProjects(s.sourceMapFilePath.sourceInfos), s.closeSourceMapFileWatcher()); + }, + 2e3, + this.hostConfiguration.watchOptions, + Fl.MissingSourceMapFile + ); + } + /** @internal */ + getSourceFileLike(t, n, i) { + const s = n.projectName ? n : this.findProject(n); + if (s) { + const c = s.toPath(t), _ = s.getSourceFile(c); + if (_ && _.resolvedPath === c) return _; + } + const o = this.getOrCreateScriptInfoNotOpenedByClient( + t, + (s || this).currentDirectory, + s ? s.directoryStructureHost : this.host, + /*deferredDeleteOk*/ + !1 + ); + if (o) { + if (i && gs(i.sourceMapFilePath) && o !== i) { + const c = this.getScriptInfoForPath(i.sourceMapFilePath); + c && (c.sourceInfos ?? (c.sourceInfos = /* @__PURE__ */ new Set())).add(o.path); + } + return o.cacheSourceFile ? o.cacheSourceFile.sourceFile : (o.sourceFileLike || (o.sourceFileLike = { + get text() { + return E.fail("shouldnt need text"), ""; + }, + getLineAndCharacterOfPosition: (c) => { + const _ = o.positionToLineOffset(c); + return { line: _.line - 1, character: _.offset - 1 }; + }, + getPositionOfLineAndCharacter: (c, _, u) => o.lineOffsetToPosition(c + 1, _ + 1, u) + }), o.sourceFileLike); + } + } + /** @internal */ + setPerformanceEventHandler(t) { + this.performanceEventHandler = t; + } + setHostConfiguration(t) { + var n; + if (t.file) { + const i = this.getScriptInfoForNormalizedPath(ro(t.file)); + i && (i.setOptions(lE(t.formatOptions), t.preferences), this.logger.info(`Host configuration update for file ${t.file}`)); + } else { + if (t.hostInfo !== void 0 && (this.hostConfiguration.hostInfo = t.hostInfo, this.logger.info(`Host information ${t.hostInfo}`)), t.formatOptions && (this.hostConfiguration.formatCodeOptions = { ...this.hostConfiguration.formatCodeOptions, ...lE(t.formatOptions) }, this.logger.info("Format host information updated")), t.preferences) { + const { + lazyConfiguredProjectsFromExternalProject: i, + includePackageJsonAutoImports: s, + includeCompletionsForModuleExports: o + } = this.hostConfiguration.preferences; + this.hostConfiguration.preferences = { ...this.hostConfiguration.preferences, ...t.preferences }, i && !this.hostConfiguration.preferences.lazyConfiguredProjectsFromExternalProject && this.externalProjectToConfiguredProjectMap.forEach( + (c) => c.forEach((_) => { + !_.deferredClose && !_.isClosed() && _.pendingUpdateLevel === 2 && !this.hasPendingProjectUpdate(_) && _.updateGraph(); + }) + ), (s !== t.preferences.includePackageJsonAutoImports || !!o != !!t.preferences.includeCompletionsForModuleExports) && this.forEachProject((c) => { + c.onAutoImportProviderSettingsChanged(); + }); + } + if (t.extraFileExtensions && (this.hostConfiguration.extraFileExtensions = t.extraFileExtensions, this.reloadProjects(), this.logger.info("Host file extension mappings updated")), t.watchOptions) { + const i = (n = J8(t.watchOptions)) == null ? void 0 : n.watchOptions, s = rO(i, this.currentDirectory); + this.hostConfiguration.watchOptions = s, this.hostConfiguration.beforeSubstitution = s === i ? void 0 : i, this.logger.info(`Host watch options changed to ${JSON.stringify(this.hostConfiguration.watchOptions)}, it will be take effect for next watches.`); + } + } + } + /** @internal */ + getWatchOptions(t) { + return this.getWatchOptionsFromProjectWatchOptions(t.getWatchOptions(), t.getCurrentDirectory()); + } + getWatchOptionsFromProjectWatchOptions(t, n) { + const i = this.hostConfiguration.beforeSubstitution ? rO( + this.hostConfiguration.beforeSubstitution, + n + ) : this.hostConfiguration.watchOptions; + return t && i ? { ...i, ...t } : t || i; + } + closeLog() { + this.logger.close(); + } + sendSourceFileChange(t) { + this.filenameToScriptInfo.forEach((n) => { + if (this.openFiles.has(n.path) || !n.fileWatcher) return; + const i = Uu( + () => this.host.fileExists(n.fileName) ? n.deferredDelete ? 0 : 1 : 2 + /* Deleted */ + ); + if (t) { + if (rfe(n) || !n.path.startsWith(t) || i() === 2 && n.deferredDelete) return; + this.logger.info(`Invoking sourceFileChange on ${n.fileName}:: ${i()}`); + } + this.onSourceFileChanged( + n, + i() + ); + }); + } + /** + * This function rebuilds the project for every file opened by the client + * This does not reload contents of open files from disk. But we could do that if needed + */ + reloadProjects() { + this.logger.info("reload projects."), this.sendSourceFileChange( + /*inPath*/ + void 0 + ), this.pendingProjectUpdates.forEach((i, s) => { + this.throttledOperations.cancel(s), this.pendingProjectUpdates.delete(s); + }), this.throttledOperations.cancel(lPe), this.pendingOpenFileProjectUpdates = void 0, this.pendingEnsureProjectForOpenFiles = !1, this.configFileExistenceInfoCache.forEach((i) => { + i.config && (i.config.updateLevel = 2, i.config.cachedDirectoryStructureHost.clearCache()); + }), this.configFileForOpenFiles.clear(), this.externalProjects.forEach((i) => { + this.clearSemanticCache(i), i.updateGraph(); + }); + const t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set(); + this.externalProjectToConfiguredProjectMap.forEach((i, s) => { + const o = `Reloading configured project in external project: ${s}`; + i.forEach((c) => { + this.getHostPreferences().lazyConfiguredProjectsFromExternalProject ? this.reloadConfiguredProjectOptimized(c, o, t) : this.reloadConfiguredProjectClearingSemanticCache( + c, + o, + t + ); + }); + }), this.openFiles.forEach((i, s) => { + const o = this.getScriptInfoForPath(s); + Nn(o.containingProjects, R8) || this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo( + o, + 7, + t, + n + ); + }), n.forEach((i) => t.set( + i, + 7 + /* Reload */ + )), this.inferredProjects.forEach((i) => this.clearSemanticCache(i)), this.ensureProjectForOpenFiles(), this.cleanupProjectsAndScriptInfos( + t, + new Set(this.openFiles.keys()), + new Set(this.externalProjectToConfiguredProjectMap.keys()) + ), this.logger.info("After reloading projects.."), this.printProjects(); + } + /** + * Remove the root of inferred project if script info is part of another project + */ + removeRootOfInferredProjectIfNowPartOfOtherProject(t) { + E.assert(t.containingProjects.length > 0); + const n = t.containingProjects[0]; + !n.isOrphan() && cE(n) && n.isRoot(t) && lr(t.containingProjects, (i) => i !== n && !i.isOrphan()) && n.removeFile( + t, + /*fileExists*/ + !0, + /*detachFromProject*/ + !0 + ); + } + /** + * This function is to update the project structure for every inferred project. + * It is called on the premise that all the configured projects are + * up to date. + * This will go through open files and assign them to inferred project if open file is not part of any other project + * After that all the inferred project graphs are updated + */ + ensureProjectForOpenFiles() { + this.logger.info("Before ensureProjectForOpenFiles:"), this.printProjects(); + const t = this.pendingOpenFileProjectUpdates; + this.pendingOpenFileProjectUpdates = void 0, t?.forEach( + (n, i) => this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo( + this.getScriptInfoForPath(i), + 5 + /* Create */ + ) + ), this.openFiles.forEach((n, i) => { + const s = this.getScriptInfoForPath(i); + s.isOrphan() ? this.assignOrphanScriptInfoToInferredProject(s, n) : this.removeRootOfInferredProjectIfNowPartOfOtherProject(s); + }), this.pendingEnsureProjectForOpenFiles = !1, this.inferredProjects.forEach(Gp), this.logger.info("After ensureProjectForOpenFiles:"), this.printProjects(); + } + /** + * Open file whose contents is managed by the client + * @param filename is absolute pathname + * @param fileContent is a known version of the file content that is more up to date than the one on disk + */ + openClientFile(t, n, i, s) { + return this.openClientFileWithNormalizedPath( + ro(t), + n, + i, + /*hasMixedContent*/ + !1, + s ? ro(s) : void 0 + ); + } + /** @internal */ + getOriginalLocationEnsuringConfiguredProject(t, n) { + const i = t.isSourceOfProjectReferenceRedirect(n.fileName), s = i ? n : t.getSourceMapper().tryGetSourcePosition(n); + if (!s) return; + const { fileName: o } = s, c = this.getScriptInfo(o); + if (!c && !this.host.fileExists(o)) return; + const _ = { fileName: ro(o), path: this.toPath(o) }, u = this.getConfigFileNameForFile( + _, + /*findFromCacheOnly*/ + !1 + ); + if (!u) return; + let g = this.findConfiguredProjectByProjectName(u); + if (!g) { + if (t.getCompilerOptions().disableReferencedProjectLoad) + return i ? n : c?.containingProjects.length ? s : n; + g = this.createConfiguredProject(u, `Creating project for original file: ${_.fileName}${n !== s ? " for location: " + n.fileName : ""}`); + } + const m = this.tryFindDefaultConfiguredProjectForOpenScriptInfoOrClosedFileInfo( + _, + 5, + efe( + g, + 4 + /* CreateOptimized */ + ), + (T) => `Creating project referenced in solution ${T.projectName} to find possible configured project for original file: ${_.fileName}${n !== s ? " for location: " + n.fileName : ""}` + ); + if (!m.defaultProject) return; + if (m.defaultProject === t) return s; + S(m.defaultProject); + const h = this.getScriptInfo(o); + if (!h || !h.containingProjects.length) return; + return h.containingProjects.forEach((T) => { + L0(T) && S(T); + }), s; + function S(T) { + (t.originalConfiguredProjects ?? (t.originalConfiguredProjects = /* @__PURE__ */ new Set())).add(T.canonicalConfigFilePath); + } + } + /** @internal */ + fileExists(t) { + return !!this.getScriptInfoForNormalizedPath(t) || this.host.fileExists(t); + } + findExternalProjectContainingOpenScriptInfo(t) { + return Nn(this.externalProjects, (n) => (Gp(n), n.containsScriptInfo(t))); + } + getOrCreateOpenScriptInfo(t, n, i, s, o) { + const c = this.getOrCreateScriptInfoWorker( + t, + o ? this.getNormalizedAbsolutePath(o) : this.currentDirectory, + /*openedByClient*/ + !0, + n, + i, + !!s, + /*hostToQueryFileExistsOn*/ + void 0, + /*deferredDeleteOk*/ + !0 + ); + return this.openFiles.set(c.path, o), c; + } + assignProjectToOpenedScriptInfo(t) { + let n, i; + const s = this.findExternalProjectContainingOpenScriptInfo(t); + let o, c; + if (!s && this.serverMode === 0) { + const _ = this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo( + t, + 5 + /* Create */ + ); + _ && (o = _.seenProjects, c = _.sentConfigDiag, _.defaultProject && (n = _.defaultProject.getConfigFilePath(), i = _.defaultProject.getAllProjectErrors())); + } + return t.containingProjects.forEach(Gp), t.isOrphan() && (o?.forEach((_, u) => { + _ !== 4 && !c.has(u) && this.sendConfigFileDiagEvent( + u, + t.fileName, + /*force*/ + !0 + ); + }), E.assert(this.openFiles.has(t.path)), this.assignOrphanScriptInfoToInferredProject(t, this.openFiles.get(t.path))), E.assert(!t.isOrphan()), { configFileName: n, configFileErrors: i, retainProjects: o }; + } + /** + * Depending on kind + * - Find the configuedProject and return it - if allowDeferredClosed is set it will find the deferredClosed project as well + * - Create - if the project doesnt exist, it creates one as well. If not delayLoad, the project is updated (with triggerFile if passed) + * - Reload - if the project doesnt exist, it creates one. If not delayLoad, the project is reloaded clearing semantic cache + * @internal + */ + findCreateOrReloadConfiguredProject(t, n, i, s, o, c, _, u, g) { + let m = g ?? this.findConfiguredProjectByProjectName(t, s), h = !1, S; + switch (n) { + case 0: + case 1: + case 3: + if (!m) return; + break; + case 2: + if (!m) return; + S = WKe(m); + break; + case 4: + case 5: + m ?? (m = this.createConfiguredProject(t, i)), _ || ({ sentConfigFileDiag: h, configFileExistenceInfo: S } = efe( + m, + n, + o + )); + break; + case 6: + if (m ?? (m = this.createConfiguredProject(t, LG(i))), m.projectService.reloadConfiguredProjectOptimized(m, i, c), S = nfe(m), S) break; + // falls through + case 7: + m ?? (m = this.createConfiguredProject(t, LG(i))), h = !u && this.reloadConfiguredProjectClearingSemanticCache(m, i, c), u && !u.has(m) && !c.has(m) && (this.setProjectForReload(m, 2, i), u.add(m)); + break; + default: + E.assertNever(n); + } + return { project: m, sentConfigFileDiag: h, configFileExistenceInfo: S, reason: i }; + } + /** + * Finds the default configured project for given info + * For any tsconfig found, it looks into that project, if not then all its references, + * The search happens for all tsconfigs till projectRootPath + */ + tryFindDefaultConfiguredProjectForOpenScriptInfo(t, n, i, s) { + const o = this.getConfigFileNameForFile( + t, + n <= 3 + /* CreateReplay */ + ); + if (!o) return; + const c = dPe(n), _ = this.findCreateOrReloadConfiguredProject( + o, + c, + UKe(t), + i, + t.fileName, + s + ); + return _ && this.tryFindDefaultConfiguredProjectForOpenScriptInfoOrClosedFileInfo( + t, + n, + _, + (u) => `Creating project referenced in solution ${u.projectName} to find possible configured project for ${t.fileName} to open`, + i, + s + ); + } + isMatchedByConfig(t, n, i) { + if (n.fileNames.some((u) => this.toPath(u) === i.path)) return !0; + if (FJ( + i.fileName, + n.options, + this.hostConfiguration.extraFileExtensions + )) return !1; + const { validatedFilesSpec: s, validatedIncludeSpecs: o, validatedExcludeSpecs: c } = n.options.configFile.configFileSpecs, _ = ro(Qi(Hn(t), this.currentDirectory)); + return s?.some((u) => this.toPath(Qi(u, _)) === i.path) ? !0 : !o?.length || aO( + i.fileName, + c, + this.host.useCaseSensitiveFileNames, + this.currentDirectory, + _ + ) ? !1 : o?.some((u) => { + const g = PJ(u, _, "files"); + return !!g && b0(`(${g})$`, this.host.useCaseSensitiveFileNames).test(i.fileName); + }); + } + tryFindDefaultConfiguredProjectForOpenScriptInfoOrClosedFileInfo(t, n, i, s, o, c) { + const _ = pPe(t), u = dPe(n), g = /* @__PURE__ */ new Map(); + let m; + const h = /* @__PURE__ */ new Set(); + let S, T, k, D; + return P(i), { + defaultProject: S ?? T, + tsconfigProject: k ?? D, + sentConfigDiag: h, + seenProjects: g, + seenConfigs: m + }; + function P(U) { + return F(U, U.project) ?? R(U.project) ?? B(U.project); + } + function A(U, $, W, _e, K, V) { + if ($) { + if (g.has($)) return; + g.set($, u); + } else { + if (m?.has(V)) return; + (m ?? (m = /* @__PURE__ */ new Set())).add(V); + } + if (!K.projectService.isMatchedByConfig( + W, + U.config.parsedCommandLine, + t + )) { + K.languageServiceEnabled && K.projectService.watchWildcards( + W, + U, + K + ); + return; + } + const ae = $ ? efe( + $, + n, + t.fileName, + _e, + c + ) : K.projectService.findCreateOrReloadConfiguredProject( + W, + n, + _e, + o, + t.fileName, + c + ); + if (!ae) { + E.assert( + n === 3 + /* CreateReplay */ + ); + return; + } + return g.set(ae.project, u), ae.sentConfigFileDiag && h.add(ae.project), O(ae.project, K); + } + function O(U, $) { + if (g.get(U) === n) return; + g.set(U, n); + const W = _ ? t : U.projectService.getScriptInfo(t.fileName), _e = W && U.containsScriptInfo(W); + if (_e && !U.isSourceOfProjectReferenceRedirect(W.path)) + return k = $, S = U; + !T && _ && _e && (D = $, T = U); + } + function F(U, $) { + return U.sentConfigFileDiag && h.add(U.project), U.configFileExistenceInfo ? A( + U.configFileExistenceInfo, + U.project, + ro(U.project.getConfigFilePath()), + U.reason, + U.project, + U.project.canonicalConfigFilePath + ) : O(U.project, $); + } + function R(U) { + return U.parsedCommandLine && gPe( + U, + U.parsedCommandLine, + A, + u, + s(U), + o, + c + ); + } + function B(U) { + return _ ? mPe( + // If not in referenced projects, try ancestors and its references + t, + U, + P, + u, + `Creating possible configured project for ${t.fileName} to open`, + o, + c, + /*searchOnlyPotentialSolution*/ + !1 + ) : void 0; + } + } + tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(t, n, i, s) { + const o = n === 1, c = this.tryFindDefaultConfiguredProjectForOpenScriptInfo( + t, + n, + o, + i + ); + if (!c) return; + const { defaultProject: _, tsconfigProject: u, seenProjects: g } = c; + return _ && mPe( + t, + u, + (m) => { + g.set(m.project, n); + }, + n, + `Creating project possibly referencing default composite project ${_.getProjectName()} of open file ${t.fileName}`, + o, + i, + /*searchOnlyPotentialSolution*/ + !0, + s + ), c; + } + /** @internal */ + loadAncestorProjectTree(t) { + t ?? (t = new Set( + uy(this.configuredProjects.entries(), ([s, o]) => o.initialLoadPending ? void 0 : s) + )); + const n = /* @__PURE__ */ new Set(), i = is(this.configuredProjects.values()); + for (const s of i) + hPe(s, (o) => t.has(o)) && Gp(s), this.ensureProjectChildren(s, t, n); + } + ensureProjectChildren(t, n, i) { + var s; + if (!u0(i, t.canonicalConfigFilePath) || t.getCompilerOptions().disableReferencedProjectLoad) return; + const o = (s = t.getCurrentProgram()) == null ? void 0 : s.getResolvedProjectReferences(); + if (o) + for (const c of o) { + if (!c) continue; + const _ = YJ(c.references, (m) => n.has(m.sourceFile.path) ? m : void 0); + if (!_) continue; + const u = ro(c.sourceFile.fileName), g = this.findConfiguredProjectByProjectName(u) ?? this.createConfiguredProject( + u, + `Creating project referenced by : ${t.projectName} as it references project ${_.sourceFile.fileName}` + ); + Gp(g), this.ensureProjectChildren(g, n, i); + } + } + cleanupConfiguredProjects(t, n, i) { + this.getOrphanConfiguredProjects( + t, + i, + n + ).forEach((s) => this.removeProject(s)); + } + cleanupProjectsAndScriptInfos(t, n, i) { + this.cleanupConfiguredProjects( + t, + i, + n + ); + for (const s of this.inferredProjects.slice()) + s.isOrphan() && this.removeProject(s); + this.removeOrphanScriptInfos(); + } + tryInvokeWildCardDirectories(t) { + this.configFileExistenceInfoCache.forEach((n, i) => { + var s, o; + !((s = n.config) != null && s.parsedCommandLine) || ms( + n.config.parsedCommandLine.fileNames, + t.fileName, + this.host.useCaseSensitiveFileNames ? bb : hy + ) || (o = n.config.watchedDirectories) == null || o.forEach((c, _) => { + np(_, t.fileName, !this.host.useCaseSensitiveFileNames) && (this.logger.info(`Invoking ${i}:: wildcard for open scriptInfo:: ${t.fileName}`), this.onWildCardDirectoryWatcherInvoke( + _, + i, + n.config, + c.watcher, + t.fileName + )); + }); + }); + } + openClientFileWithNormalizedPath(t, n, i, s, o) { + const c = this.getScriptInfoForPath(oE( + t, + o ? this.getNormalizedAbsolutePath(o) : this.currentDirectory, + this.toCanonicalFileName + )), _ = this.getOrCreateOpenScriptInfo(t, n, i, s, o); + !c && _ && !_.isDynamic && this.tryInvokeWildCardDirectories(_); + const { retainProjects: u, ...g } = this.assignProjectToOpenedScriptInfo(_); + return this.cleanupProjectsAndScriptInfos( + u, + /* @__PURE__ */ new Set([_.path]), + /*externalProjectsRetainingConfiguredProjects*/ + void 0 + ), this.telemetryOnOpenFile(_), this.printProjects(), g; + } + /** @internal */ + getOrphanConfiguredProjects(t, n, i) { + const s = new Set(this.configuredProjects.values()), o = (g) => { + g.originalConfiguredProjects && (L0(g) || !g.isOrphan()) && g.originalConfiguredProjects.forEach( + (m, h) => { + const S = this.getConfiguredProjectByCanonicalConfigFilePath(h); + return S && u(S); + } + ); + }; + if (t?.forEach((g, m) => u(m)), !s.size || (this.inferredProjects.forEach(o), this.externalProjects.forEach(o), this.externalProjectToConfiguredProjectMap.forEach((g, m) => { + i?.has(m) || g.forEach(u); + }), !s.size) || (hl(this.openFiles, (g, m) => { + if (n?.has(m)) return; + const h = this.getScriptInfoForPath(m); + if (Nn(h.containingProjects, R8)) return; + const S = this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo( + h, + 1 + /* Find */ + ); + if (S?.defaultProject && (S?.seenProjects.forEach((T, k) => u(k)), !s.size)) + return s; + }), !s.size)) return s; + return hl(this.configuredProjects, (g) => { + if (s.has(g) && (_(g) || yPe(g, c)) && (u(g), !s.size)) + return s; + }), s; + function c(g) { + return !s.has(g) || _(g); + } + function _(g) { + var m, h; + return (g.deferredClose || g.projectService.hasPendingProjectUpdate(g)) && !!((h = (m = g.projectService.configFileExistenceInfoCache.get(g.canonicalConfigFilePath)) == null ? void 0 : m.openFilesImpactedByConfigFile) != null && h.size); + } + function u(g) { + s.delete(g) && (o(g), yPe(g, u)); + } + } + removeOrphanScriptInfos() { + const t = new Map(this.filenameToScriptInfo); + this.filenameToScriptInfo.forEach((n) => { + if (!n.deferredDelete) { + if (!n.isScriptOpen() && n.isOrphan() && !j_e(n) && !R_e(n)) { + if (!n.sourceMapFilePath) return; + let i; + if (gs(n.sourceMapFilePath)) { + const s = this.filenameToScriptInfo.get(n.sourceMapFilePath); + i = s?.sourceInfos; + } else + i = n.sourceMapFilePath.sourceInfos; + if (!i || !Ag(i, (s) => { + const o = this.getScriptInfoForPath(s); + return !!o && (o.isScriptOpen() || !o.isOrphan()); + })) + return; + } + if (t.delete(n.path), n.sourceMapFilePath) { + let i; + if (gs(n.sourceMapFilePath)) { + const s = this.filenameToScriptInfo.get(n.sourceMapFilePath); + s?.deferredDelete ? n.sourceMapFilePath = { + watcher: this.addMissingSourceMapFile(s.fileName, n.path), + sourceInfos: s.sourceInfos + } : t.delete(n.sourceMapFilePath), i = s?.sourceInfos; + } else + i = n.sourceMapFilePath.sourceInfos; + i && i.forEach((s, o) => t.delete(o)); + } + } + }), t.forEach((n) => this.deleteScriptInfo(n)); + } + telemetryOnOpenFile(t) { + if (this.serverMode !== 0 || !this.eventHandler || !t.isJavaScript() || !Jp(this.allJsFilesForOpenFileTelemetry, t.path)) + return; + const n = this.ensureDefaultProjectForFile(t); + if (!n.languageServiceEnabled) + return; + const i = n.getSourceFile(t.path), s = !!i && !!i.checkJsDirective; + this.eventHandler({ eventName: $_e, data: { info: { checkJs: s } } }); + } + closeClientFile(t, n) { + const i = this.getScriptInfoForNormalizedPath(ro(t)), s = i ? this.closeOpenFile(i, n) : !1; + return n || this.printProjects(), s; + } + collectChanges(t, n, i, s) { + for (const o of n) { + const c = Nn(t, (_) => _.projectName === o.getProjectName()); + s.push(o.getChangesSinceVersion(c && c.version, i)); + } + } + /** @internal */ + synchronizeProjectList(t, n) { + const i = []; + return this.collectChanges(t, this.externalProjects, n, i), this.collectChanges(t, uy(this.configuredProjects.values(), (s) => s.deferredClose ? void 0 : s), n, i), this.collectChanges(t, this.inferredProjects, n, i), i; + } + /** @internal */ + applyChangesInOpenFiles(t, n, i) { + let s, o, c = !1; + if (t) + for (const u of t) { + (s ?? (s = [])).push(this.getScriptInfoForPath(oE( + ro(u.fileName), + u.projectRootPath ? this.getNormalizedAbsolutePath(u.projectRootPath) : this.currentDirectory, + this.toCanonicalFileName + ))); + const g = this.getOrCreateOpenScriptInfo( + ro(u.fileName), + u.content, + PG(u.scriptKind), + u.hasMixedContent, + u.projectRootPath ? ro(u.projectRootPath) : void 0 + ); + (o || (o = [])).push(g); + } + if (n) + for (const u of n) { + const g = this.getScriptInfo(u.fileName); + E.assert(!!g), this.applyChangesToFile(g, u.changes); + } + if (i) + for (const u of i) + c = this.closeClientFile( + u, + /*skipAssignOrphanScriptInfosToInferredProject*/ + !0 + ) || c; + let _; + lr( + s, + (u, g) => !u && o[g] && !o[g].isDynamic ? this.tryInvokeWildCardDirectories(o[g]) : void 0 + ), o?.forEach( + (u) => { + var g; + return (g = this.assignProjectToOpenedScriptInfo(u).retainProjects) == null ? void 0 : g.forEach( + (m, h) => (_ ?? (_ = /* @__PURE__ */ new Map())).set(h, m) + ); + } + ), c && this.assignOrphanScriptInfosToInferredProject(), o ? (this.cleanupProjectsAndScriptInfos( + _, + new Set(o.map((u) => u.path)), + /*externalProjectsRetainingConfiguredProjects*/ + void 0 + ), o.forEach((u) => this.telemetryOnOpenFile(u)), this.printProjects()) : wr(i) && this.printProjects(); + } + /** @internal */ + applyChangesToFile(t, n) { + for (const i of n) + t.editContent(i.span.start, i.span.start + i.span.length, i.newText); + } + // eslint-disable-line @typescript-eslint/unified-signatures + closeExternalProject(t, n) { + const i = ro(t); + if (this.externalProjectToConfiguredProjectMap.get(i)) + this.externalProjectToConfiguredProjectMap.delete(i); + else { + const o = this.findExternalProjectByProjectName(t); + o && this.removeProject(o); + } + n && (this.cleanupConfiguredProjects(), this.printProjects()); + } + openExternalProjects(t) { + const n = new Set(this.externalProjects.map((i) => i.getProjectName())); + this.externalProjectToConfiguredProjectMap.forEach((i, s) => n.add(s)); + for (const i of t) + this.openExternalProject( + i, + /*cleanupAfter*/ + !1 + ), n.delete(i.projectFileName); + n.forEach((i) => this.closeExternalProject( + i, + /*cleanupAfter*/ + !1 + )), this.cleanupConfiguredProjects(), this.printProjects(); + } + static escapeFilenameForRegex(t) { + return t.replace(this.filenameEscapeRegexp, "\\$&"); + } + resetSafeList() { + this.safelist = X_e; + } + applySafeList(t) { + const n = t.typeAcquisition; + E.assert(!!n, "proj.typeAcquisition should be set by now"); + const i = this.applySafeListWorker(t, t.rootFiles, n); + return i?.excludedFiles ?? []; + } + applySafeListWorker(t, n, i) { + if (i.enable === !1 || i.disableFilenameBasedTypeAcquisition) + return; + const s = i.include || (i.include = []), o = [], c = n.map((h) => zl(h.fileName)); + for (const h of Object.keys(this.safelist)) { + const S = this.safelist[h]; + for (const T of c) + if (S.match.test(T)) { + if (this.logger.info(`Excluding files based on rule ${h} matching file '${T}'`), S.types) + for (const k of S.types) + s.includes(k) || s.push(k); + if (S.exclude) + for (const k of S.exclude) { + const D = T.replace(S.match, (...P) => k.map((A) => typeof A == "number" ? gs(P[A]) ? fge.escapeFilenameForRegex(P[A]) : (this.logger.info(`Incorrect RegExp specification in safelist rule ${h} - not enough groups`), "\\*") : A).join("")); + o.includes(D) || o.push(D); + } + else { + const k = fge.escapeFilenameForRegex(T); + o.includes(k) || o.push(k); + } + } + } + const _ = o.map((h) => new RegExp(h, "i")); + let u, g; + for (let h = 0; h < n.length; h++) + if (_.some((S) => S.test(c[h]))) + m(h); + else { + if (i.enable) { + const S = Zc(my(c[h])); + if (Xo(S, "js")) { + const T = Gu(S), k = UR(T), D = this.legacySafelist.get(k); + if (D !== void 0) { + this.logger.info(`Excluded '${c[h]}' because it matched ${k} from the legacy safelist`), m(h), s.includes(D) || s.push(D); + continue; + } + } + } + /^.+[.-]min\.js$/.test(c[h]) ? m(h) : u?.push(n[h]); + } + return g ? { + rootFiles: u, + excludedFiles: g + } : void 0; + function m(h) { + g || (E.assert(!u), u = n.slice(0, h), g = []), g.push(c[h]); + } + } + // eslint-disable-line @typescript-eslint/unified-signatures + openExternalProject(t, n) { + const i = this.findExternalProjectByProjectName(t.projectFileName); + let s, o = []; + for (const c of t.rootFiles) { + const _ = ro(c.fileName); + if (gG(_)) { + if (this.serverMode === 0 && this.host.fileExists(_)) { + let u = this.findConfiguredProjectByProjectName(_); + u || (u = this.createConfiguredProject(_, `Creating configured project in external project: ${t.projectFileName}`), this.getHostPreferences().lazyConfiguredProjectsFromExternalProject || u.updateGraph()), (s ?? (s = /* @__PURE__ */ new Set())).add(u), E.assert(!u.isClosed()); + } + } else + o.push(c); + } + if (s) + this.externalProjectToConfiguredProjectMap.set(t.projectFileName, s), i && this.removeProject(i); + else { + this.externalProjectToConfiguredProjectMap.delete(t.projectFileName); + const c = t.typeAcquisition || {}; + c.include = c.include || [], c.exclude = c.exclude || [], c.enable === void 0 && (c.enable = z_e(o.map((g) => g.fileName))); + const _ = this.applySafeListWorker(t, o, c), u = _?.excludedFiles ?? []; + if (o = _?.rootFiles ?? o, i) { + i.excludedFiles = u; + const g = WL(t.options), m = J8(t.options, i.getCurrentDirectory()), h = this.getFilenameForExceededTotalSizeLimitForNonTsFiles(t.projectFileName, g, o, IG); + h ? i.disableLanguageService(h) : i.enableLanguageService(), i.setProjectErrors(m?.errors), this.updateRootAndOptionsOfNonInferredProject(i, o, IG, g, c, t.options.compileOnSave, m?.watchOptions), i.updateGraph(); + } else + this.createExternalProject(t.projectFileName, o, t.options, c, u).updateGraph(); + } + n && (this.cleanupConfiguredProjects( + s, + /* @__PURE__ */ new Set([t.projectFileName]) + ), this.printProjects()); + } + hasDeferredExtension() { + for (const t of this.hostConfiguration.extraFileExtensions) + if (t.scriptKind === 7) + return !0; + return !1; + } + /** + * Performs the initial steps of enabling a plugin by finding and instantiating the module for a plugin either asynchronously or synchronously + * @internal + */ + requestEnablePlugin(t, n, i) { + if (!this.host.importPlugin && !this.host.require) { + this.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded"); + return; + } + if (this.logger.info(`Enabling plugin ${n.name} from candidate paths: ${i.join(",")}`), !n.name || Dl(n.name) || /[\\/]\.\.?(?:$|[\\/])/.test(n.name)) { + this.logger.info(`Skipped loading plugin ${n.name || JSON.stringify(n)} because only package name is allowed plugin name`); + return; + } + if (this.host.importPlugin) { + const s = Ek.importServicePluginAsync( + n, + i, + this.host, + (c) => this.logger.info(c) + ); + this.pendingPluginEnablements ?? (this.pendingPluginEnablements = /* @__PURE__ */ new Map()); + let o = this.pendingPluginEnablements.get(t); + o || this.pendingPluginEnablements.set(t, o = []), o.push(s); + return; + } + this.endEnablePlugin( + t, + Ek.importServicePluginSync( + n, + i, + this.host, + (s) => this.logger.info(s) + ) + ); + } + /** + * Performs the remaining steps of enabling a plugin after its module has been instantiated. + */ + endEnablePlugin(t, { pluginConfigEntry: n, resolvedModule: i, errorLogs: s }) { + var o; + if (i) { + const c = (o = this.currentPluginConfigOverrides) == null ? void 0 : o.get(n.name); + if (c) { + const _ = n.name; + n = c, n.name = _; + } + t.enableProxy(i, n); + } else + lr(s, (c) => this.logger.info(c)), this.logger.info(`Couldn't find ${n.name}`); + } + /** @internal */ + hasNewPluginEnablementRequests() { + return !!this.pendingPluginEnablements; + } + /** @internal */ + hasPendingPluginEnablements() { + return !!this.currentPluginEnablementPromise; + } + /** + * Waits for any ongoing plugin enablement requests to complete. + * + * @internal + */ + async waitForPendingPlugins() { + for (; this.currentPluginEnablementPromise; ) + await this.currentPluginEnablementPromise; + } + /** + * Starts enabling any requested plugins without waiting for the result. + * + * @internal + */ + enableRequestedPlugins() { + this.pendingPluginEnablements && this.enableRequestedPluginsAsync(); + } + async enableRequestedPluginsAsync() { + if (this.currentPluginEnablementPromise && await this.waitForPendingPlugins(), !this.pendingPluginEnablements) + return; + const t = is(this.pendingPluginEnablements.entries()); + this.pendingPluginEnablements = void 0, this.currentPluginEnablementPromise = this.enableRequestedPluginsWorker(t), await this.currentPluginEnablementPromise; + } + async enableRequestedPluginsWorker(t) { + E.assert(this.currentPluginEnablementPromise === void 0); + let n = !1; + await Promise.all(hr(t, async ([i, s]) => { + const o = await Promise.all(s); + if (i.isClosed() || B8(i)) { + this.logger.info(`Cancelling plugin enabling for ${i.getProjectName()} as it is ${i.isClosed() ? "closed" : "deferred close"}`); + return; + } + n = !0; + for (const c of o) + this.endEnablePlugin(i, c); + this.delayUpdateProjectGraph(i); + })), this.currentPluginEnablementPromise = void 0, n && this.sendProjectsUpdatedInBackgroundEvent(); + } + configurePlugin(t) { + this.forEachEnabledProject((n) => n.onPluginConfigurationChanged(t.pluginName, t.configuration)), this.currentPluginConfigOverrides = this.currentPluginConfigOverrides || /* @__PURE__ */ new Map(), this.currentPluginConfigOverrides.set(t.pluginName, t.configuration); + } + /** @internal */ + getPackageJsonsVisibleToFile(t, n, i) { + const s = this.packageJsonCache, o = i && this.toPath(i), c = [], _ = (u) => { + switch (s.directoryHasPackageJson(u)) { + // Sync and check same directory again + case 3: + return s.searchDirectoryAndAncestors(u, n), _(u); + // Check package.json + case -1: + const g = On(u, "package.json"); + this.watchPackageJsonFile(g, this.toPath(g), n); + const m = s.getInDirectory(u); + m && c.push(m); + } + if (o && o === u) + return !0; + }; + return eg( + n, + Hn(t), + _ + ), c; + } + /** @internal */ + getNearestAncestorDirectoryWithPackageJson(t, n) { + return eg( + n, + t, + (i) => { + switch (this.packageJsonCache.directoryHasPackageJson(i)) { + case -1: + return i; + case 0: + return; + case 3: + return this.host.fileExists(On(i, "package.json")) ? i : void 0; + } + } + ); + } + watchPackageJsonFile(t, n, i) { + E.assert(i !== void 0); + let s = (this.packageJsonFilesMap ?? (this.packageJsonFilesMap = /* @__PURE__ */ new Map())).get(n); + if (!s) { + let o = this.watchFactory.watchFile( + t, + (c, _) => { + switch (_) { + case 0: + case 1: + this.packageJsonCache.addOrUpdate(c, n), this.onPackageJsonChange(s); + break; + case 2: + this.packageJsonCache.delete(n), this.onPackageJsonChange(s), s.projects.clear(), s.close(); + } + }, + 250, + this.hostConfiguration.watchOptions, + Fl.PackageJson + ); + s = { + projects: /* @__PURE__ */ new Set(), + close: () => { + var c; + s.projects.size || !o || (o.close(), o = void 0, (c = this.packageJsonFilesMap) == null || c.delete(n), this.packageJsonCache.invalidate(n)); + } + }, this.packageJsonFilesMap.set(n, s); + } + s.projects.add(i), (i.packageJsonWatches ?? (i.packageJsonWatches = /* @__PURE__ */ new Set())).add(s); + } + onPackageJsonChange(t) { + t.projects.forEach((n) => { + var i; + return (i = n.onPackageJsonChange) == null ? void 0 : i.call(n); + }); + } + /** @internal */ + includePackageJsonAutoImports() { + switch (this.hostConfiguration.preferences.includePackageJsonAutoImports) { + case "on": + return 1; + case "off": + return 0; + default: + return 2; + } + } + /** @internal */ + getIncompleteCompletionsCache() { + return this.incompleteCompletionsCache || (this.incompleteCompletionsCache = qKe()); + } + }; + SPe.filenameEscapeRegexp = /[-/\\^$*+?.()|[\]{}]/g; + var cfe = SPe; + function qKe() { + let e; + return { + get() { + return e; + }, + set(t) { + e = t; + }, + clear() { + e = void 0; + } + }; + } + function lfe(e) { + return e.kind !== void 0; + } + function ufe(e) { + e.print( + /*writeProjectFileNames*/ + !1, + /*writeFileExplaination*/ + !1, + /*writeFileVersionAndText*/ + !1 + ); + } + function _fe(e) { + let t, n, i; + const s = { + get(u, g, m, h) { + if (!(!n || i !== c(u, m, h))) + return n.get(g); + }, + set(u, g, m, h, S, T, k) { + if (o(u, m, h).set(g, _( + S, + T, + k, + /*packageName*/ + void 0, + /*isBlockedByPackageJsonDependencies*/ + !1 + )), k) { + for (const D of T) + if (D.isInNodeModules) { + const P = D.path.substring(0, D.path.indexOf(qg) + qg.length - 1), A = e.toPath(P); + t?.has(A) || (t || (t = /* @__PURE__ */ new Map())).set( + A, + e.watchNodeModulesForPackageJsonChanges(P) + ); + } + } + }, + setModulePaths(u, g, m, h, S) { + const T = o(u, m, h), k = T.get(g); + k ? k.modulePaths = S : T.set(g, _( + /*kind*/ + void 0, + S, + /*moduleSpecifiers*/ + void 0, + /*packageName*/ + void 0, + /*isBlockedByPackageJsonDependencies*/ + void 0 + )); + }, + setBlockedByPackageJsonDependencies(u, g, m, h, S, T) { + const k = o(u, m, h), D = k.get(g); + D ? (D.isBlockedByPackageJsonDependencies = T, D.packageName = S) : k.set(g, _( + /*kind*/ + void 0, + /*modulePaths*/ + void 0, + /*moduleSpecifiers*/ + void 0, + S, + T + )); + }, + clear() { + t?.forEach(od), n?.clear(), t?.clear(), i = void 0; + }, + count() { + return n ? n.size : 0; + } + }; + return E.isDebugging && Object.defineProperty(s, "__cache", { get: () => n }), s; + function o(u, g, m) { + const h = c(u, g, m); + return n && i !== h && s.clear(), i = h, n || (n = /* @__PURE__ */ new Map()); + } + function c(u, g, m) { + return `${u},${g.importModuleSpecifierEnding},${g.importModuleSpecifierPreference},${m.overrideImportMode}`; + } + function _(u, g, m, h, S) { + return { kind: u, modulePaths: g, moduleSpecifiers: m, packageName: h, isBlockedByPackageJsonDependencies: S }; + } + } + function ffe(e) { + const t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(); + return { + addOrUpdate: i, + invalidate: s, + delete: (c) => { + t.delete(c), n.set(Hn(c), !0); + }, + getInDirectory: (c) => t.get(e.toPath(On(c, "package.json"))) || void 0, + directoryHasPackageJson: (c) => o(e.toPath(c)), + searchDirectoryAndAncestors: (c, _) => { + eg( + _, + c, + (u) => { + const g = e.toPath(u); + if (o(g) !== 3) + return !0; + const m = On(u, "package.json"); + Ew(e, m) ? i(m, On(g, "package.json")) : n.set(g, !0); + } + ); + } + }; + function i(c, _) { + const u = E.checkDefined(lq(c, e.host)); + t.set(_, u), n.delete(Hn(_)); + } + function s(c) { + t.delete(c), n.delete(Hn(c)); + } + function o(c) { + return t.has(On(c, "package.json")) ? -1 : n.has(c) ? 0 : 3; + } + } + var TPe = { + isCancellationRequested: () => !1, + setRequest: () => { + }, + resetRequest: () => { + } + }; + function HKe(e) { + const t = e[0], n = e[1]; + return (1e9 * t + n) / 1e6; + } + function xPe(e, t) { + if ((cE(e) || R8(e)) && e.isJsOnlyProject()) { + const n = e.getScriptInfoForNormalizedPath(t); + return n && !n.isJavaScript(); + } + return !1; + } + function GKe(e) { + return J_(e) || !!e.emitDecoratorMetadata; + } + function kPe(e, t, n) { + const i = t.getScriptInfoForNormalizedPath(e); + return { + start: i.positionToLineOffset(n.start), + end: i.positionToLineOffset(n.start + n.length), + // TODO: GH#18217 + text: km(n.messageText, ` +`), + code: n.code, + category: $2(n), + reportsUnnecessary: n.reportsUnnecessary, + reportsDeprecated: n.reportsDeprecated, + source: n.source, + relatedInformation: hr(n.relatedInformation, MG) + }; + } + function MG(e) { + return e.file ? { + span: { + start: uE(js(e.file, e.start)), + end: uE(js(e.file, e.start + e.length)), + // TODO: GH#18217 + file: e.file.fileName + }, + message: km(e.messageText, ` +`), + category: $2(e), + code: e.code + } : { + message: km(e.messageText, ` +`), + category: $2(e), + code: e.code + }; + } + function uE(e) { + return { line: e.line + 1, offset: e.character + 1 }; + } + function z8(e, t) { + const n = e.file && uE(js(e.file, e.start)), i = e.file && uE(js(e.file, e.start + e.length)), s = km(e.messageText, ` +`), { code: o, source: c } = e, _ = $2(e), u = { + start: n, + end: i, + text: s, + code: o, + category: _, + reportsUnnecessary: e.reportsUnnecessary, + reportsDeprecated: e.reportsDeprecated, + source: c, + relatedInformation: hr(e.relatedInformation, MG) + }; + return t ? { ...u, fileName: e.file && e.file.fileName } : u; + } + function $Ke(e, t) { + return e.every((n) => ec(n.span) < t); + } + var CPe = O_e; + function pfe(e, t, n, i) { + const s = t.hasLevel( + 3 + /* verbose */ + ), o = JSON.stringify(e); + return s && t.info(`${e.type}:${vv(e)}`), `Content-Length: ${1 + n(o, "utf8")}\r +\r +${o}${i}`; + } + var XKe = class { + constructor(e) { + this.operationHost = e; + } + startNew(e) { + this.complete(), this.requestId = this.operationHost.getCurrentRequestId(), this.executeAction(e); + } + complete() { + this.requestId !== void 0 && (this.operationHost.sendRequestCompletedEvent(this.requestId, this.performanceData), this.requestId = void 0), this.setTimerHandle(void 0), this.setImmediateId(void 0), this.performanceData = void 0; + } + immediate(e, t) { + const n = this.requestId; + E.assert(n === this.operationHost.getCurrentRequestId(), "immediate: incorrect request id"), this.setImmediateId( + this.operationHost.getServerHost().setImmediate(() => { + this.immediateId = void 0, this.operationHost.executeWithRequestId(n, () => this.executeAction(t), this.performanceData); + }, e) + ); + } + delay(e, t, n) { + const i = this.requestId; + E.assert(i === this.operationHost.getCurrentRequestId(), "delay: incorrect request id"), this.setTimerHandle( + this.operationHost.getServerHost().setTimeout( + () => { + this.timerHandle = void 0, this.operationHost.executeWithRequestId(i, () => this.executeAction(n), this.performanceData); + }, + t, + e + ) + ); + } + executeAction(e) { + var t, n, i, s, o, c; + let _ = !1; + try { + this.operationHost.isCancellationRequested() ? (_ = !0, (t = on) == null || t.instant(on.Phase.Session, "stepCanceled", { seq: this.requestId, early: !0 })) : ((n = on) == null || n.push(on.Phase.Session, "stepAction", { seq: this.requestId }), e(this), (i = on) == null || i.pop()); + } catch (u) { + (s = on) == null || s.popAll(), _ = !0, u instanceof lD ? (o = on) == null || o.instant(on.Phase.Session, "stepCanceled", { seq: this.requestId }) : ((c = on) == null || c.instant(on.Phase.Session, "stepError", { seq: this.requestId, message: u.message }), this.operationHost.logError(u, `delayed processing of request ${this.requestId}`)); + } + this.performanceData = this.operationHost.getPerformanceData(), (_ || !this.hasPendingWork()) && this.complete(); + } + setTimerHandle(e) { + this.timerHandle !== void 0 && this.operationHost.getServerHost().clearTimeout(this.timerHandle), this.timerHandle = e; + } + setImmediateId(e) { + this.immediateId !== void 0 && this.operationHost.getServerHost().clearImmediate(this.immediateId), this.immediateId = e; + } + hasPendingWork() { + return !!this.timerHandle || !!this.immediateId; + } + }; + function dfe(e, t) { + return { + seq: 0, + type: "event", + event: e, + body: t + }; + } + function QKe(e, t, n, i) { + const s = KE(as(n) ? n : n.projects, (o) => i(o, e)); + return !as(n) && n.symLinkedProjects && n.symLinkedProjects.forEach((o, c) => { + const _ = t(c); + s.push(...ka(o, (u) => i(u, _))); + }), hb(s, gy); + } + function RG(e) { + return jR(({ textSpan: t }) => t.start + 100003 * t.length, QV(e)); + } + function YKe(e, t, n, i, s, o, c) { + const _ = mfe( + e, + t, + n, + EPe( + t, + n, + /*isForRename*/ + !0 + ), + PPe, + (m, h) => m.getLanguageService().findRenameLocations(h.fileName, h.pos, i, s, o), + (m, h) => h(Uw(m)) + ); + if (as(_)) + return _; + const u = [], g = RG(c); + return _.forEach((m, h) => { + for (const S of m) + !g.has(S) && !jG(Uw(S), h) && (u.push(S), g.add(S)); + }), u; + } + function EPe(e, t, n) { + const i = e.getLanguageService().getDefinitionAtPosition( + t.fileName, + t.pos, + /*searchOtherFilesOnly*/ + !1, + /*stopAtAlias*/ + n + ), s = i && Yc(i); + return s && !s.isLocal ? { fileName: s.fileName, pos: s.textSpan.start } : void 0; + } + function ZKe(e, t, n, i, s) { + var o, c; + const _ = mfe( + e, + t, + n, + EPe( + t, + n, + /*isForRename*/ + !1 + ), + PPe, + (h, S) => (s.info(`Finding references to ${S.fileName} position ${S.pos} in project ${h.getProjectName()}`), h.getLanguageService().findReferences(S.fileName, S.pos)), + (h, S) => { + S(Uw(h.definition)); + for (const T of h.references) + S(Uw(T)); + } + ); + if (as(_)) + return _; + const u = _.get(t); + if (((c = (o = u?.[0]) == null ? void 0 : o.references[0]) == null ? void 0 : c.isDefinition) === void 0) + _.forEach((h) => { + for (const S of h) + for (const T of S.references) + delete T.isDefinition; + }); + else { + const h = RG(i); + for (const T of u) + for (const k of T.references) + if (k.isDefinition) { + h.add(k); + break; + } + const S = /* @__PURE__ */ new Set(); + for (; ; ) { + let T = !1; + if (_.forEach((k, D) => { + if (S.has(D)) return; + D.getLanguageService().updateIsDefinitionOfReferencedSymbols(k, h) && (S.add(D), T = !0); + }), !T) break; + } + _.forEach((T, k) => { + if (!S.has(k)) + for (const D of T) + for (const P of D.references) + P.isDefinition = !1; + }); + } + const g = [], m = RG(i); + return _.forEach((h, S) => { + for (const T of h) { + const k = jG(Uw(T.definition), S), D = k === void 0 ? T.definition : { + ...T.definition, + textSpan: Kl(k.pos, T.definition.textSpan.length), + // Why would the length be the same in the original? + fileName: k.fileName, + contextSpan: eet(T.definition, S) + }; + let P = Nn(g, (A) => XV(A.definition, D, i)); + P || (P = { definition: D, references: [] }, g.push(P)); + for (const A of T.references) + !m.has(A) && !jG(Uw(A), S) && (m.add(A), P.references.push(A)); + } + }), g.filter((h) => h.references.length !== 0); + } + function DPe(e, t, n) { + for (const i of as(e) ? e : e.projects) + n(i, t); + !as(e) && e.symLinkedProjects && e.symLinkedProjects.forEach((i, s) => { + for (const o of i) + n(o, s); + }); + } + function mfe(e, t, n, i, s, o, c) { + const _ = /* @__PURE__ */ new Map(), u = JP(); + u.enqueue({ project: t, location: n }), DPe(e, n.fileName, (D, P) => { + const A = { fileName: P, pos: n.pos }; + u.enqueue({ project: D, location: A }); + }); + const g = t.projectService, m = t.getCancellationToken(), h = Uu( + () => t.isSourceOfProjectReferenceRedirect(i.fileName) ? i : t.getLanguageService().getSourceMapper().tryGetGeneratedPosition(i) + ), S = Uu( + () => t.isSourceOfProjectReferenceRedirect(i.fileName) ? i : t.getLanguageService().getSourceMapper().tryGetSourcePosition(i) + ), T = /* @__PURE__ */ new Set(); + e: + for (; !u.isEmpty(); ) { + for (; !u.isEmpty(); ) { + if (m.isCancellationRequested()) break e; + const { project: D, location: P } = u.dequeue(); + if (_.has(D) || NPe(D, P) || (Gp(D), !D.containsFile(ro(P.fileName)))) + continue; + const A = k(D, P); + _.set(D, A ?? bl), T.add(KKe(D)); + } + i && (g.loadAncestorProjectTree(T), g.forEachEnabledProject((D) => { + if (m.isCancellationRequested() || _.has(D)) return; + const P = s(i, D, h, S); + P && u.enqueue({ project: D, location: P }); + })); + } + if (_.size === 1) + return IR(_.values()); + return _; + function k(D, P) { + const A = o(D, P); + if (!A || !c) return A; + for (const O of A) + c(O, (F) => { + const R = g.getOriginalLocationEnsuringConfiguredProject(D, F); + if (!R) return; + const B = g.getScriptInfo(R.fileName); + for (const $ of B.containingProjects) + !$.isOrphan() && !_.has($) && u.enqueue({ project: $, location: R }); + const U = g.getSymlinkedProjects(B); + U && U.forEach(($, W) => { + for (const _e of $) + !_e.isOrphan() && !_.has(_e) && u.enqueue({ project: _e, location: { fileName: W, pos: R.pos } }); + }); + }); + return A; + } + } + function wPe(e, t) { + if (t.containsFile(ro(e.fileName)) && !NPe(t, e)) + return e; + } + function PPe(e, t, n, i) { + const s = wPe(e, t); + if (s) return s; + const o = n(); + if (o && t.containsFile(ro(o.fileName))) return o; + const c = i(); + return c && t.containsFile(ro(c.fileName)) ? c : void 0; + } + function NPe(e, t) { + if (!t) return !1; + const n = e.getLanguageService().getProgram(); + if (!n) return !1; + const i = n.getSourceFile(t.fileName); + return !!i && i.resolvedPath !== i.path && i.resolvedPath !== e.toPath(t.fileName); + } + function KKe(e) { + return L0(e) ? e.canonicalConfigFilePath : e.getProjectName(); + } + function Uw({ fileName: e, textSpan: t }) { + return { fileName: e, pos: t.start }; + } + function jG(e, t) { + return bw(e, t.getSourceMapper(), (n) => t.projectService.fileExists(n)); + } + function APe(e, t) { + return O9(e, t.getSourceMapper(), (n) => t.projectService.fileExists(n)); + } + function eet(e, t) { + return ZV(e, t.getSourceMapper(), (n) => t.projectService.fileExists(n)); + } + var IPe = [ + "openExternalProject", + "openExternalProjects", + "closeExternalProject", + "synchronizeProjectList", + "emit-output", + "compileOnSaveAffectedFileList", + "compileOnSaveEmitFile", + "compilerOptionsDiagnostics-full", + "encodedSemanticClassifications-full", + "semanticDiagnosticsSync", + "suggestionDiagnosticsSync", + "geterrForProject", + "reload", + "reloadProjects", + "getCodeFixes", + "getCodeFixes-full", + "getCombinedCodeFix", + "getCombinedCodeFix-full", + "applyCodeActionCommand", + "getSupportedCodeFixes", + "getApplicableRefactors", + "getMoveToRefactoringFileSuggestions", + "getEditsForRefactor", + "getEditsForRefactor-full", + "organizeImports", + "organizeImports-full", + "getEditsForFileRename", + "getEditsForFileRename-full", + "prepareCallHierarchy", + "provideCallHierarchyIncomingCalls", + "provideCallHierarchyOutgoingCalls", + "getPasteEdits", + "copilotRelated" + /* CopilotRelated */ + ], tet = [ + ...IPe, + "definition", + "definition-full", + "definitionAndBoundSpan", + "definitionAndBoundSpan-full", + "typeDefinition", + "implementation", + "implementation-full", + "references", + "references-full", + "rename", + "renameLocations-full", + "rename-full", + "quickinfo", + "quickinfo-full", + "completionInfo", + "completions", + "completions-full", + "completionEntryDetails", + "completionEntryDetails-full", + "signatureHelp", + "signatureHelp-full", + "navto", + "navto-full", + "documentHighlights", + "documentHighlights-full", + "preparePasteEdits" + /* PreparePasteEdits */ + ], FPe = class XX { + constructor(t) { + this.changeSeq = 0, this.regionDiagLineCountThreshold = 500, this.handlers = new Map(Object.entries({ + // TODO(jakebailey): correctly type the handlers + status: () => { + const o = { version: ep }; + return this.requiredResponse(o); + }, + openExternalProject: (o) => (this.projectService.openExternalProject( + o.arguments, + /*cleanupAfter*/ + !0 + ), this.requiredResponse( + /*response*/ + !0 + )), + openExternalProjects: (o) => (this.projectService.openExternalProjects(o.arguments.projects), this.requiredResponse( + /*response*/ + !0 + )), + closeExternalProject: (o) => (this.projectService.closeExternalProject( + o.arguments.projectFileName, + /*cleanupAfter*/ + !0 + ), this.requiredResponse( + /*response*/ + !0 + )), + synchronizeProjectList: (o) => { + const c = this.projectService.synchronizeProjectList(o.arguments.knownProjects, o.arguments.includeProjectReferenceRedirectInfo); + if (!c.some((u) => u.projectErrors && u.projectErrors.length !== 0)) + return this.requiredResponse(c); + const _ = hr(c, (u) => !u.projectErrors || u.projectErrors.length === 0 ? u : { + info: u.info, + changes: u.changes, + files: u.files, + projectErrors: this.convertToDiagnosticsWithLinePosition( + u.projectErrors, + /*scriptInfo*/ + void 0 + ) + }); + return this.requiredResponse(_); + }, + updateOpen: (o) => (this.changeSeq++, this.projectService.applyChangesInOpenFiles( + o.arguments.openFiles && ZE(o.arguments.openFiles, (c) => ({ + fileName: c.file, + content: c.fileContent, + scriptKind: c.scriptKindName, + projectRootPath: c.projectRootPath + })), + o.arguments.changedFiles && ZE(o.arguments.changedFiles, (c) => ({ + fileName: c.fileName, + changes: uy(NR(c.textChanges), (_) => { + const u = E.checkDefined(this.projectService.getScriptInfo(c.fileName)), g = u.lineOffsetToPosition(_.start.line, _.start.offset), m = u.lineOffsetToPosition(_.end.line, _.end.offset); + return g >= 0 ? { span: { start: g, length: m - g }, newText: _.newText } : void 0; + }) + })), + o.arguments.closedFiles + ), this.requiredResponse( + /*response*/ + !0 + )), + applyChangedToOpenFiles: (o) => (this.changeSeq++, this.projectService.applyChangesInOpenFiles( + o.arguments.openFiles, + o.arguments.changedFiles && ZE(o.arguments.changedFiles, (c) => ({ + fileName: c.fileName, + // apply changes in reverse order + changes: NR(c.changes) + })), + o.arguments.closedFiles + ), this.requiredResponse( + /*response*/ + !0 + )), + exit: () => (this.exit(), this.notRequired( + /*request*/ + void 0 + )), + definition: (o) => this.requiredResponse(this.getDefinition( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "definition-full": (o) => this.requiredResponse(this.getDefinition( + o.arguments, + /*simplifiedResult*/ + !1 + )), + definitionAndBoundSpan: (o) => this.requiredResponse(this.getDefinitionAndBoundSpan( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "definitionAndBoundSpan-full": (o) => this.requiredResponse(this.getDefinitionAndBoundSpan( + o.arguments, + /*simplifiedResult*/ + !1 + )), + findSourceDefinition: (o) => this.requiredResponse(this.findSourceDefinition(o.arguments)), + "emit-output": (o) => this.requiredResponse(this.getEmitOutput(o.arguments)), + typeDefinition: (o) => this.requiredResponse(this.getTypeDefinition(o.arguments)), + implementation: (o) => this.requiredResponse(this.getImplementation( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "implementation-full": (o) => this.requiredResponse(this.getImplementation( + o.arguments, + /*simplifiedResult*/ + !1 + )), + references: (o) => this.requiredResponse(this.getReferences( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "references-full": (o) => this.requiredResponse(this.getReferences( + o.arguments, + /*simplifiedResult*/ + !1 + )), + rename: (o) => this.requiredResponse(this.getRenameLocations( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "renameLocations-full": (o) => this.requiredResponse(this.getRenameLocations( + o.arguments, + /*simplifiedResult*/ + !1 + )), + "rename-full": (o) => this.requiredResponse(this.getRenameInfo(o.arguments)), + open: (o) => (this.openClientFile( + ro(o.arguments.file), + o.arguments.fileContent, + NG(o.arguments.scriptKindName), + // TODO: GH#18217 + o.arguments.projectRootPath ? ro(o.arguments.projectRootPath) : void 0 + ), this.notRequired(o)), + quickinfo: (o) => this.requiredResponse(this.getQuickInfoWorker( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "quickinfo-full": (o) => this.requiredResponse(this.getQuickInfoWorker( + o.arguments, + /*simplifiedResult*/ + !1 + )), + getOutliningSpans: (o) => this.requiredResponse(this.getOutliningSpans( + o.arguments, + /*simplifiedResult*/ + !0 + )), + outliningSpans: (o) => this.requiredResponse(this.getOutliningSpans( + o.arguments, + /*simplifiedResult*/ + !1 + )), + todoComments: (o) => this.requiredResponse(this.getTodoComments(o.arguments)), + indentation: (o) => this.requiredResponse(this.getIndentation(o.arguments)), + nameOrDottedNameSpan: (o) => this.requiredResponse(this.getNameOrDottedNameSpan(o.arguments)), + breakpointStatement: (o) => this.requiredResponse(this.getBreakpointStatement(o.arguments)), + braceCompletion: (o) => this.requiredResponse(this.isValidBraceCompletion(o.arguments)), + docCommentTemplate: (o) => this.requiredResponse(this.getDocCommentTemplate(o.arguments)), + getSpanOfEnclosingComment: (o) => this.requiredResponse(this.getSpanOfEnclosingComment(o.arguments)), + fileReferences: (o) => this.requiredResponse(this.getFileReferences( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "fileReferences-full": (o) => this.requiredResponse(this.getFileReferences( + o.arguments, + /*simplifiedResult*/ + !1 + )), + format: (o) => this.requiredResponse(this.getFormattingEditsForRange(o.arguments)), + formatonkey: (o) => this.requiredResponse(this.getFormattingEditsAfterKeystroke(o.arguments)), + "format-full": (o) => this.requiredResponse(this.getFormattingEditsForDocumentFull(o.arguments)), + "formatonkey-full": (o) => this.requiredResponse(this.getFormattingEditsAfterKeystrokeFull(o.arguments)), + "formatRange-full": (o) => this.requiredResponse(this.getFormattingEditsForRangeFull(o.arguments)), + completionInfo: (o) => this.requiredResponse(this.getCompletions( + o.arguments, + "completionInfo" + /* CompletionInfo */ + )), + completions: (o) => this.requiredResponse(this.getCompletions( + o.arguments, + "completions" + /* Completions */ + )), + "completions-full": (o) => this.requiredResponse(this.getCompletions( + o.arguments, + "completions-full" + /* CompletionsFull */ + )), + completionEntryDetails: (o) => this.requiredResponse(this.getCompletionEntryDetails( + o.arguments, + /*fullResult*/ + !1 + )), + "completionEntryDetails-full": (o) => this.requiredResponse(this.getCompletionEntryDetails( + o.arguments, + /*fullResult*/ + !0 + )), + compileOnSaveAffectedFileList: (o) => this.requiredResponse(this.getCompileOnSaveAffectedFileList(o.arguments)), + compileOnSaveEmitFile: (o) => this.requiredResponse(this.emitFile(o.arguments)), + signatureHelp: (o) => this.requiredResponse(this.getSignatureHelpItems( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "signatureHelp-full": (o) => this.requiredResponse(this.getSignatureHelpItems( + o.arguments, + /*simplifiedResult*/ + !1 + )), + "compilerOptionsDiagnostics-full": (o) => this.requiredResponse(this.getCompilerOptionsDiagnostics(o.arguments)), + "encodedSyntacticClassifications-full": (o) => this.requiredResponse(this.getEncodedSyntacticClassifications(o.arguments)), + "encodedSemanticClassifications-full": (o) => this.requiredResponse(this.getEncodedSemanticClassifications(o.arguments)), + cleanup: () => (this.cleanup(), this.requiredResponse( + /*response*/ + !0 + )), + semanticDiagnosticsSync: (o) => this.requiredResponse(this.getSemanticDiagnosticsSync(o.arguments)), + syntacticDiagnosticsSync: (o) => this.requiredResponse(this.getSyntacticDiagnosticsSync(o.arguments)), + suggestionDiagnosticsSync: (o) => this.requiredResponse(this.getSuggestionDiagnosticsSync(o.arguments)), + geterr: (o) => (this.errorCheck.startNew((c) => this.getDiagnostics(c, o.arguments.delay, o.arguments.files)), this.notRequired( + /*request*/ + void 0 + )), + geterrForProject: (o) => (this.errorCheck.startNew((c) => this.getDiagnosticsForProject(c, o.arguments.delay, o.arguments.file)), this.notRequired( + /*request*/ + void 0 + )), + change: (o) => (this.change(o.arguments), this.notRequired(o)), + configure: (o) => (this.projectService.setHostConfiguration(o.arguments), this.notRequired(o)), + reload: (o) => (this.reload(o.arguments), this.requiredResponse({ reloadFinished: !0 })), + saveto: (o) => { + const c = o.arguments; + return this.saveToTmp(c.file, c.tmpfile), this.notRequired(o); + }, + close: (o) => { + const c = o.arguments; + return this.closeClientFile(c.file), this.notRequired(o); + }, + navto: (o) => this.requiredResponse(this.getNavigateToItems( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "navto-full": (o) => this.requiredResponse(this.getNavigateToItems( + o.arguments, + /*simplifiedResult*/ + !1 + )), + brace: (o) => this.requiredResponse(this.getBraceMatching( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "brace-full": (o) => this.requiredResponse(this.getBraceMatching( + o.arguments, + /*simplifiedResult*/ + !1 + )), + navbar: (o) => this.requiredResponse(this.getNavigationBarItems( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "navbar-full": (o) => this.requiredResponse(this.getNavigationBarItems( + o.arguments, + /*simplifiedResult*/ + !1 + )), + navtree: (o) => this.requiredResponse(this.getNavigationTree( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "navtree-full": (o) => this.requiredResponse(this.getNavigationTree( + o.arguments, + /*simplifiedResult*/ + !1 + )), + documentHighlights: (o) => this.requiredResponse(this.getDocumentHighlights( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "documentHighlights-full": (o) => this.requiredResponse(this.getDocumentHighlights( + o.arguments, + /*simplifiedResult*/ + !1 + )), + compilerOptionsForInferredProjects: (o) => (this.setCompilerOptionsForInferredProjects(o.arguments), this.requiredResponse( + /*response*/ + !0 + )), + projectInfo: (o) => this.requiredResponse(this.getProjectInfo(o.arguments)), + reloadProjects: (o) => (this.projectService.reloadProjects(), this.notRequired(o)), + jsxClosingTag: (o) => this.requiredResponse(this.getJsxClosingTag(o.arguments)), + linkedEditingRange: (o) => this.requiredResponse(this.getLinkedEditingRange(o.arguments)), + getCodeFixes: (o) => this.requiredResponse(this.getCodeFixes( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "getCodeFixes-full": (o) => this.requiredResponse(this.getCodeFixes( + o.arguments, + /*simplifiedResult*/ + !1 + )), + getCombinedCodeFix: (o) => this.requiredResponse(this.getCombinedCodeFix( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "getCombinedCodeFix-full": (o) => this.requiredResponse(this.getCombinedCodeFix( + o.arguments, + /*simplifiedResult*/ + !1 + )), + applyCodeActionCommand: (o) => this.requiredResponse(this.applyCodeActionCommand(o.arguments)), + getSupportedCodeFixes: (o) => this.requiredResponse(this.getSupportedCodeFixes(o.arguments)), + getApplicableRefactors: (o) => this.requiredResponse(this.getApplicableRefactors(o.arguments)), + getEditsForRefactor: (o) => this.requiredResponse(this.getEditsForRefactor( + o.arguments, + /*simplifiedResult*/ + !0 + )), + getMoveToRefactoringFileSuggestions: (o) => this.requiredResponse(this.getMoveToRefactoringFileSuggestions(o.arguments)), + preparePasteEdits: (o) => this.requiredResponse(this.preparePasteEdits(o.arguments)), + getPasteEdits: (o) => this.requiredResponse(this.getPasteEdits(o.arguments)), + "getEditsForRefactor-full": (o) => this.requiredResponse(this.getEditsForRefactor( + o.arguments, + /*simplifiedResult*/ + !1 + )), + organizeImports: (o) => this.requiredResponse(this.organizeImports( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "organizeImports-full": (o) => this.requiredResponse(this.organizeImports( + o.arguments, + /*simplifiedResult*/ + !1 + )), + getEditsForFileRename: (o) => this.requiredResponse(this.getEditsForFileRename( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "getEditsForFileRename-full": (o) => this.requiredResponse(this.getEditsForFileRename( + o.arguments, + /*simplifiedResult*/ + !1 + )), + configurePlugin: (o) => (this.configurePlugin(o.arguments), this.notRequired(o)), + selectionRange: (o) => this.requiredResponse(this.getSmartSelectionRange( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "selectionRange-full": (o) => this.requiredResponse(this.getSmartSelectionRange( + o.arguments, + /*simplifiedResult*/ + !1 + )), + prepareCallHierarchy: (o) => this.requiredResponse(this.prepareCallHierarchy(o.arguments)), + provideCallHierarchyIncomingCalls: (o) => this.requiredResponse(this.provideCallHierarchyIncomingCalls(o.arguments)), + provideCallHierarchyOutgoingCalls: (o) => this.requiredResponse(this.provideCallHierarchyOutgoingCalls(o.arguments)), + toggleLineComment: (o) => this.requiredResponse(this.toggleLineComment( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "toggleLineComment-full": (o) => this.requiredResponse(this.toggleLineComment( + o.arguments, + /*simplifiedResult*/ + !1 + )), + toggleMultilineComment: (o) => this.requiredResponse(this.toggleMultilineComment( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "toggleMultilineComment-full": (o) => this.requiredResponse(this.toggleMultilineComment( + o.arguments, + /*simplifiedResult*/ + !1 + )), + commentSelection: (o) => this.requiredResponse(this.commentSelection( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "commentSelection-full": (o) => this.requiredResponse(this.commentSelection( + o.arguments, + /*simplifiedResult*/ + !1 + )), + uncommentSelection: (o) => this.requiredResponse(this.uncommentSelection( + o.arguments, + /*simplifiedResult*/ + !0 + )), + "uncommentSelection-full": (o) => this.requiredResponse(this.uncommentSelection( + o.arguments, + /*simplifiedResult*/ + !1 + )), + provideInlayHints: (o) => this.requiredResponse(this.provideInlayHints(o.arguments)), + mapCode: (o) => this.requiredResponse(this.mapCode(o.arguments)), + copilotRelated: () => this.requiredResponse(this.getCopilotRelatedInfo()) + })), this.host = t.host, this.cancellationToken = t.cancellationToken, this.typingsInstaller = t.typingsInstaller || UL, this.byteLength = t.byteLength, this.hrtime = t.hrtime, this.logger = t.logger, this.canUseEvents = t.canUseEvents, this.suppressDiagnosticEvents = t.suppressDiagnosticEvents, this.noGetErrOnBackgroundUpdate = t.noGetErrOnBackgroundUpdate; + const { throttleWaitMilliseconds: n } = t; + this.eventHandler = this.canUseEvents ? t.eventHandler || ((o) => this.defaultEventHandler(o)) : void 0; + const i = { + executeWithRequestId: (o, c, _) => this.executeWithRequestId(o, c, _), + getCurrentRequestId: () => this.currentRequestId, + getPerformanceData: () => this.performanceData, + getServerHost: () => this.host, + logError: (o, c) => this.logError(o, c), + sendRequestCompletedEvent: (o, c) => this.sendRequestCompletedEvent(o, c), + isCancellationRequested: () => this.cancellationToken.isCancellationRequested() + }; + this.errorCheck = new XKe(i); + const s = { + host: this.host, + logger: this.logger, + cancellationToken: this.cancellationToken, + useSingleInferredProject: t.useSingleInferredProject, + useInferredProjectPerProjectRoot: t.useInferredProjectPerProjectRoot, + typingsInstaller: this.typingsInstaller, + throttleWaitMilliseconds: n, + eventHandler: this.eventHandler, + suppressDiagnosticEvents: this.suppressDiagnosticEvents, + globalPlugins: t.globalPlugins, + pluginProbeLocations: t.pluginProbeLocations, + allowLocalPluginLoads: t.allowLocalPluginLoads, + typesMapLocation: t.typesMapLocation, + serverMode: t.serverMode, + session: this, + canUseWatchEvents: t.canUseWatchEvents, + incrementalVerifier: t.incrementalVerifier + }; + switch (this.projectService = new cfe(s), this.projectService.setPerformanceEventHandler(this.performanceEventHandler.bind(this)), this.gcTimer = new I_e( + this.host, + /*delay*/ + 7e3, + this.logger + ), this.projectService.serverMode) { + case 0: + break; + case 1: + IPe.forEach( + (o) => this.handlers.set(o, (c) => { + throw new Error(`Request: ${c.command} not allowed in LanguageServiceMode.PartialSemantic`); + }) + ); + break; + case 2: + tet.forEach( + (o) => this.handlers.set(o, (c) => { + throw new Error(`Request: ${c.command} not allowed in LanguageServiceMode.Syntactic`); + }) + ); + break; + default: + E.assertNever(this.projectService.serverMode); + } + } + sendRequestCompletedEvent(t, n) { + this.event( + { + request_seq: t, + performanceData: n && OPe(n) + }, + "requestCompleted" + ); + } + addPerformanceData(t, n) { + this.performanceData || (this.performanceData = {}), this.performanceData[t] = (this.performanceData[t] ?? 0) + n; + } + addDiagnosticsPerformanceData(t, n, i) { + var s, o; + this.performanceData || (this.performanceData = {}); + let c = (s = this.performanceData.diagnosticsDuration) == null ? void 0 : s.get(t); + c || ((o = this.performanceData).diagnosticsDuration ?? (o.diagnosticsDuration = /* @__PURE__ */ new Map())).set(t, c = {}), c[n] = i; + } + performanceEventHandler(t) { + switch (t.kind) { + case "UpdateGraph": + this.addPerformanceData("updateGraphDurationMs", t.durationMs); + break; + case "CreatePackageJsonAutoImportProvider": + this.addPerformanceData("createAutoImportProviderProgramDurationMs", t.durationMs); + break; + } + } + defaultEventHandler(t) { + switch (t.eventName) { + case zL: + this.projectsUpdatedInBackgroundEvent(t.data.openFiles); + break; + case bG: + this.event({ + projectName: t.data.project.getProjectName(), + reason: t.data.reason + }, t.eventName); + break; + case SG: + this.event({ + projectName: t.data.project.getProjectName() + }, t.eventName); + break; + case TG: + case EG: + case DG: + case wG: + this.event(t.data, t.eventName); + break; + case xG: + this.event({ + triggerFile: t.data.triggerFile, + configFile: t.data.configFileName, + diagnostics: hr(t.data.diagnostics, (n) => z8( + n, + /*includeFileName*/ + !0 + )) + }, t.eventName); + break; + case kG: { + this.event({ + projectName: t.data.project.getProjectName(), + languageServiceEnabled: t.data.languageServiceEnabled + }, t.eventName); + break; + } + case CG: { + this.event({ + telemetryEventName: t.eventName, + payload: t.data + }, "telemetry"); + break; + } + } + } + projectsUpdatedInBackgroundEvent(t) { + this.projectService.logger.info(`got projects updated in background ${t}`), t.length && (!this.suppressDiagnosticEvents && !this.noGetErrOnBackgroundUpdate && (this.projectService.logger.info(`Queueing diagnostics update for ${t}`), this.errorCheck.startNew((n) => this.updateErrorCheck( + n, + t, + 100, + /*requireOpen*/ + !0 + ))), this.event({ + openFiles: t + }, zL)); + } + logError(t, n) { + this.logErrorWorker(t, n); + } + logErrorWorker(t, n, i) { + let s = "Exception on executing command " + n; + if (t.message && (s += `: +` + pw(t.message), t.stack && (s += ` +` + pw(t.stack))), this.logger.hasLevel( + 3 + /* verbose */ + )) { + if (i) + try { + const { file: o, project: c } = this.getFileAndProject(i), _ = c.getScriptInfoForNormalizedPath(o); + if (_) { + const u = fk(_.getSnapshot()); + s += ` + +File text of ${i.file}:${pw(u)} +`; + } + } catch { + } + if (t.ProgramFiles) { + s += ` + +Program files: ${JSON.stringify(t.ProgramFiles)} +`, s += ` + +Projects:: +`; + let o = 0; + const c = (_) => { + s += ` +Project '${_.projectName}' (${Ww[_.projectKind]}) ${o} +`, s += _.filesToString( + /*writeProjectFileNames*/ + !0 + ), s += ` +----------------------------------------------- +`, o++; + }; + this.projectService.externalProjects.forEach(c), this.projectService.configuredProjects.forEach(c), this.projectService.inferredProjects.forEach(c); + } + } + this.logger.msg( + s, + "Err" + /* Err */ + ); + } + send(t) { + if (t.type === "event" && !this.canUseEvents) { + this.logger.hasLevel( + 3 + /* verbose */ + ) && this.logger.info(`Session does not support events: ignored event: ${vv(t)}`); + return; + } + this.writeMessage(t); + } + writeMessage(t) { + const n = pfe(t, this.logger, this.byteLength, this.host.newLine); + this.host.write(n); + } + event(t, n) { + this.send(dfe(n, t)); + } + /** @internal */ + doOutput(t, n, i, s, o, c) { + const _ = { + seq: 0, + type: "response", + command: n, + request_seq: i, + success: s, + performanceData: o && OPe(o) + }; + if (s) { + let u; + if (as(t)) + _.body = t, u = t.metadata, delete t.metadata; + else if (typeof t == "object") + if (t.metadata) { + const { metadata: g, ...m } = t; + _.body = m, u = g; + } else + _.body = t; + else + _.body = t; + u && (_.metadata = u); + } else + E.assert(t === void 0); + c && (_.message = c), this.send(_); + } + semanticCheck(t, n) { + var i, s; + const o = ao(); + (i = on) == null || i.push(on.Phase.Session, "semanticCheck", { file: t, configFilePath: n.canonicalConfigFilePath }); + const c = xPe(n, t) ? bl : n.getLanguageService().getSemanticDiagnostics(t).filter((_) => !!_.file); + this.sendDiagnosticsEvent(t, n, c, "semanticDiag", o), (s = on) == null || s.pop(); + } + syntacticCheck(t, n) { + var i, s; + const o = ao(); + (i = on) == null || i.push(on.Phase.Session, "syntacticCheck", { file: t, configFilePath: n.canonicalConfigFilePath }), this.sendDiagnosticsEvent(t, n, n.getLanguageService().getSyntacticDiagnostics(t), "syntaxDiag", o), (s = on) == null || s.pop(); + } + suggestionCheck(t, n) { + var i, s; + const o = ao(); + (i = on) == null || i.push(on.Phase.Session, "suggestionCheck", { file: t, configFilePath: n.canonicalConfigFilePath }), this.sendDiagnosticsEvent(t, n, n.getLanguageService().getSuggestionDiagnostics(t), "suggestionDiag", o), (s = on) == null || s.pop(); + } + regionSemanticCheck(t, n, i) { + var s, o, c; + const _ = ao(); + (s = on) == null || s.push(on.Phase.Session, "regionSemanticCheck", { file: t, configFilePath: n.canonicalConfigFilePath }); + let u; + if (!this.shouldDoRegionCheck(t) || !(u = n.getLanguageService().getRegionSemanticDiagnostics(t, i))) { + (o = on) == null || o.pop(); + return; + } + this.sendDiagnosticsEvent(t, n, u.diagnostics, "regionSemanticDiag", _, u.spans), (c = on) == null || c.pop(); + } + // We should only do the region-based semantic check if we think it would be + // considerably faster than a whole-file semantic check. + /** @internal */ + shouldDoRegionCheck(t) { + var n; + const i = (n = this.projectService.getScriptInfoForNormalizedPath(t)) == null ? void 0 : n.textStorage.getLineInfo().getLineCount(); + return !!(i && i >= this.regionDiagLineCountThreshold); + } + sendDiagnosticsEvent(t, n, i, s, o, c) { + try { + const _ = E.checkDefined(n.getScriptInfo(t)), u = ao() - o, g = { + file: t, + diagnostics: i.map((m) => kPe(t, n, m)), + spans: c?.map((m) => Pm(m, _)) + }; + this.event( + g, + s + ), this.addDiagnosticsPerformanceData(t, s, u); + } catch (_) { + this.logError(_, s); + } + } + /** It is the caller's responsibility to verify that `!this.suppressDiagnosticEvents`. */ + updateErrorCheck(t, n, i, s = !0) { + if (n.length === 0) + return; + E.assert(!this.suppressDiagnosticEvents); + const o = this.changeSeq, c = Math.min(i, 200); + let _ = 0; + const u = () => { + if (_++, n.length > _) + return t.delay("checkOne", c, m); + }, g = (h, S) => { + if (this.semanticCheck(h, S), this.changeSeq === o) { + if (this.getPreferences(h).disableSuggestions) + return u(); + t.immediate("suggestionCheck", () => { + this.suggestionCheck(h, S), u(); + }); + } + }, m = () => { + if (this.changeSeq !== o) + return; + let h, S = n[_]; + if (gs(S) ? S = this.toPendingErrorCheck(S) : "ranges" in S && (h = S.ranges, S = this.toPendingErrorCheck(S.file)), !S) + return u(); + const { fileName: T, project: k } = S; + if (Gp(k), !!k.containsFile(T, s) && (this.syntacticCheck(T, k), this.changeSeq === o)) { + if (k.projectService.serverMode !== 0) + return u(); + if (h) + return t.immediate("regionSemanticCheck", () => { + const D = this.projectService.getScriptInfoForNormalizedPath(T); + D && this.regionSemanticCheck(T, k, h.map((P) => this.getRange({ file: T, ...P }, D))), this.changeSeq === o && t.immediate("semanticCheck", () => g(T, k)); + }); + t.immediate("semanticCheck", () => g(T, k)); + } + }; + n.length > _ && this.changeSeq === o && t.delay("checkOne", i, m); + } + cleanProjects(t, n) { + if (n) { + this.logger.info(`cleaning ${t}`); + for (const i of n) + i.getLanguageService( + /*ensureSynchronized*/ + !1 + ).cleanupSemanticCache(), i.cleanupProgram(); + } + } + cleanup() { + this.cleanProjects("inferred projects", this.projectService.inferredProjects), this.cleanProjects("configured projects", is(this.projectService.configuredProjects.values())), this.cleanProjects("external projects", this.projectService.externalProjects), this.host.gc && (this.logger.info("host.gc()"), this.host.gc()); + } + getEncodedSyntacticClassifications(t) { + const { file: n, languageService: i } = this.getFileAndLanguageServiceForSyntacticOperation(t); + return i.getEncodedSyntacticClassifications(n, t); + } + getEncodedSemanticClassifications(t) { + const { file: n, project: i } = this.getFileAndProject(t), s = t.format === "2020" ? "2020" : "original"; + return i.getLanguageService().getEncodedSemanticClassifications(n, t, s); + } + getProject(t) { + return t === void 0 ? void 0 : this.projectService.findProject(t); + } + getConfigFileAndProject(t) { + const n = this.getProject(t.projectFileName), i = ro(t.file); + return { + configFile: n && n.hasConfigFile(i) ? i : void 0, + project: n + }; + } + getConfigFileDiagnostics(t, n, i) { + const s = n.getAllProjectErrors(), o = n.getLanguageService().getCompilerOptionsDiagnostics(), c = kn( + Bi(s, o), + (_) => !!_.file && _.file.fileName === t + ); + return i ? this.convertToDiagnosticsWithLinePositionFromDiagnosticFile(c) : hr( + c, + (_) => z8( + _, + /*includeFileName*/ + !1 + ) + ); + } + convertToDiagnosticsWithLinePositionFromDiagnosticFile(t) { + return t.map((n) => ({ + message: km(n.messageText, this.host.newLine), + start: n.start, + // TODO: GH#18217 + length: n.length, + // TODO: GH#18217 + category: $2(n), + code: n.code, + source: n.source, + startLocation: n.file && uE(js(n.file, n.start)), + // TODO: GH#18217 + endLocation: n.file && uE(js(n.file, n.start + n.length)), + // TODO: GH#18217 + reportsUnnecessary: n.reportsUnnecessary, + reportsDeprecated: n.reportsDeprecated, + relatedInformation: hr(n.relatedInformation, MG) + })); + } + getCompilerOptionsDiagnostics(t) { + const n = this.getProject(t.projectFileName); + return this.convertToDiagnosticsWithLinePosition( + kn( + n.getLanguageService().getCompilerOptionsDiagnostics(), + (i) => !i.file + ), + /*scriptInfo*/ + void 0 + ); + } + convertToDiagnosticsWithLinePosition(t, n) { + return t.map( + (i) => ({ + message: km(i.messageText, this.host.newLine), + start: i.start, + length: i.length, + category: $2(i), + code: i.code, + source: i.source, + startLocation: n && n.positionToLineOffset(i.start), + // TODO: GH#18217 + endLocation: n && n.positionToLineOffset(i.start + i.length), + reportsUnnecessary: i.reportsUnnecessary, + reportsDeprecated: i.reportsDeprecated, + relatedInformation: hr(i.relatedInformation, MG) + }) + ); + } + getDiagnosticsWorker(t, n, i, s) { + const { project: o, file: c } = this.getFileAndProject(t); + if (n && xPe(o, c)) + return bl; + const _ = o.getScriptInfoForNormalizedPath(c), u = i(o, c); + return s ? this.convertToDiagnosticsWithLinePosition(u, _) : u.map((g) => kPe(c, o, g)); + } + getDefinition(t, n) { + const { file: i, project: s } = this.getFileAndProject(t), o = this.getPositionInFile(t, i), c = this.mapDefinitionInfoLocations(s.getLanguageService().getDefinitionAtPosition(i, o) || bl, s); + return n ? this.mapDefinitionInfo(c, s) : c.map(XX.mapToOriginalLocation); + } + mapDefinitionInfoLocations(t, n) { + return t.map((i) => { + const s = APe(i, n); + return s ? { + ...s, + containerKind: i.containerKind, + containerName: i.containerName, + kind: i.kind, + name: i.name, + failedAliasResolution: i.failedAliasResolution, + ...i.unverified && { unverified: i.unverified } + } : i; + }); + } + getDefinitionAndBoundSpan(t, n) { + const { file: i, project: s } = this.getFileAndProject(t), o = this.getPositionInFile(t, i), c = E.checkDefined(s.getScriptInfo(i)), _ = s.getLanguageService().getDefinitionAndBoundSpan(i, o); + if (!_ || !_.definitions) + return { + definitions: bl, + textSpan: void 0 + // TODO: GH#18217 + }; + const u = this.mapDefinitionInfoLocations(_.definitions, s), { textSpan: g } = _; + return n ? { + definitions: this.mapDefinitionInfo(u, s), + textSpan: Pm(g, c) + } : { + definitions: u.map(XX.mapToOriginalLocation), + textSpan: g + }; + } + findSourceDefinition(t) { + var n; + const { file: i, project: s } = this.getFileAndProject(t), o = this.getPositionInFile(t, i), c = s.getLanguageService().getDefinitionAtPosition(i, o); + let _ = this.mapDefinitionInfoLocations(c || bl, s).slice(); + if (this.projectService.serverMode === 0 && (!ot(_, (T) => ro(T.fileName) !== i && !T.isAmbient) || ot(_, (T) => !!T.failedAliasResolution))) { + const T = jR( + (A) => A.textSpan.start, + QV(this.host.useCaseSensitiveFileNames) + ); + _?.forEach((A) => T.add(A)); + const k = s.getNoDtsResolutionProject(i), D = k.getLanguageService(), P = (n = D.getDefinitionAtPosition( + i, + o, + /*searchOtherFilesOnly*/ + !0, + /*stopAtAlias*/ + !1 + )) == null ? void 0 : n.filter((A) => ro(A.fileName) !== i); + if (ot(P)) + for (const A of P) { + if (A.unverified) { + const O = h(A, s.getLanguageService().getProgram(), D.getProgram()); + if (ot(O)) { + for (const F of O) + T.add(F); + continue; + } + } + T.add(A); + } + else { + const A = _.filter((O) => ro(O.fileName) !== i && O.isAmbient); + for (const O of ot(A) ? A : m()) { + const F = g(O.fileName, i, k); + if (!F) continue; + const R = this.projectService.getOrCreateScriptInfoNotOpenedByClient( + F, + k.currentDirectory, + k.directoryStructureHost, + /*deferredDeleteOk*/ + !1 + ); + if (!R) continue; + k.containsScriptInfo(R) || (k.addRoot(R), k.updateGraph()); + const B = D.getProgram(), U = E.checkDefined(B.getSourceFile(F)); + for (const $ of S(O.name, U, B)) + T.add($); + } + } + _ = is(T.values()); + } + return _ = _.filter((T) => !T.isAmbient && !T.failedAliasResolution), this.mapDefinitionInfo(_, s); + function g(T, k, D) { + var P, A, O; + const F = oF(T); + if (F && T.lastIndexOf(qg) === F.topLevelNodeModulesIndex) { + const R = T.substring(0, F.packageRootIndex), B = (P = s.getModuleResolutionCache()) == null ? void 0 : P.getPackageJsonInfoCache(), U = s.getCompilationSettings(), $ = $4(Qi(R, s.getCurrentDirectory()), G4(B, s, U)); + if (!$) return; + const W = yW( + $, + { + moduleResolution: 2 + /* Node10 */ + }, + s, + s.getModuleResolutionCache() + ), _e = T.substring( + F.topLevelPackageNameIndex + 1, + F.packageRootIndex + ), K = X4(_A(_e)), V = s.toPath(T); + if (W && ot(W, (ae) => s.toPath(ae) === V)) + return (A = D.resolutionCache.resolveSingleModuleNameWithoutWatching(K, k).resolvedModule) == null ? void 0 : A.resolvedFileName; + { + const ae = T.substring(F.packageRootIndex + 1), se = `${K}/${Gu(ae)}`; + return (O = D.resolutionCache.resolveSingleModuleNameWithoutWatching(se, k).resolvedModule) == null ? void 0 : O.resolvedFileName; + } + } + } + function m() { + const T = s.getLanguageService(), k = T.getProgram(), D = w_(k.getSourceFile(i), o); + return (ja(D) || Me(D)) && To(D.parent) && yee(D, (P) => { + var A; + if (P === D) return; + const O = (A = T.getDefinitionAtPosition( + i, + P.getStart(), + /*searchOtherFilesOnly*/ + !0, + /*stopAtAlias*/ + !1 + )) == null ? void 0 : A.filter((F) => ro(F.fileName) !== i && F.isAmbient).map((F) => ({ + fileName: F.fileName, + name: op(D) + })); + if (ot(O)) + return O; + }) || bl; + } + function h(T, k, D) { + var P; + const A = D.getSourceFile(T.fileName); + if (!A) + return; + const O = w_(k.getSourceFile(i), o), F = k.getTypeChecker().getSymbolAtLocation(O), R = F && Oo( + F, + 277 + /* ImportSpecifier */ + ); + if (!R) return; + const B = ((P = R.propertyName) == null ? void 0 : P.text) || R.name.text; + return S(B, A, D); + } + function S(T, k, D) { + const P = ko.Core.getTopMostDeclarationNamesInFile(T, k); + return Fi(P, (A) => { + const O = D.getTypeChecker().getSymbolAtLocation(A), F = qD(A); + if (O && F) + return sE.createDefinitionInfo( + F, + D.getTypeChecker(), + O, + F, + /*unverified*/ + !0 + ); + }); + } + } + getEmitOutput(t) { + const { file: n, project: i } = this.getFileAndProject(t); + if (!i.shouldEmitFile(i.getScriptInfo(n))) + return { emitSkipped: !0, outputFiles: [], diagnostics: [] }; + const s = i.getLanguageService().getEmitOutput(n); + return t.richResponse ? { + ...s, + diagnostics: t.includeLinePosition ? this.convertToDiagnosticsWithLinePositionFromDiagnosticFile(s.diagnostics) : s.diagnostics.map((o) => z8( + o, + /*includeFileName*/ + !0 + )) + } : s; + } + mapJSDocTagInfo(t, n, i) { + return t ? t.map((s) => { + var o; + return { + ...s, + text: i ? this.mapDisplayParts(s.text, n) : (o = s.text) == null ? void 0 : o.map((c) => c.text).join("") + }; + }) : []; + } + mapDisplayParts(t, n) { + return t ? t.map( + (i) => i.kind !== "linkName" ? i : { + ...i, + target: this.toFileSpan(i.target.fileName, i.target.textSpan, n) + } + ) : []; + } + mapSignatureHelpItems(t, n, i) { + return t.map((s) => ({ + ...s, + documentation: this.mapDisplayParts(s.documentation, n), + parameters: s.parameters.map((o) => ({ ...o, documentation: this.mapDisplayParts(o.documentation, n) })), + tags: this.mapJSDocTagInfo(s.tags, n, i) + })); + } + mapDefinitionInfo(t, n) { + return t.map((i) => ({ ...this.toFileSpanWithContext(i.fileName, i.textSpan, i.contextSpan, n), ...i.unverified && { unverified: i.unverified } })); + } + /* + * When we map a .d.ts location to .ts, Visual Studio gets confused because there's no associated Roslyn Document in + * the same project which corresponds to the file. VS Code has no problem with this, and luckily we have two protocols. + * This retains the existing behavior for the "simplified" (VS Code) protocol but stores the .d.ts location in a + * set of additional fields, and does the reverse for VS (store the .d.ts location where + * it used to be and stores the .ts location in the additional fields). + */ + static mapToOriginalLocation(t) { + return t.originalFileName ? (E.assert(t.originalTextSpan !== void 0, "originalTextSpan should be present if originalFileName is"), { + ...t, + fileName: t.originalFileName, + textSpan: t.originalTextSpan, + targetFileName: t.fileName, + targetTextSpan: t.textSpan, + contextSpan: t.originalContextSpan, + targetContextSpan: t.contextSpan + }) : t; + } + toFileSpan(t, n, i) { + const s = i.getLanguageService(), o = s.toLineColumnOffset(t, n.start), c = s.toLineColumnOffset(t, ec(n)); + return { + file: t, + start: { line: o.line + 1, offset: o.character + 1 }, + end: { line: c.line + 1, offset: c.character + 1 } + }; + } + toFileSpanWithContext(t, n, i, s) { + const o = this.toFileSpan(t, n, s), c = i && this.toFileSpan(t, i, s); + return c ? { ...o, contextStart: c.start, contextEnd: c.end } : o; + } + getTypeDefinition(t) { + const { file: n, project: i } = this.getFileAndProject(t), s = this.getPositionInFile(t, n), o = this.mapDefinitionInfoLocations(i.getLanguageService().getTypeDefinitionAtPosition(n, s) || bl, i); + return this.mapDefinitionInfo(o, i); + } + mapImplementationLocations(t, n) { + return t.map((i) => { + const s = APe(i, n); + return s ? { + ...s, + kind: i.kind, + displayParts: i.displayParts + } : i; + }); + } + getImplementation(t, n) { + const { file: i, project: s } = this.getFileAndProject(t), o = this.getPositionInFile(t, i), c = this.mapImplementationLocations(s.getLanguageService().getImplementationAtPosition(i, o) || bl, s); + return n ? c.map(({ fileName: _, textSpan: u, contextSpan: g }) => this.toFileSpanWithContext(_, u, g, s)) : c.map(XX.mapToOriginalLocation); + } + getSyntacticDiagnosticsSync(t) { + const { configFile: n } = this.getConfigFileAndProject(t); + return n ? bl : this.getDiagnosticsWorker( + t, + /*isSemantic*/ + !1, + (i, s) => i.getLanguageService().getSyntacticDiagnostics(s), + !!t.includeLinePosition + ); + } + getSemanticDiagnosticsSync(t) { + const { configFile: n, project: i } = this.getConfigFileAndProject(t); + return n ? this.getConfigFileDiagnostics(n, i, !!t.includeLinePosition) : this.getDiagnosticsWorker( + t, + /*isSemantic*/ + !0, + (s, o) => s.getLanguageService().getSemanticDiagnostics(o).filter((c) => !!c.file), + !!t.includeLinePosition + ); + } + getSuggestionDiagnosticsSync(t) { + const { configFile: n } = this.getConfigFileAndProject(t); + return n ? bl : this.getDiagnosticsWorker( + t, + /*isSemantic*/ + !0, + (i, s) => i.getLanguageService().getSuggestionDiagnostics(s), + !!t.includeLinePosition + ); + } + getJsxClosingTag(t) { + const { file: n, languageService: i } = this.getFileAndLanguageServiceForSyntacticOperation(t), s = this.getPositionInFile(t, n), o = i.getJsxClosingTagAtPosition(n, s); + return o === void 0 ? void 0 : { newText: o.newText, caretOffset: 0 }; + } + getLinkedEditingRange(t) { + const { file: n, languageService: i } = this.getFileAndLanguageServiceForSyntacticOperation(t), s = this.getPositionInFile(t, n), o = i.getLinkedEditingRangeAtPosition(n, s), c = this.projectService.getScriptInfoForNormalizedPath(n); + if (!(c === void 0 || o === void 0)) + return net(o, c); + } + getDocumentHighlights(t, n) { + const { file: i, project: s } = this.getFileAndProject(t), o = this.getPositionInFile(t, i), c = s.getLanguageService().getDocumentHighlights(i, o, t.filesToSearch); + return c ? n ? c.map(({ fileName: _, highlightSpans: u }) => { + const g = s.getScriptInfo(_); + return { + file: _, + highlightSpans: u.map(({ textSpan: m, kind: h, contextSpan: S }) => ({ + ...gfe(m, S, g), + kind: h + })) + }; + }) : c : bl; + } + provideInlayHints(t) { + const { file: n, project: i } = this.getFileAndProject(t), s = this.projectService.getScriptInfoForNormalizedPath(n); + return i.getLanguageService().provideInlayHints(n, t, this.getPreferences(n)).map((c) => { + const { position: _, displayParts: u } = c; + return { + ...c, + position: s.positionToLineOffset(_), + displayParts: u?.map(({ text: g, span: m, file: h }) => { + if (m) { + E.assertIsDefined(h, "Target file should be defined together with its span."); + const S = this.projectService.getScriptInfo(h); + return { + text: g, + span: { + start: S.positionToLineOffset(m.start), + end: S.positionToLineOffset(m.start + m.length), + file: h + } + }; + } else + return { text: g }; + }) + }; + }); + } + mapCode(t) { + var n; + const i = this.getHostFormatOptions(), s = this.getHostPreferences(), { file: o, languageService: c } = this.getFileAndLanguageServiceForSyntacticOperation(t), _ = this.projectService.getScriptInfoForNormalizedPath(o), u = (n = t.mapping.focusLocations) == null ? void 0 : n.map((m) => m.map((h) => { + const S = _.lineOffsetToPosition(h.start.line, h.start.offset), T = _.lineOffsetToPosition(h.end.line, h.end.offset); + return { + start: S, + length: T - S + }; + })), g = c.mapCode(o, t.mapping.contents, u, i, s); + return this.mapTextChangesToCodeEdits(g); + } + getCopilotRelatedInfo() { + return { + relatedFiles: [] + }; + } + setCompilerOptionsForInferredProjects(t) { + this.projectService.setCompilerOptionsForInferredProjects(t.options, t.projectRootPath); + } + getProjectInfo(t) { + return this.getProjectInfoWorker( + t.file, + t.projectFileName, + t.needFileNameList, + t.needDefaultConfiguredProjectInfo, + /*excludeConfigFiles*/ + !1 + ); + } + getProjectInfoWorker(t, n, i, s, o) { + const { project: c } = this.getFileAndProjectWorker(t, n); + return Gp(c), { + configFileName: c.getProjectName(), + languageServiceDisabled: !c.languageServiceEnabled, + fileNames: i ? c.getFileNames( + /*excludeFilesFromExternalLibraries*/ + !1, + o + ) : void 0, + configuredProjectInfo: s ? this.getDefaultConfiguredProjectInfo(t) : void 0 + }; + } + getDefaultConfiguredProjectInfo(t) { + var n; + const i = this.projectService.getScriptInfo(t); + if (!i) return; + const s = this.projectService.findDefaultConfiguredProjectWorker( + i, + 3 + /* CreateReplay */ + ); + if (!s) return; + let o, c; + return s.seenProjects.forEach((_, u) => { + u !== s.defaultProject && (_ !== 3 ? (o ?? (o = [])).push(ro(u.getConfigFilePath())) : (c ?? (c = [])).push(ro(u.getConfigFilePath()))); + }), (n = s.seenConfigs) == null || n.forEach((_) => (o ?? (o = [])).push(_)), { + notMatchedByConfig: o, + notInProject: c, + defaultProject: s.defaultProject && ro(s.defaultProject.getConfigFilePath()) + }; + } + getRenameInfo(t) { + const { file: n, project: i } = this.getFileAndProject(t), s = this.getPositionInFile(t, n), o = this.getPreferences(n); + return i.getLanguageService().getRenameInfo(n, s, o); + } + getProjects(t, n, i) { + let s, o; + if (t.projectFileName) { + const c = this.getProject(t.projectFileName); + c && (s = [c]); + } else { + const c = n ? this.projectService.getScriptInfoEnsuringProjectsUptoDate(t.file) : this.projectService.getScriptInfo(t.file); + if (c) + n || this.projectService.ensureDefaultProjectForFile(c); + else return i ? bl : (this.projectService.logErrorForScriptInfoNotFound(t.file), Rh.ThrowNoProject()); + s = c.containingProjects, o = this.projectService.getSymlinkedProjects(c); + } + return s = kn(s, (c) => c.languageServiceEnabled && !c.isOrphan()), !i && (!s || !s.length) && !o ? (this.projectService.logErrorForScriptInfoNotFound(t.file ?? t.projectFileName), Rh.ThrowNoProject()) : o ? { projects: s, symLinkedProjects: o } : s; + } + getDefaultProject(t) { + if (t.projectFileName) { + const i = this.getProject(t.projectFileName); + if (i) + return i; + if (!t.file) + return Rh.ThrowNoProject(); + } + return this.projectService.getScriptInfo(t.file).getDefaultProject(); + } + getRenameLocations(t, n) { + const i = ro(t.file), s = this.getPositionInFile(t, i), o = this.getProjects(t), c = this.getDefaultProject(t), _ = this.getPreferences(i), u = this.mapRenameInfo( + c.getLanguageService().getRenameInfo(i, s, _), + E.checkDefined(this.projectService.getScriptInfo(i)) + ); + if (!u.canRename) return n ? { info: u, locs: [] } : []; + const g = YKe( + o, + c, + { fileName: t.file, pos: s }, + !!t.findInStrings, + !!t.findInComments, + _, + this.host.useCaseSensitiveFileNames + ); + return n ? { info: u, locs: this.toSpanGroups(g) } : g; + } + mapRenameInfo(t, n) { + if (t.canRename) { + const { canRename: i, fileToRename: s, displayName: o, fullDisplayName: c, kind: _, kindModifiers: u, triggerSpan: g } = t; + return { canRename: i, fileToRename: s, displayName: o, fullDisplayName: c, kind: _, kindModifiers: u, triggerSpan: Pm(g, n) }; + } else + return t; + } + toSpanGroups(t) { + const n = /* @__PURE__ */ new Map(); + for (const { fileName: i, textSpan: s, contextSpan: o, originalContextSpan: c, originalTextSpan: _, originalFileName: u, ...g } of t) { + let m = n.get(i); + m || n.set(i, m = { file: i, locs: [] }); + const h = E.checkDefined(this.projectService.getScriptInfo(i)); + m.locs.push({ ...gfe(s, o, h), ...g }); + } + return is(n.values()); + } + getReferences(t, n) { + const i = ro(t.file), s = this.getProjects(t), o = this.getPositionInFile(t, i), c = ZKe( + s, + this.getDefaultProject(t), + { fileName: t.file, pos: o }, + this.host.useCaseSensitiveFileNames, + this.logger + ); + if (!n) return c; + const _ = this.getPreferences(i), u = this.getDefaultProject(t), g = u.getScriptInfoForNormalizedPath(i), m = u.getLanguageService().getQuickInfoAtPosition(i, o), h = m ? _8(m.displayParts) : "", S = m && m.textSpan, T = S ? g.positionToLineOffset(S.start).offset : 0, k = S ? g.getSnapshot().getText(S.start, ec(S)) : ""; + return { refs: ka(c, (P) => P.references.map((A) => MPe(this.projectService, A, _))), symbolName: k, symbolStartOffset: T, symbolDisplayString: h }; + } + getFileReferences(t, n) { + const i = this.getProjects(t), s = ro(t.file), o = this.getPreferences(s), c = { fileName: s, pos: 0 }, _ = mfe( + i, + this.getDefaultProject(t), + c, + c, + wPe, + (m) => (this.logger.info(`Finding references to file ${s} in project ${m.getProjectName()}`), m.getLanguageService().getFileReferences(s)) + ); + let u; + if (as(_)) + u = _; + else { + u = []; + const m = RG(this.host.useCaseSensitiveFileNames); + _.forEach((h) => { + for (const S of h) + m.has(S) || (u.push(S), m.add(S)); + }); + } + return n ? { + refs: u.map((m) => MPe(this.projectService, m, o)), + symbolName: `"${t.file}"` + } : u; + } + /** + * @param fileName is the name of the file to be opened + * @param fileContent is a version of the file content that is known to be more up to date than the one on disk + */ + openClientFile(t, n, i, s) { + this.projectService.openClientFileWithNormalizedPath( + t, + n, + i, + /*hasMixedContent*/ + !1, + s + ); + } + getPosition(t, n) { + return t.position !== void 0 ? t.position : n.lineOffsetToPosition(t.line, t.offset); + } + getPositionInFile(t, n) { + const i = this.projectService.getScriptInfoForNormalizedPath(n); + return this.getPosition(t, i); + } + getFileAndProject(t) { + return this.getFileAndProjectWorker(t.file, t.projectFileName); + } + getFileAndLanguageServiceForSyntacticOperation(t) { + const { file: n, project: i } = this.getFileAndProject(t); + return { + file: n, + languageService: i.getLanguageService( + /*ensureSynchronized*/ + !1 + ) + }; + } + getFileAndProjectWorker(t, n) { + const i = ro(t), s = this.getProject(n) || this.projectService.ensureDefaultProjectForFile(i); + return { file: i, project: s }; + } + getOutliningSpans(t, n) { + const { file: i, languageService: s } = this.getFileAndLanguageServiceForSyntacticOperation(t), o = s.getOutliningSpans(i); + if (n) { + const c = this.projectService.getScriptInfoForNormalizedPath(i); + return o.map((_) => ({ + textSpan: Pm(_.textSpan, c), + hintSpan: Pm(_.hintSpan, c), + bannerText: _.bannerText, + autoCollapse: _.autoCollapse, + kind: _.kind + })); + } else + return o; + } + getTodoComments(t) { + const { file: n, project: i } = this.getFileAndProject(t); + return i.getLanguageService().getTodoComments(n, t.descriptors); + } + getDocCommentTemplate(t) { + const { file: n, languageService: i } = this.getFileAndLanguageServiceForSyntacticOperation(t), s = this.getPositionInFile(t, n); + return i.getDocCommentTemplateAtPosition(n, s, this.getPreferences(n), this.getFormatOptions(n)); + } + getSpanOfEnclosingComment(t) { + const { file: n, languageService: i } = this.getFileAndLanguageServiceForSyntacticOperation(t), s = t.onlyMultiLine, o = this.getPositionInFile(t, n); + return i.getSpanOfEnclosingComment(n, o, s); + } + getIndentation(t) { + const { file: n, languageService: i } = this.getFileAndLanguageServiceForSyntacticOperation(t), s = this.getPositionInFile(t, n), o = t.options ? lE(t.options) : this.getFormatOptions(n), c = i.getIndentationAtPosition(n, s, o); + return { position: s, indentation: c }; + } + getBreakpointStatement(t) { + const { file: n, languageService: i } = this.getFileAndLanguageServiceForSyntacticOperation(t), s = this.getPositionInFile(t, n); + return i.getBreakpointStatementAtPosition(n, s); + } + getNameOrDottedNameSpan(t) { + const { file: n, languageService: i } = this.getFileAndLanguageServiceForSyntacticOperation(t), s = this.getPositionInFile(t, n); + return i.getNameOrDottedNameSpan(n, s, s); + } + isValidBraceCompletion(t) { + const { file: n, languageService: i } = this.getFileAndLanguageServiceForSyntacticOperation(t), s = this.getPositionInFile(t, n); + return i.isValidBraceCompletionAtPosition(n, s, t.openingBrace.charCodeAt(0)); + } + getQuickInfoWorker(t, n) { + const { file: i, project: s } = this.getFileAndProject(t), o = this.projectService.getScriptInfoForNormalizedPath(i), c = this.getPreferences(i), _ = s.getLanguageService().getQuickInfoAtPosition( + i, + this.getPosition(t, o), + c.maximumHoverLength, + t.verbosityLevel + ); + if (!_) + return; + const u = !!c.displayPartsForJSDoc; + if (n) { + const g = _8(_.displayParts); + return { + kind: _.kind, + kindModifiers: _.kindModifiers, + start: o.positionToLineOffset(_.textSpan.start), + end: o.positionToLineOffset(ec(_.textSpan)), + displayString: g, + documentation: u ? this.mapDisplayParts(_.documentation, s) : _8(_.documentation), + tags: this.mapJSDocTagInfo(_.tags, s, u), + canIncreaseVerbosityLevel: _.canIncreaseVerbosityLevel + }; + } else + return u ? _ : { + ..._, + tags: this.mapJSDocTagInfo( + _.tags, + s, + /*richResponse*/ + !1 + ) + }; + } + getFormattingEditsForRange(t) { + const { file: n, languageService: i } = this.getFileAndLanguageServiceForSyntacticOperation(t), s = this.projectService.getScriptInfoForNormalizedPath(n), o = s.lineOffsetToPosition(t.line, t.offset), c = s.lineOffsetToPosition(t.endLine, t.endOffset), _ = i.getFormattingEditsForRange(n, o, c, this.getFormatOptions(n)); + if (_) + return _.map((u) => this.convertTextChangeToCodeEdit(u, s)); + } + getFormattingEditsForRangeFull(t) { + const { file: n, languageService: i } = this.getFileAndLanguageServiceForSyntacticOperation(t), s = t.options ? lE(t.options) : this.getFormatOptions(n); + return i.getFormattingEditsForRange(n, t.position, t.endPosition, s); + } + getFormattingEditsForDocumentFull(t) { + const { file: n, languageService: i } = this.getFileAndLanguageServiceForSyntacticOperation(t), s = t.options ? lE(t.options) : this.getFormatOptions(n); + return i.getFormattingEditsForDocument(n, s); + } + getFormattingEditsAfterKeystrokeFull(t) { + const { file: n, languageService: i } = this.getFileAndLanguageServiceForSyntacticOperation(t), s = t.options ? lE(t.options) : this.getFormatOptions(n); + return i.getFormattingEditsAfterKeystroke(n, t.position, t.key, s); + } + getFormattingEditsAfterKeystroke(t) { + const { file: n, languageService: i } = this.getFileAndLanguageServiceForSyntacticOperation(t), s = this.projectService.getScriptInfoForNormalizedPath(n), o = s.lineOffsetToPosition(t.line, t.offset), c = this.getFormatOptions(n), _ = i.getFormattingEditsAfterKeystroke(n, o, t.key, c); + if (t.key === ` +` && (!_ || _.length === 0 || $Ke(_, o))) { + const { lineText: u, absolutePosition: g } = s.textStorage.getAbsolutePositionAndLineText(t.line); + if (u && u.search("\\S") < 0) { + const m = i.getIndentationAtPosition(n, o, c); + let h = 0, S, T; + for (S = 0, T = u.length; S < T; S++) + if (u.charAt(S) === " ") + h++; + else if (u.charAt(S) === " ") + h += c.tabSize; + else + break; + if (m !== h) { + const k = g + S; + _.push({ + span: Nc(g, k), + newText: nl.getIndentationString(m, c) + }); + } + } + } + if (_) + return _.map((u) => ({ + start: s.positionToLineOffset(u.span.start), + end: s.positionToLineOffset(ec(u.span)), + newText: u.newText ? u.newText : "" + })); + } + getCompletions(t, n) { + const { file: i, project: s } = this.getFileAndProject(t), o = this.projectService.getScriptInfoForNormalizedPath(i), c = this.getPosition(t, o), _ = s.getLanguageService().getCompletionsAtPosition( + i, + c, + { + ...Y_e(this.getPreferences(i)), + triggerCharacter: t.triggerCharacter, + triggerKind: t.triggerKind, + includeExternalModuleExports: t.includeExternalModuleExports, + includeInsertTextCompletions: t.includeInsertTextCompletions + }, + s.projectService.getFormatCodeOptions(i) + ); + if (_ === void 0) return; + if (n === "completions-full") return _; + const u = t.prefix || "", g = Fi(_.entries, (h) => { + if (_.isMemberCompletion || Ui(h.name.toLowerCase(), u.toLowerCase())) { + const S = h.replacementSpan ? Pm(h.replacementSpan, o) : void 0; + return { + ...h, + replacementSpan: S, + hasAction: h.hasAction || void 0, + symbol: void 0 + }; + } + }); + return n === "completions" ? (_.metadata && (g.metadata = _.metadata), g) : { + ..._, + optionalReplacementSpan: _.optionalReplacementSpan && Pm(_.optionalReplacementSpan, o), + entries: g + }; + } + getCompletionEntryDetails(t, n) { + const { file: i, project: s } = this.getFileAndProject(t), o = this.projectService.getScriptInfoForNormalizedPath(i), c = this.getPosition(t, o), _ = s.projectService.getFormatCodeOptions(i), u = !!this.getPreferences(i).displayPartsForJSDoc, g = Fi(t.entryNames, (m) => { + const { name: h, source: S, data: T } = typeof m == "string" ? { name: m, source: void 0, data: void 0 } : m; + return s.getLanguageService().getCompletionEntryDetails(i, c, h, _, S, this.getPreferences(i), T ? Us(T, cet) : void 0); + }); + return n ? u ? g : g.map((m) => ({ ...m, tags: this.mapJSDocTagInfo( + m.tags, + s, + /*richResponse*/ + !1 + ) })) : g.map((m) => ({ + ...m, + codeActions: hr(m.codeActions, (h) => this.mapCodeAction(h)), + documentation: this.mapDisplayParts(m.documentation, s), + tags: this.mapJSDocTagInfo(m.tags, s, u) + })); + } + getCompileOnSaveAffectedFileList(t) { + const n = this.getProjects( + t, + /*getScriptInfoEnsuringProjectsUptoDate*/ + !0, + /*ignoreNoProjectError*/ + !0 + ), i = this.projectService.getScriptInfo(t.file); + return i ? QKe( + i, + (s) => this.projectService.getScriptInfoForPath(s), + n, + (s, o) => { + if (!s.compileOnSaveEnabled || !s.languageServiceEnabled || s.isOrphan()) + return; + const c = s.getCompilationSettings(); + if (!(c.noEmit || Il(o.fileName) && !GKe(c))) + return { + projectFileName: s.getProjectName(), + fileNames: s.getCompileOnSaveAffectedFileList(o), + projectUsesOutFile: !!c.outFile + }; + } + ) : bl; + } + emitFile(t) { + const { file: n, project: i } = this.getFileAndProject(t); + if (i || Rh.ThrowNoProject(), !i.languageServiceEnabled) + return t.richResponse ? { emitSkipped: !0, diagnostics: [] } : !1; + const s = i.getScriptInfo(n), { emitSkipped: o, diagnostics: c } = i.emitFile(s, (_, u, g) => this.host.writeFile(_, u, g)); + return t.richResponse ? { + emitSkipped: o, + diagnostics: t.includeLinePosition ? this.convertToDiagnosticsWithLinePositionFromDiagnosticFile(c) : c.map((_) => z8( + _, + /*includeFileName*/ + !0 + )) + } : !o; + } + getSignatureHelpItems(t, n) { + const { file: i, project: s } = this.getFileAndProject(t), o = this.projectService.getScriptInfoForNormalizedPath(i), c = this.getPosition(t, o), _ = s.getLanguageService().getSignatureHelpItems(i, c, t), u = !!this.getPreferences(i).displayPartsForJSDoc; + if (_ && n) { + const g = _.applicableSpan; + return { + ..._, + applicableSpan: { + start: o.positionToLineOffset(g.start), + end: o.positionToLineOffset(g.start + g.length) + }, + items: this.mapSignatureHelpItems(_.items, s, u) + }; + } else return u || !_ ? _ : { + ..._, + items: _.items.map((g) => ({ ...g, tags: this.mapJSDocTagInfo( + g.tags, + s, + /*richResponse*/ + !1 + ) })) + }; + } + toPendingErrorCheck(t) { + const n = ro(t), i = this.projectService.tryGetDefaultProjectForFile(n); + return i && { fileName: n, project: i }; + } + getDiagnostics(t, n, i) { + this.suppressDiagnosticEvents || i.length > 0 && this.updateErrorCheck(t, i, n); + } + change(t) { + const n = this.projectService.getScriptInfo(t.file); + E.assert(!!n), n.textStorage.switchToScriptVersionCache(); + const i = n.lineOffsetToPosition(t.line, t.offset), s = n.lineOffsetToPosition(t.endLine, t.endOffset); + i >= 0 && (this.changeSeq++, this.projectService.applyChangesToFile( + n, + tQ({ + span: { start: i, length: s - i }, + newText: t.insertString + // TODO: GH#18217 + }) + )); + } + reload(t) { + const n = ro(t.file), i = t.tmpfile === void 0 ? void 0 : ro(t.tmpfile), s = this.projectService.getScriptInfoForNormalizedPath(n); + s && (this.changeSeq++, s.reloadFromFile(i)); + } + saveToTmp(t, n) { + const i = this.projectService.getScriptInfo(t); + i && i.saveTo(n); + } + closeClientFile(t) { + if (!t) + return; + const n = Hs(t); + this.projectService.closeClientFile(n); + } + mapLocationNavigationBarItems(t, n) { + return hr(t, (i) => ({ + text: i.text, + kind: i.kind, + kindModifiers: i.kindModifiers, + spans: i.spans.map((s) => Pm(s, n)), + childItems: this.mapLocationNavigationBarItems(i.childItems, n), + indent: i.indent + })); + } + getNavigationBarItems(t, n) { + const { file: i, languageService: s } = this.getFileAndLanguageServiceForSyntacticOperation(t), o = s.getNavigationBarItems(i); + return o ? n ? this.mapLocationNavigationBarItems(o, this.projectService.getScriptInfoForNormalizedPath(i)) : o : void 0; + } + toLocationNavigationTree(t, n) { + return { + text: t.text, + kind: t.kind, + kindModifiers: t.kindModifiers, + spans: t.spans.map((i) => Pm(i, n)), + nameSpan: t.nameSpan && Pm(t.nameSpan, n), + childItems: hr(t.childItems, (i) => this.toLocationNavigationTree(i, n)) + }; + } + getNavigationTree(t, n) { + const { file: i, languageService: s } = this.getFileAndLanguageServiceForSyntacticOperation(t), o = s.getNavigationTree(i); + return o ? n ? this.toLocationNavigationTree(o, this.projectService.getScriptInfoForNormalizedPath(i)) : o : void 0; + } + getNavigateToItems(t, n) { + const i = this.getFullNavigateToItems(t); + return n ? ka( + i, + ({ project: s, navigateToItems: o }) => o.map((c) => { + const _ = s.getScriptInfo(c.fileName), u = { + name: c.name, + kind: c.kind, + kindModifiers: c.kindModifiers, + isCaseSensitive: c.isCaseSensitive, + matchKind: c.matchKind, + file: c.fileName, + start: _.positionToLineOffset(c.textSpan.start), + end: _.positionToLineOffset(ec(c.textSpan)) + }; + return c.kindModifiers && c.kindModifiers !== "" && (u.kindModifiers = c.kindModifiers), c.containerName && c.containerName.length > 0 && (u.containerName = c.containerName), c.containerKind && c.containerKind.length > 0 && (u.containerKind = c.containerKind), u; + }) + ) : ka(i, ({ navigateToItems: s }) => s); + } + getFullNavigateToItems(t) { + const { currentFileOnly: n, searchValue: i, maxResultCount: s, projectFileName: o } = t; + if (n) { + E.assertIsDefined(t.file); + const { file: S, project: T } = this.getFileAndProject(t); + return [{ project: T, navigateToItems: T.getLanguageService().getNavigateToItems(i, s, S) }]; + } + const c = this.getHostPreferences(), _ = [], u = /* @__PURE__ */ new Map(); + if (!t.file && !o) + this.projectService.loadAncestorProjectTree(), this.projectService.forEachEnabledProject((S) => g(S)); + else { + const S = this.getProjects(t); + DPe( + S, + /*path*/ + void 0, + (T) => g(T) + ); + } + return _; + function g(S) { + const T = S.getLanguageService().getNavigateToItems( + i, + s, + /*fileName*/ + void 0, + /*excludeDts*/ + S.isNonTsProject(), + /*excludeLibFiles*/ + c.excludeLibrarySymbolsInNavTo + ), k = kn(T, (D) => m(D) && !jG(Uw(D), S)); + k.length && _.push({ project: S, navigateToItems: k }); + } + function m(S) { + const T = S.name; + if (!u.has(T)) + return u.set(T, [S]), !0; + const k = u.get(T); + for (const D of k) + if (h(D, S)) + return !1; + return k.push(S), !0; + } + function h(S, T) { + return S === T ? !0 : !S || !T ? !1 : S.containerKind === T.containerKind && S.containerName === T.containerName && S.fileName === T.fileName && S.isCaseSensitive === T.isCaseSensitive && S.kind === T.kind && S.kindModifiers === T.kindModifiers && S.matchKind === T.matchKind && S.name === T.name && S.textSpan.start === T.textSpan.start && S.textSpan.length === T.textSpan.length; + } + } + getSupportedCodeFixes(t) { + if (!t) return tH(); + if (t.file) { + const { file: i, project: s } = this.getFileAndProject(t); + return s.getLanguageService().getSupportedCodeFixes(i); + } + const n = this.getProject(t.projectFileName); + return n || Rh.ThrowNoProject(), n.getLanguageService().getSupportedCodeFixes(); + } + isLocation(t) { + return t.line !== void 0; + } + extractPositionOrRange(t, n) { + let i, s; + return this.isLocation(t) ? i = o(t) : s = this.getRange(t, n), E.checkDefined(i === void 0 ? s : i); + function o(c) { + return c.position !== void 0 ? c.position : n.lineOffsetToPosition(c.line, c.offset); + } + } + getRange(t, n) { + const { startPosition: i, endPosition: s } = this.getStartAndEndPosition(t, n); + return { pos: i, end: s }; + } + getApplicableRefactors(t) { + const { file: n, project: i } = this.getFileAndProject(t), s = i.getScriptInfoForNormalizedPath(n); + return i.getLanguageService().getApplicableRefactors(n, this.extractPositionOrRange(t, s), this.getPreferences(n), t.triggerReason, t.kind, t.includeInteractiveActions).map((c) => ({ ...c, actions: c.actions.map((_) => ({ ..._, range: _.range ? { start: uE({ line: _.range.start.line, character: _.range.start.offset }), end: uE({ line: _.range.end.line, character: _.range.end.offset }) } : void 0 })) })); + } + getEditsForRefactor(t, n) { + const { file: i, project: s } = this.getFileAndProject(t), o = s.getScriptInfoForNormalizedPath(i), c = s.getLanguageService().getEditsForRefactor( + i, + this.getFormatOptions(i), + this.extractPositionOrRange(t, o), + t.refactor, + t.action, + this.getPreferences(i), + t.interactiveRefactorArguments + ); + if (c === void 0) + return { + edits: [] + }; + if (n) { + const { renameFilename: _, renameLocation: u, edits: g } = c; + let m; + if (_ !== void 0 && u !== void 0) { + const h = s.getScriptInfoForNormalizedPath(ro(_)); + m = hfe(fk(h.getSnapshot()), _, u, g); + } + return { + renameLocation: m, + renameFilename: _, + edits: this.mapTextChangesToCodeEdits(g), + notApplicableReason: c.notApplicableReason + }; + } + return c; + } + getMoveToRefactoringFileSuggestions(t) { + const { file: n, project: i } = this.getFileAndProject(t), s = i.getScriptInfoForNormalizedPath(n); + return i.getLanguageService().getMoveToRefactoringFileSuggestions(n, this.extractPositionOrRange(t, s), this.getPreferences(n)); + } + preparePasteEdits(t) { + const { file: n, project: i } = this.getFileAndProject(t); + return i.getLanguageService().preparePasteEditsForFile(n, t.copiedTextSpan.map((s) => this.getRange({ file: n, startLine: s.start.line, startOffset: s.start.offset, endLine: s.end.line, endOffset: s.end.offset }, this.projectService.getScriptInfoForNormalizedPath(n)))); + } + getPasteEdits(t) { + const { file: n, project: i } = this.getFileAndProject(t); + if (zw(n)) return; + const s = t.copiedFrom ? { file: t.copiedFrom.file, range: t.copiedFrom.spans.map((c) => this.getRange({ file: t.copiedFrom.file, startLine: c.start.line, startOffset: c.start.offset, endLine: c.end.line, endOffset: c.end.offset }, i.getScriptInfoForNormalizedPath(ro(t.copiedFrom.file)))) } : void 0, o = i.getLanguageService().getPasteEdits( + { + targetFile: n, + pastedText: t.pastedText, + pasteLocations: t.pasteLocations.map((c) => this.getRange({ file: n, startLine: c.start.line, startOffset: c.start.offset, endLine: c.end.line, endOffset: c.end.offset }, i.getScriptInfoForNormalizedPath(n))), + copiedFrom: s, + preferences: this.getPreferences(n) + }, + this.getFormatOptions(n) + ); + return o && this.mapPasteEditsAction(o); + } + organizeImports(t, n) { + E.assert(t.scope.type === "file"); + const { file: i, project: s } = this.getFileAndProject(t.scope.args), o = s.getLanguageService().organizeImports( + { + fileName: i, + mode: t.mode ?? (t.skipDestructiveCodeActions ? "SortAndCombine" : void 0), + type: "file" + }, + this.getFormatOptions(i), + this.getPreferences(i) + ); + return n ? this.mapTextChangesToCodeEdits(o) : o; + } + getEditsForFileRename(t, n) { + const i = ro(t.oldFilePath), s = ro(t.newFilePath), o = this.getHostFormatOptions(), c = this.getHostPreferences(), _ = /* @__PURE__ */ new Set(), u = []; + return this.projectService.loadAncestorProjectTree(), this.projectService.forEachEnabledProject((g) => { + const m = g.getLanguageService().getEditsForFileRename(i, s, o, c), h = []; + for (const S of m) + _.has(S.fileName) || (u.push(S), h.push(S.fileName)); + for (const S of h) + _.add(S); + }), n ? u.map((g) => this.mapTextChangeToCodeEdit(g)) : u; + } + getCodeFixes(t, n) { + const { file: i, project: s } = this.getFileAndProject(t), o = s.getScriptInfoForNormalizedPath(i), { startPosition: c, endPosition: _ } = this.getStartAndEndPosition(t, o); + let u; + try { + u = s.getLanguageService().getCodeFixesAtPosition(i, c, _, t.errorCodes, this.getFormatOptions(i), this.getPreferences(i)); + } catch (g) { + const m = g instanceof Error ? g : new Error(g), h = s.getLanguageService(), S = [ + ...h.getSyntacticDiagnostics(i), + ...h.getSemanticDiagnostics(i), + ...h.getSuggestionDiagnostics(i) + ].filter((k) => t3(c, _ - c, k.start, k.length)).map((k) => k.code), T = t.errorCodes.find((k) => !S.includes(k)); + throw T !== void 0 && (m.message += ` +Additional information: BADCLIENT: Bad error code, ${T} not found in range ${c}..${_} (found: ${S.join(", ")})`), m; + } + return n ? u.map((g) => this.mapCodeFixAction(g)) : u; + } + getCombinedCodeFix({ scope: t, fixId: n }, i) { + E.assert(t.type === "file"); + const { file: s, project: o } = this.getFileAndProject(t.args), c = o.getLanguageService().getCombinedCodeFix({ type: "file", fileName: s }, n, this.getFormatOptions(s), this.getPreferences(s)); + return i ? { changes: this.mapTextChangesToCodeEdits(c.changes), commands: c.commands } : c; + } + applyCodeActionCommand(t) { + const n = t.command; + for (const i of QT(n)) { + const { file: s, project: o } = this.getFileAndProject(i); + o.getLanguageService().applyCodeActionCommand(i, this.getFormatOptions(s)).then( + (c) => { + }, + (c) => { + } + ); + } + return {}; + } + getStartAndEndPosition(t, n) { + let i, s; + return t.startPosition !== void 0 ? i = t.startPosition : (i = n.lineOffsetToPosition(t.startLine, t.startOffset), t.startPosition = i), t.endPosition !== void 0 ? s = t.endPosition : (s = n.lineOffsetToPosition(t.endLine, t.endOffset), t.endPosition = s), { startPosition: i, endPosition: s }; + } + mapCodeAction({ description: t, changes: n, commands: i }) { + return { description: t, changes: this.mapTextChangesToCodeEdits(n), commands: i }; + } + mapCodeFixAction({ fixName: t, description: n, changes: i, commands: s, fixId: o, fixAllDescription: c }) { + return { fixName: t, description: n, changes: this.mapTextChangesToCodeEdits(i), commands: s, fixId: o, fixAllDescription: c }; + } + mapPasteEditsAction({ edits: t, fixId: n }) { + return { edits: this.mapTextChangesToCodeEdits(t), fixId: n }; + } + mapTextChangesToCodeEdits(t) { + return t.map((n) => this.mapTextChangeToCodeEdit(n)); + } + mapTextChangeToCodeEdit(t) { + const n = this.projectService.getScriptInfoOrConfig(t.fileName); + return !!t.isNewFile == !!n && (n || this.projectService.logErrorForScriptInfoNotFound(t.fileName), E.fail("Expected isNewFile for (only) new files. " + JSON.stringify({ isNewFile: !!t.isNewFile, hasScriptInfo: !!n }))), n ? { fileName: t.fileName, textChanges: t.textChanges.map((i) => ret(i, n)) } : set(t); + } + convertTextChangeToCodeEdit(t, n) { + return { + start: n.positionToLineOffset(t.span.start), + end: n.positionToLineOffset(t.span.start + t.span.length), + newText: t.newText ? t.newText : "" + }; + } + getBraceMatching(t, n) { + const { file: i, languageService: s } = this.getFileAndLanguageServiceForSyntacticOperation(t), o = this.projectService.getScriptInfoForNormalizedPath(i), c = this.getPosition(t, o), _ = s.getBraceMatchingAtPosition(i, c); + return _ ? n ? _.map((u) => Pm(u, o)) : _ : void 0; + } + getDiagnosticsForProject(t, n, i) { + if (this.suppressDiagnosticEvents) + return; + const { fileNames: s, languageServiceDisabled: o } = this.getProjectInfoWorker( + i, + /*projectFileName*/ + void 0, + /*needFileNameList*/ + !0, + /*needDefaultConfiguredProjectInfo*/ + void 0, + /*excludeConfigFiles*/ + !0 + ); + if (o) return; + const c = s.filter((D) => !D.includes("lib.d.ts")); + if (c.length === 0) return; + const _ = [], u = [], g = [], m = [], h = ro(i), S = this.projectService.ensureDefaultProjectForFile(h); + for (const D of c) + this.getCanonicalFileName(D) === this.getCanonicalFileName(i) ? _.push(D) : this.projectService.getScriptInfo(D).isScriptOpen() ? u.push(D) : Il(D) ? m.push(D) : g.push(D); + const k = [..._, ...u, ...g, ...m].map((D) => ({ fileName: D, project: S })); + this.updateErrorCheck( + t, + k, + n, + /*requireOpen*/ + !1 + ); + } + configurePlugin(t) { + this.projectService.configurePlugin(t); + } + getSmartSelectionRange(t, n) { + const { locations: i } = t, { file: s, languageService: o } = this.getFileAndLanguageServiceForSyntacticOperation(t), c = E.checkDefined(this.projectService.getScriptInfo(s)); + return hr(i, (_) => { + const u = this.getPosition(_, c), g = o.getSmartSelectionRange(s, u); + return n ? this.mapSelectionRange(g, c) : g; + }); + } + toggleLineComment(t, n) { + const { file: i, languageService: s } = this.getFileAndLanguageServiceForSyntacticOperation(t), o = this.projectService.getScriptInfo(i), c = this.getRange(t, o), _ = s.toggleLineComment(i, c); + if (n) { + const u = this.projectService.getScriptInfoForNormalizedPath(i); + return _.map((g) => this.convertTextChangeToCodeEdit(g, u)); + } + return _; + } + toggleMultilineComment(t, n) { + const { file: i, languageService: s } = this.getFileAndLanguageServiceForSyntacticOperation(t), o = this.projectService.getScriptInfoForNormalizedPath(i), c = this.getRange(t, o), _ = s.toggleMultilineComment(i, c); + if (n) { + const u = this.projectService.getScriptInfoForNormalizedPath(i); + return _.map((g) => this.convertTextChangeToCodeEdit(g, u)); + } + return _; + } + commentSelection(t, n) { + const { file: i, languageService: s } = this.getFileAndLanguageServiceForSyntacticOperation(t), o = this.projectService.getScriptInfoForNormalizedPath(i), c = this.getRange(t, o), _ = s.commentSelection(i, c); + if (n) { + const u = this.projectService.getScriptInfoForNormalizedPath(i); + return _.map((g) => this.convertTextChangeToCodeEdit(g, u)); + } + return _; + } + uncommentSelection(t, n) { + const { file: i, languageService: s } = this.getFileAndLanguageServiceForSyntacticOperation(t), o = this.projectService.getScriptInfoForNormalizedPath(i), c = this.getRange(t, o), _ = s.uncommentSelection(i, c); + if (n) { + const u = this.projectService.getScriptInfoForNormalizedPath(i); + return _.map((g) => this.convertTextChangeToCodeEdit(g, u)); + } + return _; + } + mapSelectionRange(t, n) { + const i = { + textSpan: Pm(t.textSpan, n) + }; + return t.parent && (i.parent = this.mapSelectionRange(t.parent, n)), i; + } + getScriptInfoFromProjectService(t) { + const n = ro(t), i = this.projectService.getScriptInfoForNormalizedPath(n); + return i || (this.projectService.logErrorForScriptInfoNotFound(n), Rh.ThrowNoProject()); + } + toProtocolCallHierarchyItem(t) { + const n = this.getScriptInfoFromProjectService(t.file); + return { + name: t.name, + kind: t.kind, + kindModifiers: t.kindModifiers, + file: t.file, + containerName: t.containerName, + span: Pm(t.span, n), + selectionSpan: Pm(t.selectionSpan, n) + }; + } + toProtocolCallHierarchyIncomingCall(t) { + const n = this.getScriptInfoFromProjectService(t.from.file); + return { + from: this.toProtocolCallHierarchyItem(t.from), + fromSpans: t.fromSpans.map((i) => Pm(i, n)) + }; + } + toProtocolCallHierarchyOutgoingCall(t, n) { + return { + to: this.toProtocolCallHierarchyItem(t.to), + fromSpans: t.fromSpans.map((i) => Pm(i, n)) + }; + } + prepareCallHierarchy(t) { + const { file: n, project: i } = this.getFileAndProject(t), s = this.projectService.getScriptInfoForNormalizedPath(n); + if (s) { + const o = this.getPosition(t, s), c = i.getLanguageService().prepareCallHierarchy(n, o); + return c && _q(c, (_) => this.toProtocolCallHierarchyItem(_)); + } + } + provideCallHierarchyIncomingCalls(t) { + const { file: n, project: i } = this.getFileAndProject(t), s = this.getScriptInfoFromProjectService(n); + return i.getLanguageService().provideCallHierarchyIncomingCalls(n, this.getPosition(t, s)).map((c) => this.toProtocolCallHierarchyIncomingCall(c)); + } + provideCallHierarchyOutgoingCalls(t) { + const { file: n, project: i } = this.getFileAndProject(t), s = this.getScriptInfoFromProjectService(n); + return i.getLanguageService().provideCallHierarchyOutgoingCalls(n, this.getPosition(t, s)).map((c) => this.toProtocolCallHierarchyOutgoingCall(c, s)); + } + getCanonicalFileName(t) { + const n = this.host.useCaseSensitiveFileNames ? t : my(t); + return Hs(n); + } + exit() { + } + notRequired(t) { + return t && this.doOutput( + /*info*/ + void 0, + t.command, + t.seq, + /*success*/ + !0, + this.performanceData + ), { responseRequired: !1, performanceData: this.performanceData }; + } + requiredResponse(t) { + return { response: t, responseRequired: !0, performanceData: this.performanceData }; + } + addProtocolHandler(t, n) { + if (this.handlers.has(t)) + throw new Error(`Protocol handler already exists for command "${t}"`); + this.handlers.set(t, n); + } + setCurrentRequest(t) { + E.assert(this.currentRequestId === void 0), this.currentRequestId = t, this.cancellationToken.setRequest(t); + } + resetCurrentRequest(t) { + E.assert(this.currentRequestId === t), this.currentRequestId = void 0, this.cancellationToken.resetRequest(t); + } + // eslint-disable-line @typescript-eslint/unified-signatures + executeWithRequestId(t, n, i) { + const s = this.performanceData; + try { + return this.performanceData = i, this.setCurrentRequest(t), n(); + } finally { + this.resetCurrentRequest(t), this.performanceData = s; + } + } + executeCommand(t) { + const n = this.handlers.get(t.command); + if (n) { + const i = this.executeWithRequestId( + t.seq, + () => n(t), + /*perfomanceData*/ + void 0 + ); + return this.projectService.enableRequestedPlugins(), i; + } else + return this.logger.msg( + `Unrecognized JSON command:${vv(t)}`, + "Err" + /* Err */ + ), this.doOutput( + /*info*/ + void 0, + "unknown", + t.seq, + /*success*/ + !1, + /*performanceData*/ + void 0, + `Unrecognized JSON command: ${t.command}` + ), { responseRequired: !1 }; + } + onMessage(t) { + var n, i, s, o, c, _, u; + this.gcTimer.scheduleCollect(); + let g; + const m = this.performanceData; + this.logger.hasLevel( + 2 + /* requestTime */ + ) && (g = this.hrtime(), this.logger.hasLevel( + 3 + /* verbose */ + ) && this.logger.info(`request:${pw(this.toStringMessage(t))}`)); + let h, S; + try { + h = this.parseMessage(t), S = h.arguments && h.arguments.file ? h.arguments : void 0, (n = on) == null || n.instant(on.Phase.Session, "request", { seq: h.seq, command: h.command }), (i = on) == null || i.push( + on.Phase.Session, + "executeCommand", + { seq: h.seq, command: h.command }, + /*separateBeginAndEnd*/ + !0 + ); + const { response: T, responseRequired: k, performanceData: D } = this.executeCommand(h); + if ((s = on) == null || s.pop(), this.logger.hasLevel( + 2 + /* requestTime */ + )) { + const P = HKe(this.hrtime(g)).toFixed(4); + k ? this.logger.perftrc(`${h.seq}::${h.command}: elapsed time (in milliseconds) ${P}`) : this.logger.perftrc(`${h.seq}::${h.command}: async elapsed time (in milliseconds) ${P}`); + } + (o = on) == null || o.instant(on.Phase.Session, "response", { seq: h.seq, command: h.command, success: !!T }), T ? this.doOutput( + T, + h.command, + h.seq, + /*success*/ + !0, + D + ) : k && this.doOutput( + /*info*/ + void 0, + h.command, + h.seq, + /*success*/ + !1, + D, + "No content available." + ); + } catch (T) { + if ((c = on) == null || c.popAll(), T instanceof lD) { + (_ = on) == null || _.instant(on.Phase.Session, "commandCanceled", { seq: h?.seq, command: h?.command }), this.doOutput( + { canceled: !0 }, + h.command, + h.seq, + /*success*/ + !0, + this.performanceData + ); + return; + } + this.logErrorWorker(T, this.toStringMessage(t), S), (u = on) == null || u.instant(on.Phase.Session, "commandError", { seq: h?.seq, command: h?.command, message: T.message }), this.doOutput( + /*info*/ + void 0, + h ? h.command : "unknown", + h ? h.seq : 0, + /*success*/ + !1, + this.performanceData, + "Error processing request. " + T.message + ` +` + T.stack + ); + } finally { + this.performanceData = m; + } + } + parseMessage(t) { + return JSON.parse(t); + } + toStringMessage(t) { + return t; + } + getFormatOptions(t) { + return this.projectService.getFormatCodeOptions(t); + } + getPreferences(t) { + return this.projectService.getPreferences(t); + } + getHostFormatOptions() { + return this.projectService.getHostFormatCodeOptions(); + } + getHostPreferences() { + return this.projectService.getHostPreferences(); + } + }; + function OPe(e) { + const t = e.diagnosticsDuration && is(e.diagnosticsDuration, ([n, i]) => ({ ...i, file: n })); + return { ...e, diagnosticsDuration: t }; + } + function Pm(e, t) { + return { + start: t.positionToLineOffset(e.start), + end: t.positionToLineOffset(ec(e)) + }; + } + function gfe(e, t, n) { + const i = Pm(e, n), s = t && Pm(t, n); + return s ? { ...i, contextStart: s.start, contextEnd: s.end } : i; + } + function ret(e, t) { + return { start: LPe(t, e.span.start), end: LPe(t, ec(e.span)), newText: e.newText }; + } + function LPe(e, t) { + return lfe(e) ? iet(e.getLineAndCharacterOfPosition(t)) : e.positionToLineOffset(t); + } + function net(e, t) { + const n = e.ranges.map( + (i) => ({ + start: t.positionToLineOffset(i.start), + end: t.positionToLineOffset(i.start + i.length) + }) + ); + return e.wordPattern ? { ranges: n, wordPattern: e.wordPattern } : { ranges: n }; + } + function iet(e) { + return { line: e.line + 1, offset: e.character + 1 }; + } + function set(e) { + E.assert(e.textChanges.length === 1); + const t = Ca(e.textChanges); + return E.assert(t.span.start === 0 && t.span.length === 0), { fileName: e.fileName, textChanges: [{ start: { line: 0, offset: 0 }, end: { line: 0, offset: 0 }, newText: t.newText }] }; + } + function hfe(e, t, n, i) { + const s = aet(e, t, i), { line: o, character: c } = CC(nx(s), n); + return { line: o + 1, offset: c + 1 }; + } + function aet(e, t, n) { + for (const { fileName: i, textChanges: s } of n) + if (i === t) + for (let o = s.length - 1; o >= 0; o--) { + const { newText: c, span: { start: _, length: u } } = s[o]; + e = e.slice(0, _) + c + e.slice(_ + u); + } + return e; + } + function MPe(e, { fileName: t, textSpan: n, contextSpan: i, isWriteAccess: s, isDefinition: o }, { disableLineTextInReferences: c }) { + const _ = E.checkDefined(e.getScriptInfo(t)), u = gfe(n, i, _), g = c ? void 0 : oet(_, u); + return { + file: t, + ...u, + lineText: g, + isWriteAccess: s, + isDefinition: o + }; + } + function oet(e, t) { + const n = e.lineToTextSpan(t.start.line - 1); + return e.getSnapshot().getText(n.start, ec(n)).replace(/\r|\n/g, ""); + } + function cet(e) { + return e === void 0 || e && typeof e == "object" && typeof e.exportName == "string" && (e.fileName === void 0 || typeof e.fileName == "string") && (e.ambientModuleName === void 0 || typeof e.ambientModuleName == "string" && (e.isPackageJsonImport === void 0 || typeof e.isPackageJsonImport == "boolean")); + } + var _E = 4, yfe = /* @__PURE__ */ ((e) => (e[e.PreStart = 0] = "PreStart", e[e.Start = 1] = "Start", e[e.Entire = 2] = "Entire", e[e.Mid = 3] = "Mid", e[e.End = 4] = "End", e[e.PostEnd = 5] = "PostEnd", e))(yfe || {}), uet = class { + constructor() { + this.goSubtree = !0, this.lineIndex = new W8(), this.endBranch = [], this.state = 2, this.initialText = "", this.trailingText = "", this.lineIndex.root = new fE(), this.startPath = [this.lineIndex.root], this.stack = [this.lineIndex.root]; + } + get done() { + return !1; + } + insertLines(e, t) { + t && (this.trailingText = ""), e ? e = this.initialText + e + this.trailingText : e = this.initialText + this.trailingText; + const i = W8.linesFromText(e).lines; + i.length > 1 && i[i.length - 1] === "" && i.pop(); + let s, o; + for (let _ = this.endBranch.length - 1; _ >= 0; _--) + this.endBranch[_].updateCounts(), this.endBranch[_].charCount() === 0 && (o = this.endBranch[_], _ > 0 ? s = this.endBranch[_ - 1] : s = this.branchNode); + o && s.remove(o); + const c = this.startPath[this.startPath.length - 1]; + if (i.length > 0) + if (c.text = i[0], i.length > 1) { + let _ = new Array(i.length - 1), u = c; + for (let h = 1; h < i.length; h++) + _[h - 1] = new VL(i[h]); + let g = this.startPath.length - 2; + for (; g >= 0; ) { + const h = this.startPath[g]; + _ = h.insertAt(u, _), g--, u = h; + } + let m = _.length; + for (; m > 0; ) { + const h = new fE(); + h.add(this.lineIndex.root), _ = h.insertAt(this.lineIndex.root, _), m = _.length, this.lineIndex.root = h; + } + this.lineIndex.root.updateCounts(); + } else + for (let _ = this.startPath.length - 2; _ >= 0; _--) + this.startPath[_].updateCounts(); + else { + this.startPath[this.startPath.length - 2].remove(c); + for (let u = this.startPath.length - 2; u >= 0; u--) + this.startPath[u].updateCounts(); + } + return this.lineIndex; + } + post(e, t, n) { + n === this.lineCollectionAtBranch && (this.state = 4), this.stack.pop(); + } + pre(e, t, n, i, s) { + const o = this.stack[this.stack.length - 1]; + this.state === 2 && s === 1 && (this.state = 1, this.branchNode = o, this.lineCollectionAtBranch = n); + let c; + function _(u) { + return u.isLeaf() ? new VL("") : new fE(); + } + switch (s) { + case 0: + this.goSubtree = !1, this.state !== 4 && o.add(n); + break; + case 1: + this.state === 4 ? this.goSubtree = !1 : (c = _(n), o.add(c), this.startPath.push(c)); + break; + case 2: + this.state !== 4 ? (c = _(n), o.add(c), this.startPath.push(c)) : n.isLeaf() || (c = _(n), o.add(c), this.endBranch.push(c)); + break; + case 3: + this.goSubtree = !1; + break; + case 4: + this.state !== 4 ? this.goSubtree = !1 : n.isLeaf() || (c = _(n), o.add(c), this.endBranch.push(c)); + break; + case 5: + this.goSubtree = !1, this.state !== 1 && o.add(n); + break; + } + this.goSubtree && this.stack.push(c); + } + // just gather text from the leaves + leaf(e, t, n) { + this.state === 1 ? this.initialText = n.text.substring(0, e) : this.state === 2 ? (this.initialText = n.text.substring(0, e), this.trailingText = n.text.substring(e + t)) : this.trailingText = n.text.substring(e + t); + } + }, _et = class { + constructor(e, t, n) { + this.pos = e, this.deleteLen = t, this.insertedText = n; + } + getTextChangeRange() { + return r3(Kl(this.pos, this.deleteLen), this.insertedText ? this.insertedText.length : 0); + } + }, BG = class HT { + constructor() { + this.changes = [], this.versions = new Array(HT.maxVersions), this.minVersion = 0, this.currentVersion = 0; + } + versionToIndex(t) { + if (!(t < this.minVersion || t > this.currentVersion)) + return t % HT.maxVersions; + } + currentVersionToIndex() { + return this.currentVersion % HT.maxVersions; + } + // REVIEW: can optimize by coalescing simple edits + edit(t, n, i) { + this.changes.push(new _et(t, n, i)), (this.changes.length > HT.changeNumberThreshold || n > HT.changeLengthThreshold || i && i.length > HT.changeLengthThreshold) && this.getSnapshot(); + } + getSnapshot() { + return this._getSnapshot(); + } + _getSnapshot() { + let t = this.versions[this.currentVersionToIndex()]; + if (this.changes.length > 0) { + let n = t.index; + for (const i of this.changes) + n = n.edit(i.pos, i.deleteLen, i.insertedText); + t = new RPe(this.currentVersion + 1, this, n, this.changes), this.currentVersion = t.version, this.versions[this.currentVersionToIndex()] = t, this.changes = [], this.currentVersion - this.minVersion >= HT.maxVersions && (this.minVersion = this.currentVersion - HT.maxVersions + 1); + } + return t; + } + getSnapshotVersion() { + return this._getSnapshot().version; + } + getAbsolutePositionAndLineText(t) { + return this._getSnapshot().index.lineNumberToInfo(t); + } + lineOffsetToPosition(t, n) { + return this._getSnapshot().index.absolutePositionOfStartOfLine(t) + (n - 1); + } + positionToLineOffset(t) { + return this._getSnapshot().index.positionToLineOffset(t); + } + lineToTextSpan(t) { + const n = this._getSnapshot().index, { lineText: i, absolutePosition: s } = n.lineNumberToInfo(t + 1), o = i !== void 0 ? i.length : n.absolutePositionOfStartOfLine(t + 2) - s; + return Kl(s, o); + } + getTextChangesBetweenVersions(t, n) { + if (t < n) + if (t >= this.minVersion) { + const i = []; + for (let s = t + 1; s <= n; s++) { + const o = this.versions[this.versionToIndex(s)]; + for (const c of o.changesSincePreviousVersion) + i.push(c.getTextChangeRange()); + } + return tZ(i); + } else + return; + else + return g7; + } + getLineCount() { + return this._getSnapshot().index.getLineCount(); + } + static fromString(t) { + const n = new HT(), i = new RPe(0, n, new W8()); + n.versions[n.currentVersion] = i; + const s = W8.linesFromText(t); + return i.index.load(s.lines), n; + } + }; + BG.changeNumberThreshold = 8, BG.changeLengthThreshold = 256, BG.maxVersions = 8; + var JG = BG, RPe = class V5e { + constructor(t, n, i, s = bl) { + this.version = t, this.cache = n, this.index = i, this.changesSincePreviousVersion = s; + } + getText(t, n) { + return this.index.getText(t, n - t); + } + getLength() { + return this.index.getLength(); + } + getChangeRange(t) { + if (t instanceof V5e && this.cache === t.cache) + return this.version <= t.version ? g7 : this.cache.getTextChangesBetweenVersions(t.version, this.version); + } + }, W8 = class pge { + constructor() { + this.checkEdits = !1; + } + absolutePositionOfStartOfLine(t) { + return this.lineNumberToInfo(t).absolutePosition; + } + positionToLineOffset(t) { + const { oneBasedLine: n, zeroBasedColumn: i } = this.root.charOffsetToLineInfo(1, t); + return { line: n, offset: i + 1 }; + } + positionToColumnAndLineText(t) { + return this.root.charOffsetToLineInfo(1, t); + } + getLineCount() { + return this.root.lineCount(); + } + lineNumberToInfo(t) { + const n = this.getLineCount(); + if (t <= n) { + const { position: i, leaf: s } = this.root.lineNumberToInfo(t, 0); + return { absolutePosition: i, lineText: s && s.text }; + } else + return { absolutePosition: this.root.charCount(), lineText: void 0 }; + } + load(t) { + if (t.length > 0) { + const n = []; + for (let i = 0; i < t.length; i++) + n[i] = new VL(t[i]); + this.root = pge.buildTreeFromBottom(n); + } else + this.root = new fE(); + } + walk(t, n, i) { + this.root.walk(t, n, i); + } + getText(t, n) { + let i = ""; + return n > 0 && t < this.root.charCount() && this.walk(t, n, { + goSubtree: !0, + done: !1, + leaf: (s, o, c) => { + i = i.concat(c.text.substring(s, s + o)); + } + }), i; + } + getLength() { + return this.root.charCount(); + } + every(t, n, i) { + i || (i = this.root.charCount()); + const s = { + goSubtree: !0, + done: !1, + leaf(o, c, _) { + t(_, o, c) || (this.done = !0); + } + }; + return this.walk(n, i - n, s), !s.done; + } + edit(t, n, i) { + if (this.root.charCount() === 0) + return E.assert(n === 0), i !== void 0 ? (this.load(pge.linesFromText(i).lines), this) : void 0; + { + let s; + if (this.checkEdits) { + const _ = this.getText(0, this.root.charCount()); + s = _.slice(0, t) + i + _.slice(t + n); + } + const o = new uet(); + let c = !1; + if (t >= this.root.charCount()) { + t = this.root.charCount() - 1; + const _ = this.getText(t, 1); + i ? i = _ + i : i = _, n = 0, c = !0; + } else if (n > 0) { + const _ = t + n, { zeroBasedColumn: u, lineText: g } = this.positionToColumnAndLineText(_); + u === 0 && (n += g.length, i = i ? i + g : g); + } + if (this.root.walk(t, n, o), o.insertLines(i, c), this.checkEdits) { + const _ = o.lineIndex.getText(0, o.lineIndex.getLength()); + E.assert(s === _, "buffer edit mismatch"); + } + return o.lineIndex; + } + } + static buildTreeFromBottom(t) { + if (t.length < _E) + return new fE(t); + const n = new Array(Math.ceil(t.length / _E)); + let i = 0; + for (let s = 0; s < n.length; s++) { + const o = Math.min(i + _E, t.length); + n[s] = new fE(t.slice(i, o)), i = o; + } + return this.buildTreeFromBottom(n); + } + static linesFromText(t) { + const n = nx(t); + if (n.length === 0) + return { lines: [], lineMap: n }; + const i = new Array(n.length), s = n.length - 1; + for (let c = 0; c < s; c++) + i[c] = t.substring(n[c], n[c + 1]); + const o = t.substring(n[s]); + return o.length > 0 ? i[s] = o : i.pop(), { lines: i, lineMap: n }; + } + }, fE = class dge { + constructor(t = []) { + this.children = t, this.totalChars = 0, this.totalLines = 0, t.length && this.updateCounts(); + } + isLeaf() { + return !1; + } + updateCounts() { + this.totalChars = 0, this.totalLines = 0; + for (const t of this.children) + this.totalChars += t.charCount(), this.totalLines += t.lineCount(); + } + execWalk(t, n, i, s, o) { + return i.pre && i.pre(t, n, this.children[s], this, o), i.goSubtree ? (this.children[s].walk(t, n, i), i.post && i.post(t, n, this.children[s], this, o)) : i.goSubtree = !0, i.done; + } + skipChild(t, n, i, s, o) { + s.pre && !s.done && (s.pre(t, n, this.children[i], this, o), s.goSubtree = !0); + } + walk(t, n, i) { + if (this.children.length === 0) return; + let s = 0, o = this.children[s].charCount(), c = t; + for (; c >= o; ) + this.skipChild( + c, + n, + s, + i, + 0 + /* PreStart */ + ), c -= o, s++, o = this.children[s].charCount(); + if (c + n <= o) { + if (this.execWalk( + c, + n, + i, + s, + 2 + /* Entire */ + )) + return; + } else { + if (this.execWalk( + c, + o - c, + i, + s, + 1 + /* Start */ + )) + return; + let _ = n - (o - c); + for (s++, o = this.children[s].charCount(); _ > o; ) { + if (this.execWalk( + 0, + o, + i, + s, + 3 + /* Mid */ + )) + return; + _ -= o, s++, o = this.children[s].charCount(); + } + if (_ > 0 && this.execWalk( + 0, + _, + i, + s, + 4 + /* End */ + )) + return; + } + if (i.pre) { + const _ = this.children.length; + if (s < _ - 1) + for (let u = s + 1; u < _; u++) + this.skipChild( + 0, + 0, + u, + i, + 5 + /* PostEnd */ + ); + } + } + // Input position is relative to the start of this node. + // Output line number is absolute. + charOffsetToLineInfo(t, n) { + if (this.children.length === 0) + return { oneBasedLine: t, zeroBasedColumn: n, lineText: void 0 }; + for (const o of this.children) { + if (o.charCount() > n) + return o.isLeaf() ? { oneBasedLine: t, zeroBasedColumn: n, lineText: o.text } : o.charOffsetToLineInfo(t, n); + n -= o.charCount(), t += o.lineCount(); + } + const i = this.lineCount(); + if (i === 0) + return { oneBasedLine: 1, zeroBasedColumn: 0, lineText: void 0 }; + const s = E.checkDefined(this.lineNumberToInfo(i, 0).leaf); + return { oneBasedLine: i, zeroBasedColumn: s.charCount(), lineText: void 0 }; + } + /** + * Input line number is relative to the start of this node. + * Output line number is relative to the child. + * positionAccumulator will be an absolute position once relativeLineNumber reaches 0. + */ + lineNumberToInfo(t, n) { + for (const i of this.children) { + const s = i.lineCount(); + if (s >= t) + return i.isLeaf() ? { position: n, leaf: i } : i.lineNumberToInfo(t, n); + t -= s, n += i.charCount(); + } + return { position: n, leaf: void 0 }; + } + splitAfter(t) { + let n; + const i = this.children.length; + t++; + const s = t; + if (t < i) { + for (n = new dge(); t < i; ) + n.add(this.children[t]), t++; + n.updateCounts(); + } + return this.children.length = s, n; + } + remove(t) { + const n = this.findChildIndex(t), i = this.children.length; + if (n < i - 1) + for (let s = n; s < i - 1; s++) + this.children[s] = this.children[s + 1]; + this.children.pop(); + } + findChildIndex(t) { + const n = this.children.indexOf(t); + return E.assert(n !== -1), n; + } + insertAt(t, n) { + let i = this.findChildIndex(t); + const s = this.children.length, o = n.length; + if (s < _E && i === s - 1 && o === 1) + return this.add(n[0]), this.updateCounts(), []; + { + const c = this.splitAfter(i); + let _ = 0; + for (i++; i < _E && _ < o; ) + this.children[i] = n[_], i++, _++; + let u = [], g = 0; + if (_ < o) { + g = Math.ceil((o - _) / _E), u = new Array(g); + let m = 0; + for (let S = 0; S < g; S++) + u[S] = new dge(); + let h = u[0]; + for (; _ < o; ) + h.add(n[_]), _++, h.children.length === _E && (m++, h = u[m]); + for (let S = u.length - 1; S >= 0; S--) + u[S].children.length === 0 && u.pop(); + } + c && u.push(c), this.updateCounts(); + for (let m = 0; m < g; m++) + u[m].updateCounts(); + return u; + } + } + // assume there is room for the item; return true if more room + add(t) { + this.children.push(t), E.assert(this.children.length <= _E); + } + charCount() { + return this.totalChars; + } + lineCount() { + return this.totalLines; + } + }, VL = class { + constructor(e) { + this.text = e; + } + isLeaf() { + return !0; + } + walk(e, t, n) { + n.leaf(e, t, this); + } + charCount() { + return this.text.length; + } + lineCount() { + return 1; + } + }, jPe = class q5e { + constructor(t, n, i, s, o, c) { + this.telemetryEnabled = t, this.logger = n, this.host = i, this.globalTypingsCacheLocation = s, this.event = o, this.maxActiveRequestCount = c, this.activeRequestCount = 0, this.requestQueue = JP(), this.requestMap = /* @__PURE__ */ new Map(), this.requestedRegistry = !1, this.packageInstallId = 0; + } + isKnownTypesPackageName(t) { + var n; + return t1.validatePackageName(t) !== t1.NameValidationResult.Ok ? !1 : (this.requestedRegistry || (this.requestedRegistry = !0, this.installer.send({ kind: "typesRegistry" })), !!((n = this.typesRegistryCache) != null && n.has(t))); + } + installPackage(t) { + this.packageInstallId++; + const n = { kind: "installPackage", ...t, id: this.packageInstallId }, i = new Promise((s, o) => { + (this.packageInstalledPromise ?? (this.packageInstalledPromise = /* @__PURE__ */ new Map())).set(this.packageInstallId, { resolve: s, reject: o }); + }); + return this.installer.send(n), i; + } + attach(t) { + this.projectService = t, this.installer = this.createInstallerProcess(); + } + onProjectClosed(t) { + this.installer.send({ projectName: t.getProjectName(), kind: "closeProject" }); + } + enqueueInstallTypingsRequest(t, n, i) { + const s = C_e(t, n, i); + this.logger.hasLevel( + 3 + /* verbose */ + ) && this.logger.info(`TIAdapter:: Scheduling throttled operation:${vv(s)}`), this.activeRequestCount < this.maxActiveRequestCount ? this.scheduleRequest(s) : (this.logger.hasLevel( + 3 + /* verbose */ + ) && this.logger.info(`TIAdapter:: Deferring request for: ${s.projectName}`), this.requestQueue.enqueue(s), this.requestMap.set(s.projectName, s)); + } + handleMessage(t) { + var n, i; + switch (this.logger.hasLevel( + 3 + /* verbose */ + ) && this.logger.info(`TIAdapter:: Received response:${vv(t)}`), t.kind) { + case uV: + this.typesRegistryCache = new Map(Object.entries(t.typesRegistry)); + break; + case l9: { + const s = (n = this.packageInstalledPromise) == null ? void 0 : n.get(t.id); + E.assertIsDefined(s, "Should find the promise for package install"), (i = this.packageInstalledPromise) == null || i.delete(t.id), t.success ? s.resolve({ successMessage: t.message }) : s.reject(t.message), this.projectService.updateTypingsForProject(t), this.event(t, "setTypings"); + break; + } + case Ase: { + const s = { + message: t.message + }; + this.event(s, "typesInstallerInitializationFailed"); + break; + } + case _V: { + const s = { + eventId: t.eventId, + packages: t.packagesToInstall + }; + this.event(s, "beginInstallTypes"); + break; + } + case fV: { + if (this.telemetryEnabled) { + const c = { + telemetryEventName: "typingsInstalled", + payload: { + installedPackages: t.packagesToInstall.join(","), + installSuccess: t.installSuccess, + typingsInstallerVersion: t.typingsInstallerVersion + } + }; + this.event(c, "telemetry"); + } + const s = { + eventId: t.eventId, + packages: t.packagesToInstall, + success: t.installSuccess + }; + this.event(s, "endInstallTypes"); + break; + } + case c9: { + this.projectService.updateTypingsForProject(t); + break; + } + case o9: { + for (this.activeRequestCount > 0 ? this.activeRequestCount-- : E.fail("TIAdapter:: Received too many responses"); !this.requestQueue.isEmpty(); ) { + const s = this.requestQueue.dequeue(); + if (this.requestMap.get(s.projectName) === s) { + this.requestMap.delete(s.projectName), this.scheduleRequest(s); + break; + } + this.logger.hasLevel( + 3 + /* verbose */ + ) && this.logger.info(`TIAdapter:: Skipping defunct request for: ${s.projectName}`); + } + this.projectService.updateTypingsForProject(t), this.event(t, "setTypings"); + break; + } + case RA: + this.projectService.watchTypingLocations(t); + break; + } + } + scheduleRequest(t) { + this.logger.hasLevel( + 3 + /* verbose */ + ) && this.logger.info(`TIAdapter:: Scheduling request for: ${t.projectName}`), this.activeRequestCount++, this.host.setTimeout( + () => { + this.logger.hasLevel( + 3 + /* verbose */ + ) && this.logger.info(`TIAdapter:: Sending request:${vv(t)}`), this.installer.send(t); + }, + q5e.requestDelayMillis, + `${t.projectName}::${t.kind}` + ); + } + }; + jPe.requestDelayMillis = 100; + var BPe = jPe, JPe = {}; + Na(JPe, { + ActionInvalidate: () => c9, + ActionPackageInstalled: () => l9, + ActionSet: () => o9, + ActionWatchTypingLocations: () => RA, + Arguments: () => pV, + AutoImportProviderProject: () => H_e, + AuxiliaryProject: () => V_e, + CharRangeSection: () => yfe, + CloseFileWatcherEvent: () => wG, + CommandNames: () => CPe, + ConfigFileDiagEvent: () => xG, + ConfiguredProject: () => G_e, + ConfiguredProjectLoadKind: () => K_e, + CreateDirectoryWatcherEvent: () => DG, + CreateFileWatcherEvent: () => EG, + Errors: () => Rh, + EventBeginInstallTypes: () => _V, + EventEndInstallTypes: () => fV, + EventInitializationFailed: () => Ase, + EventTypesRegistry: () => uV, + ExternalProject: () => hG, + GcTimer: () => I_e, + InferredProject: () => U_e, + LargeFileReferencedEvent: () => TG, + LineIndex: () => W8, + LineLeaf: () => VL, + LineNode: () => fE, + LogLevel: () => x_e, + Msg: () => k_e, + OpenFileInfoTelemetryEvent: () => $_e, + Project: () => Ek, + ProjectInfoTelemetryEvent: () => CG, + ProjectKind: () => Ww, + ProjectLanguageServiceStateEvent: () => kG, + ProjectLoadingFinishEvent: () => SG, + ProjectLoadingStartEvent: () => bG, + ProjectService: () => cfe, + ProjectsUpdatedInBackgroundEvent: () => zL, + ScriptInfo: () => M_e, + ScriptVersionCache: () => JG, + Session: () => FPe, + TextStorage: () => L_e, + ThrottledOperations: () => A_e, + TypingsInstallerAdapter: () => BPe, + allFilesAreJsOrDts: () => J_e, + allRootFilesAreJsOrDts: () => B_e, + asNormalizedPath: () => Ywe, + convertCompilerOptions: () => WL, + convertFormatOptions: () => lE, + convertScriptKindName: () => NG, + convertTypeAcquisition: () => Q_e, + convertUserPreferences: () => Y_e, + convertWatchOptions: () => J8, + countEachFileTypes: () => M8, + createInstallTypingsRequest: () => C_e, + createModuleSpecifierCache: () => _fe, + createNormalizedPathMap: () => Zwe, + createPackageJsonCache: () => ffe, + createSortedArray: () => N_e, + emptyArray: () => bl, + findArgument: () => Zbe, + formatDiagnosticToProtocol: () => z8, + formatMessage: () => pfe, + getBaseConfigFileName: () => gG, + getDetailWatchInfo: () => OG, + getLocationInNewDocument: () => hfe, + hasArgument: () => Ybe, + hasNoTypeScriptSource: () => z_e, + indent: () => pw, + isBackgroundProject: () => j8, + isConfigFile: () => lfe, + isConfiguredProject: () => L0, + isDynamicFileName: () => zw, + isExternalProject: () => R8, + isInferredProject: () => cE, + isInferredProjectName: () => E_e, + isProjectDeferredClose: () => B8, + makeAutoImportProviderProjectName: () => w_e, + makeAuxiliaryProjectName: () => P_e, + makeInferredProjectName: () => D_e, + maxFileSize: () => vG, + maxProgramSizeForNonTsFiles: () => yG, + normalizedPathToPath: () => oE, + nowString: () => Kbe, + nullCancellationToken: () => TPe, + nullTypingsInstaller: () => UL, + protocol: () => F_e, + scriptInfoIsContainedByBackgroundProject: () => R_e, + scriptInfoIsContainedByDeferredClosedProject: () => j_e, + stringifyIndented: () => vv, + toEvent: () => dfe, + toNormalizedPath: () => ro, + tryConvertScriptKindName: () => PG, + typingsInstaller: () => T_e, + updateProjectIfDirty: () => Gp + }), typeof console < "u" && (E.loggingHost = { + log(e, t) { + switch (e) { + case 1: + return console.error(t); + case 2: + return console.warn(t); + case 3: + return console.log(t); + case 4: + return console.log(t); + } + } + }); + })({ get exports() { + return es; + }, set exports(Ja) { + es = Ja, Cl.exports && (Cl.exports = Ja); + } }); + }(lge)), lge.exports; +} +var gpt = mpt(); +const hpt = /* @__PURE__ */ ept(gpt); +function $X(Cl, es) { + ypt(Cl) ? (O5e("show-in-ide", { attach: es ?? !1, goToCustomComponentFile: !0 }), age(`${oge}show-in-ide`, { + javaClassName: Cl.className, + fileName: Cl.absoluteFilePath + })) : rpt(Cl) ? (O5e("show-in-ide", { attach: es ?? !1 }), age(`${oge}show-in-ide`, { ...npt(Cl), attach: es ?? !1 })) : (ipt("show-in-ide"), age(`${oge}show-in-ide`, Cl)); +} +mge.on("show-in-ide", (Cl) => { + const es = Cl.detail.node; + if (Cl.detail.source) { + $X(Cl.detail.source); + return; + } + if (Cl.detail.javaSource) { + $X(Cl.detail.javaSource); + return; + } + if (!es) + return; + if (es.isFlowComponent) { + $X(es.node, Cl.detail.attach); + return; + } + const Ja = H5e(es); + Ja && $X(Ja); +}); +function ypt(Cl) { + return Cl === void 0 ? !1 : Cl.className !== void 0 ? !0 : Cl.absoluteFilePath !== void 0; +} +function H5e(Cl) { + if (!Cl.isReactComponent) + return; + const es = F5e(Cl.node); + if (es) + return es; + const Ja = tpt(Cl.node); + if (Ja) + return Ja; + const Pc = Cl.children.sort((Na, Tg) => Na.siblingIndex - Tg.siblingIndex).find((Na) => Na.isReactComponent && H5e(Na) !== void 0); + if (!Pc) + throw new Error(`Could not find the source of ${Cl.nameAndIdentifier}`); + return F5e(Pc.node); +} +function vpt(Cl) { + cge.active || cge.setActive(!0), spt("copilot-init-app", { framework: Cl }, async (es) => { + if (es.data.success) + document.body.innerHTML = `

The files have been created

+

You need to restart the server for the changes to have effect.

`; + else { + const Ja = es.data.reason; + apt(Ja); + } + }), cge.setActive(!1); +} +class bpt { + constructor(es) { + this._currentTree = es; + } + get root() { + return this.currentTree.root; + } + get allNodesFlat() { + return this.currentTree.allNodesFlat; + } + getNodeOfElement(es) { + return this.currentTree.getNodeOfElement(es); + } + getChildren(es) { + return this.currentTree.getChildren(es); + } + hasFlowComponents() { + return this.currentTree.hasFlowComponents(); + } + findNodeByUuid(es) { + return this.currentTree.findNodeByUuid(es); + } + getElementByNodeUuid(es) { + return this.currentTree.getElementByNodeUuid(es); + } + findByTreePath(es) { + return this.currentTree.findByTreePath(es); + } + get currentTree() { + return this._currentTree; + } + set currentTree(es) { + this._currentTree = es, mge.emit("copilot-tree-created", {}); + } + get customComponentDataLoaded() { + return this._currentTree.customComponentDataLoaded; + } +} +mge.on("navigate", (Cl) => { + const es = window.history.state?.idx, Ja = {}; + es !== void 0 && (Ja.idx = es + 1), window.history.pushState(Ja, "", Cl.detail.path), window.dispatchEvent(new PopStateEvent("popstate")); +}); +function Spt(Cl) { + const es = window.Vaadin.copilot.tree; + return Cl.map((Ja) => { + let Pc = null; + const { nodeUuid: Na, treePath: Tg, childIndex: mb } = Ja; + if (Na) { + const q2 = es.findNodeByUuid(Na); + q2 && (Pc = q2); + } + return Pc || (Pc = es.findByTreePath(Tg) ?? null), Pc && mb !== void 0 && Pc.children.length > mb ? Pc.children[mb] : Pc; + }).filter((Ja) => Ja !== null); +} +class bR { + constructor() { + this.drillDownComponentStack = [], opt(this, { + drillDownComponentStack: cpt.shallow + }); + } + getCustomComponentIcon(es) { + const Ja = this.getIconTag(es); + return Ja === void 0 ? lpt : fpt[Ja]; + } + getIconTag(es) { + const Pc = this.getCustomComponentInfo(es)?.type; + if (Pc === "IN_PROJECT") + return "thermostatCarbon"; + if (Pc === "EXTERNAL") + return "deployedCube"; + } + getCustomComponentInfo(es) { + if (es.customComponentData && bR.isCustomComponentInstanceInfo(es.customComponentData)) + return es.customComponentData; + } + isCustomComponent(es) { + return this.getCustomComponentInfo(es) !== void 0; + } + isVisibleAndSelectable(es) { + if (!this.getTree().customComponentDataLoaded) + return !0; + const Ja = this.getActiveDrillDownContext(); + if (!es.customComponentData) + return es.isReactComponent && !es.parent && es.name === "App" && !Ja; + if (Ja?.uuid === es.uuid) + return !1; + const Pc = this.getActiveDrillDownData(), Na = es.customComponentData; + return Pc?.filePath ? es.customComponentData ? this.checkNodeIsInDrillDownContext(Na, Pc) : !1 : Na ? !Na.childOfCustomComponent : !0; + } + pushDrillDownContext(es) { + this.drillDownComponentStack.push(es), this.persistIntoStorage(), L5e(es); + } + isDrillDownContext(es) { + return this.getActiveDrillDownContext()?.uuid === es.uuid; + } + getActiveDrillDownContext() { + if (this.drillDownComponentStack.length !== 0) + return this.drillDownComponentStack[this.drillDownComponentStack.length - 1]; + } + clearDrillDownContext() { + this.drillDownComponentStack = [], this.persistIntoStorage(); + } + popDrillDownContext() { + this.drillDownComponentStack.pop(), this.persistIntoStorage(); + } + isChildInDrillContext(es) { + const Ja = es.customComponentData; + if (!Ja) + return !0; + const Pc = this.getActiveDrillDownData(); + return Pc ? this.checkNodeIsInDrillDownContext(Ja, Pc) : !1; + } + getActiveDrillDownData() { + const es = this.getActiveDrillDownContext(); + if (es === void 0) + return; + const Ja = this.getCustomComponentInfo(es); + if (!Ja?.javaClassName && !Ja?.reactMethodName) + return; + const Pc = es.node; + return { + className: Ja.javaClassName, + methodName: Ja.reactMethodName, + nodeId: Pc.nodeId, + uiId: Pc.uiId, + filePath: Ja.customComponentFilePath ?? void 0 + }; + } + checkNodeIsInDrillDownContext(es, Ja) { + return es.createLocationMethodName && Ja.methodName ? es.createLocationMethodName === Ja.methodName && Ja.filePath === es.createLocationPath : Ja.filePath === es.createLocationPath && Ja.className === es.createdClassName; + } + persistIntoStorage() { + const es = this.drillDownComponentStack.map((Ja) => ({ + treePath: Ja.path, + nodeUuid: Ja.uuid + })); + M5e.saveDrillDownContextReference(es); + } + restoreDrillDownFromStorage() { + const es = M5e.getDrillDownContextReference(); + let Ja = []; + if (es === void 0) { + const Na = this.getTree().allNodesFlat.find((Tg) => Tg.customComponentData?.routeView); + Na?.customComponentData && bR.isCustomComponentInstanceInfo(Na.customComponentData) && (Ja = [Na]); + } else + Ja = Spt(es); + Ja.forEach((Na) => { + const Tg = this.drillDownComponentStack.findIndex((mb) => mb.uuid === Na.uuid); + Tg !== -1 && this.drillDownComponentStack.splice(Tg, 1), this.drillDownComponentStack.push(Na); + }); + const Pc = this.getActiveDrillDownContext(); + Pc && L5e(Pc); + } + areInternalsVisible(es) { + if (!this.getCustomComponentInfo(es)) + return !0; + const Pc = this.getActiveDrillDownData(); + let Na; + return Pc && Pc.filePath && (Na = Pc.filePath), Na ? this.checkChildrenCreateLocationToDisplayInternals(es.children, Na) : !1; + } + checkChildrenCreateLocationToDisplayInternals(es, Ja) { + for (const Pc of es) { + const Na = Pc.customComponentData; + if (Na && Na.createLocationPath === Ja || this.checkChildrenCreateLocationToDisplayInternals(Pc.children, Ja)) + return !0; + } + return !1; + } + getDescendantsCreatedInActiveDrillDownContextFlatten(es) { + if (es.customComponentData && bR.isCustomComponentInstanceInfo(es.customComponentData)) { + const Ja = this.getActiveDrillDownData(); + let Pc; + if (Ja && Ja.filePath ? Pc = Ja.filePath : this.getRouteViewPath() && (Pc = this.getRouteViewPath()), Pc) + return this.getChildrenInPathFlattenRecursively(es, Pc); + } + return []; + } + getChildrenInPathFlattenRecursively(es, Ja) { + const Pc = es.children, Na = []; + for (const Tg of Pc) { + const mb = Tg.customComponentData; + mb && mb.createLocationPath === Ja && Na.push(Tg), Na.push(...this.getChildrenInPathFlattenRecursively(Tg, Ja)); + } + return Na; + } + /** + * Accessed to copilot tree through window object to avoid circular dependency or initialization issues. + * @private + */ + getTree() { + return window.Vaadin.copilot.tree; + } + getRouteViewPath() { + const es = this.getTree().allNodesFlat.find((Ja) => Ja.customComponentData?.routeView === !0); + if (es) + return es.customComponentData?.createLocationPath ?? void 0; + } + static isCustomComponentInstanceInfo(es) { + return "type" in es && "activeLevel" in es; + } +} +window.Vaadin.copilot.comm = upt; +window.Vaadin.copilot.ts = hpt; +const Tpt = new _pt(); +window.Vaadin.copilot.tree = new bpt(Tpt); +window.Vaadin.copilot.customComponentHandler = new bR(); +window.Vaadin.copilot.initEmptyApp = vpt; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/copilot-info-plugin-C03ukXfd.js b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-info-plugin-C03ukXfd.js new file mode 100644 index 0000000..72f6fcf --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-info-plugin-C03ukXfd.js @@ -0,0 +1,202 @@ +import { j as p, J as c, w as y, D as s, K as g, E as k, ar as u, T as $, _ as I, a7 as V, a8 as S, M as C, b as D, r as b } from "./copilot-BvIxHaRg.js"; +import { B as E } from "./base-panel-C5as2IDv.js"; +import { i as d } from "./icons-DpjjuYvb.js"; +import { c as P } from "./index-DjQvWJdw.js"; +const A = 'copilot-info-panel{--dev-tools-red-color: red;--dev-tools-grey-color: gray;--dev-tools-green-color: green;position:relative}copilot-info-panel dl{margin:0;width:100%}copilot-info-panel dl>div{align-items:center;display:flex;gap:var(--space-50);height:var(--copilot-size-md);padding:0 var(--space-150);position:relative}copilot-info-panel dl>div:after{border-bottom:1px solid var(--divider-secondary-color);content:"";inset:auto var(--space-150) 0;position:absolute}copilot-info-panel dl dt{color:var(--vaadin-text-color-secondary)}copilot-info-panel dl dd{align-items:center;display:flex;font-weight:var(--copilot-font-weight-medium);gap:var(--space-50);margin:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}copilot-info-panel dl dd span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}copilot-info-panel dl dd span.icon{display:inline-flex;vertical-align:bottom}copilot-info-panel dd.live-reload-status>span{overflow:hidden;text-overflow:ellipsis;display:block;color:var(--status-color)}copilot-info-panel dd span.hidden{display:none}copilot-info-panel code{white-space:nowrap;-webkit-user-select:all;user-select:all}copilot-info-panel .checks{display:inline-grid;grid-template-columns:auto 1fr;gap:var(--space-50)}copilot-info-panel span.hint{font-size:var(--copilot-font-size-xs);background:var(--gray-50);padding:var(--space-75);border-radius:var(--vaadin-radius-m)}'; +var T = Object.getOwnPropertyDescriptor, h = (e, t, i, o) => { + for (var a = o > 1 ? void 0 : o ? T(t, i) : t, n = e.length - 1, l; n >= 0; n--) + (l = e[n]) && (a = l(a) || a); + return a; +}; +let m = class extends E { + connectedCallback() { + super.connectedCallback(), this.onEventBus("system-info-with-callback", (e) => { + e.detail.callback(this.getInfoForClipboard(e.detail.notify)); + }), this.reaction( + () => p.idePluginState, + () => { + this.requestUpdate("serverInfo"); + } + ); + } + getIndex(e) { + return c.serverVersions.findIndex((t) => t.name === e); + } + render() { + const e = p.newVaadinVersionState?.versions !== void 0 && p.newVaadinVersionState.versions.length > 0, t = []; + p.userInfo?.vaadiner && t.push({ + name: "Vaadin Employee", + version: "true" + }); + const i = [ + ...c.serverVersions, + ...t, + ...c.clientVersions + ].map((a) => { + const n = { ...a }; + return n.name === "Vaadin" && (n.more = s` `), n; + }); + let o = this.getIndex("Spring") + 1; + return o === 0 && (o = i.length), c.springSecurityEnabled && (i.splice(o, 0, { name: "Spring Security", version: "true" }), o++), c.springJpaDataEnabled && (i.splice(o, 0, { name: "Spring Data JPA", version: "true" }), o++), s` +
+
+ ${i.map( + (a) => s` +
+
${a.name}
+
+ ${this.renderValue(a.version)} + ${a.more} +
+
+ ` + )} + ${this.renderDevWorkflowSection()} ${this.renderDevelopmentWorkflowButton()} +
+
`; + } + renderDevWorkflowSection() { + const e = g(), t = this.getIdePluginLabelText(p.idePluginState), i = this.getHotswapAgentLabelText(e); + return s` +
+
Java Hotswap
+
+ ${f(e === "success", e === "success" ? "Enabled" : "Disabled")} ${i} +
+
+ ${u() !== "unsupported" ? s`
+
IDE Plugin
+
+ ${f( + u() === "success", + u() === "success" ? "Installed" : "Not Installed" + )} + ${t} +
+
` : k} + `; + } + renderDevelopmentWorkflowButton() { + const e = $(); + let t = "", i = null, o = ""; + return e.status === "success" ? (t = "success", i = d.check, o = "IDE Plugin and Java Hotswap are in use.") : e.status === "warning" ? (t = "warning", i = d.lightning, o = "Improve Development Workflow") : e.status === "error" && (t = "error", i = d.alertCircle, o = "Fix Development Workflow"), s` +
+
Development Workflow
+
+ ${i} + + +
+
+ `; + } + getHotswapAgentLabelText(e) { + return e === "success" ? "Java Hotswap is enabled" : e === "error" ? "Hotswap is partially enabled" : "Hotswap is disabled"; + } + getIdePluginLabelText(e) { + if (u() !== "success") + return "Not installed"; + if (e?.version) { + let t = null; + return e?.ide && (e?.ide === "intellij" ? t = "IntelliJ" : e?.ide === "vscode" ? t = "VS Code" : e?.ide === "eclipse" && (t = "Eclipse")), t ? `${e?.version} ${t}` : e?.version; + } + return "Not installed"; + } + renderValue(e) { + return e === "false" ? f(!1, "False") : e === "true" ? f(!0, "True") : e; + } + getInfoForClipboard(e) { + const t = this.renderRoot.querySelectorAll(".items-start dt"), a = Array.from(t).map((n) => ({ + key: n.textContent.trim(), + value: n.nextElementSibling.textContent.trim() + })).filter((n) => n.key !== "Live reload").filter((n) => !n.key.startsWith("Vaadin Emplo")).filter((n) => n.key !== "Development Workflow").map((n) => { + const { key: l } = n; + let { value: r } = n; + if (l === "IDE Plugin") + r = this.getIdePluginLabelText(p.idePluginState) ?? "false"; + else if (l === "Java Hotswap") { + const x = c.jdkInfo?.jrebel, v = g(); + x && v === "success" ? r = "JRebel is in use" : r = this.getHotswapAgentLabelText(v); + } else l === "Vaadin" && r.indexOf(` +`) !== -1 && (r = r.substring(0, r.indexOf(` +`))); + return `${l}: ${r}`; + }).join(` +`); + return e && V({ + type: S.INFORMATION, + message: "Environment information copied to clipboard", + dismissId: "versionInfoCopied" + }), a.trim(); + } +}; +m = h([ + b("copilot-info-panel") +], m); +let w = class extends C { + createRenderRoot() { + return this; + } + connectedCallback() { + super.connectedCallback(), this.style.display = "flex"; + } + render() { + return s` `; + } +}; +w = h([ + b("copilot-info-actions") +], w); +const H = { + header: "Info", + expanded: !1, + panelOrder: 15, + panel: "right", + floating: !1, + tag: "copilot-info-panel", + actionsTag: "copilot-info-actions", + eager: !0 + // Render even when collapsed as error handling depends on this +}, J = { + init(e) { + e.addPanel(H); + } +}; +window.Vaadin.copilot.plugins.push(J); +function f(e, t) { + return e ? s`${d.check}` : s`${d.x}`; +} +export { + w as Actions, + m as CopilotInfoPanel +}; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/copilot-init-step2-TY87urez.js b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-init-step2-TY87urez.js new file mode 100644 index 0000000..fe70170 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-init-step2-TY87urez.js @@ -0,0 +1,3690 @@ +import { r as b, M as I, u as ge, v as j, b as u, j as l, C as K, w as p, x as m, y as se, z as Y, A as _, O as xe, B as E, D as r, F as X, G as pt, H as ht, I as ut, J as f, K as Q, L as Se, N as Ee, E as g, Q as Je, k as ae, l as qe, P as We, R as gt, V as ft, S as c, T as Ge, U as S, W as vt, X as Pe, Y as Ie, Z as Ye, _ as mt, $ as le, a0 as bt, a1 as Re, a2 as wt, a3 as yt, a4 as xt, a5 as Pt, a6 as Xe, a7 as N, a8 as R, a9 as It, aa as At, ab as $t, ac as Ke, ad as Ct, ae as kt, af as St, ag as Et, ah as Rt, ai as Ze, aj as Dt, ak as Ae, al as $e, am as Lt, an as Mt } from "./copilot-BvIxHaRg.js"; +import { n as y, r as x } from "./state-BGGS46O3.js"; +import { e as O } from "./query-BykXNUlT.js"; +import { i as d } from "./icons-DpjjuYvb.js"; +import { c as Qe } from "./index-DjQvWJdw.js"; +const zt = 1, De = 40, _t = 18; +function Ot(e, t) { + if (e.length === 0) + return; + const i = Tt(e, t); + for (const n in e) + e[n].style.setProperty("--content-height", `${i[n]}px`); +} +function Tt(e, t) { + const i = e.length, n = e.filter((s) => s.panelInfo && s.panelInfo.expanded).length, o = i - n; + return e.map((s) => { + const a = s.panelInfo; + return a && !a.expanded ? De : (t.offsetHeight - (t.position === "bottom" ? _t : 0) - o * De - i * zt) / n; + }); +} +var Ht = Object.defineProperty, Ut = Object.getOwnPropertyDescriptor, B = (e, t, i, n) => { + for (var o = n > 1 ? void 0 : n ? Ut(t, i) : t, s = e.length - 1, a; s >= 0; s--) + (a = e[s]) && (o = (n ? a(t, i, o) : a(o)) || o); + return n && o && Ht(t, i, o), o; +}; +const de = "data-drag-initial-index", q = "data-drag-final-index"; +let M = class extends I { + constructor() { + super(...arguments), this.position = "right", this.opened = !1, this.keepOpen = !1, this.resizing = !1, this.closingForcefully = !1, this.draggingSectionPanel = null, this.openedDescendantOverlayOwners = /* @__PURE__ */ new Set(), this.drawerDragLeaveListener = (e) => { + const { x: t, y: i } = e; + ge(this.getBoundingClientRect(), t, i) ? this.debounceHideDrawerWhenDragLeave.clear() : this.debounceHideDrawerWhenDragLeave(); + }, this.drawerDragEnterListener = () => { + this.opened = !0; + }, this.debounceHideDrawerWhenDragLeave = j(() => { + this.opened = !1; + }, 200), this.panelCountChanged = j(() => { + this.refreshSplit(); + }, 100), this.documentMouseUpListener = () => { + this.resizing && u.emit("user-select", { allowSelection: !0 }), this.resizing = !1, l.setDrawerResizing(!1), this.removeAttribute("resizing"); + }, this.resizingMouseMoveListener = (e) => { + if (!this.resizing) + return; + const { x: t, y: i } = e; + e.stopPropagation(), e.preventDefault(), requestAnimationFrame(() => { + let n; + if (this.position === "right") { + const o = document.body.clientWidth - t; + this.style.setProperty("--size", `${o}px`), K.saveDrawerSize(this.position, o), n = { width: o }; + } else if (this.position === "left") { + const o = t; + this.style.setProperty("--size", `${o}px`), K.saveDrawerSize(this.position, o), n = { width: o }; + } else if (this.position === "bottom") { + const o = document.body.clientHeight - i; + this.style.setProperty("--size", `${o}px`), K.saveDrawerSize(this.position, o), n = { height: o }; + } + this.setActualSize(), p.panels.filter((o) => !o.floating && o.panel === this.position).forEach((o) => { + p.updatePanel(o.tag, n); + }); + }); + }, this.sectionPanelDraggingStarted = (e, t) => { + this.draggingSectionPanel = e, u.emit("user-select", { allowSelection: !1 }), this.draggingSectionPointerStartY = t.clientY, e.toggleAttribute("dragging", !0), e.style.zIndex = "1000", Array.from(this.querySelectorAll("copilot-section-panel-wrapper")).forEach((i, n) => { + i.setAttribute(de, `${n}`); + }), document.addEventListener("mousemove", this.sectionPanelDragging), document.addEventListener("mouseup", this.sectionPanelDraggingFinished); + }, this.sectionPanelDragging = (e) => { + if (!this.draggingSectionPanel) + return; + const { clientX: t, clientY: i } = e; + if (!ge(this.getBoundingClientRect(), t, i)) { + this.cleanUpDragging(); + return; + } + const n = i - this.draggingSectionPointerStartY; + this.draggingSectionPanel.style.transform = `translateY(${n}px)`, this.updateSectionPanelPositionsWhileDragging(); + }, this.sectionPanelDraggingFinished = () => { + if (!this.draggingSectionPanel) + return; + u.emit("user-select", { allowSelection: !0 }); + const e = this.getAllPanels().filter( + (t) => t.hasAttribute(q) && t.panelInfo?.panelOrder !== Number.parseInt(t.getAttribute(q), 10) + ).map((t) => ({ + tag: t.panelTag, + order: Number.parseInt(t.getAttribute(q), 10) + })); + this.cleanUpDragging(), p.updateOrders(e), document.removeEventListener("mouseup", this.sectionPanelDraggingFinished), document.removeEventListener("mousemove", this.sectionPanelDragging), this.refreshSplit(); + }, this.updateSectionPanelPositionsWhileDragging = () => { + const e = this.draggingSectionPanel.getBoundingClientRect().height; + this.getAllPanels().sort((t, i) => { + const n = t.getBoundingClientRect(), o = i.getBoundingClientRect(), s = (n.top + n.bottom) / 2, a = (o.top + o.bottom) / 2; + return s - a; + }).forEach((t, i) => { + if (t.setAttribute(q, `${i}`), t.panelTag !== this.draggingSectionPanel?.panelTag) { + const n = Number.parseInt(t.getAttribute(de), 10); + n > i ? t.style.transform = `translateY(${-e}px)` : n < i ? t.style.transform = `translateY(${e}px)` : t.style.removeProperty("transform"); + } + }); + }, this.panelExpandedListener = (e) => { + this.querySelector(`copilot-section-panel-wrapper[paneltag="${e.detail.panelTag}"]`) && this.refreshSplit(); + }, this.setActualSize = () => { + let e = this.offsetWidth; + this.position === "bottom" && (e = this.offsetHeight), this.style.setProperty("--actual-size", `calc(${e}px - var(--hover-size))`); + }; + } + static get styles() { + return [ + m(se), + m(Y), + _` + :host { + --size: 350px; + --actual-size: 350px; + --min-size: 20%; + --max-size: 80%; + --default-content-height: 300px; + --transition-duration: var(--duration-2); + --opening-delay: var(--duration-2); + --closing-delay: var(--duration-3); + --hover-size: 18px; + position: absolute; + z-index: var(--z-index-drawer); + transition: translate var(--transition-duration) var(--closing-delay); + } + + :host(:is([position='left'], [position='right'])) { + width: var(--size); + min-width: var(--min-size); + max-width: var(--max-size); + top: 0; + bottom: 0; + } + + :host([position='left']) { + left: calc(0px - var(--actual-size)); + translate: 0% 0%; + padding-right: var(--hover-size); + } + + :host([position='right']) { + right: calc(0px - var(--actual-size)); + translate: 0% 0%; + padding-left: var(--hover-size); + } + + :host([position='bottom']) { + height: var(--size); + min-height: var(--min-size); + max-height: var(--max-size); + bottom: calc(0px - var(--actual-size)); + left: 0; + right: 0; + translate: 0% 0%; + padding-top: var(--hover-size); + } + + /* The visible container. Needed to have extra space for hover and resize handle outside it. */ + + .container { + display: flex; + flex-direction: column; + box-sizing: border-box; + height: 100%; + background: var(--background-color); + -webkit-backdrop-filter: var(--surface-backdrop-filter); + backdrop-filter: var(--surface-backdrop-filter); + overflow-y: auto; + overflow-x: hidden; + box-shadow: var(--surface-box-shadow-2); + transition: + opacity var(--transition-duration) var(--closing-delay), + visibility calc(var(--transition-duration) * 2) var(--closing-delay); + opacity: 0; + /* For accessibility (restored when open) */ + visibility: hidden; + } + + :host([position='left']) .container { + border-right: 1px solid var(--surface-border-color); + } + + :host([position='right']) .container { + border-left: 1px solid var(--surface-border-color); + } + + :host([position='bottom']) .container { + border-top: 1px solid var(--surface-border-color); + } + + /* Opened state */ + + :host([position='left']:is([opened], [keepopen])) { + translate: calc(100% - var(--hover-size)) 0%; + } + :host([position='right']:is([opened], [keepopen])) { + translate: calc(-100% + var(--hover-size)) 0%; + } + :host([position='bottom']:is([opened], [keepopen])) { + translate: 0 calc(-100% + var(--hover-size)); + } + + :host(:is([opened], [keepopen])) { + transition-delay: var(--opening-delay); + z-index: var(--z-index-opened-drawer); + } + + :host(:is([opened], [keepopen])) .container { + transition-delay: var(--opening-delay); + visibility: visible; + opacity: 1; + } + + .resize { + position: absolute; + z-index: 10; + inset: 0; + } + + :host(:is([position='left'], [position='right'])) .resize { + width: var(--hover-size); + cursor: col-resize; + } + + :host([position='left']) .resize { + left: auto; + right: calc(var(--hover-size) * 0.5); + } + + :host([position='right']) .resize { + right: auto; + left: calc(var(--hover-size) * 0.5); + } + + :host([position='bottom']) .resize { + height: var(--hover-size); + bottom: auto; + top: calc(var(--hover-size) * 0.5); + cursor: row-resize; + } + + :host([resizing]) .container { + /* vaadin-grid (used in the outline) blocks the mouse events */ + pointer-events: none; + } + + /* Visual indication of the drawer */ + + :host::before { + content: ''; + position: absolute; + pointer-events: none; + z-index: -1; + inset: var(--hover-size); + } + + :host([document-hidden])::before { + animation: none; + } + + :host(:is([opened], [keepopen]))::before { + transition-delay: var(--opening-delay); + opacity: 0; + } + + /* Drawer indicator */ + #drawer-indicator { + transition-delay: 0.5s; + } + #drawer-indicator::before, + #drawer-indicator::after { + border-radius: inherit; + content: ''; + inset: 0; + position: absolute; + } + #drawer-indicator::before { + animation: var(--animate-swirl); + background-image: + radial-gradient(circle at 50% -10%, var(--blue-9) 0%, transparent 60%), + radial-gradient(circle at 25% 40%, var(--violet-9) 0%, transparent 70%), + radial-gradient(circle at 80% 10%, var(--gray-9) 0%, transparent 80%), + radial-gradient(circle at 110% 50%, var(--teal-9) 20%, transparent 100%); + } + #drawer-indicator::after { + border: 1px solid rgba(255, 255, 255, 0.5); + } + :host([attention-required]) #drawer-indicator::before { + background-image: + radial-gradient(circle at 50% -10%, var(--ruby-11) 0%, transparent 60%), + radial-gradient(circle at 25% 40%, var(--ruby-8) 0%, transparent 70%), + radial-gradient(circle at 80% 10%, var(--ruby-12) 0%, transparent 80%), + radial-gradient(circle at 110% 50%, var(--ruby-7) 20%, transparent 100%); + } + :host([opened]) #drawer-indicator { + opacity: 0; + transition-delay: 0s; + } + :host([document-hidden]) #drawer-indicator { + filter: grayscale(100%); + -webkit-filter: grayscale(100%); + } + :host([position='right']) #drawer-indicator { + left: 0.25rem; + top: calc(50% - 0.875rem); + } + :host([position='right']) #drawer-indicator vaadin-icon { + margin-inline-start: -0.625rem; + transform: rotate(-90deg); + } + :host([position='left']) #drawer-indicator { + right: 0.25rem; + top: calc(50% - 0.875rem); + } + :host([position='left']) #drawer-indicator vaadin-icon { + margin-inline-end: -0.625rem; + transform: rotate(90deg); + } + :host([position='bottom']) #drawer-indicator { + left: calc(50% - 0.875rem); + top: 0.25rem; + } + :host([position='bottom']) #drawer-indicator vaadin-icon { + margin-top: -0.625rem; + } + ` + ]; + } + connectedCallback() { + super.connectedCallback(), this.reaction( + () => p.panels, + () => this.requestUpdate() + ), this.reaction( + () => l.operationInProgress, + (t) => { + t === xe.DragAndDrop && !this.opened && !this.keepOpen ? this.style.setProperty("pointer-events", "none") : this.style.setProperty("pointer-events", "auto"); + } + ), this.reaction( + () => p.getAttentionRequiredPanelConfiguration(), + () => { + const t = p.getAttentionRequiredPanelConfiguration(); + t && !t.floating && this.toggleAttribute(E, t.panel === this.position); + } + ), this.reaction( + () => l.active, + () => { + l.active || (this.opened = !1); + } + ), document.addEventListener("mouseup", this.documentMouseUpListener); + const e = K.getDrawerSize(this.position); + e && (this.style.setProperty("--size", `${e}px`), this.setActualSize()), document.addEventListener("mousemove", this.resizingMouseMoveListener), this.addEventListener("mouseenter", this.mouseEnterListener), u.on("document-activation-change", (t) => { + this.toggleAttribute("document-hidden", !t.detail.active); + }), u.on("panel-expanded", this.panelExpandedListener), u.on("copilot-main-resized", this.setActualSize), this.reaction( + () => p.panels.filter( + (t) => !t.floating && t.panel === this.position + ).length, + () => { + this.panelCountChanged(); + } + ), this.addEventListener("dragleave", this.drawerDragLeaveListener), this.addEventListener("dragenter", this.drawerDragEnterListener); + } + firstUpdated(e) { + super.firstUpdated(e), this.resizeElement.addEventListener("mousedown", (t) => { + t.button === 0 && (this.resizing = !0, l.setDrawerResizing(!0), this.setAttribute("resizing", ""), u.emit("user-select", { allowSelection: !1 })); + }); + } + updated(e) { + super.updated(e), e.has("opened") && this.opened && this.hasAttribute(E) && (this.removeAttribute(E), p.clearAttention()); + } + disconnectedCallback() { + super.disconnectedCallback(), document.removeEventListener("mousemove", this.resizingMouseMoveListener), document.removeEventListener("mouseup", this.documentMouseUpListener), this.removeEventListener("mouseenter", this.mouseEnterListener), u.off("panel-expanded", this.panelExpandedListener), u.off("copilot-main-resized", this.setActualSize), this.removeEventListener("dragleave", this.drawerDragLeaveListener), this.removeEventListener("dragenter", this.drawerDragEnterListener); + } + /** + * Cleans up attributes/styles etc... for dragging operations + * @private + */ + cleanUpDragging() { + this.draggingSectionPanel && (l.setSectionPanelDragging(!1), this.draggingSectionPanel.style.zIndex = "", Array.from(this.querySelectorAll("copilot-section-panel-wrapper")).forEach((e) => { + e.style.removeProperty("transform"), e.removeAttribute(q), e.removeAttribute(de); + }), this.draggingSectionPanel.removeAttribute("dragging"), this.draggingSectionPanel = null); + } + getAllPanels() { + return Array.from(this.querySelectorAll("copilot-section-panel-wrapper")); + } + getAllPanelsOrdered() { + return this.getAllPanels().sort((e, t) => e.panelInfo && t.panelInfo ? e.panelInfo.panelOrder - t.panelInfo.panelOrder : 0); + } + /** + * Closes the drawer and disables mouse enter event for a while. + */ + forceClose() { + this.closingForcefully = !0, this.opened = !1, setTimeout(() => { + this.closingForcefully = !1; + }, 0.5); + } + mouseEnterListener(e) { + if (this.closingForcefully || l.sectionPanelResizing) + return; + document.querySelector("copilot-main").shadowRoot.querySelector("copilot-drawer-panel[opened]") || (this.refreshSplit(), this.opened = !0); + } + render() { + return r` +
+ +
+
+
+ +
+ `; + } + refreshSplit() { + Ot(this.getAllPanelsOrdered(), this); + } +}; +B([ + y({ reflect: !0, attribute: !0 }) +], M.prototype, "position", 2); +B([ + y({ reflect: !0, type: Boolean }) +], M.prototype, "opened", 2); +B([ + y({ reflect: !0, type: Boolean }) +], M.prototype, "keepOpen", 2); +B([ + O(".container") +], M.prototype, "container", 2); +B([ + O(".resize") +], M.prototype, "resizeElement", 2); +M = B([ + b("copilot-drawer-panel") +], M); +var jt = Object.defineProperty, Nt = Object.getOwnPropertyDescriptor, Ce = (e, t, i, n) => { + for (var o = n > 1 ? void 0 : n ? Nt(t, i) : t, s = e.length - 1, a; s >= 0; s--) + (a = e[s]) && (o = (n ? a(t, i, o) : a(o)) || o); + return n && o && jt(t, i, o), o; +}; +let ee = class extends X { + constructor() { + super(...arguments), this.checked = !1, this.documentMouseDownEventClickListener = (e) => { + const t = pt([this]); + ge(t, e.x, e.y) || (this.inputElement.blur(), document.removeEventListener("mousedown", this.documentMouseDownEventClickListener, { capture: !0 })); + }; + } + static get styles() { + return _` + .switch { + display: inline-flex; + gap: var(--space-100); + padding-block: calc((var(--copilot-size-md) - var(--copilot-line-height-sm)) / 2); + position: relative; + } + + .switch input { + opacity: 0; + position: absolute; + } + + .slider { + align-items: center; + border: 2px solid var(--vaadin-text-color-secondary); + border-radius: 9999px; + box-sizing: border-box; + display: flex; + flex-shrink: 0; + height: 1.125rem; + transition: 200ms; + width: 1.75rem; + } + + .slider::before { + background: var(--vaadin-text-color-secondary); + border-radius: 9999px; + content: ''; + display: flex; + height: 0.5rem; + transition: 200ms; + translate: 0.1875rem 0; + width: 0.5rem; + } + + input:focus + .slider { + outline: 2px solid var(--focus-color); + outline-offset: 1px; + } + + input:checked + .slider { + background: var(--blue-11); + border-color: var(--blue-11); + } + + input:checked + .slider::before { + background: var(--blue-5); + height: 0.75rem; + translate: 0.6875rem 0; + width: 0.75rem; + } + `; + } + /* + TODO: We should refactor to use button instead. + + + +
+
${s}
+ + + `} + + `; + } + renderJRebelNotInstalledContent() { + return r` +
+ JRebel ${d.share} is a commercial hotswap solution. Vaadin detects the + JRebel Agent and automatically reloads the application in the browser after the Java changes have been + hotpatched. +

+ Go to + + https://www.jrebel.com/products/jrebel/learn ${d.share} + to get started +

+
+ `; + } + renderHotswapAgentNotInstalledContent(e) { + const t = [ + this.renderJavaRunningInDebugModeSection(), + this.renderHotswapAgentJdkSection(e), + this.renderInstallHotswapAgentJdkSection(e), + this.renderHotswapAgentVersionSection(), + this.renderHotswapAgentMissingArgParam(e) + ]; + return r`
${t}
`; + } + renderHotswapAgentPluginContent(e) { + const i = Q() === "success"; + return r` +
+
+ ${i ? d.checkCircle : d.alertTriangle} + ${e()} +
+
+ `; + } + renderIntelliJHotswapHint() { + return r`
+

Use 'Debug using Hotswap Agent' launch configuration

+ Vaadin IntelliJ plugin offers launch mode that does not require any manual configuration! +

+ In order to run recommended launch configuration, you should click three dots right next to Debug button and + select Debug using Hotswap Agent option. +

+
`; + } + renderVSCodeHotswapHint() { + return r`
+

Use 'Debug (hotswap)'

+ With Vaadin Visual Studio Code extension you can run Hotswap Agent without any manual configuration required! +

Click Debug (hotswap) within your main class to debug application using Hotswap Agent.

+
`; + } + renderJavaRunningInDebugModeSection() { + const e = f.jdkInfo?.runningInJavaDebugMode; + return r` +
+
+ + ${e ? d.checkCircle : d.alertTriangle} +
Run Java in debug mode
+ +
Start the application in debug mode in the IDE
+
+
+ `; + } + renderHotswapAgentMissingArgParam(e) { + const t = f.jdkInfo?.runningWitHotswap && f.jdkInfo?.runningWithExtendClassDef; + return r` +
+
+ + ${t ? d.checkCircle : d.alertTriangle} +
Enable HotswapAgent
+ +
+
    + ${e.intellij ? r`
  • Launch as mentioned in the previous step
    • ` : g} + ${e.intellij ? r`
  • + To manually configure IntelliJ, add the + -XX:HotswapAgent=fatjar -XX:+AllowEnhancedClassRedefinition -XX:+UpdateClasses JVM + arguments when launching the application +
    • ` : r`
  • + Add the + -XX:HotswapAgent=fatjar -XX:+AllowEnhancedClassRedefinition -XX:+UpdateClasses JVM + arguments when launching the application +
    • `} +
+
+
+
+ `; + } + renderHotswapAgentJdkSection(e) { + const t = f.jdkInfo?.extendedClassDefCapable, i = this.downloadStatusMessages?.[this.downloadStatusMessages.length - 1] === Me; + return r` +
+
+ + ${t ? d.checkCircle : d.alertTriangle} +
Run using JetBrains Runtime JDK
+ +
+ JetBrains Runtime provides much better hotswapping compared to other JDKs. +
    + ${e.intellij && Jt("1.3.0", l.idePluginState?.version) ? r`
  • Upgrade to the latest IntelliJ plugin
    • ` : g} + ${e.intellij ? r`
  • Launch the application in IntelliJ using "Debug using Hotswap Agent"
    • ` : g} + ${e.vscode ? r`
  • + Let Copilot download and set up JetBrains Runtime for VS Code + ${this.downloadProgress > 0 ? r`` : g} +
      + ${this.downloadStatusMessages.map((n) => r`
    • ${n}
      • `)} + ${i ? r`

      Go to VS Code and launch the 'Debug using Hotswap Agent' configuration

      ` : g} +
    +
    • ` : g} +
  • + ${e.intellij || e.vscode ? r`If there is a problem, you can manually + download JetBrains Runtime JDK and set up + your debug configuration to use it.` : r`Download JetBrains Runtime JDK and set up + your debug configuration to use it.`} +
    • +
+
+
+
+ `; + } + renderInstallHotswapAgentJdkSection(e) { + const t = f.jdkInfo?.hotswapAgentFound, i = f.jdkInfo?.extendedClassDefCapable; + return r` +
+
+ + ${t ? d.checkCircle : d.alertTriangle} +
Install HotswapAgent
+ +
+ Hotswap Agent provides application level support for hot reloading, such as reinitalizing Vaadin @Route or + @BrowserCallable classes when they are updated +
    + ${e.intellij ? r`
  • Launch as mentioned in the previous step
    • ` : g} + ${!e.intellij && !i ? r`
  • First install JetBrains Runtime as mentioned in the step above.
    • ` : g} + ${e.intellij ? r`
  • + To manually configure IntelliJ, download HotswapAgent and install the jar file as + [JAVA_HOME]/lib/hotswap/hotswap-agent.jar in the JetBrains Runtime JDK. Note that the + file must be renamed to exactly match this path. +
    • ` : r`
  • + Download HotswapAgent and install the jar file as + [JAVA_HOME]/lib/hotswap/hotswap-agent.jar in the JetBrains Runtime JDK. Note that the + file must be renamed to exactly match this path. +
    • `} +
+
+
+
+ `; + } + renderHotswapAgentVersionSection() { + if (!f.jdkInfo?.hotswapAgentFound) + return g; + const e = f.jdkInfo?.hotswapVersionOk, t = f.jdkInfo?.hotswapVersion, i = f.jdkInfo?.hotswapAgentLocation; + return r` +
+
+ + ${e ? d.checkCircle : d.alertTriangle} +
Hotswap version requires update
+ +
+ HotswapAgent version ${t} is in use + Download the latest HotswapAgent + and place it in ${i} +
+
+
+ `; + } + renderJRebelInstalledContent() { + return r`
JRebel is in use. Enjoy your awesome development workflow!
`; + } + renderHotswapAgentInstalledContent() { + return r`
Hotswap agent is in use. Enjoy your awesome development workflow!
`; + } + async downloadJetbrainsRuntime(e) { + return e.target.disabled = !0, e.preventDefault(), this.downloadStatusMessages = [], ae(`${We}set-up-vs-code-hotswap`, {}, (t) => { + t.data.error ? (qe("Error downloading JetBrains runtime", t.data.error), this.downloadStatusMessages = [...this.downloadStatusMessages, "Download failed"]) : this.downloadStatusMessages = [...this.downloadStatusMessages, Me]; + }); + } + downloadStatusUpdate(e) { + const t = e.detail.progress; + t ? this.downloadProgress = t : this.downloadStatusMessages = [...this.downloadStatusMessages, e.detail.message]; + } + addESCListener() { + document.addEventListener("keydown", this.handleESC); + } + removeESCListener() { + document.removeEventListener("keydown", this.handleESC); + } +}; +A.NAME = "copilot-development-setup-user-guide"; +A.styles = _` + :host { + --icon-size: 24px; + --summary-header-gap: 10px; + --footer-height: calc(50px + var(--space-150)); + color: var(--color); + } + :host code { + background-color: var(--gray-50); + font-size: var(--copilot-font-size-xs); + display: inline-block; + margin-top: var(--space-100); + margin-bottom: var(--space-100); + user-select: all; + } + + [part='container'] { + display: flex; + flex-direction: column; + gap: var(--space-150); + padding: var(--space-150); + box-sizing: border-box; + height: calc(100% - var(--footer-height)); + overflow: auto; + } + + [part='footer'] { + display: flex; + justify-content: flex-end; + height: var(--footer-height); + padding-left: var(--space-150); + padding-right: var(--space-150); + } + [part='hotswap-agent-section-container'] { + display: flex; + flex-direction: column; + gap: var(--space-100); + position: relative; + } + [part='content'] { + display: flex; + padding: var(--space-150); + flex-direction: column; + } + div.inner-section div.hint { + margin-left: calc(var(--summary-header-gap) + var(--icon-size)); + margin-top: var(--space-75); + } + details { + display: flex; + flex-direction: column; + box-sizing: border-box; + + & span.icon { + display: flex; + } + & span.icon.warning { + color: var(--warning-color); + } + & span.icon.success { + color: var(--success-color); + } + & span.hotswap.icon { + position: absolute; + top: var(--space-75); + left: var(--space-75); + } + & > summary, + summary::part(header) { + display: flex; + flex-direction: row; + align-items: center; + cursor: pointer; + position: relative; + gap: var(--summary-header-gap); + font: var(--copilot-font-md); + font-size: var(--copilot-font-size-sm); + } + summary::after, + summary::part(header)::after { + content: ''; + display: block; + width: 4px; + height: 4px; + border-color: var(--color); + opacity: var(--panel-toggle-opacity, 0.2); + border-width: 2px; + border-style: solid solid none none; + transform: rotate(var(--panel-toggle-angle, -45deg)); + position: absolute; + right: 15px; + top: calc(50% - var(--panel-toggle-offset, 2px)); + } + &:not([open]) { + --panel-toggle-angle: 135deg; + --panel-toggle-offset: 4px; + } + } + details[part='panel'] { + background: var(--card-bg); + border: var(--card-border); + border-radius: 4px; + user-select: none; + + &:has(summary:hover) { + border-color: var(--accent-color); + } + + & > summary, + summary::part(header) { + padding: 10px 10px; + padding-right: 25px; + } + + summary:hover, + summary::part(header):hover { + --panel-toggle-opacity: 0.5; + } + + input[type='checkbox'], + summary::part(checkbox) { + margin: 0; + } + + &:not([open]):hover { + background: var(--card-hover-bg); + } + + &[open] { + background: var(--card-open-bg); + box-shadow: var(--card-open-shadow); + + & > summary { + font-weight: bold; + } + } + .tabs { + border-bottom: 1px solid var(--border-color); + box-sizing: border-box; + display: flex; + height: 2.25rem; + } + + .tab { + background: none; + border: none; + border-bottom: 1px solid transparent; + color: var(--color); + font: var(--copilot-font-button); + height: 2.25rem; + padding: 0 0.75rem; + } + + .tab[aria-selected='true'] { + color: var(--color-high-contrast); + border-bottom-color: var(--color-high-contrast); + } + + .tab-content { + flex: 1 1 auto; + gap: var(--space-150); + overflow: auto; + padding: var(--space-150); + } + + h3 { + margin-top: 0; + } + } + `; +F([ + x() +], A.prototype, "javaPluginSectionOpened", 2); +F([ + x() +], A.prototype, "hotswapSectionOpened", 2); +F([ + x() +], A.prototype, "hotswapTab", 2); +F([ + x() +], A.prototype, "downloadStatusMessages", 2); +F([ + x() +], A.prototype, "downloadProgress", 2); +A = F([ + b(A.NAME) +], A); +const te = ht({ + header: "Development Workflow", + tag: ut, + width: 800, + height: 800, + floatingPosition: { + top: 50, + left: 50 + }, + individual: !0 +}), qt = { + init(e) { + e.addPanel(te); + } +}; +window.Vaadin.copilot.plugins.push(qt); +p.addPanel(te); +var Wt = Object.getOwnPropertyDescriptor, Gt = (e, t, i, n) => { + for (var o = n > 1 ? void 0 : n ? Wt(t, i) : t, s = e.length - 1, a; s >= 0; s--) + (a = e[s]) && (o = a(o) || o); + return o; +}; +let ze = class extends I { + createRenderRoot() { + return this; + } + connectedCallback() { + super.connectedCallback(), this.classList.add("flex", "gap-2"); + } + render() { + let e = "???"; + return c.getAIProvider() === "ANY" ? e = "Any" : c.getAIProvider() === "EU_ONLY" && (e = "Inside EU"), r` + + + AI Provider: + ${e} + + Experimental ⋅ Vaadin employees only + + `; + } +}; +ze = Gt([ + b("copilot-activation-button-ai-provider") +], ze); +var Yt = Object.getOwnPropertyDescriptor, Xt = (e, t, i, n) => { + for (var o = n > 1 ? void 0 : n ? Yt(t, i) : t, s = e.length - 1, a; s >= 0; s--) + (a = e[s]) && (o = a(o) || o); + return o; +}; +let _e = class extends I { + createRenderRoot() { + return this; + } + connectedCallback() { + super.connectedCallback(), this.classList.add("flex", "gap-2"); + } + render() { + const e = c.isAIUsageAllowed(); + let t, i; + return e === "ask" ? (t = "Always Ask", i = "text-blue-11") : e === "no" ? (t = "Disabled", i = "text-ruby-11") : (t = "Enabled", i = "text-teal-11"), r` + + + AI Usage: + ${t} + + + `; + } +}; +_e = Xt([ + b("copilot-activation-button-ai-usage") +], _e); +var Kt = Object.getOwnPropertyDescriptor, Zt = (e, t, i, n) => { + for (var o = n > 1 ? void 0 : n ? Kt(t, i) : t, s = e.length - 1, a; s >= 0; s--) + (a = e[s]) && (o = a(o) || o); + return o; +}; +let Oe = class extends I { + createRenderRoot() { + return this; + } + connectedCallback() { + super.connectedCallback(), this.classList.add("flex", "gap-2", "-m-2", "p-2", "rounded-md", "w-full"); + } + render() { + const t = Ge(), { status: i, message: n } = t; + let o = "", s = "", a = ""; + return i === "warning" ? (o = "bg-amber-3 dark:bg-amber-6", s = "text-amber-11", a = "text-amber-12 dark:text-amber-11") : i === "error" && (o = "bg-ruby-3 dark:bg-ruby-6", s = "text-ruby-11", a = "text-ruby-11"), o && this.classList.add(...o.split(" ")), r` + + + Development Workflow + ${n} + + `; + } +}; +Oe = Zt([ + b("copilot-activation-button-development-workflow") +], Oe); +var Qt = Object.getOwnPropertyDescriptor, ei = (e, t, i, n) => { + for (var o = n > 1 ? void 0 : n ? Qt(t, i) : t, s = e.length - 1, a; s >= 0; s--) + (a = e[s]) && (o = a(o) || o); + return o; +}; +function ti() { + p.updatePanel("copilot-feedback-panel", { + floating: !0 + }), c.setFeedbackDisplayedAtLeastOnce(!0); +} +let Te = class extends I { + constructor() { + super(), this.reaction( + () => c.isFeedbackDisplayedAtLeastOnce(), + () => { + this.requestUpdate(); + } + ); + } + createRenderRoot() { + return this; + } + connectedCallback() { + super.connectedCallback(), this.classList.add("flex", "gap-2"); + } + render() { + return r` + + + + Tell Us What You Think + ${c.isFeedbackDisplayedAtLeastOnce() ? g : r``} + + Give feedback or report an issue + + `; + } +}; +Te = ei([ + b("copilot-activation-button-feedback") +], Te); +var ii = Object.getOwnPropertyDescriptor, ni = (e, t, i, n) => { + for (var o = n > 1 ? void 0 : n ? ii(t, i) : t, s = e.length - 1, a; s >= 0; s--) + (a = e[s]) && (o = a(o) || o); + return o; +}; +let He = class extends I { + constructor() { + super(), this.reaction( + () => l.userInfo, + () => { + this.requestUpdate(); + } + ); + } + createRenderRoot() { + return this; + } + connectedCallback() { + super.connectedCallback(), this.classList.add("flex", "gap-3", "items-center", "px-1", "w-full"), this.addEventListener("click", this.clickListener); + } + disconnectedCallback() { + super.disconnectedCallback(), this.removeEventListener("click", this.clickListener); + } + render() { + const e = this.getStatus(); + return r` + ${this.renderPortrait()} + + ${this.getUsername()} + ${e ? r`${e}` : g} + + + `; + } + clickListener() { + if (l.userInfo?.validLicense) { + window.open("https://vaadin.com/myaccount", "_blank", "noopener"); + return; + } + if (S.active) { + ae(`${We}log-in`, {}, (e) => { + window.open(e.data.loginUrl, "_blank"); + }).catch((e) => qe("Login processing failed", e)); + return; + } + l.setLoginCheckActive(!0); + } + getUsername() { + return l.userInfo?.firstName ? `${l.userInfo.firstName} ${l.userInfo.lastName}` : "Log in"; + } + getStatus() { + if (l.userInfo?.validLicense) + return l.userInfo?.copilotProjectCannotLeaveLocalhost ? "AI Disabled" : void 0; + if (S.active) { + const e = Math.round(S.remainingTimeInMillis / 864e5); + return `Trial expires in ${e}${e === 1 ? " day" : " days"}`; + } + if (S.expired && !l.userInfo?.validLicense) + return "Trial expired"; + if (!S.active && !S.expired && !l.userInfo?.validLicense) + return "No valid license available"; + } + renderPortrait() { + return l.userInfo?.portraitUrl ? r`
` : g; + } + renderDot() { + return l.userInfo?.validLicense ? g : S.active || S.expired ? r`
` : g; + } +}; +He = ni([ + b("copilot-activation-button-user-info") +], He); +function v(e) { + return et("vaadin-menu-bar-item", e); +} +function ce(e) { + return et("vaadin-context-menu-item", e); +} +function et(e, t) { + const i = document.createElement(e); + if (t.style && (i.className = t.style), i.classList.add("no-checkmark"), t.icon) + if (typeof t.icon == "string") { + const n = document.createElement("vaadin-icon"); + n.setAttribute("icon", t.icon), i.append(n); + } else { + const n = document.createElement("vaadin-icon"); + n.svg = t.icon, i.append(n); + } + if (t.label) { + const n = document.createElement("span"); + n.classList.add("me-auto"), n.innerHTML = t.label, i.append(n); + } else if (t.component) { + const n = vt(t.component) ? t.component : document.createElement(t.component); + i.append(n); + } + if (t.description) { + const n = document.createElement("span"); + n.className = "text-secondary text-xs", n.innerHTML = t.description, i.append(n); + } + if (t.hint) { + const n = t.hint.replace( + " t.data.error ? { success: !1, errorMessage: t.data.error.message } : { success: !0 }); +} +var si = Object.defineProperty, ai = Object.getOwnPropertyDescriptor, V = (e, t, i, n) => { + for (var o = n > 1 ? void 0 : n ? ai(t, i) : t, s = e.length - 1, a; s >= 0; s--) + (a = e[s]) && (o = (n ? a(t, i, o) : a(o)) || o); + return n && o && si(t, i, o), o; +}; +const ri = 8; +function li() { + const e = document.createElement("vaadin-text-field"); + return e.label = "Username to Switch To", e.classList.add("w-full"), e.autocomplete = "off", e.addEventListener("click", async (t) => { + t.stopPropagation(); + }), e.addEventListener("keydown", async (t) => { + if (t.stopPropagation(), t.key === "Enter") { + const i = e.value, n = await tt(i); + n.success ? (c.addRecentSwitchedUsername(i), window.location.reload()) : (e.errorMessage = n.errorMessage, e.invalid = !0); + } + }), e; +} +let fe = class extends I { + constructor() { + super(...arguments), this.username = ""; + } + connectedCallback() { + super.connectedCallback(), this.style.display = "contents"; + } + render() { + return r`${this.username} { + c.removeRecentSwitchedUsername(this.username), e.stopPropagation(); + const t = this.parentElement; + if (t.style.display = "none", c.getRecentSwitchedUsernames().length === 0) { + const i = t.parentElement?.firstElementChild; + i && (i.style.display = "none"); + } + }} + >${d.delete}`; + } +}; +V([ + y({ type: String }) +], fe.prototype, "username", 2); +fe = V([ + b("copilot-switch-user") +], fe); +function di(e) { + const t = document.createElement("copilot-switch-user"); + return t.username = e, t; +} +let G = class extends I { + constructor() { + super(...arguments), this.initialMouseDownPosition = null, this.dragging = !1, this.items = [], this.mouseDownListener = (e) => { + e.composed && e.composedPath().some((t) => t instanceof HTMLElement && t === this.getMenuBarButton()) && (this.initialMouseDownPosition = { x: e.clientX, y: e.clientY }, C.draggingStarts(this, e), document.addEventListener("mousemove", this.documentDraggingMouseMoveEventListener)); + }, this.documentDraggingMouseMoveEventListener = (e) => { + if (this.initialMouseDownPosition && !this.dragging) { + const { clientX: t, clientY: i } = e; + this.dragging = Math.abs(t - this.initialMouseDownPosition.x) + Math.abs(i - this.initialMouseDownPosition.y) > ri; + } + this.dragging && (document.body.style.webkitUserSelect = "none", this.setSubMenuVisibility(!1), C.dragging(this, e)); + }, this.documentMouseUpListener = (e) => { + if (this.initialMouseDownPosition = null, document.removeEventListener("mousemove", this.documentDraggingMouseMoveEventListener), this.dragging) { + const t = C.dragging(this, e); + c.setActivationButtonPosition(t), this.setSubMenuVisibility(!0); + } else + this.setMenuBarOnClick(); + this.postDragReset(e.composed ? e.composedPath() : []); + }, this.postDragReset = j((e) => { + this.dragging = !1, this.closeMenuIfMouseTargetIsOutsideOfActivationButton(e), this.resetBodyInlineStyles(); + }, 100), this.closeMenuMouseMoveListener = (e) => { + e.composed && (this.dragging || this.closeMenuIfMouseTargetIsOutsideOfActivationButton(e.composedPath())); + }, this.closeMenuIfMouseTargetIsOutsideOfActivationButton = (e) => { + e.some((i) => { + if (i instanceof HTMLElement) { + const n = i; + if (n.localName === this.localName || n.localName === "vaadin-menu-bar-overlay" && n.classList.contains("activation-button-menu")) + return !0; + } + return !1; + }) ? this.closeMenuWithDebounce.clear() : this.closeMenuWithDebounce(); + }, this.closeMenuWithDebounce = j(() => { + this.closeMenu(); + }, 250), this.activationBtnClicked = (e) => { + if (this.dragging) { + e?.preventDefault(); + return; + } + if (l.active && this.handleAttentionRequiredOnClick()) { + e?.stopPropagation(), e?.preventDefault(); + return; + } + e?.stopPropagation(), this.dispatchEvent(new CustomEvent("activation-btn-clicked")), requestAnimationFrame(() => { + this.closeMenu(), this.openMenu(); + }); + }, this.handleAttentionRequiredOnClick = () => { + const e = p.getAttentionRequiredPanelConfiguration(); + return e ? e.panel && !e.floating ? (u.emit("open-attention-required-drawer", null), !0) : (p.clearAttention(), !0) : !1; + }, this.closeMenu = () => { + this.menubar._close(); + }, this.openMenu = () => { + this.menubar._buttons[0].dispatchEvent(new CustomEvent("mouseover", { bubbles: !0 })); + }, this.setMenuBarOnClick = () => { + const e = this.shadowRoot.querySelector("vaadin-menu-bar-button"); + e && (e.onclick = this.activationBtnClicked); + }; + } + static get styles() { + return [ + m(se), + m(Pe), + m(Ie), + m(Ye), + m(Y), + _` + :host { + --space: 1rem; + --height: var(--copilot-size-xl); + --width: var(--copilot-size-xl); + position: absolute; + top: clamp(var(--space), var(--top), calc(100vh - var(--height) - var(--space))); + left: clamp(var(--space), var(--left), calc(100vw - var(--width) - var(--space))); + bottom: clamp(var(--space), var(--bottom), calc(100vh - var(--height) - var(--space))); + right: clamp(var(--space), var(--right), calc(100vw - var(--width) - var(--space))); + user-select: none; + -ms-user-select: none; + -moz-user-select: none; + -webkit-user-select: none; + --indicator-color: var(--ruby-9); + /* Don't add a z-index or anything else that creates a stacking context */ + } + :host([document-hidden]) { + filter: grayscale(100%); + -webkit-filter: grayscale(100%); + z-index: 200; + } + :host([attention-required]) { + animation: bounce 0.5s; + animation-iteration-count: 2; + } + [part='indicator'] { + background: var(--indicator-color); + display: var(--indicator-display, none); + z-index: calc(var(--z-index-activation-button) + 1); + } + :host([indicator='info']) { + --indicator-color: var(--blue-9); + --indicator-display: block; + } + :host([indicator='warning']) { + --indicator-color: var(--amber-9); + --indicator-display: block; + } + :host([indicator='error']) { + --indicator-color: var(--ruby-9); + --indicator-display: block; + } + ` + ]; + } + connectedCallback() { + super.connectedCallback(), this.reaction( + () => p.attentionRequiredPanelTag, + () => { + this.toggleAttribute(E, p.attentionRequiredPanelTag !== null), this.updateIndicator(); + } + ), this.reaction( + () => l.active, + () => { + this.toggleAttribute("active", l.active); + }, + { fireImmediately: !0 } + ), this.addEventListener("mousedown", this.mouseDownListener), document.addEventListener("mouseup", this.documentMouseUpListener); + const e = c.getActivationButtonPosition(); + e ? (this.style.setProperty("--left", `${e.left}px`), this.style.setProperty("--bottom", `${e.bottom}px`), this.style.setProperty("--right", `${e.right}px`), this.style.setProperty("--top", `${e.top}px`)) : (this.style.setProperty("--bottom", "var(--space)"), this.style.setProperty("--right", "var(--space)")), u.on("document-activation-change", (t) => { + this.toggleAttribute("document-hidden", !t.detail.active); + }), this.reaction( + () => [ + f.jdkInfo, + l.idePluginState, + c.isFeedbackDisplayedAtLeastOnce() + ], + () => { + this.updateIndicator(); + } + ), this.reaction( + () => [ + l.active, + l.idePluginState, + c.isActivationAnimation(), + c.isActivationShortcut(), + c.isSendErrorReportsAllowed(), + c.isAIUsageAllowed(), + c.getDismissedNotifications() + ], + () => { + this.generateItems(); + } + ), document.addEventListener("mousemove", this.closeMenuMouseMoveListener); + } + disconnectedCallback() { + super.disconnectedCallback(), this.removeEventListener("mousedown", this.mouseDownListener), document.removeEventListener("mouseup", this.documentMouseUpListener), document.removeEventListener("mousemove", this.closeMenuMouseMoveListener); + } + updateIndicator() { + if (this.hasAttribute(E)) { + this.setAttribute("indicator", "error"); + return; + } + const e = Ge(); + if (e.status !== "success") { + this.setAttribute("indicator", e.status); + return; + } + if (!c.isFeedbackDisplayedAtLeastOnce()) { + this.setAttribute("indicator", "info"); + return; + } + this.removeAttribute("indicator"); + } + /** + * To hide overlay while dragging + * @param visible + */ + setSubMenuVisibility(e) { + const t = this.shadowRoot.querySelector("vaadin-menu-bar-submenu"); + if (!t) + return; + const i = t.$.overlay; + e ? i.style.visibility = "" : i.style.visibility = "hidden"; + } + resetBodyInlineStyles() { + document.body.style.webkitUserSelect === "none" && (document.body.style.webkitUserSelect = ""); + } + generateItems() { + const e = l.active, t = e && !!l.idePluginState?.supportedActions?.find((s) => s === "undo"), i = [], n = li(); + if (f.springSecurityEnabled) { + const s = c.getRecentSwitchedUsernames(); + i.push( + ...s.map((a) => ({ + component: v({ component: di(a) }), + action: async () => { + const h = await tt(a); + h.success ? window.location.reload() : n && (n.errorMessage = h.errorMessage, n.invalid = !0); + } + })) + ), i.length > 0 && i.unshift({ + component: v({ label: "Recently Used Usernames" }), + disabled: !0 + }); + } + const o = [ + { + text: "Vaadin Copilot", + children: [ + { visible: e, component: v({ component: "copilot-activation-button-user-info" }) }, + { visible: e, component: "hr" }, + { + component: v({ component: "copilot-activation-button-development-workflow" }), + action: mt + }, + { visible: f.springSecurityEnabled, component: "hr" }, + { + visible: f.springSecurityEnabled, + component: v({ + icon: d.accountCircle, + label: "Application's User" + }), + children: [ + ...i, + { + component: v({ component: n }) + } + ] + }, + { + component: "hr", + visible: t + }, + { + visible: t, + component: v({ + icon: d.undo, + label: "Undo", + hint: le.undo + }), + action: () => { + u.emit("undoRedo", { undo: !0 }); + } + }, + { + visible: t, + component: v({ + icon: d.redo, + label: "Redo", + hint: le.redo + }), + action: () => { + u.emit("undoRedo", { undo: !1 }); + } + }, + { + component: "hr", + visible: e + }, + { + visible: e, + component: v({ + icon: d.settings, + label: "Settings" + }), + children: [ + { + component: v({ + icon: d.keyboardAlt, + label: "Activation Shortcut", + suffix: c.isActivationShortcut() ? '' : '' + }), + keepOpen: !0, + action: (s) => { + c.setActivationShortcut(!c.isActivationShortcut()), pe(s, c.isActivationShortcut()); + } + }, + { + component: v({ + icon: d.playCircle, + label: "Activation Animation", + suffix: c.isActivationAnimation() ? '' : '' + }), + keepOpen: !0, + action: (s) => { + c.setActivationAnimation(!c.isActivationAnimation()), pe(s, c.isActivationAnimation()); + } + }, + { + component: v({ + component: "copilot-activation-button-ai-usage" + }), + keepOpen: !0, + action: (s) => { + let a; + const h = c.isAIUsageAllowed(); + h === "ask" ? a = "yes" : h === "no" ? a = "ask" : a = "no", c.setAIUsageAllowed(a), Ue(s); + } + }, + { + visible: l.userInfo?.vaadiner, + component: v({ component: "copilot-activation-button-ai-provider" }), + keepOpen: !0, + action: (s) => { + const a = c.getAIProvider() === "ANY" ? "EU_ONLY" : "ANY"; + c.setAIProvider(a), Ue(s); + } + }, + { + component: v({ + icon: d.bugReport, + label: "Report Errors to Vaadin", + suffix: c.isSendErrorReportsAllowed() ? '' : '' + }), + keepOpen: !0, + action: (s) => { + c.setSendErrorReportsAllowed(!c.isSendErrorReportsAllowed()), pe(s, c.isSendErrorReportsAllowed()); + } + }, + { component: "hr" }, + { + visible: e, + component: v({ + icon: d.emojiPeople, + label: "Show Welcome Message" + }), + keepOpen: !0, + action: () => { + l.setWelcomeActive(!0); + } + }, + { + visible: e, + component: v({ + icon: d.keyboard, + label: "Show Keyboard Shortcuts" + }), + action: () => { + p.updatePanel("copilot-shortcuts-panel", { + floating: !0 + }); + } + }, + { + visible: c.getDismissedNotifications().length > 0, + component: v({ + icon: d.deleteSweep, + label: "Clear Dismissed Notifications" + }), + action: () => { + c.clearDismissedNotifications(); + } + } + ] + }, + { component: "hr" }, + { + component: v({ + component: "copilot-activation-button-feedback" + }), + action: ti + }, + { + component: v({ + icon: d.vaadin, + label: "Copilot", + hint: c.isActivationShortcut() ? le.toggleCopilot : void 0, + suffix: l.active ? '' : '' + }), + action: () => { + this.activationBtnClicked(); + } + } + ] + } + ]; + this.items = o.filter(bt); + } + render() { + return r` + + +
+ `; + } + handleMenuItemClick(e) { + e.action && e.action(e); + } + getMenuBarButton() { + return this.shadowRoot.querySelector("vaadin-menu-bar-button"); + } +}; +V([ + O("vaadin-menu-bar") +], G.prototype, "menubar", 2); +V([ + x() +], G.prototype, "dragging", 2); +V([ + x() +], G.prototype, "items", 2); +G = V([ + b("copilot-activation-button") +], G); +function pe(e, t) { + const i = e.component; + if (!i || typeof i == "string") { + console.error("Unable to set switch value for a non-component item"); + return; + } + const n = i.querySelector('button[role="switch"]'); + if (!n) { + console.error("No element found when setting switch value"); + return; + } + n.setAttribute("aria-checked", t ? "true" : "false"); +} +function Ue(e) { + const t = e.component; + if (!t || typeof t == "string") { + console.error("Unable to set switch value for a non-component item"); + return; + } + t.requestUpdate && t.requestUpdate(); +} +var ci = Object.defineProperty, pi = Object.getOwnPropertyDescriptor, J = (e, t, i, n) => { + for (var o = n > 1 ? void 0 : n ? pi(t, i) : t, s = e.length - 1, a; s >= 0; s--) + (a = e[s]) && (o = (n ? a(t, i, o) : a(o)) || o); + return n && o && ci(t, i, o), o; +}; +const P = "resize-dir", he = "floating-resizing-active"; +let z = class extends I { + constructor() { + super(...arguments), this.panelTag = "", this.dockingItems = [ + { + component: ce({ + icon: d.dockToRight, + label: "Dock right" + }), + panel: "right" + }, + { + component: ce({ + icon: d.dockToLeft, + label: "Dock left" + }), + panel: "left" + }, + { + component: ce({ + icon: d.dockToBottom, + label: "Dock bottom" + }), + panel: "bottom" + } + ], this.floatingResizingStarted = !1, this.resizingInDrawerStarted = !1, this.toggling = !1, this.rectangleBeforeResizing = null, this.floatingResizeHandlerMouseMoveListener = (e) => { + if (!this.panelInfo?.floating || this.floatingResizingStarted || !this.panelInfo?.expanded) + return; + const t = this.getBoundingClientRect(), i = Math.abs(e.clientX - t.x), n = Math.abs(t.x + t.width - e.clientX), o = Math.abs(e.clientY - t.y), s = Math.abs(t.y + t.height - e.clientY), a = Number.parseInt( + window.getComputedStyle(this).getPropertyValue("--floating-offset-resize-threshold"), + 10 + ); + let h = ""; + i < a ? o < a ? (h = "nw-resize", this.setAttribute(P, "top left")) : s < a ? (h = "sw-resize", this.setAttribute(P, "bottom left")) : (h = "col-resize", this.setAttribute(P, "left")) : n < a ? o < a ? (h = "ne-resize", this.setAttribute(P, "top right")) : s < a ? (h = "se-resize", this.setAttribute(P, "bottom right")) : (h = "col-resize", this.setAttribute(P, "right")) : s < a ? (h = "row-resize", this.setAttribute(P, "bottom")) : o < a && (h = "row-resize", this.setAttribute(P, "top")), h !== "" ? (this.rectangleBeforeResizing = this.getBoundingClientRect(), this.style.setProperty("--resize-cursor", h)) : (this.style.removeProperty("--resize-cursor"), this.removeAttribute(P)), this.toggleAttribute(he, h !== ""); + }, this.floatingResizingMouseDownListener = (e) => { + this.hasAttribute(he) && e.button === 0 && (e.stopPropagation(), e.preventDefault(), this.rectangleBeforeResizing = this.getBoundingClientRect(), C.anchorLeftTop(this), this.floatingResizingStarted = !0, this.toggleAttribute("resizing", !0), l.setSectionPanelResizing(!0)); + }, this.floatingResizingMouseLeaveListener = () => { + this.panelInfo?.floating && (this.floatingResizingStarted || (this.removeAttribute("resizing"), this.removeAttribute(he), this.removeAttribute("dragging"), this.style.removeProperty("--resize-cursor"), this.removeAttribute(P), this.panelInfo != null && this.panelInfo.height != null && this.panelInfo?.height > window.innerHeight && (p.updatePanel(this.panelInfo.tag, { + height: window.innerHeight - 10 + }), this.setCssSizePositionProperties()))); + }, this.floatingResizingMouseMoveListener = (e) => { + if (!this.panelInfo?.floating || !this.floatingResizingStarted) + return; + e.stopPropagation(), e.preventDefault(); + const t = this.getResizeDirections(), { clientX: i, clientY: n } = e; + t.forEach((o) => this.setResizePosition(o, i, n)); + }, this.setFloatingResizeDirectionProps = (e, t, i, n) => { + i && i > Number.parseFloat(window.getComputedStyle(this).getPropertyValue("--min-width")) && (this.style.setProperty(`--${e}`, `${t}px`), this.style.setProperty("width", `${i}px`)); + const o = window.getComputedStyle(this), s = Number.parseFloat(o.getPropertyValue("--header-height")), a = Number.parseFloat(o.getPropertyValue("--floating-offset-resize-threshold")) / 2; + n && n > s + a && (this.style.setProperty(`--${e}`, `${t}px`), this.style.setProperty("height", `${n}px`), this.container.style.setProperty("margin-top", "calc(var(--floating-offset-resize-threshold) / 4)"), this.container.style.height = `calc(${n}px - var(--floating-offset-resize-threshold) / 2)`, this.contentArea.style.setProperty("height", `${n}px`)); + }, this.floatingResizingMouseUpListener = (e) => { + if (!this.floatingResizingStarted || !this.panelInfo?.floating) + return; + e.stopPropagation(), e.preventDefault(), this.floatingResizingStarted = !1, this.contentArea.style.removeProperty("height"), l.setSectionPanelResizing(!1); + const { width: t, height: i } = this.getBoundingClientRect(), { left: n, top: o, bottom: s, right: a } = C.anchor(this); + p.updatePanel(this.panelInfo.tag, { + width: t, + height: i, + floatingPosition: { + ...this.panelInfo.floatingPosition, + left: n, + top: o, + bottom: s, + right: a + } + }), this.style.removeProperty("width"), this.style.removeProperty("height"), this.container.style.removeProperty("height"), this.container.style.removeProperty("margin-top"), this.setCssSizePositionProperties(), this.toggleAttribute("dragging", !1); + }, this.transitionEndEventListener = () => { + this.toggling && (this.toggling = !1, C.anchor(this)); + }, this.sectionPanelMouseEnterListener = () => { + this.hasAttribute(E) && (this.removeAttribute(E), p.clearAttention()); + }, this.contentAreaMouseDownListener = () => { + p.bringToFront(this.panelInfo.tag); + }, this.documentMouseUpEventListener = () => { + document.removeEventListener("mousemove", this.draggingEventListener), this.panelInfo?.floating && (this.toggleAttribute("dragging", !1), l.setSectionPanelDragging(!1)); + }, this.panelHeaderMouseDownEventListener = (e) => { + e.button === 0 && (p.bringToFront(this.panelInfo.tag), !this.hasAttribute(P) && (e.target instanceof HTMLElement && e.target.getAttribute("part") === "title-button" ? this.startDraggingDebounce(e) : this.startDragging(e))); + }, this.panelHeaderMouseUpEventListener = (e) => { + e.button === 0 && this.startDraggingDebounce.clear(); + }, this.startDragging = (e) => { + C.draggingStarts(this, e), document.addEventListener("mousemove", this.draggingEventListener), l.setSectionPanelDragging(!0), this.panelInfo?.floating ? this.toggleAttribute("dragging", !0) : this.parentElement.sectionPanelDraggingStarted(this, e), e.preventDefault(), e.stopPropagation(); + }, this.startDraggingDebounce = j(this.startDragging, 200), this.draggingEventListener = (e) => { + const t = C.dragging(this, e); + if (this.panelInfo?.floating && this.panelInfo?.floatingPosition) { + e.preventDefault(); + const { left: i, top: n, bottom: o, right: s } = t; + p.updatePanel(this.panelInfo.tag, { + floatingPosition: { + ...this.panelInfo.floatingPosition, + left: i, + top: n, + bottom: o, + right: s + } + }); + } + }, this.setCssSizePositionProperties = () => { + const e = p.getPanelByTag(this.panelTag); + if (!e) + return; + if (e.floating && e.expanded && e.height !== void 0 ? this.style.setProperty("height", `${e.height}px`) : this.style.removeProperty("height"), e.height !== void 0 && (this.panelInfo?.floating || e.panel === "left" || e.panel === "right" ? this.style.setProperty("--section-height", `${e.height}px`) : this.style.removeProperty("--section-height")), e.width !== void 0 && (e.floating || e.panel === "bottom" ? this.style.setProperty("--section-width", `${e.width}px`) : this.style.removeProperty("--section-width")), e.floating && e.floatingPosition && !this.toggling) { + const { left: i, top: n, bottom: o, right: s } = e.floatingPosition; + this.style.setProperty("--left", i !== void 0 ? `${i}px` : "auto"), this.style.setProperty("--top", n !== void 0 ? `${n}px` : "auto"), this.style.setProperty("--bottom", o !== void 0 ? `${o}px` : ""), this.style.setProperty("--right", s !== void 0 ? `${s}px` : ""); + const a = window.getComputedStyle(this); + parseInt(a.top, 10) < 0 && this.style.setProperty("--top", "0px"), parseInt(a.bottom, 10) < 0 && this.style.setProperty("--bottom", "0px"); + } + }, this.renderPopupButton = () => { + if (!this.panelInfo) + return g; + let e; + return this.panelInfo.panel === void 0 ? e = "Close the popup" : e = this.panelInfo.floating ? `Dock ${this.panelInfo.header} to ${this.panelInfo.panel}` : `Open ${this.panelInfo.header} as a popup`, r` + + + + + + + `; + }, this.changePanelFloating = (e) => { + if (this.panelInfo) + if (e.stopPropagation(), Re(this), this.panelInfo?.floating) + p.updatePanel(this.panelInfo.tag, { floating: !1 }); + else { + let t; + if (this.panelInfo.floatingPosition) + t = this.panelInfo.floatingPosition; + else { + const { left: o, top: s } = this.getBoundingClientRect(); + t = { + left: o, + top: s + }; + } + let i = this.panelInfo?.height; + i === void 0 && this.panelInfo.expanded && (i = Number.parseInt(window.getComputedStyle(this).height, 10)), this.parentElement.forceClose(), p.updatePanel(this.panelInfo.tag, { + floating: !0, + expanded: !0, + width: this.panelInfo?.width || Number.parseInt(window.getComputedStyle(this).width, 10), + height: i, + floatingPosition: t + }), p.bringToFront(this.panelInfo.tag); + } + }, this.toggleExpand = (e) => { + this.panelInfo && (e.stopPropagation(), C.anchorLeftTop(this), p.updatePanel(this.panelInfo.tag, { + expanded: !this.panelInfo.expanded + }), this.toggling = !0, this.toggleAttribute("expanded", this.panelInfo.expanded), u.emit("panel-expanded", { panelTag: this.panelInfo.tag, expanded: this.panelInfo.expanded })); + }; + } + static get styles() { + return [ + m(se), + m(Pe), + m(Ie), + m(Ye), + m(Y), + _` + * { + box-sizing: border-box; + } + + :host { + flex: none; + --min-width: 160px; + --header-height: 40px; + --content-width: var(--content-width, 100%); + --floating-border-width: 1px; + --floating-offset-resize-threshold: 8px; + cursor: var(--cursor, var(--resize-cursor, default)); + overflow: hidden; + } + + :host(:not([expanded])) { + grid-template-rows: auto 0fr; + } + + :host([floating]) { + --content-height: calc(var(--section-height)); + } + + [part='content'] { + height: calc(var(--content-height) - var(--header-height)); + overflow: auto; + transition: + height var(--duration-2), + width var(--duration-2), + opacity var(--duration-2), + visibility calc(var(--duration-2) * 2); + } + + :host([floating]) [part='drawer-resize'] { + display: none; + } + + :host(:not([expanded])) [part='drawer-resize'] { + display: none; + } + + :host(:not([floating]):not(:last-child)) { + border-bottom: 1px solid var(--divider-primary-color); + } + + :host(:not([expanded])) [part='content'] { + opacity: 0; + visibility: hidden; + } + + :host([floating]:not([expanded])) [part='content'] { + width: 0; + height: 0; + } + + :host(:not([expanded])) [part='content'][style*='width'] { + width: 0 !important; + } + + :host([floating]) { + position: fixed; + min-width: 0; + min-height: 0; + z-index: calc(var(--z-index-floating-panel) + var(--z-index-focus, 0)); + top: clamp(0px, var(--top), calc(100vh - var(--section-height, var(--header-height)) * 0.5)); + left: clamp(calc(var(--section-width) * -0.5), var(--left), calc(100vw - var(--section-width) * 0.5)); + bottom: clamp( + calc(var(--section-height, var(--header-height)) * -0.5), + var(--bottom), + calc(100vh - var(--section-height, var(--header-height)) * 0.5) + ); + right: clamp(calc(var(--section-width) * -0.5), var(--right), calc(100vw - var(--section-width) * 0.5)); + width: var(--section-width); + overflow: visible; + } + :host([floating]) [part='container'] { + background: var(--background-color); + border: var(--floating-border-width) solid var(--surface-border-color); + -webkit-backdrop-filter: var(--surface-backdrop-filter); + backdrop-filter: var(--surface-backdrop-filter); + border-radius: var(--vaadin-radius-m); + margin: auto; + box-shadow: var(--surface-box-shadow-2); + } + [part='container'] { + overflow: hidden; + } + :host([floating][expanded]) [part='container'] { + height: calc(100% - var(--floating-offset-resize-threshold) / 2); + width: calc(100% - var(--floating-offset-resize-threshold) / 2); + } + + :host([floating]:not([expanded])) { + width: unset; + } + + :host([floating]) .drag-handle { + cursor: var(--resize-cursor, move); + } + + :host([floating][expanded]) [part='content'] { + min-width: var(--min-width); + min-height: 0; + width: var(--content-width); + } + + /* :hover for Firefox, :active for others */ + + :host([floating][expanded]) [part='content']:is(:hover, :active) { + transition: none; + } + + ::slotted(*) { + box-sizing: border-box; + display: block; + /* padding: var(--space-150); */ + width: 100%; + } + + /*workaround for outline to have a explicit height while floating by default. + may be removed after https://github.com/vaadin/web-components/issues/7620 is solved + */ + :host([floating][expanded][paneltag='copilot-outline-panel']) { + --grid-default-height: 400px; + } + + :host([dragging]) { + opacity: 0.4; + } + + :host([dragging]) [part='content'] { + pointer-events: none; + } + + :host([hiding-while-drag-and-drop]) { + display: none; + } + + // dragging in drawer + + :host(:not([floating])) .drag-handle { + cursor: grab; + } + + :host(:not([floating])[dragging]) .drag-handle { + cursor: grabbing; + } + ` + ]; + } + connectedCallback() { + super.connectedCallback(), this.setAttribute("role", "region"), this.reaction( + () => p.getAttentionRequiredPanelConfiguration(), + () => { + const e = p.getAttentionRequiredPanelConfiguration(); + this.toggleAttribute(E, e?.tag === this.panelTag && e?.floating); + } + ), this.addEventListener("mouseenter", this.sectionPanelMouseEnterListener), this.reaction( + () => l.operationInProgress, + () => { + requestAnimationFrame(() => { + this.toggleAttribute( + "hiding-while-drag-and-drop", + l.operationInProgress === xe.DragAndDrop && this.panelInfo?.floating && !this.panelInfo.showWhileDragging && !this.hasDropTarget() + ); + }); + } + ), this.reaction( + () => p.floatingPanelsZIndexOrder, + () => { + this.style.setProperty("--z-index-focus", `${p.getFloatingPanelZIndex(this.panelTag)}`); + }, + { fireImmediately: !0 } + ), this.reaction( + () => p.getPanelByTag(this.panelTag)?.floatingPosition, + () => { + !this.floatingResizingStarted && !l.sectionPanelDragging && this.setCssSizePositionProperties(); + } + ), this.addEventListener("transitionend", this.transitionEndEventListener), this.addEventListener("mousemove", this.floatingResizeHandlerMouseMoveListener), this.addEventListener("mousedown", this.floatingResizingMouseDownListener), this.addEventListener("mouseleave", this.floatingResizingMouseLeaveListener), document.addEventListener("mousemove", this.floatingResizingMouseMoveListener), document.addEventListener("mouseup", this.floatingResizingMouseUpListener); + } + disconnectedCallback() { + super.disconnectedCallback(), this.removeEventListener("mouseenter", this.sectionPanelMouseEnterListener), this.removeEventListener("mousemove", this.floatingResizeHandlerMouseMoveListener), this.removeEventListener("mousedown", this.floatingResizingMouseDownListener), document.removeEventListener("mousemove", this.floatingResizingMouseMoveListener), document.removeEventListener("mouseup", this.floatingResizingMouseUpListener); + } + setResizePosition(e, t, i) { + const n = this.rectangleBeforeResizing, o = 0, s = window.innerWidth, a = 0, h = window.innerHeight, w = Math.max(o, Math.min(s, t)), k = Math.max(a, Math.min(h, i)); + if (e === "left") + this.setFloatingResizeDirectionProps( + "left", + w, + n.left - w + n.width + ); + else if (e === "right") + this.setFloatingResizeDirectionProps( + "right", + w, + w - n.right + n.width + ); + else if (e === "top") { + const L = n.top - k + n.height; + this.setFloatingResizeDirectionProps("top", k, void 0, L); + } else if (e === "bottom") { + const L = k - n.bottom + n.height; + this.setFloatingResizeDirectionProps("bottom", k, void 0, L); + } + } + willUpdate(e) { + super.willUpdate(e), e.has("panelTag") && (this.panelInfo = p.getPanelByTag(this.panelTag), this.setAttribute("aria-labelledby", this.panelInfo.tag.concat("-title"))), this.toggleAttribute("floating", this.panelInfo?.floating); + } + updated(e) { + super.updated(e), this.setCssSizePositionProperties(), requestAnimationFrame(() => { + if (this.panelInfo !== void 0 && this.panelInfo.floating && this.panelInfo.floatingPosition?.top != null && (this.panelInfo?.height === void 0 || this.panelInfo?.width === void 0)) { + let t = this.panelInfo?.height, i = this.panelInfo?.width, n = !1; + const o = this.panelInfo.floatingPosition; + if (this.offsetWidth !== void 0 && this.offsetWidth !== 0 && this.panelInfo.width === void 0 && (n = !0, i = this.offsetWidth), this.offsetHeight !== void 0 && this.offsetHeight !== 0 && this.panelInfo.height === void 0) { + n = !0, t = this.offsetHeight; + const s = window.innerHeight; + let a = this.panelInfo.floatingPosition.top; + t > s && (t = s); + const h = Math.floor(s / 3); + t < h ? (t = h, a = h) : t > 2 * h ? a -= t - (s - this.panelInfo.floatingPosition.top) : a = h, o.top = a; + } + n && (p.updatePanel(this.panelInfo?.tag, { + height: t, + width: i, + floatingPosition: o + }), this.setCssSizePositionProperties()); + } + }); + } + firstUpdated(e) { + super.firstUpdated(e), document.addEventListener("mouseup", this.documentMouseUpEventListener), this.headerDraggableArea.addEventListener("mousedown", this.panelHeaderMouseDownEventListener), this.headerDraggableArea.addEventListener("mouseup", this.panelHeaderMouseUpEventListener), this.toggleAttribute("expanded", this.panelInfo?.expanded), this.toggleAttribute("individual", this.panelInfo?.individual ?? !1), wt(this), this.setCssSizePositionProperties(), this.contentArea.addEventListener("mousedown", this.contentAreaMouseDownListener); + } + render() { + return this.panelInfo ? r` +
+
+ ${this.panelInfo.expandable !== !1 ? r` + + + ` : g} +

+ + ${p.getPanelHeader(this.panelInfo)} + +

+ ${this.panelInfo.expanded ? r`
+ ${this.renderActions()} +
` : g} + ${this.renderHelpButton()} ${this.renderPopupButton()} +
+
+ +
+
+ ` : g; + } + getPopupButtonIcon() { + return this.panelInfo ? this.panelInfo.panel === void 0 ? d.close : this.panelInfo.floating ? this.panelInfo.panel === "bottom" ? d.dockToBottom : this.panelInfo.panel === "left" ? d.thumbnailBar : this.panelInfo.panel === "right" ? d.dockToRight : g : d.adsGroup : g; + } + renderHelpButton() { + return this.panelInfo?.helpUrl ? r` ` : g; + } + renderActions() { + if (!this.panelInfo?.actionsTag) + return g; + const e = this.panelInfo.actionsTag; + return yt(`<${e}>`); + } + changeDockingPanel(e) { + const t = e.detail.value.panel; + if (this.panelInfo?.panel !== t) { + const i = p.panels.filter((n) => n.panel === t).map((n) => n.panelOrder).sort((n, o) => o - n)[0]; + Re(this), p.updatePanel(this.panelInfo.tag, { panel: t, panelOrder: i + 1 }); + } + this.panelInfo.floating && this.changePanelFloating(e); + } + getResizeDirections() { + const e = this.getAttribute(P); + return e ? e.split(" ") : []; + } + hasDropTarget() { + const e = this.shadowRoot?.querySelector("slot")?.assignedElements(); + if (!e) + return !1; + for (const t of e) { + const i = xt( + t.shadowRoot ?? t, + "copilot-image-upload" + ); + if (i && window.getComputedStyle(i).display !== "none") + return !0; + } + return !1; + } +}; +J([ + y() +], z.prototype, "panelTag", 2); +J([ + O(".drag-handle") +], z.prototype, "headerDraggableArea", 2); +J([ + O("#content") +], z.prototype, "contentArea", 2); +J([ + O('[part="container"]') +], z.prototype, "container", 2); +J([ + x() +], z.prototype, "dockingItems", 2); +z = J([ + b("copilot-section-panel-wrapper") +], z); +const ve = window.Vaadin.copilot.customComponentHandler; +if (!ve) + throw new Error("Tried to access custom component handler before it was initialized."); +function hi(e) { + l.setOperationWaitsHmrUpdate(e, 3e4); +} +u.on("undoRedo", (e) => { + const i = { files: ui(e), uiId: Pt() }, n = e.detail.undo ? "copilot-plugin-undo" : "copilot-plugin-redo", o = e.detail.undo ? "undo" : "redo"; + Xe(o), hi(xe.RedoUndo), ae(n, i, (s) => { + if (!s.data.performed) { + if (s.data.error && s.data.error.message) { + N({ + type: R.ERROR, + message: s.data.error.message + }), u.emit("vite-after-update", {}); + return; + } + N({ + type: R.INFORMATION, + message: `Nothing to ${o}` + }), u.emit("vite-after-update", {}); + } + }); +}); +function ui(e) { + if (e.detail.files) + return e.detail.files; + const t = ve.getActiveDrillDownContext(); + if (t) { + const i = ve.getCustomComponentInfo(t); + if (i) + return new Array(i.customComponentFilePath); + } + return It(); +} +var gi = Object.getOwnPropertyDescriptor, fi = (e, t, i, n) => { + for (var o = n > 1 ? void 0 : n ? gi(t, i) : t, s = e.length - 1, a; s >= 0; s--) + (a = e[s]) && (o = a(o) || o); + return o; +}; +let je = class extends I { + static get styles() { + return [ + m(se), + m(Pe), + m(At), + m(Y), + _` + :host { + --lumo-secondary-text-color: var(--dev-tools-text-color); + --lumo-contrast-80pct: var(--dev-tools-text-color-emphasis); + --lumo-contrast-60pct: var(--dev-tools-text-color-secondary); + --lumo-font-size-m: 14px; + + position: fixed; + bottom: 2.5rem; + right: 0rem; + visibility: visible; /* Always show, even if copilot is off */ + user-select: none; + z-index: var(--copilot-notifications-container-z-index); + + --dev-tools-text-color: rgba(255, 255, 255, 0.8); + + --dev-tools-text-color-secondary: rgba(255, 255, 255, 0.65); + --dev-tools-text-color-emphasis: rgba(255, 255, 255, 0.95); + --dev-tools-text-color-active: rgba(255, 255, 255, 1); + + --dev-tools-background-color-inactive: rgba(45, 45, 45, 0.25); + --dev-tools-background-color-active: rgba(45, 45, 45, 0.98); + --dev-tools-background-color-active-blurred: rgba(45, 45, 45, 0.85); + + --dev-tools-border-radius: 0.5rem; + --dev-tools-box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.05), 0 4px 12px -2px rgba(0, 0, 0, 0.4); + + --dev-tools-blue-hsl: 206, 100%, 70%; + --dev-tools-blue-color: hsl(var(--dev-tools-blue-hsl)); + --dev-tools-green-hsl: 145, 80%, 42%; + --dev-tools-green-color: hsl(var(--dev-tools-green-hsl)); + --dev-tools-grey-hsl: 0, 0%, 50%; + --dev-tools-grey-color: hsl(var(--dev-tools-grey-hsl)); + --dev-tools-yellow-hsl: 38, 98%, 64%; + --dev-tools-yellow-color: hsl(var(--dev-tools-yellow-hsl)); + --dev-tools-red-hsl: 355, 100%, 68%; + --dev-tools-red-color: hsl(var(--dev-tools-red-hsl)); + + /* Needs to be in ms, used in JavaScript as well */ + --dev-tools-transition-duration: 180ms; + + /* Copilot go to source file link styling */ + --source-file-link-color: var(--dev-tools-text-color-secondary); + --source-file-link-text-decoration: underline; + --source-file-link-font-weight: 500; + --source-file-link-button-color: white; + } + + .notification-tray { + display: flex; + flex-direction: column-reverse; + align-items: flex-end; + margin: 0.5rem; + flex: none; + } + + @supports (backdrop-filter: blur(1px)) { + .notification-tray div.message { + backdrop-filter: blur(8px); + } + + .notification-tray div.message { + background-color: var(--dev-tools-background-color-active-blurred); + } + } + + .notification-tray .message { + animation: slideIn var(--dev-tools-transition-duration); + background-color: var(--dev-tools-background-color-active); + border-radius: var(--dev-tools-border-radius); + box-shadow: var(--dev-tools-box-shadow); + box-sizing: border-box; + color: var(--dev-tools-text-color); + flex-direction: row; + gap: var(--space-100); + justify-content: space-between; + margin-top: var(--space-100); + max-width: 40rem; + padding-block: var(--space-100); + pointer-events: auto; + transform-origin: bottom right; + transition: var(--dev-tools-transition-duration); + } + + .notification-tray .message.animate-out { + animation: slideOut forwards var(--dev-tools-transition-duration); + } + + .notification-tray .message .message-details { + word-break: break-all; + } + + .message.information { + --dev-tools-notification-color: var(--dev-tools-blue-color); + } + + .message.warning { + --dev-tools-notification-color: var(--dev-tools-yellow-color); + } + + .message.error { + --dev-tools-notification-color: var(--dev-tools-red-color); + } + + .message { + background-clip: padding-box; + display: flex; + padding-block: var(--space-75); + padding-inline: var(--space-450) var(--space-100); + } + + .message.log { + padding-left: 0.75rem; + } + + .message-content { + align-self: center; + flex: 1 1 auto; + max-width: 100%; + min-width: 0; + user-select: text; + -moz-user-select: text; + -webkit-user-select: text; + } + + .message .message-details { + align-items: start; + color: rgba(255, 255, 255, 0.7); + display: flex; + flex-direction: column; + } + + .message .message-details[hidden] { + display: none; + } + + .message .message-details p { + display: inline; + margin: 0; + margin-right: 0.375em; + word-break: break-word; + } + + .message .message-details vaadin-details { + margin: 0; + width: 100%; + } + + .message .message-details vaadin-details-summary { + font-size: var(--copilot-font-size-xs); + font-weight: var(--copilot-font-weight-medium); + line-height: var(--copilot-line-height-sm); + } + + .message .persist::before { + } + + .message .persist:hover::before { + } + + .message .persist.on::before { + } + + .message.log { + color: var(--dev-tools-text-color-secondary); + } + + .message-heading { + color: white; + } + + .message-heading::before { + height: var(--icon-size-m); + margin-inline-start: calc((var(--space-400) / -1) + ((var(--space-400) - var(--icon-size-m)) / 2)); + position: absolute; + width: var(--icon-size-m); + } + + .message.information .message-heading::before { + content: url("data:image/svg+xml,%3Csvg width='18' height='18' viewBox='0 0 24 24' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M12 16V12M12 8H12.01M22 12C22 17.5228 17.5228 22 12 22C6.47715 22 2 17.5228 2 12C2 6.47715 6.47715 2 12 2C17.5228 2 22 6.47715 22 12Z' stroke='%2395C6FF' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E"); + } + + .message.warning .message-heading::before, + .message.error .message-heading::before { + content: url("data:image/svg+xml,%3Csvg width='18' height='18' viewBox='0 0 24 24' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M12 8V12M12 16H12.01M22 12C22 17.5228 17.5228 22 12 22C6.47715 22 2 17.5228 2 12C2 6.47715 6.47715 2 12 2C17.5228 2 22 6.47715 22 12Z' stroke='%23ff707a' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E"); + } + + @keyframes slideIn { + from { + transform: translateX(100%); + opacity: 0; + } + to { + transform: translateX(0%); + opacity: 1; + } + } + + @keyframes slideOut { + from { + transform: translateX(0%); + opacity: 1; + } + to { + transform: translateX(100%); + opacity: 0; + } + } + + @keyframes fade-in { + 0% { + opacity: 0; + } + } + + @keyframes bounce { + 0% { + transform: scale(0.8); + } + 50% { + transform: scale(1.5); + background-color: hsla(var(--dev-tools-red-hsl), 1); + } + 100% { + transform: scale(1); + } + } + ` + ]; + } + render() { + return r`
+ ${l.notifications.map((e) => this.renderNotification(e))} +
`; + } + renderNotification(e) { + return r` +
+
+

${e.message}

+
+ ${$t(e.details)} + ${e.link ? r`Learn more` : ""} +
+ + ${e.dismissId ? r`
+
{ + this.toggleDontShowAgain(e); + }}> + ${r`${e.dontShowAgain ? d.checkSquare : d.square}`} + ${vi(e)} +
` : ""} +
+ +
+ `; + } + toggleDontShowAgain(e) { + e.dontShowAgain = !e.dontShowAgain, this.requestUpdate(); + } +}; +je = fi([ + b("copilot-notifications-container") +], je); +function vi(e) { + return e.dontShowAgainMessage ? e.dontShowAgainMessage : "Do not show this again"; +} +N({ + type: R.WARNING, + message: "Development Mode", + details: "This application is running in development mode.", + dismissId: "devmode" +}); +const me = j(async () => { + await Ct(); +}, 100); +u.on("vite-after-update", () => { + l.active && me(); +}); +function it() { + l.active && (me.clear(), me(), St()); +} +if (window.__REACT_DEVTOOLS_GLOBAL_HOOK__) { + const e = window.__REACT_DEVTOOLS_GLOBAL_HOOK__, t = e.onCommitFiberRoot; + e.onCommitFiberRoot = (i, n, o, s) => (it(), t(i, n, o, s)); +} +kt(() => { + const e = window?.Vaadin?.connectionState; + if (e) + return e; +}).then((e) => { + e.addStateChangeListener && typeof e.addStateChangeListener == "function" ? e.addStateChangeListener((t, i) => { + t === "loading" && i === "connected" && l.active && it(); + }) : console.error("Unable to add listener for connection state changes"); +}); +u.on("copilot-plugin-state", (e) => { + l.setIdePluginState(e.detail), e.preventDefault(); +}); +u.on("copilot-early-project-state", (e) => { + f.setSpringSecurityEnabled(e.detail.springSecurityEnabled), f.setSpringJpaDataEnabled(e.detail.springJpaDataEnabled), f.setSpringJpaDatasourceInitialization(e.detail.springJpaDatasourceInitialization), f.setSupportsHilla(e.detail.supportsHilla), f.setSpringApplication(e.detail.springApplication), f.setUrlPrefix(e.detail.urlPrefix), f.setServerVersions(e.detail.serverVersions), f.setJdkInfo(e.detail.jdkInfo), Q() === "success" && Xe("hotswap-active", { value: Je() }), e.preventDefault(); +}); +u.on("copilot-ide-notification", (e) => { + N({ + type: R[e.detail.type], + message: e.detail.message, + dismissId: e.detail.dismissId + }), e.preventDefault(); +}); +/** + * @license + * Copyright (c) 2017 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +let Ne = 0, nt = 0; +const U = []; +let be = !1; +function mi() { + be = !1; + const e = U.length; + for (let t = 0; t < e; t++) { + const i = U[t]; + if (i) + try { + i(); + } catch (n) { + setTimeout(() => { + throw n; + }); + } + } + U.splice(0, e), nt += e; +} +const bi = { + /** + * Enqueues a function called at microtask timing. + * + * @memberof microTask + * @param {!Function=} callback Callback to run + * @return {number} Handle used for canceling task + */ + run(e) { + be || (be = !0, queueMicrotask(() => mi())), U.push(e); + const t = Ne; + return Ne += 1, t; + }, + /** + * Cancels a previously enqueued `microTask` callback. + * + * @memberof microTask + * @param {number} handle Handle returned from `run` of callback to cancel + * @return {void} + */ + cancel(e) { + const t = e - nt; + if (t >= 0) { + if (!U[t]) + throw new Error(`invalid async handle: ${e}`); + U[t] = null; + } + } +}; +/** +@license +Copyright (c) 2017 The Polymer Project Authors. All rights reserved. +This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt +The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt +The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt +Code distributed by Google as part of the polymer project is also +subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt +*/ +const Be = /* @__PURE__ */ new Set(); +class ie { + /** + * Creates a debouncer if no debouncer is passed as a parameter + * or it cancels an active debouncer otherwise. The following + * example shows how a debouncer can be called multiple times within a + * microtask and "debounced" such that the provided callback function is + * called once. Add this method to a custom element: + * + * ```js + * import {microTask} from '@vaadin/component-base/src/async.js'; + * import {Debouncer} from '@vaadin/component-base/src/debounce.js'; + * // ... + * + * _debounceWork() { + * this._debounceJob = Debouncer.debounce(this._debounceJob, + * microTask, () => this._doWork()); + * } + * ``` + * + * If the `_debounceWork` method is called multiple times within the same + * microtask, the `_doWork` function will be called only once at the next + * microtask checkpoint. + * + * Note: In testing it is often convenient to avoid asynchrony. To accomplish + * this with a debouncer, you can use `enqueueDebouncer` and + * `flush`. For example, extend the above example by adding + * `enqueueDebouncer(this._debounceJob)` at the end of the + * `_debounceWork` method. Then in a test, call `flush` to ensure + * the debouncer has completed. + * + * @param {Debouncer?} debouncer Debouncer object. + * @param {!AsyncInterface} asyncModule Object with Async interface + * @param {function()} callback Callback to run. + * @return {!Debouncer} Returns a debouncer object. + */ + static debounce(t, i, n) { + return t instanceof ie ? t._cancelAsync() : t = new ie(), t.setConfig(i, n), t; + } + constructor() { + this._asyncModule = null, this._callback = null, this._timer = null; + } + /** + * Sets the scheduler; that is, a module with the Async interface, + * a callback and optional arguments to be passed to the run function + * from the async module. + * + * @param {!AsyncInterface} asyncModule Object with Async interface. + * @param {function()} callback Callback to run. + * @return {void} + */ + setConfig(t, i) { + this._asyncModule = t, this._callback = i, this._timer = this._asyncModule.run(() => { + this._timer = null, Be.delete(this), this._callback(); + }); + } + /** + * Cancels an active debouncer and returns a reference to itself. + * + * @return {void} + */ + cancel() { + this.isActive() && (this._cancelAsync(), Be.delete(this)); + } + /** + * Cancels a debouncer's async callback. + * + * @return {void} + */ + _cancelAsync() { + this.isActive() && (this._asyncModule.cancel( + /** @type {number} */ + this._timer + ), this._timer = null); + } + /** + * Flushes an active debouncer and returns a reference to itself. + * + * @return {void} + */ + flush() { + this.isActive() && (this.cancel(), this._callback()); + } + /** + * Returns true if the debouncer is active. + * + * @return {boolean} True if active. + */ + isActive() { + return this._timer != null; + } +} +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const W = (e, t) => { + const i = e._$AN; + if (i === void 0) return !1; + for (const n of i) n._$AO?.(t, !1), W(n, t); + return !0; +}, ne = (e) => { + let t, i; + do { + if ((t = e._$AM) === void 0) break; + i = t._$AN, i.delete(e), e = t; + } while (i?.size === 0); +}, ot = (e) => { + for (let t; t = e._$AM; e = t) { + let i = t._$AN; + if (i === void 0) t._$AN = i = /* @__PURE__ */ new Set(); + else if (i.has(e)) break; + i.add(e), xi(t); + } +}; +function wi(e) { + this._$AN !== void 0 ? (ne(this), this._$AM = e, ot(this)) : this._$AM = e; +} +function yi(e, t = !1, i = 0) { + const n = this._$AH, o = this._$AN; + if (o !== void 0 && o.size !== 0) if (t) if (Array.isArray(n)) for (let s = i; s < n.length; s++) W(n[s], !1), ne(n[s]); + else n != null && (W(n, !1), ne(n)); + else W(this, e); +} +const xi = (e) => { + e.type == Ze.CHILD && (e._$AP ??= yi, e._$AQ ??= wi); +}; +class Pi extends Et { + constructor() { + super(...arguments), this._$AN = void 0; + } + _$AT(t, i, n) { + super._$AT(t, i, n), ot(this), this.isConnected = t._$AU; + } + _$AO(t, i = !0) { + t !== this.isConnected && (this.isConnected = t, t ? this.reconnected?.() : this.disconnected?.()), i && (W(this, t), ne(this)); + } + setValue(t) { + if (Rt(this._$Ct)) this._$Ct._$AI(t, this); + else { + const i = [...this._$Ct._$AH]; + i[this._$Ci] = t, this._$Ct._$AI(i, this, 0); + } + } + disconnected() { + } + reconnected() { + } +} +/** + * @license + * Copyright (c) 2016 - 2025 Vaadin Ltd. + * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/ + */ +const Fe = Symbol("valueNotInitialized"); +class Ii extends Pi { + constructor(t) { + if (super(t), t.type !== Ze.ELEMENT) + throw new Error(`\`${this.constructor.name}\` must be bound to an element.`); + this.previousValue = Fe; + } + /** @override */ + render(t, i) { + return g; + } + /** @override */ + update(t, [i, n]) { + return this.hasChanged(n) ? (this.host = t.options && t.options.host, this.element = t.element, this.renderer = i, this.previousValue === Fe ? this.addRenderer() : this.runRenderer(), this.previousValue = Array.isArray(n) ? [...n] : n, g) : g; + } + /** @override */ + reconnected() { + this.addRenderer(); + } + /** @override */ + disconnected() { + this.removeRenderer(); + } + /** @abstract */ + addRenderer() { + throw new Error("The `addRenderer` method must be implemented."); + } + /** @abstract */ + runRenderer() { + throw new Error("The `runRenderer` method must be implemented."); + } + /** @abstract */ + removeRenderer() { + throw new Error("The `removeRenderer` method must be implemented."); + } + /** @protected */ + renderRenderer(t, ...i) { + const n = this.renderer.call(this.host, ...i); + Dt(n, t, { host: this.host }); + } + /** @protected */ + hasChanged(t) { + return Array.isArray(t) ? !Array.isArray(this.previousValue) || this.previousValue.length !== t.length ? !0 : t.some((i, n) => i !== this.previousValue[n]) : this.previousValue !== t; + } +} +/** + * @license + * Copyright (c) 2017 - 2025 Vaadin Ltd. + * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/ + */ +const ue = Symbol("contentUpdateDebouncer"); +class ke extends Ii { + /** + * A property to that the renderer callback will be assigned. + * + * @abstract + */ + get rendererProperty() { + throw new Error("The `rendererProperty` getter must be implemented."); + } + /** + * Adds the renderer callback to the dialog. + */ + addRenderer() { + this.element[this.rendererProperty] = (t, i) => { + this.renderRenderer(t, i); + }; + } + /** + * Runs the renderer callback on the dialog. + */ + runRenderer() { + this.element[ue] = ie.debounce( + this.element[ue], + bi, + () => { + this.element.requestContentUpdate(); + } + ); + } + /** + * Removes the renderer callback from the dialog. + */ + removeRenderer() { + this.element[this.rendererProperty] = null, delete this.element[ue]; + } +} +class Ai extends ke { + get rendererProperty() { + return "renderer"; + } +} +class $i extends ke { + get rendererProperty() { + return "headerRenderer"; + } +} +class Ci extends ke { + get rendererProperty() { + return "footerRenderer"; + } +} +const st = Ae(Ai), at = Ae($i), rt = Ae(Ci); +var ki = Object.defineProperty, Si = Object.getOwnPropertyDescriptor, lt = (e, t, i, n) => { + for (var o = n > 1 ? void 0 : n ? Si(t, i) : t, s = e.length - 1, a; s >= 0; s--) + (a = e[s]) && (o = (n ? a(t, i, o) : a(o)) || o); + return n && o && ki(t, i, o), o; +}; +let we = class extends X { + constructor() { + super(...arguments), this.rememberChoice = !1, this.opened = !1, this.handleESC = (e) => { + !l.active || !this.opened || (e.key === "Escape" && this.sendEvent("cancel"), e.preventDefault(), e.stopPropagation()); + }; + } + createRenderRoot() { + return this; + } + connectedCallback() { + super.connectedCallback(), this.addESCListener(); + } + disconnectedCallback() { + super.disconnectedCallback(), this.removeESCListener(); + } + render() { + return r` r` +

This Operation Uses AI

+ + ` + )} + ${st( + () => r` +

AI is a third-party service that will receive some of your project code as context for the operation.

+ + ` + )} + ${rt( + () => r` + + + ` + )}>`; + } + sendEvent(e) { + this.dispatchEvent( + new CustomEvent("ai-usage-response", { + detail: { response: e, rememberChoice: this.rememberChoice } + }) + ); + } + addESCListener() { + document.addEventListener("keydown", this.handleESC, { capture: !0 }); + } + removeESCListener() { + document.removeEventListener("keydown", this.handleESC, { capture: !0 }); + } +}; +lt([ + y() +], we.prototype, "opened", 2); +we = lt([ + b("copilot-ai-usage-confirmation-dialog") +], we); +var Ei = Object.defineProperty, Ri = Object.getOwnPropertyDescriptor, T = (e, t, i, n) => { + for (var o = n > 1 ? void 0 : n ? Ri(t, i) : t, s = e.length - 1, a; s >= 0; s--) + (a = e[s]) && (o = (n ? a(t, i, o) : a(o)) || o); + return n && o && Ei(t, i, o), o; +}; +const Ve = { + info: "UI state info", + stacktrace: "Exception details", + versions: "Vaadin, Java, OS, etc.." +}; +let D = class extends X { + constructor() { + super(...arguments), this.exceptionReport = void 0, this.dialogOpened = !1, this.visibleItemIndex = 0, this.versions = void 0, this.selectedItems = [], this.eventListener = (e) => { + this.exceptionReport = e.detail, this.selectedItems = this.exceptionReport.items.map((t, i) => i), this.visibleItemIndex = 0, this.searchInputValue = void 0, this.dialogOpened = this.exceptionReport !== void 0; + }; + } + connectedCallback() { + super.connectedCallback(), u.on("submit-exception-report-clicked", this.eventListener); + } + createRenderRoot() { + return this; + } + disconnectedCallback() { + super.disconnectedCallback(), u.off("submit-exception-report-clicked", this.eventListener); + } + close() { + this.dialogOpened = !1; + } + clear() { + this.exceptionReport = void 0; + } + render() { + let e = ""; + return this.exceptionReport && this.exceptionReport.items.length > 0 && (e = this.exceptionReport.items[this.visibleItemIndex].content), r` r` +
+

Send report

+ + + +
+ ` + )} + ${st( + () => r` +
+ { + this.searchInputValue = t.target.value; + }} + label="Description of the Bug" + placeholder="A short, concise description of the bug and why you consider it a bug."> +
+
+
+
Include in Report
+ + ${this.exceptionReport?.items.map( + (t, i) => r` + +
+ ${t.name} + ${this.renderItemDescription(t)} +
+ ` + )} + +
+
+
Preview: ${this.exceptionReport?.items[this.visibleItemIndex].name}
+ ${e} +
+
+ `, + [this.exceptionReport, this.visibleItemIndex, this.selectedItems] + )} + ${rt( + () => r` + + + + `, + [this.exceptionReport, this.selectedItems, this.searchInputValue] + )}>`; + } + renderItemDescription(e) { + return Object.keys(Ve).indexOf(e.name.toLowerCase()) !== -1 ? Ve[e.name.toLowerCase()] : null; + } + bodyLengthExceeds() { + const e = this.getIssueBodyNotEncoded(); + return e !== void 0 && encodeURIComponent(e).length > 7500; + } + getIssueBodyNotEncoded() { + if (!this.exceptionReport) + return; + const e = this.exceptionReport.items.filter((t, i) => this.selectedItems.indexOf(i) !== -1).map((t) => { + let i = "```"; + return t.name.includes(".java") && (i = `${i}java`), `## ${t.name} + + ${i} +${t.content} +\`\`\``; + }); + return this.searchInputValue ? `## Description of the bug + ${this.searchInputValue} + ${e.join(` +`)}` : `## Description of the bug + Please enter bug description here + ${e.join(` +`)}`; + } + submitErrorToGithub() { + const e = this.exceptionReport; + if (!e) + return; + const t = encodeURIComponent(e.title ?? "Bug report "), i = this.getIssueBodyNotEncoded(); + if (!i) + return; + let n = encodeURIComponent(i); + n.length >= 7500 && (Qe(i), n = encodeURIComponent("Please paste report here. It was automatically added to your clipboard.")); + const o = `https://github.com/vaadin/copilot/issues/new?title=${t}&body=${n}`; + window.open(o, "_blank"); + } +}; +T([ + x() +], D.prototype, "exceptionReport", 2); +T([ + x() +], D.prototype, "dialogOpened", 2); +T([ + x() +], D.prototype, "visibleItemIndex", 2); +T([ + x() +], D.prototype, "versions", 2); +T([ + x() +], D.prototype, "selectedItems", 2); +T([ + x() +], D.prototype, "searchInputValue", 2); +D = T([ + b("copilot-report-exception-dialog") +], D); +let Z; +u.on("copilot-project-compilation-error", (e) => { + if (e.detail.error) { + let t; + if (e.detail.files && e.detail.files.length > 0) { + const i = l.idePluginState?.supportedActions?.includes("undo") ? r` + + ` : g; + t = $e( + r`
+ Following files have compilation errors: +
    + ${e.detail.files.map( + (n) => r`
  • + +
    • ` + )} +
+
+ ${i} +
` + ); + } else + t = "Project contains one or more compilation errors."; + Z = N({ + message: "Compilation error", + details: t, + type: R.WARNING, + delay: 3e4 + }); + } else + Z && Ke(Z), Z = void 0; +}); +var Di = Object.defineProperty, Li = Object.getOwnPropertyDescriptor, dt = (e, t, i, n) => { + for (var o = n > 1 ? void 0 : n ? Li(t, i) : t, s = e.length - 1, a; s >= 0; s--) + (a = e[s]) && (o = (n ? a(t, i, o) : a(o)) || o); + return n && o && Di(t, i, o), o; +}; +let ye = class extends X { + constructor() { + super(...arguments), this.text = () => (this.parentElement.textContent ?? "").trim(); + } + createRenderRoot() { + return this; + } + render() { + return r``; + } +}; +dt([ + y({ type: Function }) +], ye.prototype, "text", 2); +ye = dt([ + b("copilot-copy") +], ye); +var Mi = { + 202: "Accepted", + 502: "Bad Gateway", + 400: "Bad Request", + 409: "Conflict", + 100: "Continue", + 201: "Created", + 417: "Expectation Failed", + 424: "Failed Dependency", + 403: "Forbidden", + 504: "Gateway Timeout", + 410: "Gone", + 505: "HTTP Version Not Supported", + 418: "I'm a teapot", + 419: "Insufficient Space on Resource", + 507: "Insufficient Storage", + 500: "Internal Server Error", + 411: "Length Required", + 423: "Locked", + 420: "Method Failure", + 405: "Method Not Allowed", + 301: "Moved Permanently", + 302: "Moved Temporarily", + 207: "Multi-Status", + 300: "Multiple Choices", + 511: "Network Authentication Required", + 204: "No Content", + 203: "Non Authoritative Information", + 406: "Not Acceptable", + 404: "Not Found", + 501: "Not Implemented", + 304: "Not Modified", + 200: "OK", + 206: "Partial Content", + 402: "Payment Required", + 308: "Permanent Redirect", + 412: "Precondition Failed", + 428: "Precondition Required", + 102: "Processing", + 103: "Early Hints", + 426: "Upgrade Required", + 407: "Proxy Authentication Required", + 431: "Request Header Fields Too Large", + 408: "Request Timeout", + 413: "Request Entity Too Large", + 414: "Request-URI Too Long", + 416: "Requested Range Not Satisfiable", + 205: "Reset Content", + 303: "See Other", + 503: "Service Unavailable", + 101: "Switching Protocols", + 307: "Temporary Redirect", + 429: "Too Many Requests", + 401: "Unauthorized", + 451: "Unavailable For Legal Reasons", + 422: "Unprocessable Entity", + 415: "Unsupported Media Type", + 305: "Use Proxy", + 421: "Misdirected Request" +}; +function zi(e) { + var t = Mi[e.toString()]; + if (!t) + throw new Error("Status code does not exist: " + e); + return t; +} +function ct(e) { + return `endpoint-request-${e.id}`; +} +u.on("endpoint-request", (e) => { + const t = e.detail, i = ct(t); + delete t.id; + const n = Object.values(t.params), o = n.map(oe).join(", "); + u.emit("log", { + id: i, + type: R.INFORMATION, + message: `Called endpoint ${t.endpoint}.${t.method}(${o})`, + expandedMessage: $e( + r`Called endpoint ${t.endpoint}.${t.method} with parameters + ${oe(n)}` + ), + details: "Response: " + }); +}); +u.on("endpoint-response", (e) => { + let t; + try { + t = JSON.parse(e.detail.text); + } catch { + t = e.detail.text; + } + const i = {}, n = e.detail.status ?? 200; + n === 200 ? (i.details = `Response: ${oe(t)}`, i.expandedDetails = $e( + r`Response: ${oe(t)}` + )) : (i.details = `Error: ${n} ${zi(n)}`, i.type = R.ERROR), u.emit("update-log", { + id: ct(e.detail), + ...i + }); +}); +function oe(e) { + return typeof e == "string" ? `${e}` : JSON.stringify(e, void 0, 2); +} +var _i = Object.defineProperty, Oi = Object.getOwnPropertyDescriptor, H = (e, t, i, n) => { + for (var o = n > 1 ? void 0 : n ? Oi(t, i) : t, s = e.length - 1, a; s >= 0; s--) + (a = e[s]) && (o = (n ? a(t, i, o) : a(o)) || o); + return n && o && _i(t, i, o), o; +}; +class Ti extends CustomEvent { + constructor(t) { + super("show-in-ide-clicked", { + detail: t, + bubbles: !0, + composed: !0 + }); + } +} +let $ = class extends X { + constructor() { + super(...arguments), this.iconHidden = !1, this.linkHidden = !1, this.tooltipText = void 0, this.linkText = void 0, this.source = void 0, this.javaSource = void 0; + } + static get styles() { + return [ + m(Ie), + m(Y), + _` + a { + cursor: pointer; + color: var(--source-file-link-color, var(--blue-600)); + text-decoration: var(--source-file-link-text-decoration, none); + text-decoration-color: var(--source-file-link-decoration-color, currentColor); + font-weight: var(--source-file-link-font-weight, normal); + } + ` + ]; + } + render() { + if (this.iconHidden) { + if (!this.linkHidden) + return this.renderContent(this.renderAnchor()); + } else return this.linkHidden ? this.renderContent(this.renderIcon()) : this.renderContent([this.renderIcon(), this.renderAnchor()]); + return g; + } + renderContent(e) { + return r`
${e}
`; + } + renderIcon() { + const e = this.tooltipText ?? `Open ${this.getFileName()} in IDE`; + return r` + { + t.stopPropagation(), t.preventDefault(), this._showInIde(); + }}> + + + + `; + } + renderAnchor() { + return r` + { + e.preventDefault(), this._showInIde(); + }} + >${this.linkText ?? this.getFileName() ?? ""} + ${this.renderTooltip("link")} + `; + } + dispatchClickedEvent() { + this.dispatchEvent( + new Ti({ + source: this.source, + javaSource: this.javaSource + }) + ); + } + renderTooltip(e) { + const t = this.tooltipText ?? `Open ${this.getFileName()} in IDE`; + return r``; + } + getFileName() { + if (this.tooltipText) + return this.tooltipText; + if (this.source && this.source.fileName) + return Lt(this.source.fileName); + if (this.javaSource) + return this.javaSource.className; + } + _showInIde() { + u.emit("show-in-ide", { + source: this.source, + javaSource: this.javaSource + }), this.dispatchClickedEvent(); + } +}; +$.TAG = "copilot-go-to-source"; +H([ + y({ type: Boolean }) +], $.prototype, "iconHidden", 2); +H([ + y({ type: Boolean }) +], $.prototype, "linkHidden", 2); +H([ + y() +], $.prototype, "tooltipText", 2); +H([ + y() +], $.prototype, "linkText", 2); +H([ + y() +], $.prototype, "source", 2); +H([ + y() +], $.prototype, "javaSource", 2); +$ = H([ + b($.TAG) +], $); +u.on("copilot-java-after-update", (e) => { + const t = e.detail.classes.filter((n) => n.redefined).map((n) => n.class).join(", "); + if (t.length === 0) + return; + const i = "java-hot-deploy"; + e.detail.classes.find((n) => n.routePath !== void 0) && u.emit("update-routes", {}), N({ + type: R.INFORMATION, + message: `Java changes were hot deployed for ${Mt(t)}`, + dismissId: i, + delay: 5e3 + }); +}); diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/copilot-log-plugin-k9jQ-PoP.js b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-log-plugin-k9jQ-PoP.js new file mode 100644 index 0000000..d04e390 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-log-plugin-k9jQ-PoP.js @@ -0,0 +1,240 @@ +import { j as R, ao as L, ap as f, ab as c, D as l, a8 as p, aq as S, a6 as M, M as D, b as I, L as k, m as q, w as y, r as w } from "./copilot-BvIxHaRg.js"; +import { r as v } from "./state-BGGS46O3.js"; +import { B as P } from "./base-panel-C5as2IDv.js"; +import { i as r } from "./icons-DpjjuYvb.js"; +const A = 'copilot-log-panel ul{list-style-type:none;margin:0;padding:0}copilot-log-panel ul li{align-items:start;display:flex;gap:var(--space-50);padding:var(--space-100) var(--space-50);position:relative}copilot-log-panel ul li:before{border-bottom:1px dashed var(--divider-primary-color);content:"";inset:auto 0 0 calc(var(--copilot-size-md) + var(--space-100));position:absolute}copilot-log-panel ul li span.icon{display:flex;flex-shrink:0;justify-content:center;width:var(--copilot-size-md)}copilot-log-panel ul li.information span.icon{color:var(--blue-color)}copilot-log-panel ul li.warning span.icon{color:var(--warning-color)}copilot-log-panel ul li.error span.icon{color:var(--error-color)}copilot-log-panel ul li .message{display:flex;flex-direction:column;flex-grow:1;overflow:hidden}copilot-log-panel ul li:not(.expanded) span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}copilot-log-panel ul li button svg{transition:transform .15s cubic-bezier(.2,0,0,1)}copilot-log-panel ul li button[aria-expanded=true] svg{transform:rotate(90deg)}copilot-log-panel ul li code{margin-top:var(--space-50)}copilot-log-panel ul li.expanded .secondary{margin-top:var(--space-100)}copilot-log-panel .secondary a{display:block;margin-bottom:var(--space-50)}', C = () => { + const e = { hour: "numeric", minute: "numeric", second: "numeric", fractionalSecondDigits: 3 }; + let t; + const a = navigator.language ?? "", s = a.indexOf("@"), o = s === -1 ? a : a.slice(0, s); + try { + t = new Intl.DateTimeFormat(Intl.getCanonicalLocales(o), e); + } catch (i) { + console.error("Failed to create date time formatter for ", o, i), t = new Intl.DateTimeFormat("en-US", e); + } + return t; +}, _ = C(); +var b = Object.defineProperty, B = Object.getOwnPropertyDescriptor, u = (e, t, a, s) => { + for (var o = s > 1 ? void 0 : s ? B(t, a) : t, i = e.length - 1, n; i >= 0; i--) + (n = e[i]) && (o = (s ? n(t, a, o) : n(o)) || o); + return s && o && b(t, a, o), o; +}; +class F { + constructor() { + this.showTimestamps = !1, q(this); + } + toggleShowTimestamps() { + this.showTimestamps = !this.showTimestamps; + } +} +const h = new F(); +let d = class extends P { + constructor() { + super(...arguments), this.unreadErrors = !1, this.messages = [], this.nextMessageId = 1, this.transitionDuration = 0, this.errorHandlersAdded = !1; + } + connectedCallback() { + if (super.connectedCallback(), this.onCommand("log", (e) => { + this.handleLogEventData({ type: e.data.type, message: e.data.message }); + }), this.onEventBus("log", (e) => this.handleLogEvent(e)), this.onEventBus("update-log", (e) => this.updateLog(e.detail)), this.onEventBus("notification-shown", (e) => this.handleNotification(e)), this.onEventBus("clear-log", () => this.clear()), this.reaction( + () => R.sectionPanelResizing, + () => { + this.requestUpdate(); + } + ), this.transitionDuration = parseInt( + window.getComputedStyle(this).getPropertyValue("--dev-tools-transition-duration"), + 10 + ), !this.errorHandlersAdded) { + const e = (t) => { + k(() => { + y.attentionRequiredPanelTag = "copilot-log-panel"; + }), this.log(p.ERROR, t.message, !!t.internal, t.details, t.link); + }; + L((t) => { + e(t); + }), f.forEach((t) => { + e(t); + }), f.length = 0, this.errorHandlersAdded = !0; + } + } + clear() { + this.messages = []; + } + handleNotification(e) { + this.log(e.detail.type, e.detail.message, !0, e.detail.details, e.detail.link); + } + handleLogEvent(e) { + this.handleLogEventData(e.detail); + } + handleLogEventData(e) { + this.log( + e.type, + e.message, + !!e.internal, + e.details, + e.link, + c(e.expandedMessage), + c(e.expandedDetails), + e.id + ); + } + activate() { + this.unreadErrors = !1, this.updateComplete.then(() => { + const e = this.renderRoot.querySelector(".message:last-child"); + e && e.scrollIntoView(); + }); + } + render() { + return l` + +
    + ${this.messages.map((e) => this.renderMessage(e))} +
+ `; + } + renderMessage(e) { + let t, a; + return e.type === p.ERROR ? (a = r.alertTriangle, t = "Error") : e.type === p.WARNING ? (a = r.warning, t = "Warning") : (a = r.info, t = "Info"), l` +
  • + ${a} + this.toggleExpanded(e)}> + ${N(e.timestamp)} + + ${e.expanded && e.expandedMessage ? e.expandedMessage : e.message} + + ${e.expanded ? l` ${e.expandedDetails ?? e.details} ` : l` + ${c(e.details)} + ${e.link ? l` Learn more` : ""} + `} + + + +
    • + `; + } + log(e, t, a, s, o, i, n, E) { + const T = this.nextMessageId; + this.nextMessageId += 1, n || (n = t); + const g = { + id: T, + type: e, + message: t, + details: s, + link: o, + dontShowAgain: !1, + deleted: !1, + expanded: !1, + expandedMessage: i, + expandedDetails: n, + timestamp: /* @__PURE__ */ new Date(), + internal: a, + userId: E + }; + for (this.messages.push(g); this.messages.length > d.MAX_LOG_ROWS; ) + this.messages.shift(); + return this.requestUpdate(), this.updateComplete.then(() => { + const m = this.renderRoot.querySelector(".message:last-child"); + m ? (setTimeout(() => m.scrollIntoView({ behavior: "smooth" }), this.transitionDuration), this.unreadErrors = !1) : e === p.ERROR && (this.unreadErrors = !0); + }), g; + } + updateLog(e) { + let t = this.messages.find((a) => a.userId === e.id); + t || (t = this.log(p.INFORMATION, "", !1)), Object.assign(t, e), S(t.expandedDetails) && (t.expandedDetails = c(t.expandedDetails)), this.requestUpdate(); + } + updated() { + const e = this.querySelector(".row:last-child"); + e && this.isTooLong(e.querySelector(".firstrowmessage")) && e.querySelector("button.expand")?.removeAttribute("hidden"); + } + toggleExpanded(e) { + this.canBeExpanded(e) && (e.expanded = !e.expanded, this.requestUpdate()), M("use-log", { source: "toggleExpanded" }); + } + canBeExpanded(e) { + if (e.expandedMessage || e.expanded) + return !0; + const t = this.querySelector(`[data\\-id="${e.id}"]`)?.querySelector( + ".firstrowmessage" + ); + return this.isTooLong(t); + } + isTooLong(e) { + return e && e.offsetWidth < e.scrollWidth; + } +}; +d.MAX_LOG_ROWS = 1e3; +u([ + v() +], d.prototype, "unreadErrors", 2); +u([ + v() +], d.prototype, "messages", 2); +d = u([ + w("copilot-log-panel") +], d); +let x = class extends D { + createRenderRoot() { + return this; + } + render() { + return l` + + + + `; + } +}; +x = u([ + w("copilot-log-panel-actions") +], x); +const $ = { + header: "Log", + expanded: !0, + panelOrder: 0, + panel: "bottom", + floating: !1, + tag: "copilot-log-panel", + actionsTag: "copilot-log-panel-actions", + individual: !0 +}, U = { + init(e) { + e.addPanel($); + } +}; +window.Vaadin.copilot.plugins.push(U); +y.addPanel($); +function N(e) { + return _.format(e); +} +export { + x as Actions, + d as CopilotLogPanel +}; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/copilot-shortcuts-plugin-C9BiTUJ_.js b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-shortcuts-plugin-C9BiTUJ_.js new file mode 100644 index 0000000..a619cb7 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-shortcuts-plugin-C9BiTUJ_.js @@ -0,0 +1,137 @@ +import { r as f, b as n, E as v, D as p, w as b, a3 as g, $ as s, H as $ } from "./copilot-BvIxHaRg.js"; +import { B as m } from "./base-panel-C5as2IDv.js"; +import { i as e } from "./icons-DpjjuYvb.js"; +const y = 'copilot-shortcuts-panel{display:flex;flex-direction:column;padding:var(--space-150)}copilot-shortcuts-panel h3{font:var(--copilot-font-xs-semibold);margin-bottom:var(--space-100);margin-top:0}copilot-shortcuts-panel h3:not(:first-of-type){margin-top:var(--space-200)}copilot-shortcuts-panel ul{display:flex;flex-direction:column;list-style:none;margin:0;padding:0}copilot-shortcuts-panel ul li{display:flex;align-items:center;gap:var(--space-50);position:relative}copilot-shortcuts-panel ul li:not(:last-of-type):before{border-bottom:1px dashed var(--border-color);content:"";inset:auto 0 0 calc(var(--copilot-size-md) + var(--space-50));position:absolute}copilot-shortcuts-panel ul li span:has(svg){align-items:center;display:flex;height:var(--copilot-size-md);justify-content:center;width:var(--copilot-size-md)}copilot-shortcuts-panel .kbds{margin-inline-start:auto}copilot-shortcuts-panel kbd{align-items:center;border:1px solid var(--border-color);border-radius:var(--vaadin-radius-m);box-sizing:border-box;display:inline-flex;font-family:var(--copilot-font-family);font-size:var(--copilot-font-size-xs);line-height:var(--copilot-line-height-sm);padding:0 var(--space-50)}', u = window.Vaadin.copilot.tree; +if (!u) + throw new Error("Tried to access copilot tree before it was initialized."); +var x = Object.getOwnPropertyDescriptor, P = (o, i, h, r) => { + for (var a = r > 1 ? void 0 : r ? x(i, h) : i, l = o.length - 1, c; l >= 0; l--) + (c = o[l]) && (a = c(a) || a); + return a; +}; +let d = class extends m { + constructor() { + super(), this.onKeyPressedEvent = (o) => { + o.detail.event.defaultPrevented || this.close(); + }, this.onTreeUpdated = () => { + this.requestUpdate(); + }; + } + connectedCallback() { + super.connectedCallback(), n.on("copilot-tree-created", this.onTreeUpdated), n.on("escape-key-pressed", this.onKeyPressedEvent); + } + disconnectedCallback() { + super.disconnectedCallback(), n.off("copilot-tree-created", this.onTreeUpdated), n.off("escape-key-pressed", this.onKeyPressedEvent); + } + render() { + const o = u.hasFlowComponents(); + return p` +

    Global

    +
      +
    • + ${e.vaadin} + Copilot + ${t(s.toggleCopilot)} +
      • +
    • + ${e.flipBack} + Undo + ${t(s.undo)} +
      • +
    • + ${e.flipForward} + Redo + ${t(s.redo)} +
      • +
    +

    Selected component

    +
      +
    • + ${e.terminal} + Open AI popover + ${t(s.openAiPopover)} +
      • +
    • + ${e.fileCodeAlt} + Go to source + ${t(s.goToSource)} +
      • + ${o ? p`
    • + ${e.code} + Go to attach source + ${t(s.goToAttachSource)} +
      • ` : v} +
    • + ${e.copy} + Copy + ${t(s.copy)} +
      • +
    • + ${e.clipboard} + Paste + ${t(s.paste)} +
      • +
    • + ${e.copyAlt} + Duplicate + ${t(s.duplicate)} +
      • +
    • + ${e.userUp} + Select parent + ${t(s.selectParent)} +
      • +
    • + ${e.userLeft} + Select previous sibling + ${t(s.selectPreviousSibling)} +
      • +
    • + ${e.userRight} + Select first child / next sibling + ${t(s.selectNextSibling)} +
      • +
    • + ${e.delete} + Delete + ${t(s.delete)} +
      • +
    • + ${e.zap} + Quick add from palette + ${t("A ... Z")} +
      • +
    `; + } + /** + * Closes the panel. Used from shortcuts + */ + close() { + b.updatePanel("copilot-shortcuts-panel", { + floating: !1 + }); + } +}; +d = P([ + f("copilot-shortcuts-panel") +], d); +function t(o) { + return p`${g(o)}`; +} +const w = $({ + header: "Keyboard Shortcuts", + tag: "copilot-shortcuts-panel", + width: 400, + height: 550, + floatingPosition: { + top: 50, + left: 50 + } +}), k = { + init(o) { + o.addPanel(w); + } +}; +window.Vaadin.copilot.plugins.push(k); diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/figma-public/figma-api.d.ts b/backend/src/main/frontend/generated/jar-resources/copilot/figma-public/figma-api.d.ts new file mode 100644 index 0000000..4205274 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/figma-public/figma-api.d.ts @@ -0,0 +1,102 @@ +import { NodeType, StackAlign, StackCounterAlign, StackJustify, StackMode, StackSize } from 'fig-kiwi/fig-kiwi'; +import { ComponentDefinition } from '../shared/flow-utils'; +export type SwappedInstance = { + name: string | undefined; + symbolDescription: string | undefined; +}; +export type PropertyValue = SwappedInstance | boolean | number | string; +export type FigmaNode = { + type: NodeType | undefined; + name: string | undefined; + symbolDescription: string | undefined; + parent: FigmaNode | undefined; + children: FigmaNode[]; + htmlTag: string; + reactTag: string; + vaadinComponent: boolean; + vaadinLayout: boolean; + width: number | undefined; + height: number | undefined; + x: number | undefined; + y: number | undefined; + classNames: string[]; + styles: Record; + properties: Record; + relativePosition: boolean; + stackMode: StackMode | undefined; + stackSpacing: number | undefined; + stackPrimaryAlignItems: StackJustify | undefined; + stackCounterAlignItems: StackAlign | undefined; + stackPrimarySizing: StackSize | undefined; + stackCounterSizing: StackSize | undefined; + stackChildAlignSelf: StackCounterAlign | undefined; + stackChildPrimaryGrow: number | undefined; + stackHorizontalPadding: number | undefined; + stackVerticalPadding: number | undefined; + stackPadding: number | undefined; + stackPaddingBottom: number | undefined; + stackPaddingRight: number | undefined; + _innerHTML: string | undefined; +}; +export type Importer = (node: FigmaNode, metadata: ImportMetadata) => ComponentDefinition | undefined; +export type ImportMetadata = { + target: 'java' | 'react'; +}; +/** + * Registers a custom importer function that can be used to convert Figma nodes into Vaadin components. + *

    + * For example if you have a figma component called "AcmeCard" with a marker property `type=AcmeCard` and with two properties for customizing it: title and content, + * you can register an importer like this: + * + * ```typescript + * import type { ComponentDefinition, FigmaNode } from 'Frontend/generated/jar-resources/copilot.js'; + * import { registerImporter } from 'Frontend/generated/jar-resources/copilot.js'; + * + * function acmeCardImporter(node: FigmaNode): ComponentDefinition | undefined { + * if (node.properties.type === 'AcmeCard') { + * return { + * tag: 'AcmeCard', + * props: { + * cardTitle: node.properties.title, + * cardText: node.properties.content, + * }, + * children: [], + * javaClass: 'my.project.components.AcmeCard', + * reactImports: { + * AcmeCard: 'Frontend/components/AcmeCard', + * }, + * }; + * } + * } + * + * registerImporter(acmeCardImporter); + * ``` + * If you only want to support either Java or React, you can omit the `javaClass` or `reactImports` property respectively. + * + * The above content should be placed in a file that is imported only in development mode, for example in `src/main/frontend/figma-importer.ts`. + * In `index.tsx` you can then place + * ```typescript + * // @ts-ignore + * if (import.meta.env.DEV) { + * import('./figma-importer'); + * } + * ``` + * + * Registered importers will be used before the built in importers, so you can override the built-in importers if needed. + * + * This method is experimental and may change in the future. + * + * @param importer the importer to register + */ +export declare function registerImporter(importer: Importer): void; +export declare function _registerInternalImporter(importer: Importer): void; +export declare function _getImporters(): Importer[]; +export declare function _getIcon(node: FigmaNode, enablerKey: string, iconKey: string, slot?: string | undefined): ComponentDefinition | undefined; +export declare function renderNodesAs(htmlTag: string, nodes: Array, metadata: ImportMetadata): ComponentDefinition[]; +export declare function renderNodeAs(htmlTag: string, node: FigmaNode, metadata: ImportMetadata, customProperties?: Record): ComponentDefinition | undefined; +export declare function renderNodes(childNodes: FigmaNode[], metadata: ImportMetadata): ComponentDefinition[]; +export declare function renderNode(node: FigmaNode, metadata: ImportMetadata, customProperties?: Record): ComponentDefinition | undefined; +export declare function findChild(node: FigmaNode, matcher: (node: FigmaNode) => boolean): FigmaNode | undefined; +export declare function findFirstChild(node: FigmaNode, name: string): FigmaNode | undefined; +export declare function findAllChildren(node: FigmaNode, matcher: (node: FigmaNode) => boolean): FigmaNode[]; +export declare function createChildrenDefinitions(node: FigmaNode, metadata: ImportMetadata, matcher: (n: FigmaNode) => boolean): ComponentDefinition[]; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/icons-DpjjuYvb.js b/backend/src/main/frontend/generated/jar-resources/copilot/icons-DpjjuYvb.js new file mode 100644 index 0000000..b8e9a7b --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/icons-DpjjuYvb.js @@ -0,0 +1,3226 @@ +import { az as t } from "./copilot-BvIxHaRg.js"; +const r = { + _123: t``, + accountCircle: t``, + add: t``, + addHome: t``, + addLocation: t``, + addLocationAlt: t``, + adminPanelSettings: t``, + adsClick: t``, + adsGroup: t``, + alternateEmail: t``, + appBadging: t``, + apps: t``, + areaChart: t``, + arrowDropDown: t``, + arrowDropDownCircle: t``, + arrowLeftAlt: t``, + arrowRightAlt: t``, + arrowSelectorTool: t``, + article: t``, + autoAwesomeMosaic: t``, + badge: t``, + barChart: t``, + barChartAlt: t``, + block: t``, + bolt: t``, + bottomPanelClose: t``, + bubbleChart: t``, + bugReport: t``, + calendarClock: t``, + calendarMonth: t``, + capture: t``, + changeHistory: t``, + checkBox: t``, + checklist: t``, + chevronRight: t``, + close: t``, + code: t``, + contentCopy: t``, + contentPaste: t``, + darkMode: t``, + dashboard: t``, + delete: t``, + deleteSweep: t``, + deployedCube: t``, + draft: t``, + dragIndicator: t``, + dockToBottom: t``, + dockToLeft: t``, + dockToRight: t``, + doNotDisturbOn: t``, + edit: t``, + editLocation: t``, + editSquare: t``, + emojiPeople: t``, + expand: t``, + expandCircleDown: t``, + expansionPanels: t``, + feedback: t``, + fileCopy: t``, + filterAlt: t``, + flexDirection: t``, + flexDirectionAlt: t``, + flow: t` `, + formatImageLeft: t``, + forum: t``, + globe: t``, + gridView: t``, + group: t``, + h1: t``, + h2: t``, + h3: t``, + h4: t``, + h5: t``, + h6: t``, + height: t``, + help: t``, + hilla: t``, + home: t``, + horizontalRule: t``, + idCard: t``, + image: t``, + inbox: t``, + info: t``, + inkSelection: t``, + input: t``, + key: t``, + keyboard: t``, + keyboardAlt: t``, + keyboardArrowDown: t``, + keyboardArrowUp: t``, + keyboardDoubleArrowRight: t``, + keyboardTab: t``, + label: t``, + lightMode: t``, + link: t``, + list: t``, + login: t``, + menu: t``, + moreVert: t``, + north: t``, + numbers: t``, + openInNew: t``, + orbit: t``, + password: t``, + pentagon: t``, + pieChart: t``, + playArrow: t``, + playCircle: t``, + planet: t``, + progressActivity: t``, + progressBar: t``, + public: t``, + radioButtonChecked: t``, + redo: t``, + refresh: t``, + save: t``, + scatterPlot: t``, + schedule: t``, + search: t``, + send: t``, + settings: t``, + showChart: t``, + sparkles: t``, + speed: t``, + square: t``, + stars2: t``, + steppers: t``, + stop: t``, + subdirectoryArrowRight: t``, + table: t``, + tab: t``, + tabs: t``, + thermostatCarbon: t``, + thumbnailBar: t``, + title: t``, + trendingUp: t``, + toolbar: t``, + tune: t``, + undo: t``, + unfoldLess: t``, + unfoldMore: t``, + vaadin: t``, + viewComfy: t``, + warning: t``, + webAsset: t``, + webTraffic: t``, + west: t``, + widget: t``, + alertCircle: t` + + +`, + alertTriangle: t` + + +`, + alignBottom: t` + + +`, + alignCenter: t` + + +`, + alignHorizontalAlt: t` + + +`, + alignHorizontal: t` + + + +`, + alignVerticalAlt: t` + + +`, + alignVertical: t` + + + +`, + alignVerticalCenter: t``, + annotation: t` + + + `, + annotationX: t` + + + `, + arrowCircleUp: t` + + + + + + + + + +`, + arrowDownLeft: t` + + +`, + arrowDownRight: t` + + +`, + arrowDown: t` + + +`, + arrowLeft: t` + + +`, + arrowRight: t` + + +`, + arrowUpLeft: t` + + +`, + arrowUpRight: t` + + +`, + atSign: t` + + + + + + + + + +`, + atom: t` + + +`, + autoMode: t` + + `, + bell: t` + + +`, + bookOpen: t` + + +`, + calendarPlus: t` + + +`, + calendar: t` + + +`, + caretDown: t` + + +`, + caretLeft: t` + + +`, + caretRight: t` + + +`, + caretUp: t` + + +`, + category: t` + +`, + checkCircle: t` + + + + + + + + + +`, + checkDone: t` + + + + + + + + + +`, + checkSquare: t` + + +`, + check: t` + + +`, + chevronDown: t` + + +`, + chevronLeft: t` + + +`, + chevronSelectorHorizontal: t` + + +`, + chevronSelectorVertical: t` + + +`, + chevronUp: t` + + +`, + circle: t` + + + + + + + + + +`, + clickAlt: t` + + + + + + + + + +`, + click: t` + + + + + + + + + +`, + clipboardCheck: t` + + +`, + clipboard: t` + + +`, + clock: t` + + +`, + cloud: t` + + +`, + codeAlt: t` + + +`, + codeBrowser: t` + + +`, + coinsHand: t` + + + + + + + + + +`, + columnsAlt: t` + + + +`, + columns: t` + + +`, + command: t` + + +`, + components: t` + + + + +`, + cookie: t` + + +`, + copilot: t` + + + + + + + + + +`, + copyAlt: t` + + + + + + + + + +`, + copy: t` + + + + + + + + + +`, + cornerDownRight: t` + + +`, + creditCard: t` + + +`, + cursorAlt: t` + + +`, + cursorBox: t` + + +`, + cursor: t` + + +`, + databaseUpload: t` + + +`, + database: t` + + +`, + distributeSpaceHorizontal: t` + + +`, + distributeSpaceVertical: t` + + +`, + dotpoints: t` + + +`, + dots: t` + + + + +`, + download: t` + + +`, + dragHandle: t` + + +`, + dragPan: t` + + +`, + expandAlt: t` + + +`, + eyeOff: t` + + +`, + eye: t` + + + +`, + faceSmile: t` + + + + + + + + + +`, + fileCodeAlt: t` + + +`, + fileCode: t` + + +`, + file: t` + + +`, + filterFunnel: t` + + +`, + flexAlignBottom: t` + + +`, + flexAlignLeft: t` + + +`, + flexAlignRight: t` + + +`, + flipBack: t` + + +`, + flipForward: t` + + +`, + github: t` + + +`, + gridAlt: t` + + +`, + gridDotsBlank: t` + + +`, + gridDotsBottom: t` + + +`, + gridDotsHorizontal: t` + + +`, + gridDotsLeft: t` + + +`, + gridDotsRight: t` + + +`, + gridDotsTop: t` + + +`, + gridDotsVertical: t` + + +`, + hash: t` + + +`, + heading: t` + + +`, + heightFill: t` + + +`, + heightFixed: t` + + +`, + heightHug: t` + + +`, + hexagon: t` + + +`, + horizontalBarChart: t` + + +`, + horizontalBottom: t` + + + + +`, + horizontalCenter: t` + + + + +`, + horizontalTop: t` + + + + +`, + html: t` + + +`, + imageIndentLeft: t` + + +`, + justifyCenter: t` + + +`, + justifyEnd: t` + + +`, + justifyStart: t` + + +`, + kubernetes: t` + + + + + + + + + + +`, + layoutTop: t` + + +`, + layout: t` + + +`, + letterSpacing: t` + + +`, + lightning: t` + + +`, + lineChart: t` + + +`, + lineHeight: t` + + +`, + loading: t` + + +`, + lock: t` + + +`, + lowPriority: t` + + +`, + magic: t` + + +`, + map: t` + + + + + + + + + +`, + markerPin: t` + + + +`, + menuAlt: t` + + +`, + messageChat: t` + + + + + + + + + +`, + message: t` + + +`, + minus: t` + + +`, + mouse: t` + + +`, + paddingBottom: t` + + + +`, + paddingHorizontal: t` + + + +`, + paddingLeft: t` + + + +`, + paddingRight: t` + + + +`, + paddingTop: t` + + + +`, + paddingVertical: t` + + + +`, + padding: t` + + + + +`, + palette: t` + + + + + + + + + + + + +`, + passcode: t` + + +`, + phone: t` + + + + `, + pinAlt: t` + + +`, + pin: t` + + + +`, + play: t` + + +`, + plus: t` + + +`, + radioButtonPartial: t` + + +`, + refreshAlt: t` + + +`, + repeat: t` + + +`, + rocket: t` + + +`, + rotatingSpinner: t` + + + + + +`, + share: t` + + +`, + shieldTick: t` + + +`, + shoppingCart: t` + + + + + + + + + +`, + slidersAlt: t` + + +`, + sliders: t` + + +`, + spacingHeight: t` + + +`, + spacingWidth: t` + + +`, + star: t` + + +`, + stars: t` + + + + + + + + + + +`, + stopCircle: t` + + + + + + + + + +`, + switchOff: t` + + + +`, + switchOn: t` + + + +`, + switchVertical: t` + + +`, + tableAlt: t` + +`, + tableAltEdit: t` + +`, + tag: t` + + + + + + + + + + + + `, + terminal: t` + + +`, + textInput: t` + + +`, + thumbsDownAlt: t` + + + +`, + thumbsDown: t` + + +`, + thumbsUpAlt: t` + + + +`, + thumbsUp: t` + + +`, + tool: t` + + +`, + topPanelOpen: t` + + +`, + touchApp: t` + + +`, + triangle: t` + + +`, + type: t` + + +`, + unlock: t` + + +`, + upload: t` + + +`, + userLeft: t` + + +`, + userRight: t` + + +`, + userUp: t` + + +`, + user: t` + + +`, + userCircle: t` + + +`, + users: t` + + +`, + verticalCenter: t` + + + + +`, + verticalEnd: t` + + + + +`, + verticalStart: t` + + + + +`, + viewDay: t` + + +`, + x: t` + + +`, + zap: t` + + +`, + filePlus: t` + + + + + + ` +}; +export { + r as i +}; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/index-DjQvWJdw.js b/backend/src/main/frontend/generated/jar-resources/copilot/index-DjQvWJdw.js new file mode 100644 index 0000000..608a1ef --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/index-DjQvWJdw.js @@ -0,0 +1,77 @@ +import { a as D } from "./copilot-BvIxHaRg.js"; +var g, b; +function x() { + return b || (b = 1, g = function() { + var a = document.getSelection(); + if (!a.rangeCount) + return function() { + }; + for (var o = document.activeElement, s = [], i = 0; i < a.rangeCount; i++) + s.push(a.getRangeAt(i)); + switch (o.tagName.toUpperCase()) { + // .toUpperCase handles XHTML + case "INPUT": + case "TEXTAREA": + o.blur(); + break; + default: + o = null; + break; + } + return a.removeAllRanges(), function() { + a.type === "Caret" && a.removeAllRanges(), a.rangeCount || s.forEach(function(d) { + a.addRange(d); + }), o && o.focus(); + }; + }), g; +} +var m, C; +function E() { + if (C) return m; + C = 1; + var a = x(), o = { + "text/plain": "Text", + "text/html": "Url", + default: "Text" + }, s = "Copy to clipboard: #{key}, Enter"; + function i(n) { + var t = (/mac os x/i.test(navigator.userAgent) ? "⌘" : "Ctrl") + "+C"; + return n.replace(/#{\s*key\s*}/g, t); + } + function d(n, t) { + var c, y, v, u, l, e, f = !1; + t || (t = {}), c = t.debug || !1; + try { + v = a(), u = document.createRange(), l = document.getSelection(), e = document.createElement("span"), e.textContent = n, e.ariaHidden = "true", e.style.all = "unset", e.style.position = "fixed", e.style.top = 0, e.style.clip = "rect(0, 0, 0, 0)", e.style.whiteSpace = "pre", e.style.webkitUserSelect = "text", e.style.MozUserSelect = "text", e.style.msUserSelect = "text", e.style.userSelect = "text", e.addEventListener("copy", function(r) { + if (r.stopPropagation(), t.format) + if (r.preventDefault(), typeof r.clipboardData > "u") { + c && console.warn("unable to use e.clipboardData"), c && console.warn("trying IE specific stuff"), window.clipboardData.clearData(); + var p = o[t.format] || o.default; + window.clipboardData.setData(p, n); + } else + r.clipboardData.clearData(), r.clipboardData.setData(t.format, n); + t.onCopy && (r.preventDefault(), t.onCopy(r.clipboardData)); + }), document.body.appendChild(e), u.selectNodeContents(e), l.addRange(u); + var w = document.execCommand("copy"); + if (!w) + throw new Error("copy command was unsuccessful"); + f = !0; + } catch (r) { + c && console.error("unable to copy using execCommand: ", r), c && console.warn("trying IE specific stuff"); + try { + window.clipboardData.setData(t.format || "text", n), t.onCopy && t.onCopy(window.clipboardData), f = !0; + } catch (p) { + c && console.error("unable to copy using clipboardData: ", p), c && console.error("falling back to prompt"), y = i("message" in t ? t.message : s), window.prompt(y, n); + } + } finally { + l && (typeof l.removeRange == "function" ? l.removeRange(u) : l.removeAllRanges()), e && document.body.removeChild(e), v(); + } + return f; + } + return m = d, m; +} +var h = E(); +const T = /* @__PURE__ */ D(h); +export { + T as c +}; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/query-BykXNUlT.js b/backend/src/main/frontend/generated/jar-resources/copilot/query-BykXNUlT.js new file mode 100644 index 0000000..ac2a239 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/query-BykXNUlT.js @@ -0,0 +1,22 @@ +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const c = (r, t, e) => (e.configurable = !0, e.enumerable = !0, Reflect.decorate && typeof t != "object" && Object.defineProperty(r, t, e), e); +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +function f(r, t) { + return (e, o, l) => { + const n = (u) => u.renderRoot?.querySelector(r) ?? null; + return c(e, o, { get() { + return n(this); + } }); + }; +} +export { + f as e +}; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/shared/copilot-plugin-support.d.ts b/backend/src/main/frontend/generated/jar-resources/copilot/shared/copilot-plugin-support.d.ts new file mode 100644 index 0000000..9d88d3e --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/shared/copilot-plugin-support.d.ts @@ -0,0 +1,117 @@ +import { IObservableValue } from 'mobx'; +import { TemplateResult } from 'lit'; +/** + * Plugin API for the dev tools window. + */ +export interface CopilotInterface { + send(command: string, data: any): void; + addPanel(panel: PanelConfiguration): void; +} +export interface MessageHandler { + handleMessage(message: ServerMessage): boolean; +} +export interface ServerMessage { + /** + * The command + */ + command: string; + /** + * The data for the command + */ + data: any; +} +export type Framework = 'flow' | 'hilla-lit' | 'hilla-react'; +export interface CopilotPlugin { + /** + * Called once to initialize the plugin. + * + * @param copilotInterface provides methods to interact with the dev tools + */ + init(copilotInterface: CopilotInterface): void; +} +export declare enum MessageType { + INFORMATION = "information", + WARNING = "warning", + ERROR = "error" +} +export interface Message { + id: number; + type: MessageType; + message: string; + timestamp: Date; + details?: IObservableValue | string; + link?: string; + persistentId?: string; + dontShowAgain: boolean; + deleted: boolean; +} +/** + * Known Copilot panel tags used throughout the application. + * This object serves as a registry of all panel identifiers. + */ +export declare const CopilotPanelTags: { + readonly FEATURES: "copilot-features-panel"; + readonly FEEDBACK: "copilot-feedback-panel"; + readonly SHORTCUTS: "copilot-shortcuts-panel"; + readonly INFO: "copilot-info-panel"; + readonly LOG: "copilot-log-panel"; + readonly DEVELOPMENT_SETUP: "copilot-development-setup-user-guide"; + readonly A11Y_CHECKER: "copilot-a11y-checker"; + readonly BACKEND_AND_DATA: "copilot-backend-and-data-panel"; + readonly COMPONENT_PROPERTIES: "copilot-component-properties"; + readonly CONNECT_TO_SERVICE: "copilot-connect-to-service"; + readonly DOCS: "copilot-docs"; + readonly EDIT_COMPONENT: "copilot-edit-component"; + readonly I18N: "copilot-i18n-panel"; + readonly NEW_ROUTE: "copilot-new-route"; + readonly OUTLINE: "copilot-outline-panel"; + readonly PALETTE: "copilot-palette"; + readonly ROUTES: "copilot-routes-panel"; + readonly SPRING_SECURITY: "copilot-spring-security"; + readonly TEST_BENCH_TEST_GENERATOR: "copilot-test-bench-test-generator-panel"; + readonly THEME_EDITOR: "copilot-theme-editor-panel"; + readonly UI_SERVICES: "copilot-ui-services-panel"; + readonly UI_TEST_GENERATOR: "copilot-ui-test-generator-panel"; + readonly VAADIN_VERSIONS: "copilot-vaadin-versions"; + readonly TEST_LOG_PANEL: "test-log-panel"; + readonly TEST_PLUGIN_PANEL: "test-plugin-panel"; + readonly TEST_FOO_PANEL: "foo-panel"; + readonly TEST_FOO_PANEL_2: "foo-panel-2"; + readonly TEST_FOO_PANEL_BOTTOM: "foo-panel-bottom"; + readonly TEST_FOO_PANEL_LEFT: "foo-panel-left"; + readonly TEST_FOO_PANEL_RIGHT: "foo-panel-right"; +}; +/** + * Type representing all known Copilot panel tags. + * String literals matching these values are automatically compatible. + */ +export type CopilotPanelTag = (typeof CopilotPanelTags)[keyof typeof CopilotPanelTags]; +export interface PanelConfiguration { + header: string; + expanded: boolean; + expandable?: boolean; + panel?: 'bottom' | 'left' | 'right'; + panelOrder: number; + tag: CopilotPanelTag; + actionsTag?: string; + floating: boolean; + height?: number; + width?: number; + floatingPosition?: FloatingPosition; + showWhileDragging?: boolean; + helpUrl?: string; + /** + * These panels can be visible regardless of copilot activation status + */ + individual?: boolean; + /** + * A panel is rendered the first time when it is expanded unless eager is set to true, which causes it be always be rendered + */ + eager?: boolean; +} +export interface FloatingPosition { + top?: number; + left?: number; + right?: number; + bottom?: number; +} diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/shared/flow-utils.d.ts b/backend/src/main/frontend/generated/jar-resources/copilot/shared/flow-utils.d.ts new file mode 100644 index 0000000..9892aa4 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/shared/flow-utils.d.ts @@ -0,0 +1,41 @@ +import { FiberNode, Source } from 'react-devtools-inline'; +import { CopilotTreeNode } from './copilot-tree'; +import { JavaSource } from '../show-in-ide'; +export type FlowComponentReference = { + nodeId: number; + uiId: number; +}; +export type FlowComponentInfo = FlowComponentReference & { + element: HTMLElement; + javaClass?: string; + hiddenByServer: boolean; + styles: Record; +}; +export type ComponentDefinitionProperties = Record | boolean | number | string | null>; +export type ComponentDefinition = { + tag?: string; + className?: string; + props?: ComponentDefinitionProperties; + children?: Array; + reactImports?: Record; + javaClass?: string; + metadata?: any; +}; +export declare function isFlowComponentInfo(info: FlowComponentInfo | JavaSource | Source | undefined): info is FlowComponentInfo; +export declare function isFlowComponent(element: HTMLElement): boolean; +export declare function getJavaClassName(component: FlowComponentInfo): string | undefined; +export declare function getFlowComponent(element: HTMLElement): FlowComponentInfo | undefined; +export declare const fetchComponentDefinition: (flowComponent: FlowComponentInfo) => Promise; +export declare function getUIId(): string | undefined; +export declare function getFlowComponentId(flowComponent: FlowComponentInfo): FlowComponentReference; +export declare function isServerRouteContainer(fiber?: FiberNode): boolean; +export declare const isEditableComponentText: (node: CopilotTreeNode | undefined, propertyToCheck: string) => Promise<{ + canBeEdited: boolean; + isTranslation: boolean; +}> | { + canBeEdited: boolean; + isTranslation: boolean; +}; +export declare function isServerRouteContainerElement(element: HTMLElement): boolean; +export declare function getSimpleName(className: string): string; +export declare function getPackageName(className: string): string; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/state-BGGS46O3.js b/backend/src/main/frontend/generated/jar-resources/copilot/state-BGGS46O3.js new file mode 100644 index 0000000..0914709 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/state-BGGS46O3.js @@ -0,0 +1,45 @@ +import { aw as u, ax as l } from "./copilot-BvIxHaRg.js"; +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +const p = { attribute: !0, type: String, converter: l, reflect: !1, hasChanged: u }, d = (t = p, o, e) => { + const { kind: s, metadata: i } = e; + let r = globalThis.litPropertyMetadata.get(i); + if (r === void 0 && globalThis.litPropertyMetadata.set(i, r = /* @__PURE__ */ new Map()), s === "setter" && ((t = Object.create(t)).wrapped = !0), r.set(e.name, t), s === "accessor") { + const { name: a } = e; + return { set(n) { + const c = o.get.call(this); + o.set.call(this, n), this.requestUpdate(a, c, t); + }, init(n) { + return n !== void 0 && this.C(a, void 0, t, n), n; + } }; + } + if (s === "setter") { + const { name: a } = e; + return function(n) { + const c = this[a]; + o.call(this, n), this.requestUpdate(a, c, t); + }; + } + throw Error("Unsupported decorator location: " + s); +}; +function h(t) { + return (o, e) => typeof e == "object" ? d(t, o, e) : ((s, i, r) => { + const a = i.hasOwnProperty(r); + return i.constructor.createProperty(r, s), a ? Object.getOwnPropertyDescriptor(i, r) : void 0; + })(t, o, e); +} +/** + * @license + * Copyright 2017 Google LLC + * SPDX-License-Identifier: BSD-3-Clause + */ +function b(t) { + return h({ ...t, state: !0, attribute: !1 }); +} +export { + h as n, + b as r +}; diff --git a/backend/src/main/frontend/generated/jar-resources/datepickerConnector.js b/backend/src/main/frontend/generated/jar-resources/datepickerConnector.js new file mode 100644 index 0000000..372ea4f --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/datepickerConnector.js @@ -0,0 +1,179 @@ +import dateFnsFormat from 'date-fns/format'; +import dateFnsParse from 'date-fns/parse'; +import dateFnsIsValid from 'date-fns/isValid'; +import { extractDateParts, parseDate as _parseDate } from '@vaadin/date-picker/src/vaadin-date-picker-helper.js'; + +window.Vaadin.Flow.datepickerConnector = {}; +window.Vaadin.Flow.datepickerConnector.initLazy = (datepicker) => { + // Check whether the connector was already initialized for the datepicker + if (datepicker.$connector) { + return; + } + + datepicker.$connector = {}; + + const createLocaleBasedDateFormat = function (locale) { + try { + // Check whether the locale is supported or not + new Date().toLocaleDateString(locale); + } catch (e) { + console.warn('The locale is not supported, using default format setting (ISO 8601).'); + return 'yyyy-MM-dd'; + } + + // format test date and convert to date-fns pattern + const testDate = new Date(Date.UTC(1234, 4, 6)); + let pattern = testDate.toLocaleDateString(locale, { timeZone: 'UTC' }); + pattern = pattern + // escape date-fns pattern letters by enclosing them in single quotes + .replace(/([a-zA-Z]+)/g, "'$1'") + // insert date placeholder + .replace('06', 'dd') + .replace('6', 'd') + // insert month placeholder + .replace('05', 'MM') + .replace('5', 'M') + // insert year placeholder + .replace('1234', 'yyyy'); + const isValidPattern = pattern.includes('d') && pattern.includes('M') && pattern.includes('y'); + if (!isValidPattern) { + console.warn('The locale is not supported, using default format setting (ISO 8601).'); + return 'yyyy-MM-dd'; + } + + return pattern; + }; + + function createFormatterAndParser(formats) { + if (!formats || formats.length === 0) { + throw new Error('Array of custom date formats is null or empty'); + } + + function getShortYearFormat(format) { + if (format.includes('yyyy') && !format.includes('yyyyy')) { + return format.replace('yyyy', 'yy'); + } + if (format.includes('YYYY') && !format.includes('YYYYY')) { + return format.replace('YYYY', 'YY'); + } + return undefined; + } + + function isFormatWithYear(format) { + return format.includes('y') || format.includes('Y'); + } + + function isShortYearFormat(format) { + // Format is long if it includes a four-digit year. + return !format.includes('yyyy') && !format.includes('YYYY'); + } + + function getExtendedFormats(formats) { + return formats.reduce((acc, format) => { + // We first try to match the date with the shorter version, + // as short years are supported with the long date format. + if (isFormatWithYear(format) && !isShortYearFormat(format)) { + acc.push(getShortYearFormat(format)); + } + acc.push(format); + return acc; + }, []); + } + + function correctFullYear(date) { + // The last parsed date check handles the case where a four-digit year is parsed, then formatted + // as a two-digit year, and then parsed again. In this case we want to keep the century of the + // originally parsed year, instead of using the century of the reference date. + + // Do not apply any correction if the previous parse attempt was failed. + if (datepicker.$connector._lastParseStatus === 'error') { + return; + } + + // Update century if the last parsed date is the same except the century. + if (datepicker.$connector._lastParseStatus === 'successful') { + if ( + datepicker.$connector._lastParsedDate.day === date.getDate() && + datepicker.$connector._lastParsedDate.month === date.getMonth() && + datepicker.$connector._lastParsedDate.year % 100 === date.getFullYear() % 100 + ) { + date.setFullYear(datepicker.$connector._lastParsedDate.year); + } + return; + } + + // Update century if this is the first parse after overlay open. + const currentValue = _parseDate(datepicker.value); + if ( + dateFnsIsValid(currentValue) && + currentValue.getDate() === date.getDate() && + currentValue.getMonth() === date.getMonth() && + currentValue.getFullYear() % 100 === date.getFullYear() % 100 + ) { + date.setFullYear(currentValue.getFullYear()); + } + } + + function formatDate(dateParts) { + const format = formats[0]; + const date = _parseDate(`${dateParts.year}-${dateParts.month + 1}-${dateParts.day}`); + + return dateFnsFormat(date, format); + } + + function doParseDate(dateString, format, referenceDate) { + // When format does not contain a year, then current year should be used. + const refDate = isFormatWithYear(format) ? referenceDate : new Date(); + const date = dateFnsParse(dateString, format, refDate); + if (dateFnsIsValid(date)) { + if (isFormatWithYear(format) && isShortYearFormat(format)) { + correctFullYear(date); + } + return { + day: date.getDate(), + month: date.getMonth(), + year: date.getFullYear() + }; + } + } + + function parseDate(dateString) { + const referenceDate = _getReferenceDate(); + for (let format of getExtendedFormats(formats)) { + const parsedDate = doParseDate(dateString, format, referenceDate); + if (parsedDate) { + datepicker.$connector._lastParseStatus = 'successful'; + datepicker.$connector._lastParsedDate = parsedDate; + return parsedDate; + } + } + datepicker.$connector._lastParseStatus = 'error'; + return false; + } + + return { + formatDate: formatDate, + parseDate: parseDate + }; + } + + function _getReferenceDate() { + const { referenceDate } = datepicker.i18n; + return referenceDate ? new Date(referenceDate.year, referenceDate.month, referenceDate.day) : new Date(); + } + + datepicker.$connector.updateI18n = (locale, i18n) => { + // Either use custom formats specified in I18N, or create format from locale + const hasCustomFormats = i18n && i18n.dateFormats && i18n.dateFormats.length > 0; + if (i18n && i18n.referenceDate) { + i18n.referenceDate = extractDateParts(new Date(i18n.referenceDate)); + } + const usedFormats = hasCustomFormats ? i18n.dateFormats : [createLocaleBasedDateFormat(locale)]; + const formatterAndParser = createFormatterAndParser(usedFormats); + + // Merge current web component I18N settings with new I18N settings and the formatting and parsing functions + datepicker.i18n = Object.assign({}, datepicker.i18n, i18n, formatterAndParser); + }; + + datepicker.addEventListener('opened-changed', () => (datepicker.$connector._lastParseStatus = undefined)); +}; diff --git a/backend/src/main/frontend/generated/jar-resources/disableOnClickFunctions.js b/backend/src/main/frontend/generated/jar-resources/disableOnClickFunctions.js new file mode 100644 index 0000000..c2592b8 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/disableOnClickFunctions.js @@ -0,0 +1,6 @@ +document.addEventListener('click', (event) => { + const target = event.composedPath().find((node) => node.hasAttribute && node.hasAttribute('disableonclick')); + if (target) { + target.disabled = true; + } +}); diff --git a/backend/src/main/frontend/generated/jar-resources/dndConnector.js b/backend/src/main/frontend/generated/jar-resources/dndConnector.js new file mode 100644 index 0000000..f8ef82c --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/dndConnector.js @@ -0,0 +1,131 @@ +window.Vaadin = window.Vaadin || {}; +window.Vaadin.Flow = window.Vaadin.Flow || {}; +window.Vaadin.Flow.dndConnector = { + __ondragenterListener: function (event) { + // TODO filter by data type + // TODO prevent dropping on itself (by default) + const effect = event.currentTarget['__dropEffect']; + if (!event.currentTarget.hasAttribute('disabled')) { + if (effect) { + event.dataTransfer.dropEffect = effect; + } + + if (effect !== 'none') { + /* #7108: if drag moves on top of drop target's children, first another ondragenter event + * is fired and then a ondragleave event. This happens again once the drag + * moves on top of another children, or back on top of the drop target element. + * Thus need to "cancel" the following ondragleave, to not remove class name. + * Drop event will happen even when dropped to a child element. */ + if (event.currentTarget.classList.contains('v-drag-over-target')) { + event.currentTarget['__skip-leave'] = true; + } else { + event.currentTarget.classList.add('v-drag-over-target'); + } + // enables browser specific pseudo classes (at least FF) + event.preventDefault(); + event.stopPropagation(); // don't let parents know + } + } + }, + + __ondragoverListener: function (event) { + // TODO filter by data type + // TODO filter by effectAllowed != dropEffect due to Safari & IE11 ? + if (!event.currentTarget.hasAttribute('disabled')) { + const effect = event.currentTarget['__dropEffect']; + if (effect) { + event.dataTransfer.dropEffect = effect; + } + // allows the drop && don't let parents know + event.preventDefault(); + event.stopPropagation(); + } + }, + + __ondragleaveListener: function (event) { + if (event.currentTarget['__skip-leave']) { + event.currentTarget['__skip-leave'] = false; + } else { + event.currentTarget.classList.remove('v-drag-over-target'); + } + // #7109 need to stop or any parent drop target might not get highlighted, + // as ondragenter for it is fired before the child gets dragleave. + event.stopPropagation(); + }, + + __ondropListener: function (event) { + const effect = event.currentTarget['__dropEffect']; + if (effect) { + event.dataTransfer.dropEffect = effect; + } + event.currentTarget.classList.remove('v-drag-over-target'); + // prevent browser handling && don't let parents know + event.preventDefault(); + event.stopPropagation(); + }, + + updateDropTarget: function (element) { + if (element['__active']) { + element.addEventListener('dragenter', this.__ondragenterListener, false); + element.addEventListener('dragover', this.__ondragoverListener, false); + element.addEventListener('dragleave', this.__ondragleaveListener, false); + element.addEventListener('drop', this.__ondropListener, false); + } else { + element.removeEventListener('dragenter', this.__ondragenterListener, false); + element.removeEventListener('dragover', this.__ondragoverListener, false); + element.removeEventListener('dragleave', this.__ondragleaveListener, false); + element.removeEventListener('drop', this.__ondropListener, false); + element.classList.remove('v-drag-over-target'); + } + }, + + /** DRAG SOURCE METHODS: */ + + __dragstartListener: function (event) { + event.stopPropagation(); + event.dataTransfer.setData('text/plain', ''); + if (event.currentTarget.hasAttribute('disabled')) { + event.preventDefault(); + } else { + if (event.currentTarget['__effectAllowed']) { + event.dataTransfer.effectAllowed = event.currentTarget['__effectAllowed']; + } + event.currentTarget.classList.add('v-dragged'); + } + if (event.currentTarget.__dragImage) { + if (event.currentTarget.__dragImage.style.display === 'none') { + event.currentTarget.__dragImage.style.display = 'block'; + event.currentTarget.classList.add('shown'); + } + event.dataTransfer.setDragImage( + event.currentTarget.__dragImage, + event.currentTarget.__dragImageOffsetX, + event.currentTarget.__dragImageOffsetY + ); + } + }, + + __dragendListener: function (event) { + event.currentTarget.classList.remove('v-dragged'); + if (event.currentTarget.classList.contains('shown')) { + event.currentTarget.classList.remove('shown'); + event.currentTarget.__dragImage.style.display = 'none'; + } + }, + + updateDragSource: function (element) { + if (element['draggable']) { + element.addEventListener('dragstart', this.__dragstartListener, false); + element.addEventListener('dragend', this.__dragendListener, false); + } else { + element.removeEventListener('dragstart', this.__dragstartListener, false); + element.removeEventListener('dragend', this.__dragendListener, false); + } + }, + + setDragImage: function (dragImage, offsetX, offsetY, dragSource) { + dragSource.__dragImage = dragImage; + dragSource.__dragImageOffsetX = offsetX; + dragSource.__dragImageOffsetY = offsetY; + } +}; diff --git a/backend/src/main/frontend/generated/jar-resources/flow-component-directive.js b/backend/src/main/frontend/generated/jar-resources/flow-component-directive.js new file mode 100644 index 0000000..9727016 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/flow-component-directive.js @@ -0,0 +1,68 @@ +import { noChange } from 'lit'; +import { directive, PartType } from 'lit/directive.js'; +import { AsyncDirective } from 'lit/async-directive.js'; + +class FlowComponentDirective extends AsyncDirective { + constructor(partInfo) { + super(partInfo); + if (partInfo.type !== PartType.CHILD) { + throw new Error(`${this.constructor.directiveName}() can only be used in child bindings`); + } + } + + update(part, [appid, nodeid]) { + this.updateContent(part, appid, nodeid); + return noChange; + } + + updateContent(part, appid, nodeid) { + const { parentNode, startNode } = part; + this.__parentNode = parentNode; + + const hasNewNodeId = nodeid !== undefined && nodeid !== null; + const newNode = hasNewNodeId ? this.getNewNode(appid, nodeid) : null; + const oldNode = this.getOldNode(part); + + clearTimeout(this.__parentNode.__nodeRetryTimeout); + + if (hasNewNodeId && !newNode) { + // If the node is not found, try again later. + this.__parentNode.__nodeRetryTimeout = setTimeout(() => this.updateContent(part, appid, nodeid)); + } else if (oldNode === newNode) { + return; + } else if (oldNode && newNode) { + parentNode.replaceChild(newNode, oldNode); + } else if (oldNode) { + parentNode.removeChild(oldNode); + } else if (newNode) { + startNode.after(newNode); + } + } + + getNewNode(appid, nodeid) { + return window.Vaadin.Flow.clients[appid].getByNodeId(nodeid); + } + + getOldNode(part) { + const { startNode, endNode } = part; + if (startNode.nextSibling === endNode) { + return; + } + return startNode.nextSibling; + } + + disconnected() { + clearTimeout(this.__parentNode.__nodeRetryTimeout); + } +} + +/** + * Renders the given flow component node. + * + * WARNING: This directive is not intended for public use. + * + * @param {string} appid + * @param {number} nodeid + * @private + */ +export const flowComponentDirective = directive(FlowComponentDirective); diff --git a/backend/src/main/frontend/generated/jar-resources/flow-component-renderer.js b/backend/src/main/frontend/generated/jar-resources/flow-component-renderer.js new file mode 100644 index 0000000..5a3ea46 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/flow-component-renderer.js @@ -0,0 +1,47 @@ +import { flowComponentDirective } from './flow-component-directive.js'; +import { render, html as litHtml } from 'lit'; + +/** + * Returns the requested node in a form suitable for Lit template interpolation. + * @param {string} appid + * @param {number} nodeid + * @returns {any} a Lit directive + */ +function getNode(appid, nodeid) { + return flowComponentDirective(appid, nodeid); +} + +/** + * Sets the nodes defined by the given node ids as the child nodes of the + * given root element. + * @param {string} appid + * @param {number[]} nodeIds + * @param {Element} root + */ +function setChildNodes(appid, nodeIds, root) { + render(litHtml`${nodeIds.map((id) => flowComponentDirective(appid, id))}`, root); +} + +/** + * SimpleElementBindingStrategy::addChildren uses insertBefore to add child + * elements to the container. When the children are manually placed under + * another element, the call to insertBefore can occasionally fail due to + * an invalid reference node. + * + * This is a temporary workaround which patches the container's native API + * to not fail when called with invalid arguments. + */ +function patchVirtualContainer(container) { + const originalInsertBefore = container.insertBefore; + + container.insertBefore = function (newNode, referenceNode) { + if (referenceNode && referenceNode.parentNode === this) { + return originalInsertBefore.call(this, newNode, referenceNode); + } else { + return originalInsertBefore.call(this, newNode, null); + } + }; +} + +window.Vaadin ||= {}; +window.Vaadin.FlowComponentHost ||= { patchVirtualContainer, getNode, setChildNodes }; diff --git a/backend/src/main/frontend/generated/jar-resources/gridConnector.ts b/backend/src/main/frontend/generated/jar-resources/gridConnector.ts new file mode 100644 index 0000000..32947f4 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/gridConnector.ts @@ -0,0 +1,776 @@ +// @ts-nocheck +import { Debouncer } from '@vaadin/component-base/src/debounce.js'; +import { timeOut, animationFrame } from '@vaadin/component-base/src/async.js'; +import { Grid } from '@vaadin/grid/src/vaadin-grid.js'; +import { isFocusable } from '@vaadin/grid/src/vaadin-grid-active-item-mixin.js'; +import { GridFlowSelectionColumn } from './vaadin-grid-flow-selection-column.js'; + +window.Vaadin.Flow.gridConnector = {}; +window.Vaadin.Flow.gridConnector.initLazy = (grid) => { + // Check whether the connector was already initialized for the grid + if (grid.$connector) { + return; + } + + const dataProviderController = grid._dataProviderController; + + let cache = {}; + + const rootRequestDelay = 150; + let rootRequestDebouncer; + + let lastRequestedRange = [0, 0]; + + const validSelectionModes = ['SINGLE', 'NONE', 'MULTI']; + let selectedKeys = {}; + let selectionMode = 'SINGLE'; + + let sorterDirectionsSetFromServer = false; + + grid.size = 0; // To avoid NaN here and there before we get proper data + grid.itemIdPath = 'key'; + + grid.$connector = {}; + + grid.$connector.hasRootRequestQueue = () => { + const { pendingRequests } = dataProviderController.rootCache; + return Object.keys(pendingRequests).length > 0 || !!rootRequestDebouncer?.isActive(); + }; + + grid.$connector.doSelection = function (items, userOriginated) { + if (selectionMode === 'NONE' || !items.length || (userOriginated && grid.hasAttribute('disabled'))) { + return; + } + if (selectionMode === 'SINGLE') { + selectedKeys = {}; + } + + let selectedItemsChanged = false; + items.forEach((item) => { + const selectable = !userOriginated || grid.isItemSelectable(item); + selectedItemsChanged = selectedItemsChanged || selectable; + if (item && selectable) { + selectedKeys[item.key] = item; + item.selected = true; + if (userOriginated) { + grid.$server.select(item.key); + } + } + + // FYI: In single selection mode, the server can send items = [null] + // which means a "Deselect All" command. + const isSelectedItemDifferentOrNull = !grid.activeItem || !item || item.key != grid.activeItem.key; + if (!userOriginated && selectionMode === 'SINGLE' && isSelectedItemDifferentOrNull) { + grid.activeItem = item; + } + }); + + if (selectedItemsChanged) { + grid.selectedItems = Object.values(selectedKeys); + } + }; + + grid.$connector.doDeselection = function (items, userOriginated) { + if (selectionMode === 'NONE' || !items.length || (userOriginated && grid.hasAttribute('disabled'))) { + return; + } + + const updatedSelectedItems = grid.selectedItems.slice(); + while (items.length) { + const itemToDeselect = items.shift(); + const selectable = !userOriginated || grid.isItemSelectable(itemToDeselect); + if (!selectable) { + continue; + } + for (let i = 0; i < updatedSelectedItems.length; i++) { + const selectedItem = updatedSelectedItems[i]; + if (itemToDeselect?.key === selectedItem.key) { + updatedSelectedItems.splice(i, 1); + break; + } + } + if (itemToDeselect) { + delete selectedKeys[itemToDeselect.key]; + delete itemToDeselect.selected; + if (userOriginated) { + grid.$server.deselect(itemToDeselect.key); + } + } + } + grid.selectedItems = updatedSelectedItems; + }; + + grid.__activeItemChanged = function (newVal, oldVal) { + if (selectionMode != 'SINGLE') { + return; + } + if (!newVal) { + if (oldVal && selectedKeys[oldVal.key]) { + if (grid.__deselectDisallowed) { + grid.activeItem = oldVal; + } else { + // The item instance may have changed since the item was stored as active item + // and information such as whether the item may be selected or deselected may + // be stale. Use data provider controller to get updated instance from grid + // cache. + oldVal = dataProviderController.getItemContext(oldVal).item; + grid.$connector.doDeselection([oldVal], true); + } + } + } else if (!selectedKeys[newVal.key]) { + grid.$connector.doSelection([newVal], true); + } + }; + grid._createPropertyObserver('activeItem', '__activeItemChanged', true); + + grid.__activeItemChangedDetails = function (newVal, oldVal) { + if (grid.__disallowDetailsOnClick) { + return; + } + // when grid is attached, newVal is not set and oldVal is undefined + // do nothing + if (newVal == null && oldVal === undefined) { + return; + } + if (newVal && !newVal.detailsOpened) { + grid.$server.setDetailsVisible(newVal.key); + } else { + grid.$server.setDetailsVisible(null); + } + }; + grid._createPropertyObserver('activeItem', '__activeItemChangedDetails', true); + + grid.$connector.debounceRootRequest = function (page) { + const delay = grid._hasData ? rootRequestDelay : 0; + + rootRequestDebouncer = Debouncer.debounce(rootRequestDebouncer, timeOut.after(delay), () => { + grid.$connector.fetchPage((firstIndex, size) => grid.$server.setViewportRange(firstIndex, size), page); + }); + }; + + grid.$connector.fetchPage = function (fetch, page) { + // Adjust the requested page to be within the valid range in case + // the grid size has changed while fetchPage was debounced. + page = Math.min(page, Math.floor((grid.size - 1) / grid.pageSize)); + + // Determine what to fetch based on scroll position and not only + // what grid asked for + const visibleRows = grid._getRenderedRows(); + let start = visibleRows.length > 0 ? visibleRows[0].index : 0; + let end = visibleRows.length > 0 ? visibleRows[visibleRows.length - 1].index : 0; + + // The buffer size could be multiplied by some constant defined by the user, + // if he needs to reduce the number of items sent to the Grid to improve performance + // or to increase it to make Grid smoother when scrolling + let buffer = end - start; + start = Math.max(0, start - buffer); + end = Math.min(end + buffer, grid.size); + + let pageRange = [Math.floor(start / grid.pageSize), Math.floor(end / grid.pageSize)]; + + // When the viewport doesn't contain the requested page or it doesn't contain any items from + // the requested level at all, it means that the scroll position has changed while fetchPage + // was debounced. For example, it can happen if the user scrolls the grid to the bottom and + // then immediately back to the top. In this case, the request for the last page will be left + // hanging. To avoid this, as a workaround, we reset the range to only include the requested page + // to make sure all hanging requests are resolved. After that, the grid requests the first page + // or whatever in the viewport again. + if (page < pageRange[0] || page > pageRange[1]) { + pageRange = [page, page]; + } + + if (lastRequestedRange[0] != pageRange[0] || lastRequestedRange[1] != pageRange[1]) { + lastRequestedRange = pageRange; + let pageCount = pageRange[1] - pageRange[0] + 1; + fetch(pageRange[0] * grid.pageSize, pageCount * grid.pageSize); + } + }; + + grid.dataProvider = function (params, callback) { + if (params.pageSize != grid.pageSize) { + throw 'Invalid pageSize'; + } + + let page = params.page; + + // size is controlled by the server (data communicator), so if the + // size is zero, we know that there is no data to fetch. + // This also prevents an empty grid getting stuck in a loading state. + // The connector does not cache empty pages, so if the grid requests + // data again, there would be no cache entry, causing a request to + // the server. However, the data communicator will never respond, + // as it assumes that the data is already cached. + if (grid.size === 0) { + callback([], 0); + return; + } + + if (cache[page]) { + callback(cache[page]); + } else { + grid.$connector.debounceRootRequest(page); + } + }; + + grid.$connector.setSorterDirections = function (directions) { + sorterDirectionsSetFromServer = true; + setTimeout(() => { + try { + const sorters = Array.from(grid.querySelectorAll('vaadin-grid-sorter')); + + // Sorters for hidden columns are removed from DOM but stored in the web component. + // We need to ensure that all the sorters are reset when using `grid.sort(null)`. + grid._sorters.forEach((sorter) => { + if (!sorters.includes(sorter)) { + sorters.push(sorter); + } + }); + + sorters.forEach((sorter) => { + sorter.direction = null; + }); + + // Apply directions in correct order, depending on configured multi-sort priority. + // For the default "prepend" mode, directions need to be applied in reverse, in + // order for the sort indicators to match the order on the server. For "append" + // just keep the order passed from the server. + if (grid.multiSortPriority !== 'append') { + directions = directions.reverse(); + } + directions.forEach(({ column, direction }) => { + sorters.forEach((sorter) => { + if (sorter.getAttribute('path') === column) { + sorter.direction = direction; + } + }); + }); + + // Manually trigger a re-render of the sorter priority indicators + // in case some of the sorters were hidden while being updated above + // and therefore didn't notify the grid about their direction change. + grid.__applySorters(); + } finally { + sorterDirectionsSetFromServer = false; + } + }); + }; + + let preventUpdateVisibleRowsActive = 0; + + function preventUpdateVisibleRows(callback) { + try { + preventUpdateVisibleRowsActive++; + callback(); + } finally { + preventUpdateVisibleRowsActive--; + } + } + + grid.__updateVisibleRows = function (...args) { + if (preventUpdateVisibleRowsActive === 0) { + Object.getPrototypeOf(this).__updateVisibleRows.call(this, ...args); + } + }; + + grid.__updateRow = function (row, ...args) { + Object.getPrototypeOf(this).__updateRow.call(this, row, ...args); + + // since no row can be selected when selection mode is NONE + // if selectionMode is set to NONE, remove aria-selected attribute from the row + if (selectionMode === validSelectionModes[1]) { + // selectionMode === NONE + row.removeAttribute('aria-selected'); + Array.from(row.children).forEach((cell) => cell.removeAttribute('aria-selected')); + } + }; + + const itemsUpdated = function (items) { + if (!items || !Array.isArray(items)) { + throw 'Attempted to call itemsUpdated with an invalid value: ' + JSON.stringify(items); + } + let detailsOpenedItems = Array.from(grid.detailsOpenedItems); + for (let i = 0; i < items.length; ++i) { + const item = items[i]; + if (!item) { + continue; + } + if (item.detailsOpened) { + if (grid._getItemIndexInArray(item, detailsOpenedItems) < 0) { + detailsOpenedItems.push(item); + } + } else if (grid._getItemIndexInArray(item, detailsOpenedItems) >= 0) { + detailsOpenedItems.splice(grid._getItemIndexInArray(item, detailsOpenedItems), 1); + } + } + grid.detailsOpenedItems = detailsOpenedItems; + }; + + /** + * Updates the cache for the given page for grid or tree-grid. + * + * @param page index of the page to update + */ + const updateGridCache = function (page) { + const { rootCache } = dataProviderController; + + // Force update unless there's a callback waiting. + if (cache[page] && rootCache.pendingRequests[page]) { + return; + } + + for (let i = 0; i < grid.pageSize; i++) { + const index = page * grid.pageSize + i; + const item = cache[page]?.[i]; + rootCache.items[index] = item; + } + }; + + grid.$connector.set = function (startIndex, items) { + items.forEach((item, i) => { + const index = startIndex + i; + const page = Math.floor(index / grid.pageSize); + cache[page] ??= []; + cache[page][index % grid.pageSize] = item; + }); + + const firstPage = Math.floor(startIndex / grid.pageSize); + const updatedPageCount = Math.ceil(items.length / grid.pageSize); + for (let i = 0; i < updatedPageCount; i++) { + updateGridCache(firstPage + i); + } + + preventUpdateVisibleRows(() => { + grid.$connector.doSelection(items.filter((item) => item.selected)); + grid.$connector.doDeselection(items.filter((item) => !item.selected && selectedKeys[item.key])); + itemsUpdated(items); + }); + + grid.__updateVisibleRows(startIndex, startIndex + items.length - 1); + }; + + const itemToCacheLocation = function (item) { + for (let page in cache) { + for (let index in cache[page]) { + if (grid.getItemId(cache[page][index]) === grid.getItemId(item)) { + return { page: page, index: index }; + } + } + } + return null; + }; + + /** + * Updates the given items for a non-hierarchical grid. + * + * @param updatedItems the updated items array + */ + grid.$connector.updateFlatData = function (updatedItems) { + const updatedIndexes = []; + + // update (flat) caches + for (let i = 0; i < updatedItems.length; i++) { + let cacheLocation = itemToCacheLocation(updatedItems[i]); + if (cacheLocation) { + // update connector cache + cache[cacheLocation.page][cacheLocation.index] = updatedItems[i]; + + // update grid's cache + const index = parseInt(cacheLocation.page) * grid.pageSize + parseInt(cacheLocation.index); + const { rootCache } = dataProviderController; + if (rootCache.items[index]) { + rootCache.items[index] = updatedItems[i]; + } + updatedIndexes.push(index); + } + } + + preventUpdateVisibleRows(() => { + itemsUpdated(updatedItems); + }); + + updatedIndexes.forEach((index) => grid.__updateVisibleRows(index, index)); + }; + + grid.$connector.clear = function (index, length) { + if (!cache || Object.keys(cache).length === 0) { + return; + } + if (index % grid.pageSize != 0) { + throw 'Got cleared data for index ' + index + ' which is not aligned with the page size of ' + grid.pageSize; + } + + let firstPage = Math.floor(index / grid.pageSize); + let updatedPageCount = Math.ceil(length / grid.pageSize); + + for (let i = 0; i < updatedPageCount; i++) { + let page = firstPage + i; + let items = cache[page]; + if (items) { + preventUpdateVisibleRows(() => { + grid.$connector.doDeselection(items.filter((item) => selectedKeys[item.key])); + items.forEach((item) => grid.closeItemDetails(item)); + }); + delete cache[page]; + updateGridCache(page); + } + } + + grid.__updateVisibleRows(index, index + length - 1); + }; + + grid.$connector.reset = function () { + cache = {}; + dataProviderController.clearCache(); + lastRequestedRange = [-1, -1]; + rootRequestDebouncer?.cancel(); + grid.__updateVisibleRows(); + }; + + grid.$connector.updateSize = (newSize) => (grid.size = newSize); + + grid.$connector.updateUniqueItemIdPath = (path) => (grid.itemIdPath = path); + + grid.$connector.confirm = function (id) { + // We're done applying changes from this batch, resolve pending + // callbacks + const { pendingRequests } = dataProviderController.rootCache; + Object.entries(pendingRequests).forEach(([page, callback]) => { + const lastAvailablePage = grid.size ? Math.ceil(grid.size / grid.pageSize) - 1 : 0; + // It's possible that the lastRequestedRange includes a page that's beyond lastAvailablePage if the grid's size got reduced during an ongoing data request + const lastRequestedRangeEnd = Math.min(lastRequestedRange[1], lastAvailablePage); + // Resolve if we have data or if we don't expect to get data + if (cache[page]) { + // Cached data is available, resolve the callback + callback(cache[page]); + } else if (page < lastRequestedRange[0] || +page > lastRequestedRangeEnd) { + // No cached data, resolve the callback with an empty array + callback(new Array(grid.pageSize)); + // Request grid for content update + grid.requestContentUpdate(); + } else if (callback && grid.size === 0) { + // The grid has 0 items => resolve the callback with an empty array + callback([]); + } + }); + + // If all pending requests have already been resolved (which can happen + // for example if the server sent preloaded data while the grid had + // already made its own requests), cancel the request debouncer to + // prevent further unnecessary calls. + if (Object.keys(pendingRequests).length === 0) { + rootRequestDebouncer?.cancel(); + lastRequestedRange = [-1, -1]; + } + + // Let server know we're done + grid.$server.confirmUpdate(id); + }; + + grid.$connector.setSelectionMode = function (mode) { + if ((typeof mode === 'string' || mode instanceof String) && validSelectionModes.indexOf(mode) >= 0) { + selectionMode = mode; + selectedKeys = {}; + grid.selectedItems = []; + grid.$connector.updateMultiSelectable(); + } else { + throw 'Attempted to set an invalid selection mode'; + } + }; + + /* + * Manage aria-multiselectable attribute depending on the selection mode. + * see more: https://github.com/vaadin/web-components/issues/1536 + * or: https://www.w3.org/TR/wai-aria-1.1/#aria-multiselectable + * For selection mode SINGLE, set the aria-multiselectable attribute to false + */ + grid.$connector.updateMultiSelectable = function () { + if (!grid.$) { + return; + } + + if (selectionMode === validSelectionModes[0]) { + grid.$.table.setAttribute('aria-multiselectable', false); + // For selection mode NONE, remove the aria-multiselectable attribute + } else if (selectionMode === validSelectionModes[1]) { + grid.$.table.removeAttribute('aria-multiselectable'); + // For selection mode MULTI, set aria-multiselectable to true + } else { + grid.$.table.setAttribute('aria-multiselectable', true); + } + }; + + // Have the multi-selectable state updated on attach + grid._createPropertyObserver('isAttached', () => grid.$connector.updateMultiSelectable()); + + const singleTimeRenderer = (renderer) => { + return (root) => { + if (renderer) { + renderer(root); + renderer = null; + } + }; + }; + + grid.$connector.setHeaderRenderer = function (column, options) { + const { content, showSorter, sorterPath } = options; + + if (content === null) { + column.headerRenderer = null; + return; + } + + column.headerRenderer = singleTimeRenderer((root) => { + // Clear previous contents + root.innerHTML = ''; + // Render sorter + let contentRoot = root; + if (showSorter) { + const sorter = document.createElement('vaadin-grid-sorter'); + sorter.setAttribute('path', sorterPath); + const ariaLabel = content instanceof Node ? content.textContent : content; + if (ariaLabel) { + sorter.setAttribute('aria-label', `Sort by ${ariaLabel}`); + } + root.appendChild(sorter); + + // Use sorter as content root + contentRoot = sorter; + } + // Add content + if (content instanceof Node) { + contentRoot.appendChild(content); + } else { + contentRoot.textContent = content; + } + }); + }; + + // This method is overridden to prevent the grid web component from + // automatically excluding columns from sorting when they get hidden. + // In Flow, it's the developer's responsibility to remove the column + // from the backend sort order when the column gets hidden. + grid._getActiveSorters = function () { + return this._sorters.filter((sorter) => sorter.direction); + }; + + grid.__applySorters = function (...args) { + const sorters = grid._mapSorters(); + const sortersChanged = JSON.stringify(grid._previousSorters) !== JSON.stringify(sorters); + + // Update the _previousSorters in vaadin-grid-sort-mixin so that the __applySorters + // method in the mixin will skip calling clearCache(). + // + // In Flow Grid's case, we never want to clear the cache eagerly when the sorter elements + // change due to one of the following reasons: + // + // 1. Sorted by user: The items in the new sort order need to be fetched from the server, + // and we want to avoid a heavy re-render before the updated items have actually been fetched. + // + // 2. Sorted programmatically on the server: The items in the new sort order have already + // been fetched and applied to the grid. The sorter element states are updated programmatically + // to reflect the new sort order, but there's no need to re-render the grid rows. + grid._previousSorters = sorters; + + // Call the original __applySorters method in vaadin-grid-sort-mixin + Object.getPrototypeOf(this).__applySorters.call(this, ...args); + + if (sortersChanged && !sorterDirectionsSetFromServer) { + grid.$server.sortersChanged(sorters); + } + }; + + grid.$connector.setFooterRenderer = function (column, options) { + const { content } = options; + + if (content === null) { + column.footerRenderer = null; + return; + } + + column.footerRenderer = singleTimeRenderer((root) => { + // Clear previous contents + root.innerHTML = ''; + // Add content + if (content instanceof Node) { + root.appendChild(content); + } else { + root.textContent = content; + } + }); + }; + + grid.addEventListener('vaadin-context-menu-before-open', function (e) { + const { key, columnId } = e.detail; + grid.$server.updateContextMenuTargetItem(key, columnId); + }); + + grid.getContextMenuBeforeOpenDetail = function (event) { + // For `contextmenu` events, we need to access the source event, + // when using open on click we just use the click event itself + const sourceEvent = event.detail.sourceEvent || event; + const eventContext = grid.getEventContext(sourceEvent); + const key = eventContext.item?.key || ''; + const columnId = eventContext.column?.id || ''; + return { key, columnId }; + }; + + grid.preventContextMenu = function (event) { + const isLeftClick = event.type === 'click'; + const { column } = grid.getEventContext(event); + + return isLeftClick && column instanceof GridFlowSelectionColumn; + }; + + grid.addEventListener('click', (e) => _fireClickEvent(e, 'item-click')); + grid.addEventListener('dblclick', (e) => _fireClickEvent(e, 'item-double-click')); + + grid.addEventListener('column-resize', (e) => { + const cols = grid._getColumnsInOrder().filter((col) => !col.hidden); + + cols.forEach((col) => { + col.dispatchEvent(new CustomEvent('column-drag-resize')); + }); + + grid.dispatchEvent( + new CustomEvent('column-drag-resize', { + detail: { + resizedColumnKey: e.detail.resizedColumn._flowId + } + }) + ); + }); + + grid.addEventListener('column-reorder', (e) => { + const columns = grid._columnTree + .slice(0) + .pop() + .filter((c) => c._flowId) + .sort((b, a) => b._order - a._order) + .map((c) => c._flowId); + + grid.dispatchEvent( + new CustomEvent('column-reorder-all-columns', { + detail: { columns } + }) + ); + }); + + grid.addEventListener('cell-focus', (e) => { + const eventContext = grid.getEventContext(e); + const expectedSectionValues = ['header', 'body', 'footer']; + + if (expectedSectionValues.indexOf(eventContext.section) === -1) { + return; + } + + grid.dispatchEvent( + new CustomEvent('grid-cell-focus', { + detail: { + itemKey: eventContext.item ? eventContext.item.key : null, + + internalColumnId: eventContext.column ? eventContext.column._flowId : null, + + section: eventContext.section + } + }) + ); + }); + + function _fireClickEvent(event, eventName) { + // Click event was handled by the component inside grid, do nothing. + if (event.defaultPrevented) { + return; + } + + const path = event.composedPath(); + const idx = path.findIndex((node) => node.localName === 'td' || node.localName === 'th'); + const cell = path[idx]; + const content = path.slice(0, idx); + + // Do not fire item click event if cell content contains focusable elements. + // Use this instead of event.target to detect cases like icon inside button. + // See https://github.com/vaadin/flow-components/issues/4065 + if ( + content.some((node) => { + // Ignore focus buttons that the component renders into cells in focus button mode on MacOS + const focusable = cell?._focusButton !== node && isFocusable(node); + return focusable || node instanceof HTMLLabelElement; + }) + ) { + return; + } + + const eventContext = grid.getEventContext(event); + const section = eventContext.section; + + if (eventContext.item && section !== 'details') { + event.itemKey = eventContext.item.key; + // if you have a details-renderer, getEventContext().column is undefined + if (eventContext.column) { + event.internalColumnId = eventContext.column._flowId; + } + grid.dispatchEvent(new CustomEvent(eventName, { detail: event })); + } + } + + grid.cellPartNameGenerator = function (column, rowData) { + const part = rowData.item.part; + if (!part) { + return; + } + return (part.row || '') + ' ' + ((column && part[column._flowId]) || ''); + }; + + grid.dropFilter = (rowData) => rowData.item && !rowData.item.dropDisabled; + + grid.dragFilter = (rowData) => rowData.item && !rowData.item.dragDisabled; + + grid.addEventListener('grid-dragstart', (e) => { + if (grid._isSelected(e.detail.draggedItems[0])) { + // Dragging selected (possibly multiple) items + if (grid.__selectionDragData) { + Object.keys(grid.__selectionDragData).forEach((type) => { + e.detail.setDragData(type, grid.__selectionDragData[type]); + }); + } else { + (grid.__dragDataTypes || []).forEach((type) => { + e.detail.setDragData(type, e.detail.draggedItems.map((item) => item.dragData[type]).join('\n')); + }); + } + + if (grid.__selectionDraggedItemsCount > 1) { + e.detail.setDraggedItemsCount(grid.__selectionDraggedItemsCount); + } + } else { + // Dragging just one (non-selected) item + (grid.__dragDataTypes || []).forEach((type) => { + e.detail.setDragData(type, e.detail.draggedItems[0].dragData[type]); + }); + } + }); + + grid.isItemSelectable = (item) => { + // If there is no selectable data, assume the item is selectable + return item?.selectable === undefined || item.selectable; + }; + + function isRowFullyInViewport(row) { + const rowRect = row.getBoundingClientRect(); + const tableRect = grid.$.table.getBoundingClientRect(); + const headerRect = grid.$.header.getBoundingClientRect(); + const footerRect = grid.$.footer.getBoundingClientRect(); + return rowRect.top >= tableRect.top + headerRect.height && rowRect.bottom <= tableRect.bottom - footerRect.height; + } + + grid.$connector.scrollToItem = function (itemKey, ...args) { + const targetRow = grid._getRenderedRows().find((row) => { + const { item } = grid.__getRowModel(row); + return grid.getItemId(item) === itemKey; + }); + if (targetRow && isRowFullyInViewport(targetRow)) { + return; + } + + grid.scrollToIndex(...args); + }; +}; diff --git a/backend/src/main/frontend/generated/jar-resources/index.d.ts b/backend/src/main/frontend/generated/jar-resources/index.d.ts new file mode 100644 index 0000000..3bf9a52 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/index.d.ts @@ -0,0 +1,2 @@ +export * from './copilot' +export {} diff --git a/backend/src/main/frontend/generated/jar-resources/index.js b/backend/src/main/frontend/generated/jar-resources/index.js new file mode 100644 index 0000000..6c14827 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/index.js @@ -0,0 +1,2 @@ +export * from './Flow'; +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/backend/src/main/frontend/generated/jar-resources/index.js.map b/backend/src/main/frontend/generated/jar-resources/index.js.map new file mode 100644 index 0000000..c662ab4 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/main/frontend/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC","sourcesContent":["export * from './Flow';\n"]} \ No newline at end of file diff --git a/backend/src/main/frontend/generated/jar-resources/lit-renderer.ts b/backend/src/main/frontend/generated/jar-resources/lit-renderer.ts new file mode 100644 index 0000000..029ff0a --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/lit-renderer.ts @@ -0,0 +1,112 @@ +/* eslint-disable no-restricted-syntax */ +/* eslint-disable max-params */ +import { html, render } from 'lit'; +import { live } from 'lit/directives/live.js'; + +type RenderRoot = HTMLElement & { __litRenderer?: Renderer; _$litPart$?: any }; + +type ItemModel = { item: any; index: number }; + +type Renderer = ((root: RenderRoot, rendererOwner: HTMLElement, model: ItemModel) => void) & { __rendererId?: string }; + +type Component = HTMLElement & { [key: string]: Renderer | undefined }; + +const _window = window as any; +_window.Vaadin = _window.Vaadin || {}; + +/** + * Assigns the component a renderer function which uses Lit to render + * the given template expression inside the render root element. + * + * @param component The host component to which the renderer runction is to be set + * @param rendererName The name of the renderer function + * @param templateExpression The content of the template literal passed to Lit for rendering. + * @param returnChannel A channel to the server. + * Calling it will end up invoking a handler in the server-side LitRenderer. + * @param clientCallables A list of function names that can be called from within the template literal. + * @param propertyNamespace LitRenderer-specific namespace for properties. + * Needed to avoid property name collisions between renderers. + */ +_window.Vaadin.setLitRenderer = ( + component: Component, + rendererName: string, + templateExpression: string, + returnChannel: (name: string, itemKey: string, args: any[]) => void, + clientCallables: string[], + propertyNamespace: string, + appId: string +) => { + const callablesCreator = (itemKey: string) => { + return clientCallables.map((clientCallable) => (...args: any[]) => { + if (itemKey !== undefined) { + returnChannel(clientCallable, itemKey, args[0] instanceof Event ? [] : [...args]); + } + }); + }; + const fnArgs = [ + 'html', + 'root', + 'live', + 'appId', + 'itemKey', + 'model', + 'item', + 'index', + ...clientCallables, + `return html\`${templateExpression}\`` + ]; + const htmlGenerator = new Function(...fnArgs); + const renderFunction = (root: RenderRoot, model: ItemModel, itemKey: string) => { + const { item, index } = model; + render(htmlGenerator(html, root, live, appId, itemKey, model, item, index, ...callablesCreator(itemKey)), root); + }; + + const renderer: Renderer = (root, _, model) => { + const { item } = model; + // Clean up the root element of any existing content + // (and Lit's _$litPart$ property) from other renderers + // TODO: Remove once https://github.com/vaadin/web-components/issues/2235 is done + if (root.__litRenderer !== renderer) { + root.innerHTML = ''; + delete root._$litPart$; + root.__litRenderer = renderer; + } + + // Map a new item that only includes the properties defined by + // this specific LitRenderer instance. The renderer instance specific + // "propertyNamespace" prefix is stripped from the property name at this point: + // + // item: { key: "2", lr_3769df5394a74ef3_lastName: "Tyler"} + // -> + // mappedItem: { lastName: "Tyler" } + const mappedItem: { [key: string]: any } = {}; + for (const key in item) { + if (key.startsWith(propertyNamespace)) { + mappedItem[key.replace(propertyNamespace, '')] = item[key]; + } + } + + renderFunction(root, { ...model, item: mappedItem }, item.key); + }; + + renderer.__rendererId = propertyNamespace; + component[rendererName] = renderer; +}; + +/** + * Removes the renderer function with the given name from the component + * if the propertyNamespace matches the renderer's id. + * + * @param component The host component whose renderer function is to be removed + * @param rendererName The name of the renderer function + * @param rendererId The rendererId of the function to be removed + */ +_window.Vaadin.unsetLitRenderer = (component: Component, rendererName: string, rendererId: string) => { + // The check for __rendererId property is necessary since the renderer function + // may get overridden by another renderer, for example, by one coming from + // vaadin-template-renderer. We don't want LitRenderer registration cleanup to + // unintentionally remove the new renderer. + if (component[rendererName]?.__rendererId === rendererId) { + component[rendererName] = undefined; + } +}; diff --git a/backend/src/main/frontend/generated/jar-resources/menubarConnector.js b/backend/src/main/frontend/generated/jar-resources/menubarConnector.js new file mode 100644 index 0000000..0aa323a --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/menubarConnector.js @@ -0,0 +1,110 @@ +/* + * Copyright 2000-2026 Vaadin Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +import './contextMenuConnector.js'; + +/** + * Initializes the connector for a menu bar element. + * + * @param {HTMLElement} menubar + * @param {string} appId + */ +function initLazy(menubar, appId) { + if (menubar.$connector) { + return; + } + + const observer = new MutationObserver((records) => { + const hasChangedAttributes = records.some((entry) => { + const oldValue = entry.oldValue; + const newValue = entry.target.getAttribute(entry.attributeName); + return oldValue !== newValue; + }); + + if (hasChangedAttributes) { + menubar.$connector.generateItems(); + } + }); + + menubar.$connector = { + /** + * Generates and assigns the items to the menu bar. + * + * When the method is called without providing a node id, + * the previously generated items tree will be used. + * That can be useful if you only want to sync the disabled and hidden properties of root items. + * + * @param {number | undefined} nodeId + */ + generateItems(nodeId) { + if (!menubar.shadowRoot) { + // workaround for https://github.com/vaadin/flow/issues/5722 + setTimeout(() => menubar.$connector.generateItems(nodeId)); + return; + } + + if (!menubar._container) { + // Menu-bar defers first buttons render to avoid re-layout + // See https://github.com/vaadin/web-components/issues/7271 + queueMicrotask(() => menubar.$connector.generateItems(nodeId)); + return; + } + + if (nodeId) { + menubar.__generatedItems = window.Vaadin.Flow.contextMenuConnector.generateItemsTree(appId, nodeId); + } + + let items = menubar.__generatedItems || []; + + items.forEach((item) => { + // Propagate disabled state from items to parent buttons + item.disabled = item.component.disabled; + + // Saving item to component because `_item` can be reassigned to a new value + // when the component goes to the overflow menu + item.component._rootItem = item; + }); + + // Observe for hidden and disabled attributes in case they are changed by Flow. + // When a change occurs, the observer will re-generate items on top of the existing tree + // to sync the new attribute values with the corresponding properties in the items array. + items.forEach((item) => { + observer.observe(item.component, { + attributeFilter: ['hidden', 'disabled'], + attributeOldValue: true + }); + }); + + // Remove hidden items entirely from the array. Just hiding them + // could cause the overflow button to be rendered without items. + // + // The items-prop needs to be set even when all items are visible + // to update the disabled state and re-render buttons. + items = items.filter((item) => !item.component.hidden); + + menubar.items = items; + } + }; +} + +function setClassName(component) { + const item = component._rootItem || component._item; + + if (item) { + item.className = component.className; + } +} + +window.Vaadin.Flow.menubarConnector = { initLazy, setClassName }; diff --git a/backend/src/main/frontend/generated/jar-resources/messageListConnector.js b/backend/src/main/frontend/generated/jar-resources/messageListConnector.js new file mode 100644 index 0000000..5138392 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/messageListConnector.js @@ -0,0 +1,95 @@ +/* + * Copyright 2000-2026 Vaadin Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +/** + * Creates a DateTimeFormat with the given locale, or throws if invalid. + */ +function createDateTimeFormatter(locale) { + return new Intl.DateTimeFormat(locale, { + year: 'numeric', + month: 'short', + day: 'numeric', + hour: 'numeric', + minute: 'numeric' + }); +} + +function getFormatter(locale) { + // Try creating formatter with progressive fallbacks + const localeParts = locale?.split('-'); + const fallbackLocales = [ + locale, // Full locale (e.g., "de-DE-hw") + localeParts?.slice(0, 2).join('-'), // Base locale without variant (e.g., "de-DE") + localeParts?.[0] // Language only (e.g., "de") + ]; + + for (const fallbackLocale of fallbackLocales) { + try { + return createDateTimeFormatter(fallbackLocale); + } catch (e) { + // Continue to next fallback + } + } + + return createDateTimeFormatter(undefined); // Default locale +} + +/** + * Maps the given items to a new array of items with formatted time. + */ +function formatItems(items, locale) { + const formatter = getFormatter(locale); + + return items.map((item) => + item.time + ? Object.assign(item, { + time: formatter.format(new Date(item.time)) + }) + : item + ); +} + +window.Vaadin.Flow.messageListConnector = { + /** + * Fully replaces the items in the list with the given items. + */ + setItems(list, items, locale) { + list.items = formatItems(items, locale); + }, + + /** + * Sets the text of the item at the given index to the given text. + */ + setItemText(list, text, index) { + list.items[index].text = text; + list.items = [...list.items]; + }, + + /** + * Appends the given text to the text of the item at the given index. + */ + appendItemText(list, appendedText, index) { + const currentText = list.items[index].text || ''; + this.setItemText(list, currentText + appendedText, index); + }, + + /** + * Adds the given items to the end of the list. + */ + addItems(list, newItems, locale) { + list.items = [...(list.items || []), ...formatItems(newItems, locale)]; + } +}; diff --git a/backend/src/main/frontend/generated/jar-resources/selectConnector.js b/backend/src/main/frontend/generated/jar-resources/selectConnector.js new file mode 100644 index 0000000..2b29403 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/selectConnector.js @@ -0,0 +1,19 @@ +window.Vaadin.Flow.selectConnector = {}; +window.Vaadin.Flow.selectConnector.initLazy = (select) => { + // do not init this connector twice for the given select + if (select.$connector) { + return; + } + + select.$connector = {}; + + select.renderer = (root) => { + const listBox = select.querySelector('vaadin-select-list-box'); + if (listBox) { + if (root.firstChild) { + root.removeChild(root.firstChild); + } + root.appendChild(listBox); + } + }; +}; diff --git a/backend/src/main/frontend/generated/jar-resources/theme-util.js b/backend/src/main/frontend/generated/jar-resources/theme-util.js new file mode 100644 index 0000000..174a767 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/theme-util.js @@ -0,0 +1,175 @@ +import stripCssComments from 'strip-css-comments'; + +// Safari 15 - 16.3, polyfilled +const polyfilledSafari = CSSStyleSheet.toString().includes('document.createElement'); + +const createLinkReferences = (css, target) => { + // Unresolved urls are written as '@import url(text);' or '@import "text";' to the css + // media query can be present on @media tag or on @import directive after url + // Note that with Vite production build there is no space between @import and "text" + // [0] is the full match + // [1] matches the media query + // [2] matches the url + // [3] matches the quote char surrounding in '@import "..."' + // [4] matches the url in '@import "..."' + // [5] matches media query on @import statement + const importMatcher = + /(?:@media\s(.+?))?(?:\s{)?\@import\s*(?:url\(\s*['"]?(.+?)['"]?\s*\)|(["'])((?:\\.|[^\\])*?)\3)([^;]*);(?:})?/g; + + // Only cleanup if comment exist + if (/\/\*(.|[\r\n])*?\*\//gm.exec(css) != null) { + // clean up comments + css = stripCssComments(css); + } + + var match; + var styleCss = css; + + // For each external url import add a link reference + while ((match = importMatcher.exec(css)) !== null) { + styleCss = styleCss.replace(match[0], ''); + const link = document.createElement('link'); + link.rel = 'stylesheet'; + link.href = match[2] || match[4]; + const media = match[1] || match[5]; + if (media) { + link.media = media; + } + // For target document append to head else append to target + if (target === document) { + document.head.appendChild(link); + } else { + target.appendChild(link); + } + } + return styleCss; +}; + +const addAdoptedStyleSafariPolyfill = (sheet, target, first) => { + if (first) { + target.adoptedStyleSheets = [sheet, ...target.adoptedStyleSheets]; + } else { + target.adoptedStyleSheets = [...target.adoptedStyleSheets, sheet]; + } + return () => { + target.adoptedStyleSheets = target.adoptedStyleSheets.filter((ss) => ss !== sheet); + }; +}; + +const addAdoptedStyle = (cssText, target, first) => { + const sheet = new CSSStyleSheet(); + sheet.replaceSync(cssText); + if (polyfilledSafari) { + return addAdoptedStyleSafariPolyfill(sheet, target, first); + } + if (first) { + target.adoptedStyleSheets.splice(0, 0, sheet); + } else { + target.adoptedStyleSheets.push(sheet); + } + return () => { + target.adoptedStyleSheets.splice(target.adoptedStyleSheets.indexOf(sheet), 1); + }; +}; + +const addStyleTag = (cssText, referenceComment) => { + const styleTag = document.createElement('style'); + styleTag.type = 'text/css'; + styleTag.textContent = cssText; + + let beforeThis = undefined; + if (referenceComment) { + const comments = Array.from(document.head.childNodes).filter((elem) => elem.nodeType === Node.COMMENT_NODE); + const container = comments.find((comment) => comment.data.trim() === referenceComment); + if (container) { + beforeThis = container; + } + } + document.head.insertBefore(styleTag, beforeThis); + return () => { + styleTag.remove(); + }; +}; + +// target: Document | ShadowRoot +export const injectGlobalCss = (css, referenceComment, target, first) => { + if (target === document) { + const hash = getHash(css); + if (window.Vaadin.theme.injectedGlobalCss.indexOf(hash) !== -1) { + return; + } + window.Vaadin.theme.injectedGlobalCss.push(hash); + } + const cssText = createLinkReferences(css, target); + + // We avoid mixing style tags and adoptedStyleSheets to make override order clear + if (target === document) { + return addStyleTag(cssText, referenceComment); + } + + return addAdoptedStyle(cssText, target, first); +}; + +window.Vaadin = window.Vaadin || {}; +window.Vaadin.theme = window.Vaadin.theme || {}; +window.Vaadin.theme.injectedGlobalCss = []; + +const webcomponentGlobalCss = { + css: [], + importers: [] +}; + +export const injectGlobalWebcomponentCss = (css) => { + webcomponentGlobalCss.css.push(css); + webcomponentGlobalCss.importers.forEach((registrar) => { + registrar(css); + }); +}; + +export const webcomponentGlobalCssInjector = (registrar) => { + const registeredCss = []; + const wrapper = (css) => { + const hash = getHash(css); + if (!registeredCss.includes(hash)) { + registeredCss.push(hash); + registrar(css); + } + }; + webcomponentGlobalCss.importers.push(wrapper); + webcomponentGlobalCss.css.forEach(wrapper); +}; + +/** + * Calculate a 32 bit FNV-1a hash + * Found here: https://gist.github.com/vaiorabbit/5657561 + * Ref.: http://isthe.com/chongo/tech/comp/fnv/ + * + * @param {string} str the input value + * @returns {string} 32 bit (as 8 byte hex string) + */ +function hashFnv32a(str) { + /*jshint bitwise:false */ + let i, + l, + hval = 0x811c9dc5; + + for (i = 0, l = str.length; i < l; i++) { + hval ^= str.charCodeAt(i); + hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24); + } + + // Convert to 8 digit hex string + return ('0000000' + (hval >>> 0).toString(16)).substr(-8); +} + +/** + * Calculate a 64 bit hash for the given input. + * Double hash is used to significantly lower the collision probability. + * + * @param {string} input value to get hash for + * @returns {string} 64 bit (as 16 byte hex string) + */ +function getHash(input) { + let h1 = hashFnv32a(input); // returns 32 bit (as 8 byte hex string) + return h1 + hashFnv32a(h1 + input); +} diff --git a/backend/src/main/frontend/generated/jar-resources/tooltip.ts b/backend/src/main/frontend/generated/jar-resources/tooltip.ts new file mode 100644 index 0000000..351527c --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/tooltip.ts @@ -0,0 +1,23 @@ +import { Tooltip } from '@vaadin/tooltip/src/vaadin-tooltip.js'; + +const _window = window as any; +_window.Vaadin ||= {}; +_window.Vaadin.Flow ||= {}; +_window.Vaadin.Flow.tooltip ||= {}; + +Object.assign(_window.Vaadin.Flow.tooltip, { + setDefaultHideDelay: (hideDelay: number) => Tooltip.setDefaultHideDelay(hideDelay), + setDefaultFocusDelay: (focusDelay: number) => Tooltip.setDefaultFocusDelay(focusDelay), + setDefaultHoverDelay: (hoverDelay: number) => Tooltip.setDefaultHoverDelay(hoverDelay) +}); + +const { defaultHideDelay, defaultFocusDelay, defaultHoverDelay } = _window.Vaadin.Flow.tooltip; +if (defaultHideDelay) { + Tooltip.setDefaultHideDelay(defaultHideDelay); +} +if (defaultFocusDelay) { + Tooltip.setDefaultFocusDelay(defaultFocusDelay); +} +if (defaultHoverDelay) { + Tooltip.setDefaultHoverDelay(defaultHoverDelay); +} diff --git a/backend/src/main/frontend/generated/jar-resources/treeGridConnector.ts b/backend/src/main/frontend/generated/jar-resources/treeGridConnector.ts new file mode 100644 index 0000000..ae1a59f --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/treeGridConnector.ts @@ -0,0 +1,88 @@ +// @ts-nocheck +import './gridConnector.ts'; + +/** + * treeGridConnector is a communication layer between TreeGrid's flow component + * (server-side) and web component (client-side). + * + * TreeGrid does not rely on the web component's built-in features for handling + * hierarchical data. Instead, the hierarchy is fully managed on the server side + * and sent to the client as a flattened structure. This approach simplifies the + * client-side implementation and improves performance by avoiding recursive + * requests to the data provider. + * + * While the data is transferred as a flat list, the connector makes it appear as + * a hierarchy by overriding the web component's methods to add indentation based + * on information from server-provided fields `item.level`, `item.expanded`, etc. + * + * The connector overrides the web component's default `scrollToIndex(...indexes)` + * implementation, as it by default assumes that the hierarchy is managed on the + * client side. Instead, it uses the server-side method to resolve the hierarchical + * path and preload the viewport range, all in a single round-trip. As a result, + * required data is already loaded on the client-side by the time the scrolling + * begins, which allows the scrollToIndex operation to be executed faster. + * + * The server estimates the viewport range for `scrollToIndex` based on the `padding` + * parameter of $server.setViewportRangeByIndexPath, which defines how many items to + * include above and below the target item in the range. + */ +window.Vaadin.Flow.treeGridConnector = {}; +window.Vaadin.Flow.treeGridConnector.initLazy = function (grid) { + if (grid.$connector) { + return; + } + + window.Vaadin.Flow.gridConnector.initLazy(grid); + + function getViewportRange() { + const renderedRows = grid._getRenderedRows(); + return [renderedRows[0]?.index ?? 0, renderedRows[renderedRows.length - 1]?.index ?? 0]; + } + + grid._dataProviderController._shouldLoadCachePage = function (cache, page) { + // `$server.setViewportRangeByIndexPath` sends a preloaded viewport range based on + // the provided index path and `padding` parameter. Applying the new range clears + // the old range, which is still visible because the actual scroll happens only + // after all connector calls in that update are processed. This check prevents + // the old range from being unnecessarily re-requested while the new range is + // still being processed, which could cause flickering. + return !grid.__pendingScrollToIndexes; + }; + + grid.scrollToIndex = async function (...indexes) { + grid.__pendingScrollToIndexes = indexes; + + if (!grid.clientHeight || !grid._columnTree || grid._dataProviderController.isLoading()) { + return; + } + + const [start, end] = getViewportRange(); + const padding = Math.floor((end - start) * 1.5); + const flatIndex = await grid.$server.setViewportRangeByIndexPath(indexes, padding); + grid._scrollToFlatIndex(flatIndex); + + delete grid.__pendingScrollToIndexes; + + return flatIndex; + }; + + grid.__getRowLevel = function (row) { + return row._item?.level ?? 0; + }; + + grid._isExpanded = function (item) { + return !!item?.expanded; + }; + + grid.expandItem = function (item) { + if (item !== undefined) { + grid.$server.updateExpandedState(grid.getItemId(item), true); + } + }; + + grid.collapseItem = function (item) { + if (item !== undefined) { + grid.$server.updateExpandedState(grid.getItemId(item), false); + } + }; +}; diff --git a/backend/src/main/frontend/generated/jar-resources/vaadin-big-decimal-field.js b/backend/src/main/frontend/generated/jar-resources/vaadin-big-decimal-field.js new file mode 100644 index 0000000..21e233c --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/vaadin-big-decimal-field.js @@ -0,0 +1,69 @@ +/* + * Copyright 2000-2026 Vaadin Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +import { css } from 'lit'; +import { TextField } from '@vaadin/text-field/src/vaadin-text-field.js'; +import { defineCustomElement } from '@vaadin/component-base/src/define.js'; + +class BigDecimalField extends TextField { + static get is() { + return 'vaadin-big-decimal-field'; + } + + static get lumoInjector() { + return { ...super.lumoInjector, is: 'vaadin-text-field' }; + } + + static get styles() { + return [ + ...super.styles, + css` + :host([dir='rtl']) [part='input-field'] { + direction: ltr; + } + + :host([dir='rtl']) [part='input-field'] ::slotted(input) { + --_lumo-text-field-overflow-mask-image: linear-gradient(to left, transparent, #000 1.25em) !important; + } + ` + ]; + } + + static get properties() { + return { + _decimalSeparator: { + type: String, + value: '.', + sync: true, + observer: '__decimalSeparatorChanged' + } + }; + } + + ready() { + super.ready(); + this.inputElement.setAttribute('inputmode', 'decimal'); + } + + __decimalSeparatorChanged(separator, oldSeparator) { + this.allowedCharPattern = '[-+\\d' + separator + ']'; + + if (this.value && oldSeparator) { + this.value = this.value.split(oldSeparator).join(separator); + } + } +} + +defineCustomElement(BigDecimalField); diff --git a/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/License.d.ts b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/License.d.ts new file mode 100644 index 0000000..0062408 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/License.d.ts @@ -0,0 +1,25 @@ +import { ServerMessage } from './vaadin-dev-tools'; +export interface Product { + name: string; + version: string; +} +export interface PreTrial { + trialName?: String; + trialState: String; + daysRemaining?: number; + daysRemainingUntilRenewal?: number; +} +export interface ProductAndMessage { + message: string; + messageHtml?: string; + product: Product; + preTrial?: PreTrial; +} +export declare const findAll: (element: Element | ShadowRoot | Document, tags: string[]) => Element[]; +export declare const licenseCheckOk: (data: Product) => void; +export declare const licenseCheckFailed: (data: ProductAndMessage) => void; +export declare const licenseCheckNoKey: (data: ProductAndMessage) => void; +export declare const handleLicenseMessage: (message: ServerMessage, bodyShadowRoot: ShadowRoot | null) => boolean; +export declare const startPreTrial: () => void; +export declare const tryAcquireLicense: () => void; +export declare const licenseInit: () => void; diff --git a/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/connection.d.ts b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/connection.d.ts new file mode 100644 index 0000000..805a724 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/connection.d.ts @@ -0,0 +1,15 @@ +export declare enum ConnectionStatus { + ACTIVE = "active", + INACTIVE = "inactive", + UNAVAILABLE = "unavailable", + ERROR = "error" +} +export declare abstract class Connection { + static HEARTBEAT_INTERVAL: number; + status: ConnectionStatus; + onHandshake(): void; + onConnectionError(_: string): void; + onStatusChange(_: ConnectionStatus): void; + setActive(yes: boolean): void; + setStatus(status: ConnectionStatus): void; +} diff --git a/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/live-reload-connection.d.ts b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/live-reload-connection.d.ts new file mode 100644 index 0000000..426e8a7 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/live-reload-connection.d.ts @@ -0,0 +1,8 @@ +import { Connection } from './connection.js'; +export declare class LiveReloadConnection extends Connection { + webSocket?: WebSocket; + constructor(url: string); + onReload(_strategy: string): void; + handleMessage(msg: any): void; + handleError(msg: any): void; +} diff --git a/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/pre-trial-splash-screen.d.ts b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/pre-trial-splash-screen.d.ts new file mode 100644 index 0000000..a599899 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/pre-trial-splash-screen.d.ts @@ -0,0 +1,4 @@ +import { ProductAndMessage } from './License'; +export declare const showPreTrialSplashScreen: (shadowRoot: ShadowRoot | null, message: ProductAndMessage) => void; +export declare const preTrialStartFailed: (expired: boolean, shadowRoot: ShadowRoot | null) => void; +export declare const updateLicenseDownloadStatus: (action: "started" | "failed" | "completed", shadowRoot: ShadowRoot | null) => void; diff --git a/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/vaadin-dev-tools.d.ts b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/vaadin-dev-tools.d.ts new file mode 100644 index 0000000..d2eea6b --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/vaadin-dev-tools.d.ts @@ -0,0 +1,105 @@ +import { LitElement } from 'lit'; +import { Product } from './License'; +import { ConnectionStatus } from './connection'; +/** + * Plugin API for the dev tools window. + */ +export interface DevToolsInterface { + send(command: string, data: any): void; +} +export interface MessageHandler { + handleMessage(message: ServerMessage): boolean; +} +export interface ServerMessage { + /** + * The command + */ + command: string; + /** + * the data for the command + */ + data: any; +} +/** + * To create and register a plugin, use e.g. + * @example + * export class MyTab extends LitElement implements MessageHandler { + * render() { + * return html`

    Here I am
    `; + * } + * } + * customElements.define('my-tab', MyTab); + * + * const plugin: DevToolsPlugin = { + * init: function (devToolsInterface: DevToolsInterface): void { + * devToolsInterface.addTab('Tab title', 'my-tab') + * } + * }; + * + * (window as any).Vaadin.devToolsPlugins.push(plugin); + */ +export interface DevToolsPlugin { + /** + * Called once to initialize the plugin. + * + * @param devToolsInterface provides methods to interact with the dev tools + */ + init(devToolsInterface: DevToolsInterface): void; +} +export declare enum MessageType { + LOG = "log", + INFORMATION = "information", + WARNING = "warning", + ERROR = "error" +} +type DevToolsConf = { + enable: boolean; + url: string; + contextRelativePath: string; + backend?: string; + liveReloadPort?: number; + token?: string; + usageStatisticsEnabled?: boolean; +}; +export declare class VaadinDevTools extends LitElement { + unhandledMessages: ServerMessage[]; + conf: DevToolsConf; + bodyShadowRoot: ShadowRoot | null; + static get styles(): import("lit").CSSResult[]; + static DISMISSED_NOTIFICATIONS_IN_LOCAL_STORAGE: string; + static ACTIVE_KEY_IN_SESSION_STORAGE: string; + static TRIGGERED_KEY_IN_SESSION_STORAGE: string; + static TRIGGERED_COUNT_KEY_IN_SESSION_STORAGE: string; + static AUTO_DEMOTE_NOTIFICATION_DELAY: number; + static HOTSWAP_AGENT: string; + static JREBEL: string; + static SPRING_BOOT_DEVTOOLS: string; + static BACKEND_DISPLAY_NAME: Record; + static get isActive(): boolean; + frontendStatus: ConnectionStatus; + javaStatus: ConnectionStatus; + private root; + componentPickActive: boolean; + private javaConnection?; + private frontendConnection?; + private nextMessageId; + private transitionDuration; + elementTelemetry(): void; + openWebSocketConnection(): void; + removeOldLinks(path: string): void; + tabHandleMessage(tabElement: HTMLElement, message: ServerMessage): boolean; + handleFrontendMessage(message: ServerMessage): void; + handleHmrMessage(message: ServerMessage): boolean; + getDedicatedWebSocketUrl(): string | undefined; + getSpringBootWebSocketUrl(location: any): string; + connectedCallback(): void; + initPlugin(plugin: DevToolsPlugin): Promise; + format(o: any): string; + checkLicense(productInfo: Product): void; + startPreTrial(): void; + downloadLicense(productInfo: Product): void; + setActive(yes: boolean): void; + render(): import("lit-html").TemplateResult<1>; + setJavaLiveReloadActive(active: boolean): void; +} +export {}; diff --git a/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/vaadin-dev-tools.js b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/vaadin-dev-tools.js new file mode 100644 index 0000000..b671252 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/vaadin-dev-tools.js @@ -0,0 +1,764 @@ +import{LitElement as $,css as U,html as F}from"lit";import{property as P,query as B,state as H,customElement as D}from"lit/decorators.js";function b(o,e,t,s){var n=arguments.length,r=n<3?e:s===null?s=Object.getOwnPropertyDescriptor(e,t):s,a;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")r=Reflect.decorate(o,e,t,s);else for(var l=o.length-1;l>=0;l--)(a=o[l])&&(r=(n<3?a(r):n>3?a(e,t,r):a(e,t))||r);return n>3&&r&&Object.defineProperty(e,t,r),r}class j extends HTMLElement{#o;#n;#e;#s;#t;constructor(){super(),this.#o=null,this.#e=!1,this.#s=null,this.#t=null,this.#n=this.attachShadow({mode:"closed"}),this.render(),this.setupProtection()}static get observedAttributes(){return["expired","start-failure","license-download"]}render(){const e=` + + `;this.#n.innerHTML=` + ${e} +
    + ${this.#e?` +

    Trial expired

    +

    + Vaadin Core is free and open-source. Sign in to keep using + + + + + + + + + + + Pro components + and + + + + + + + + + + + Team features + for 30 more days. +

    +

    Continue getting full access to:

    + ${this.getProductsList()} + + `:` +

    Get full access to all features

    +

    + Vaadin Core is free and open-source. To use Pro components like + + + + + + + + + + Charts in your app, activate a free trial. +

    +

    Get full access:

    + ${this.getProductsList()} + + + `} + ${this.#s?` +
    +

    Trial failed to start

    +

    Something went wrong while starting your trial. Try again in a moment. If the issue persists, contact our support team.

    +
    `:""} + ${this.#t==="started"?"

    Waiting for the license key to be downloaded...

    ":""} + ${this.#t==="failed"?'
    Failed to download the license key. Please try again later.
    ':""} +
    +

    + By starting your trial, you agree to our terms and conditions. +

    +
    + `,this.#n.querySelector("button.primary")?.addEventListener("click",()=>{this.dispatchEvent(new CustomEvent("primary-button-click",{detail:{expired:this.#e}}))}),this.#n.querySelector("button.secondary")?.addEventListener("click",()=>{this.dispatchEvent(new CustomEvent("secondary-button-click"))})}getProductsList(){return` +
      +
    • + + + + + + + + + + Pro components⋅Charts, Grid Pro, CRUD and more +
      • +
    • + + + + + + + + + Team features⋅Acceleration Kits +
      • +
    + `}connectedCallback(){this.setupParentRemovalProtection()}disconnectedCallback(){this.cleanup()}attributeChangedCallback(e,t,s){e==="expired"?this.handleExpiredChange(s!==null&&s!=="false"):e==="start-failure"?this.handleStartFailed(s==="expired"):e==="license-download"&&this.handleLicenseDownload(s)}handleLicenseDownload(e){this.#t!==e&&(this.#t=e,this.render())}handleExpiredChange(e){this.#e!==e&&(this.#e=e,this.render())}handleStartFailed(e){(this.#s!==e||this.#e!==e)&&(this.#e=e,this.#s=!0,this.render())}setupProtection(){const e=Element.prototype.remove;this.remove=function(){console.debug("Attempt to remove vaadin-pretrial detected - restoring");const t=this.parentNode;e.apply(this,arguments),this.restoreSplashScreen(t)},this.protectStyles()}setupParentRemovalProtection(){!this.#o&&this.parentNode&&(this.#o=new MutationObserver(e=>{e.forEach(t=>{t.type==="childList"&&t.removedNodes.forEach(s=>{s===this&&(console.debug("vaadin-pretrial removal detected - restoring"),this.restoreSplashScreen(t.target))})})}),this.#o.observe(this.parentNode,{childList:!0,subtree:!0}))}protectStyles(){Object.defineProperty(this,"style",{get(){return{}},set(e){}})}cleanup(){this.#o&&this.#o.disconnect()}restoreSplashScreen(e){e&&setTimeout(()=>{console.debug("Re-adding vaadin-pretrial component");const t=this.querySelector('[slot="products"]');e.contains(this)&&e.removeChild(this);const s=document.createElement("vaadin-pretrial");this.#e&&s.setAttribute("expired","true"),this.#s&&s.setAttribute("start-failure",this.#e?"expired":""),t&&s.appendChild(t.cloneNode(!0)),e.appendChild(s)},0)}}customElements.define("vaadin-pretrial",j);function z(o){o.detail.expired?G():J()}function W(){G()}const q=(o,e)=>{if(o&&!o.querySelector("vaadin-pretrial")){const t=e.preTrial?.trialState==="EXPIRED",s=document.createElement("vaadin-pretrial");t&&s.setAttribute("expired","");const n=document.createElement("div");n.setAttribute("slot","products"),n.innerHTML=` + This application is using: +
      +
    • ${e.product.name}
      • +
    + `,s.appendChild(n),s.addEventListener("secondary-button-click",W),s.addEventListener("primary-button-click",z),o.innerHTML="",o.appendChild(s)}},y=(o,e)=>{e&&e.querySelector("vaadin-pretrial")?.setAttribute("start-failure",o?"expired":"")},S=(o,e)=>{e&&e.querySelector("vaadin-pretrial")?.setAttribute("license-download",o)},x=1e3,k=(o,e)=>{const t=Array.from(o.querySelectorAll(e.join(", "))),s=Array.from(o.querySelectorAll("*")).filter(n=>n.shadowRoot).flatMap(n=>k(n.shadowRoot,e));return[...t,...s]};let I=!1;const g=(o,e)=>{I||(window.addEventListener("message",n=>{n.data==="validate-license"&&window.location.reload()},!1),I=!0);const t=o._overlayElement;if(t){if(t.shadowRoot){const n=t.shadowRoot.querySelector("slot:not([name])");if(n&&n.assignedElements().length>0){g(n.assignedElements()[0],e);return}}g(t,e);return}const s=e.messageHtml?e.messageHtml:`${e.message}

    Component: ${e.product.name} ${e.product.version}

    `.replace(/https:([^ ]*)/g,"https:$1");o.isConnected&&(o.outerHTML=`
    ${s}
    `)},f={},R={},m={},V={},h=o=>`${o.name}_${o.version}`,L=o=>{const{cvdlName:e,version:t}=o.constructor,s={name:e,version:t},n=o.tagName.toLowerCase();f[e]=f[e]??[],f[e].push(n);const r=m[h(s)];r&&setTimeout(()=>g(o,r),x),m[h(s)]||V[h(s)]||R[h(s)]||(R[h(s)]=!0,window.Vaadin.devTools.checkLicense(s))},M=o=>{V[h(o)]=!0,console.debug("License check ok for",o)},Z=o=>{const e=o.product.name;m[h(o.product)]=o,console.error("License check failed for",e);const t=f[e];t?.length>0&&k(document,t).forEach(s=>{setTimeout(()=>g(s,m[h(o.product)]),x)})},K=o=>{const e=o.message,t=o.product.name;o.messageHtml=`No license found. Go here to start a trial or retrieve your license.`,m[h(o.product)]=o,console.error("No license found when checking",t);const s=f[t];s?.length>0&&k(document,s).forEach(n=>{setTimeout(()=>g(n,m[h(o.product)]),x)})},Y=(o,e)=>o.command==="license-check-ok"?(M(o.data),!0):o.command==="license-check-failed"?(Z(o.data),!0):o.command==="license-check-nokey"?(q(e,o.data),K(o.data),!0):o.command==="license-pretrial-started"?(console.debug("Pre-trial period started",o.data),window.location.reload(),!0):o.command==="license-pretrial-expired"?(console.debug("Pre-trial period expired",o.data),y(!0,e),!0):o.command==="license-pretrial-failed"?(console.debug("Pre-trial period start failed",o.data),y(!1,e),!0):o.command==="license-download-completed"?(console.debug("License downloaded"),window.location.reload(),!0):o.command==="license-download-started"?(S("started",e),!0):o.command==="license-download-failed"?(S("failed",e),!0):!1,J=()=>{window.Vaadin.devTools.startPreTrial()},G=()=>{const o=Object.values(m);o.length>0&&window.Vaadin.devTools.downloadLicense(o[0].product)},X=()=>{window.Vaadin.devTools.createdCvdlElements.forEach(o=>{L(o)}),window.Vaadin.devTools.createdCvdlElements={push:o=>{L(o)}}};var i;(function(o){o.ACTIVE="active",o.INACTIVE="inactive",o.UNAVAILABLE="unavailable",o.ERROR="error"})(i||(i={}));const A=class A{constructor(){this.status=i.UNAVAILABLE}onHandshake(){}onConnectionError(e){}onStatusChange(e){}setActive(e){!e&&this.status===i.ACTIVE?this.setStatus(i.INACTIVE):e&&this.status===i.INACTIVE&&this.setStatus(i.ACTIVE)}setStatus(e){this.status!==e&&(this.status=e,this.onStatusChange(e))}};A.HEARTBEAT_INTERVAL=18e4;let v=A;class Q extends v{constructor(e){super(),this.webSocket=new WebSocket(e),this.webSocket.onmessage=t=>this.handleMessage(t),this.webSocket.onerror=t=>this.handleError(t),this.webSocket.onclose=t=>{this.status!==i.ERROR&&this.setStatus(i.UNAVAILABLE),this.webSocket=void 0},setInterval(()=>{this.webSocket&&self.status!==i.ERROR&&this.status!==i.UNAVAILABLE&&this.webSocket.send("")},v.HEARTBEAT_INTERVAL)}onReload(e){}handleMessage(e){let t;try{t=JSON.parse(e.data)}catch(s){this.handleError(`[${s.name}: ${s.message}`);return}if(t.command==="hello")this.setStatus(i.ACTIVE),this.onHandshake();else if(t.command==="reload"){if(this.status===i.ACTIVE){const s=t.strategy||"reload";this.onReload(s)}}else this.handleError(`Unknown message from the livereload server: ${e}`)}handleError(e){console.error(e),this.setStatus(i.ERROR),e instanceof Event&&this.webSocket?this.onConnectionError(`Error in WebSocket connection to ${this.webSocket.url}`):this.onConnectionError(e)}}const _=16384,T=class T extends v{constructor(e){if(super(),this.canSend=!1,!e)return;const t={transport:"websocket",fallbackTransport:"websocket",url:e,contentType:"application/json; charset=UTF-8",reconnectInterval:5e3,timeout:-1,maxReconnectOnClose:1e7,trackMessageLength:!0,enableProtocol:!0,handleOnlineOffline:!1,executeCallbackBeforeReconnect:!0,messageDelimiter:"|",onMessage:s=>{const n={data:s.responseBody};this.handleMessage(n)},onError:s=>{this.canSend=!1,this.handleError(s)},onOpen:()=>{this.canSend=!0},onClose:()=>{this.canSend=!1},onClientTimeout:()=>{this.canSend=!1},onReconnect:()=>{this.canSend=!1},onReopen:()=>{this.canSend=!0}};ee().then(s=>{this.socket=s.subscribe(t)})}onReload(e){}onUpdate(e,t){}onMessage(e){}handleMessage(e){let t;try{t=JSON.parse(e.data)}catch(s){this.handleError(`[${s.name}: ${s.message}`);return}if(t.command==="hello")this.setStatus(i.ACTIVE),this.onHandshake();else if(t.command==="reload"){if(this.status===i.ACTIVE){const s=t.strategy||"reload";this.onReload(s)}}else t.command==="update"?this.status===i.ACTIVE&&this.onUpdate(t.path,t.content):this.onMessage(t)}handleError(e){console.error(e),this.setStatus(i.ERROR),this.onConnectionError(e)}send(e,t){if(!this.socket||!this.canSend){C(()=>this.socket&&this.canSend,a=>this.send(e,t));return}const s=JSON.stringify({command:e,data:t});let r=s.length+"|"+s;for(;r.length;)this.socket.push(r.substring(0,_)),r=r.substring(_)}};T.HEARTBEAT_INTERVAL=18e4;let E=T;function C(o,e){const t=o();t?e(t):setTimeout(()=>C(o,e),50)}function ee(){return new Promise((o,e)=>{C(()=>window?.vaadinPush?.atmosphere,o)})}var c,O;(function(o){o.LOG="log",o.INFORMATION="information",o.WARNING="warning",o.ERROR="error"})(O||(O={}));const N=import.meta.hot?import.meta.hot.hmrClient:void 0;var d;let p=(d=class extends ${constructor(){super(...arguments),this.unhandledMessages=[],this.conf={enable:!1,url:"",contextRelativePath:"",liveReloadPort:-1},this.bodyShadowRoot=null,this.frontendStatus=i.UNAVAILABLE,this.javaStatus=i.UNAVAILABLE,this.componentPickActive=!1,this.nextMessageId=1,this.transitionDuration=0}static get styles(){return[U` + :host { + --dev-tools-font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen-Sans, Ubuntu, Cantarell, + 'Helvetica Neue', sans-serif; + --dev-tools-font-family-monospace: SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', + monospace; + + --dev-tools-font-size: 0.8125rem; + --dev-tools-font-size-small: 0.75rem; + + --dev-tools-text-color: rgba(255, 255, 255, 0.8); + --dev-tools-text-color-secondary: rgba(255, 255, 255, 0.65); + --dev-tools-text-color-emphasis: rgba(255, 255, 255, 0.95); + --dev-tools-text-color-active: rgba(255, 255, 255, 1); + + --dev-tools-background-color-inactive: rgba(45, 45, 45, 0.25); + --dev-tools-background-color-active: rgba(45, 45, 45, 0.98); + --dev-tools-background-color-active-blurred: rgba(45, 45, 45, 0.85); + + --dev-tools-border-radius: 0.5rem; + --dev-tools-box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.05), 0 4px 12px -2px rgba(0, 0, 0, 0.4); + + --dev-tools-blue-hsl: 206, 100%, 70%; + --dev-tools-blue-color: hsl(var(--dev-tools-blue-hsl)); + --dev-tools-green-hsl: 145, 80%, 42%; + --dev-tools-green-color: hsl(var(--dev-tools-green-hsl)); + --dev-tools-grey-hsl: 0, 0%, 50%; + --dev-tools-grey-color: hsl(var(--dev-tools-grey-hsl)); + --dev-tools-yellow-hsl: 38, 98%, 64%; + --dev-tools-yellow-color: hsl(var(--dev-tools-yellow-hsl)); + --dev-tools-red-hsl: 355, 100%, 68%; + --dev-tools-red-color: hsl(var(--dev-tools-red-hsl)); + + /* Needs to be in ms, used in JavaScript as well */ + --dev-tools-transition-duration: 180ms; + + all: initial; + + direction: ltr; + cursor: default; + font: normal 400 var(--dev-tools-font-size) / 1.125rem var(--dev-tools-font-family); + color: var(--dev-tools-text-color); + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; + color-scheme: dark; + + position: fixed; + z-index: 20000; + pointer-events: none; + bottom: 0; + right: 0; + width: 100%; + height: 100%; + display: flex; + flex-direction: column-reverse; + align-items: flex-end; + } + + .dev-tools { + pointer-events: auto; + display: flex; + align-items: center; + position: fixed; + z-index: inherit; + right: 0.5rem; + bottom: 0.5rem; + min-width: 1.75rem; + height: 1.75rem; + max-width: 1.75rem; + border-radius: 0.5rem; + padding: 0.375rem; + box-sizing: border-box; + background-color: var(--dev-tools-background-color-inactive); + box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.05); + color: var(--dev-tools-text-color); + transition: var(--dev-tools-transition-duration); + white-space: nowrap; + line-height: 1rem; + } + + .dev-tools:hover, + .dev-tools.active { + background-color: var(--dev-tools-background-color-active); + box-shadow: var(--dev-tools-box-shadow); + } + + .dev-tools.active { + max-width: calc(100% - 1rem); + } + + .dev-tools .status-description { + overflow: hidden; + text-overflow: ellipsis; + padding: 0 0.25rem; + } + + .dev-tools.error { + background-color: hsla(var(--dev-tools-red-hsl), 0.15); + animation: bounce 0.5s; + animation-iteration-count: 2; + } + + .window.hidden { + opacity: 0; + transform: scale(0); + position: absolute; + } + + .window.visible { + transform: none; + opacity: 1; + pointer-events: auto; + } + + .window.visible ~ .dev-tools { + opacity: 0; + pointer-events: none; + } + + .window.visible ~ .dev-tools .dev-tools-icon, + .window.visible ~ .dev-tools .status-blip { + transition: none; + opacity: 0; + } + + .window { + border-radius: var(--dev-tools-border-radius); + overflow: auto; + margin: 0.5rem; + min-width: 30rem; + max-width: calc(100% - 1rem); + max-height: calc(100vh - 1rem); + flex-shrink: 1; + background-color: var(--dev-tools-background-color-active); + color: var(--dev-tools-text-color); + transition: var(--dev-tools-transition-duration); + transform-origin: bottom right; + display: flex; + flex-direction: column; + box-shadow: var(--dev-tools-box-shadow); + outline: none; + } + + .window-toolbar { + display: flex; + flex: none; + align-items: center; + padding: 0.375rem; + white-space: nowrap; + order: 1; + background-color: rgba(0, 0, 0, 0.2); + gap: 0.5rem; + } + + .ahreflike { + font-weight: 500; + color: var(--dev-tools-text-color-secondary); + text-decoration: underline; + cursor: pointer; + } + + .ahreflike:hover { + color: var(--dev-tools-text-color-emphasis); + } + + .button { + all: initial; + font-family: inherit; + font-size: var(--dev-tools-font-size-small); + line-height: 1; + white-space: nowrap; + background-color: rgba(0, 0, 0, 0.2); + color: inherit; + font-weight: 600; + padding: 0.25rem 0.375rem; + border-radius: 0.25rem; + } + + .button:focus, + .button:hover { + color: var(--dev-tools-text-color-emphasis); + } + + .message.information { + --dev-tools-notification-color: var(--dev-tools-blue-color); + } + + .message.warning { + --dev-tools-notification-color: var(--dev-tools-yellow-color); + } + + .message.error { + --dev-tools-notification-color: var(--dev-tools-red-color); + } + + .message { + display: flex; + padding: 0.1875rem 0.75rem 0.1875rem 2rem; + background-clip: padding-box; + } + + .message.log { + padding-left: 0.75rem; + } + + .message-content { + margin-right: 0.5rem; + -webkit-user-select: text; + -moz-user-select: text; + user-select: text; + } + + .message-heading { + position: relative; + display: flex; + align-items: center; + margin: 0.125rem 0; + } + + .message.log { + color: var(--dev-tools-text-color-secondary); + } + + .message:not(.log) .message-heading { + font-weight: 500; + } + + .message.has-details .message-heading { + color: var(--dev-tools-text-color-emphasis); + font-weight: 600; + } + + .message-heading::before { + position: absolute; + margin-left: -1.5rem; + display: inline-block; + text-align: center; + font-size: 0.875em; + font-weight: 600; + line-height: calc(1.25em - 2px); + width: 14px; + height: 14px; + box-sizing: border-box; + border: 1px solid transparent; + border-radius: 50%; + } + + .message.information .message-heading::before { + content: 'i'; + border-color: currentColor; + color: var(--dev-tools-notification-color); + } + + .message.warning .message-heading::before, + .message.error .message-heading::before { + content: '!'; + color: var(--dev-tools-background-color-active); + background-color: var(--dev-tools-notification-color); + } + + .features-tray { + padding: 0.75rem; + flex: auto; + overflow: auto; + animation: fade-in var(--dev-tools-transition-duration) ease-in; + user-select: text; + } + + .features-tray p { + margin-top: 0; + color: var(--dev-tools-text-color-secondary); + } + + .features-tray .feature { + display: flex; + align-items: center; + gap: 1rem; + padding-bottom: 0.5em; + } + + .message .message-details { + font-weight: 400; + color: var(--dev-tools-text-color-secondary); + margin: 0.25rem 0; + } + + .message .message-details[hidden] { + display: none; + } + + .message .message-details p { + display: inline; + margin: 0; + margin-right: 0.375em; + word-break: break-word; + } + + .message .persist { + color: var(--dev-tools-text-color-secondary); + white-space: nowrap; + margin: 0.375rem 0; + display: flex; + align-items: center; + position: relative; + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; + } + + .message .persist::before { + content: ''; + width: 1em; + height: 1em; + border-radius: 0.2em; + margin-right: 0.375em; + background-color: rgba(255, 255, 255, 0.3); + } + + .message .persist:hover::before { + background-color: rgba(255, 255, 255, 0.4); + } + + .message .persist.on::before { + background-color: rgba(255, 255, 255, 0.9); + } + + .message .persist.on::after { + content: ''; + order: -1; + position: absolute; + width: 0.75em; + height: 0.25em; + border: 2px solid var(--dev-tools-background-color-active); + border-width: 0 0 2px 2px; + transform: translate(0.05em, -0.05em) rotate(-45deg) scale(0.8, 0.9); + } + + .message .dismiss-message { + font-weight: 600; + align-self: stretch; + display: flex; + align-items: center; + padding: 0 0.25rem; + margin-left: 0.5rem; + color: var(--dev-tools-text-color-secondary); + } + + .message .dismiss-message:hover { + color: var(--dev-tools-text-color); + } + + .notification-tray { + display: flex; + flex-direction: column-reverse; + align-items: flex-end; + margin: 0.5rem; + flex: none; + } + + .window.hidden + .notification-tray { + margin-bottom: 3rem; + } + + .notification-tray .message { + pointer-events: auto; + background-color: var(--dev-tools-background-color-active); + color: var(--dev-tools-text-color); + max-width: 30rem; + box-sizing: border-box; + border-radius: var(--dev-tools-border-radius); + margin-top: 0.5rem; + transition: var(--dev-tools-transition-duration); + transform-origin: bottom right; + animation: slideIn var(--dev-tools-transition-duration); + box-shadow: var(--dev-tools-box-shadow); + padding-top: 0.25rem; + padding-bottom: 0.25rem; + } + + .notification-tray .message.animate-out { + animation: slideOut forwards var(--dev-tools-transition-duration); + } + + .notification-tray .message .message-details { + max-height: 10em; + overflow: hidden; + } + + .message-tray { + flex: auto; + overflow: auto; + max-height: 20rem; + user-select: text; + } + + .message-tray .message { + animation: fade-in var(--dev-tools-transition-duration) ease-in; + padding-left: 2.25rem; + } + + .message-tray .message.warning { + background-color: hsla(var(--dev-tools-yellow-hsl), 0.09); + } + + .message-tray .message.error { + background-color: hsla(var(--dev-tools-red-hsl), 0.09); + } + + .message-tray .message.error .message-heading { + color: hsl(var(--dev-tools-red-hsl)); + } + + .message-tray .message.warning .message-heading { + color: hsl(var(--dev-tools-yellow-hsl)); + } + + .message-tray .message + .message { + border-top: 1px solid rgba(255, 255, 255, 0.07); + } + + .message-tray .dismiss-message, + .message-tray .persist { + display: none; + } + + @keyframes slideIn { + from { + transform: translateX(100%); + opacity: 0; + } + to { + transform: translateX(0%); + opacity: 1; + } + } + + @keyframes slideOut { + from { + transform: translateX(0%); + opacity: 1; + } + to { + transform: translateX(100%); + opacity: 0; + } + } + + @keyframes fade-in { + 0% { + opacity: 0; + } + } + + @keyframes bounce { + 0% { + transform: scale(0.8); + } + 50% { + transform: scale(1.5); + background-color: hsla(var(--dev-tools-red-hsl), 1); + } + 100% { + transform: scale(1); + } + } + + @supports (backdrop-filter: blur(1px)) { + .dev-tools, + .window, + .notification-tray .message { + backdrop-filter: blur(8px); + } + + .dev-tools:hover, + .dev-tools.active, + .window, + .notification-tray .message { + background-color: var(--dev-tools-background-color-active-blurred); + } + } + `]}static get isActive(){const e=window.sessionStorage.getItem(c.ACTIVE_KEY_IN_SESSION_STORAGE);return e===null||e!=="false"}elementTelemetry(){let e={};try{const t=localStorage.getItem("vaadin.statistics.basket");if(!t)return;e=JSON.parse(t)}catch{return}this.frontendConnection&&this.frontendConnection.send("reportTelemetry",{browserData:e})}openWebSocketConnection(){if(this.frontendStatus=i.UNAVAILABLE,this.javaStatus=i.UNAVAILABLE,!this.conf.token){console.error("Dev tools functionality denied for this host. See Vaadin documentation on how to configure devmode.hostsAllowed property: https://vaadin.com/docs/latest/configuration/properties#properties");return}const e=r=>console.error(r),t=(r="reload")=>{if(r==="refresh"||r==="full-refresh"){const a=window.Vaadin;Object.keys(a.Flow.clients).filter(l=>l!=="TypeScript").map(l=>a.Flow.clients[l]).forEach(l=>{l.sendEventMessage?l.sendEventMessage(1,"ui-refresh",{fullRefresh:r==="full-refresh"}):console.warn("Ignoring ui-refresh event for application ",id)})}else{const a=window.sessionStorage.getItem(c.TRIGGERED_COUNT_KEY_IN_SESSION_STORAGE),l=a?parseInt(a,10)+1:1;window.sessionStorage.setItem(c.TRIGGERED_COUNT_KEY_IN_SESSION_STORAGE,l.toString()),window.sessionStorage.setItem(c.TRIGGERED_KEY_IN_SESSION_STORAGE,"true"),window.location.reload()}},s=(r,a)=>{const l="context://",w=r.substring(l.length);if(r.startsWith(l)&&(r=this.conf.contextRelativePath+w),a){let u=document.head.querySelector(`style[data-file-path='${r}']`);u||(u=document.createElement("style"),u.setAttribute("data-file-path",r),document.head.appendChild(u),this.removeOldLinks(w)),u.textContent=a,document.dispatchEvent(new CustomEvent("vaadin-theme-updated"))}else if(a===""||a===null){const u=document.head.querySelector(`style[data-file-path='${r}']`);u?u.remove():this.removeOldLinks(w),document.dispatchEvent(new CustomEvent("vaadin-theme-updated"))}},n=new E(this.getDedicatedWebSocketUrl());n.onHandshake=()=>{c.isActive||n.setActive(!1),this.conf.usageStatisticsEnabled===!1?(localStorage.setItem("vaadin.statistics.optout","true"),localStorage.removeItem("vaadin.statistics.basket"),localStorage.removeItem("vaadin.statistics.firstuse")):localStorage.removeItem("vaadin.statistics.optout"),this.elementTelemetry()},n.onConnectionError=e,n.onReload=t,n.onUpdate=s,n.onStatusChange=r=>{this.frontendStatus=r},n.onMessage=r=>this.handleFrontendMessage(r),this.frontendConnection=n,this.conf.backend===c.SPRING_BOOT_DEVTOOLS&&this.conf.liveReloadPort&&(this.javaConnection=new Q(this.getSpringBootWebSocketUrl(window.location)),this.javaConnection.onHandshake=()=>{c.isActive||this.javaConnection.setActive(!1)},this.javaConnection.onReload=t,this.javaConnection.onConnectionError=e,this.javaConnection.onStatusChange=r=>{this.javaStatus=r})}removeOldLinks(e){Array.from(document.head.querySelectorAll('link[rel="stylesheet"]')).forEach(s=>{let n=s.getAttribute("data-file-path")||s.getAttribute("href");n&&n.includes(e)&&s.remove()})}tabHandleMessage(e,t){const s=e;return s.handleMessage&&s.handleMessage.call(e,t)}handleFrontendMessage(e){e.command==="featureFlags"||Y(e,this.bodyShadowRoot)||this.handleHmrMessage(e)||this.unhandledMessages.push(e)}handleHmrMessage(e){return e.command!=="hmr"?!1:(N&&N.notifyListeners(e.data.event,e.data.eventData),!0)}getDedicatedWebSocketUrl(){function e(s){const n=document.createElement("div");return n.innerHTML=``,n.firstChild.href}if(this.conf.url===void 0)return;const t=e(this.conf.url);if(!t.startsWith("http://")&&!t.startsWith("https://")){console.error("The protocol of the url should be http or https for live reload to work.");return}return`${t}?v-r=push&debug_window&token=${this.conf.token}`}getSpringBootWebSocketUrl(e){const{hostname:t}=e,s=e.protocol==="https:"?"wss":"ws";if(t.endsWith("gitpod.io")){const n=t.replace(/.*?-/,"");return`${s}://${this.conf.liveReloadPort}-${n}`}else return`${s}://${t}:${this.conf.liveReloadPort}`}connectedCallback(){if(super.connectedCallback(),this.bodyShadowRoot=document.body.attachShadow({mode:"closed"}),this.bodyShadowRoot.innerHTML="",this.conf=window.Vaadin.devToolsConf||this.conf,window.sessionStorage.getItem(c.TRIGGERED_KEY_IN_SESSION_STORAGE)){const n=new Date;`${`0${n.getHours()}`.slice(-2)}${`0${n.getMinutes()}`.slice(-2)}${`0${n.getSeconds()}`.slice(-2)}`,window.sessionStorage.removeItem(c.TRIGGERED_KEY_IN_SESSION_STORAGE)}this.transitionDuration=parseInt(window.getComputedStyle(this).getPropertyValue("--dev-tools-transition-duration"),10);const t=window;t.Vaadin=t.Vaadin||{},t.Vaadin.devTools=Object.assign(this,t.Vaadin.devTools);const s=window.Vaadin;s.devToolsPlugins&&(Array.from(s.devToolsPlugins).forEach(n=>this.initPlugin(n)),s.devToolsPlugins={push:n=>this.initPlugin(n)}),this.openWebSocketConnection(),X()}async initPlugin(e){const t=this;e.init({send:function(s,n){t.frontendConnection.send(s,n)}})}format(e){return e.toString()}checkLicense(e){this.frontendConnection?this.frontendConnection.send("checkLicense",e):M(e)}startPreTrial(){this.frontendConnection?this.frontendConnection.send("startPreTrialLicense",{}):(console.error("Cannot start pre-trial: no connection"),y(!1,this.bodyShadowRoot))}downloadLicense(e){this.frontendConnection?this.frontendConnection.send("downloadLicense",e):S("failed",this.bodyShadowRoot)}setActive(e){this.frontendConnection?.setActive(e),this.javaConnection?.setActive(e),window.sessionStorage.setItem(c.ACTIVE_KEY_IN_SESSION_STORAGE,e?"true":"false")}render(){return F` `}setJavaLiveReloadActive(e){this.javaConnection?this.javaConnection.setActive(e):this.frontendConnection?.setActive(e)}},c=d,d.DISMISSED_NOTIFICATIONS_IN_LOCAL_STORAGE="vaadin.live-reload.dismissedNotifications",d.ACTIVE_KEY_IN_SESSION_STORAGE="vaadin.live-reload.active",d.TRIGGERED_KEY_IN_SESSION_STORAGE="vaadin.live-reload.triggered",d.TRIGGERED_COUNT_KEY_IN_SESSION_STORAGE="vaadin.live-reload.triggeredCount",d.AUTO_DEMOTE_NOTIFICATION_DELAY=5e3,d.HOTSWAP_AGENT="HOTSWAP_AGENT",d.JREBEL="JREBEL",d.SPRING_BOOT_DEVTOOLS="SPRING_BOOT_DEVTOOLS",d.BACKEND_DISPLAY_NAME={HOTSWAP_AGENT:"HotswapAgent",JREBEL:"JRebel",SPRING_BOOT_DEVTOOLS:"Spring Boot Devtools"},d);b([P({type:String,attribute:!1})],p.prototype,"frontendStatus",void 0);b([P({type:String,attribute:!1})],p.prototype,"javaStatus",void 0);b([B(".window")],p.prototype,"root",void 0);b([H()],p.prototype,"componentPickActive",void 0);p=c=b([D("vaadin-dev-tools")],p); +//# sourceMappingURL=vaadin-dev-tools.js.map diff --git a/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/vaadin-dev-tools.js.map b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/vaadin-dev-tools.js.map new file mode 100644 index 0000000..1cd61ab --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/vaadin-dev-tools.js.map @@ -0,0 +1 @@ +{"version":3,"file":"vaadin-dev-tools.js","sources":["../../../../../../node_modules/tslib/tslib.es6.mjs","../../../../frontend/pre-trial-splash-screen.ts","../../../../frontend/License.ts","../../../../frontend/connection.ts","../../../../frontend/live-reload-connection.ts","../../../../frontend/websocket-connection.ts","../../../../frontend/vaadin-dev-tools.ts"],"sourcesContent":["/******************************************************************************\nCopyright (c) Microsoft Corporation.\n\nPermission to use, copy, modify, and/or distribute this software for any\npurpose with or without fee is hereby granted.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\nPERFORMANCE OF THIS SOFTWARE.\n***************************************************************************** */\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\n\nvar extendStatics = function(d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n return extendStatics(d, b);\n};\n\nexport function __extends(d, b) {\n if (typeof b !== \"function\" && b !== null)\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nexport var __assign = function() {\n __assign = Object.assign || function __assign(t) {\n for (var s, i = 1, n = arguments.length; i < n; i++) {\n s = arguments[i];\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n }\n return t;\n }\n return __assign.apply(this, arguments);\n}\n\nexport function __rest(s, e) {\n var t = {};\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n t[p] = s[p];\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n t[p[i]] = s[p[i]];\n }\n return t;\n}\n\nexport function __decorate(decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\n\nexport function __param(paramIndex, decorator) {\n return function (target, key) { decorator(target, key, paramIndex); }\n}\n\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\n function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\n var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\n var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\n var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\n var _, done = false;\n for (var i = decorators.length - 1; i >= 0; i--) {\n var context = {};\n for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\n for (var p in contextIn.access) context.access[p] = contextIn.access[p];\n context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\n var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\n if (kind === \"accessor\") {\n if (result === void 0) continue;\n if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\n if (_ = accept(result.get)) descriptor.get = _;\n if (_ = accept(result.set)) descriptor.set = _;\n if (_ = accept(result.init)) initializers.unshift(_);\n }\n else if (_ = accept(result)) {\n if (kind === \"field\") initializers.unshift(_);\n else descriptor[key] = _;\n }\n }\n if (target) Object.defineProperty(target, contextIn.name, descriptor);\n done = true;\n};\n\nexport function __runInitializers(thisArg, initializers, value) {\n var useValue = arguments.length > 2;\n for (var i = 0; i < initializers.length; i++) {\n value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\n }\n return useValue ? value : void 0;\n};\n\nexport function __propKey(x) {\n return typeof x === \"symbol\" ? x : \"\".concat(x);\n};\n\nexport function __setFunctionName(f, name, prefix) {\n if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\n};\n\nexport function __metadata(metadataKey, metadataValue) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\n\nexport function __awaiter(thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n}\n\nexport function __generator(thisArg, body) {\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\n return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n function verb(n) { return function (v) { return step([n, v]); }; }\n function step(op) {\n if (f) throw new TypeError(\"Generator is already executing.\");\n while (g && (g = 0, op[0] && (_ = 0)), _) try {\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n if (y = 0, t) op = [op[0] & 2, t.value];\n switch (op[0]) {\n case 0: case 1: t = op; break;\n case 4: _.label++; return { value: op[1], done: false };\n case 5: _.label++; y = op[1]; op = [0]; continue;\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\n default:\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n if (t[2]) _.ops.pop();\n _.trys.pop(); continue;\n }\n op = body.call(thisArg, _);\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n }\n}\n\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n var desc = Object.getOwnPropertyDescriptor(m, k);\n if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n desc = { enumerable: true, get: function() { return m[k]; } };\n }\n Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n});\n\nexport function __exportStar(m, o) {\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\n}\n\nexport function __values(o) {\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n if (m) return m.call(o);\n if (o && typeof o.length === \"number\") return {\n next: function () {\n if (o && i >= o.length) o = void 0;\n return { value: o && o[i++], done: !o };\n }\n };\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\n\nexport function __read(o, n) {\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n if (!m) return o;\n var i = m.call(o), r, ar = [], e;\n try {\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n }\n catch (error) { e = { error: error }; }\n finally {\n try {\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\n }\n finally { if (e) throw e.error; }\n }\n return ar;\n}\n\n/** @deprecated */\nexport function __spread() {\n for (var ar = [], i = 0; i < arguments.length; i++)\n ar = ar.concat(__read(arguments[i]));\n return ar;\n}\n\n/** @deprecated */\nexport function __spreadArrays() {\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n r[k] = a[j];\n return r;\n}\n\nexport function __spreadArray(to, from, pack) {\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n if (ar || !(i in from)) {\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n ar[i] = from[i];\n }\n }\n return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nexport function __await(v) {\n return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\n\nexport function __asyncGenerator(thisArg, _arguments, generator) {\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\n return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\n function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\n function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n function fulfill(value) { resume(\"next\", value); }\n function reject(value) { resume(\"throw\", value); }\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n}\n\nexport function __asyncDelegator(o) {\n var i, p;\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\n}\n\nexport function __asyncValues(o) {\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n var m = o[Symbol.asyncIterator], i;\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n}\n\nexport function __makeTemplateObject(cooked, raw) {\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n return cooked;\n};\n\nvar __setModuleDefault = Object.create ? (function(o, v) {\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n o[\"default\"] = v;\n};\n\nvar ownKeys = function(o) {\n ownKeys = Object.getOwnPropertyNames || function (o) {\n var ar = [];\n for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\n return ar;\n };\n return ownKeys(o);\n};\n\nexport function __importStar(mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\n __setModuleDefault(result, mod);\n return result;\n}\n\nexport function __importDefault(mod) {\n return (mod && mod.__esModule) ? mod : { default: mod };\n}\n\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n}\n\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\n if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n}\n\nexport function __classPrivateFieldIn(state, receiver) {\n if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\n return typeof state === \"function\" ? receiver === state : state.has(receiver);\n}\n\nexport function __addDisposableResource(env, value, async) {\n if (value !== null && value !== void 0) {\n if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\n var dispose, inner;\n if (async) {\n if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\n dispose = value[Symbol.asyncDispose];\n }\n if (dispose === void 0) {\n if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\n dispose = value[Symbol.dispose];\n if (async) inner = dispose;\n }\n if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\n if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\n env.stack.push({ value: value, dispose: dispose, async: async });\n }\n else if (async) {\n env.stack.push({ async: true });\n }\n return value;\n}\n\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\n var e = new Error(message);\n return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\n};\n\nexport function __disposeResources(env) {\n function fail(e) {\n env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\n env.hasError = true;\n }\n var r, s = 0;\n function next() {\n while (r = env.stack.pop()) {\n try {\n if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\n if (r.dispose) {\n var result = r.dispose.call(r.value);\n if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\n }\n else s |= 1;\n }\n catch (e) {\n fail(e);\n }\n }\n if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\n if (env.hasError) throw env.error;\n }\n return next();\n}\n\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\n if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\n return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\n return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\n });\n }\n return path;\n}\n\nexport default {\n __extends,\n __assign,\n __rest,\n __decorate,\n __param,\n __esDecorate,\n __runInitializers,\n __propKey,\n __setFunctionName,\n __metadata,\n __awaiter,\n __generator,\n __createBinding,\n __exportStar,\n __values,\n __read,\n __spread,\n __spreadArrays,\n __spreadArray,\n __await,\n __asyncGenerator,\n __asyncDelegator,\n __asyncValues,\n __makeTemplateObject,\n __importStar,\n __importDefault,\n __classPrivateFieldGet,\n __classPrivateFieldSet,\n __classPrivateFieldIn,\n __addDisposableResource,\n __disposeResources,\n __rewriteRelativeImportExtension,\n};\n","import { ProductAndMessage, startPreTrial, tryAcquireLicense } from './License';\n\nclass PreTrial extends HTMLElement {\n #parentObserver: MutationObserver | null;\n #shadowRoot: ShadowRoot;\n #trialExpired: boolean;\n #startFailed: boolean | null;\n #licenseDownloadStatus: string | null;\n private remove: Function;\n\n constructor() {\n super();\n\n this.#parentObserver = null;\n this.#trialExpired = false;\n this.#startFailed = null;\n this.#licenseDownloadStatus = null;\n\n // Create a shadow DOM for encapsulation\n this.#shadowRoot = this.attachShadow({ mode: 'closed' });\n\n // Initialize the component\n this.render();\n this.setupProtection();\n }\n\n // Define the observed attributes for the web component\n static get observedAttributes(): string[] {\n return ['expired', 'start-failure', 'license-download'];\n }\n\n private render(): void {\n // Use template string for HTML structure\n const commonStyles = `\n \n `;\n\n this.#shadowRoot.innerHTML = `\n ${commonStyles}\n
    \n ${\n this.#trialExpired\n ? `\n

    Trial expired

    \n

    \n Vaadin Core is free and open-source. Sign in to keep using\n \n \n\n \n \n \n \n \n \n \n Pro components\n and \n \n \n \n \n \n \n \n \n \n \n Team features\n for 30 more days.\n

    \n

    Continue getting full access to:

    \n ${this.getProductsList()}\n \n `\n : `\n

    Get full access to all features

    \n

    \n Vaadin Core is free and open-source. To use Pro components like \n \n \n \n \n \n \n \n \n \n Charts in your app, activate a free trial.\n

    \n

    Get full access:

    \n ${this.getProductsList()}\n \n \n `\n }\n ${\n this.#startFailed\n ? `\n
    \n

    Trial failed to start

    \n

    Something went wrong while starting your trial. Try again in a moment. If the issue persists, contact our support team.

    \n
    `\n : ''\n }\n ${\n this.#licenseDownloadStatus === 'started'\n ? '

    Waiting for the license key to be downloaded...

    '\n : ''\n }\n ${\n this.#licenseDownloadStatus === 'failed'\n ? '
    Failed to download the license key. Please try again later.
    '\n : ''\n }\n
    \n

    \n By starting your trial, you agree to our terms and conditions.\n

    \n
    \n `;\n\n const primaryButton = this.#shadowRoot.querySelector('button.primary')!;\n primaryButton?.addEventListener('click', () => {\n this.dispatchEvent(\n new CustomEvent('primary-button-click', {\n detail: {\n expired: this.#trialExpired\n }\n })\n );\n });\n const secondaryButton = this.#shadowRoot.querySelector('button.secondary')!;\n secondaryButton?.addEventListener('click', () => {\n this.dispatchEvent(new CustomEvent('secondary-button-click'));\n });\n }\n\n private getProductsList(): string {\n return `\n
      \n
    • \n \n \n \n \n \n \n \n \n \n Pro components⋅Charts, Grid Pro, CRUD and more\n
      • \n
    • \n \n \n \n \n \n \n \n \n Team features⋅Acceleration Kits\n
      • \n
    \n `;\n }\n\n connectedCallback(): void {\n this.setupParentRemovalProtection();\n }\n\n disconnectedCallback(): void {\n this.cleanup();\n }\n\n attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void {\n if (name === 'expired') {\n this.handleExpiredChange(newValue !== null && newValue !== 'false');\n } else if (name === 'start-failure') {\n this.handleStartFailed(newValue === 'expired');\n } else if (name === 'license-download') {\n this.handleLicenseDownload(newValue);\n }\n }\n\n private handleLicenseDownload(value: string | null) {\n if (this.#licenseDownloadStatus !== value) {\n this.#licenseDownloadStatus = value;\n this.render();\n }\n }\n\n private handleExpiredChange(value: boolean) {\n if (this.#trialExpired !== value) {\n this.#trialExpired = value;\n this.render();\n }\n }\n\n private handleStartFailed(expired: boolean) {\n if (this.#startFailed !== expired || this.#trialExpired !== expired) {\n this.#trialExpired = expired;\n this.#startFailed = true;\n this.render();\n }\n }\n\n private setupProtection(): void {\n const originalRemove = Element.prototype.remove;\n this.remove = function (this: PreTrial): void {\n console.debug('Attempt to remove vaadin-pretrial detected - restoring');\n const currentParent = this.parentNode;\n // Let the removal happen\n originalRemove.apply(this, arguments);\n // Re-add the component\n this.restoreSplashScreen(currentParent as Node);\n };\n\n // Protect against style changes\n this.protectStyles();\n }\n\n private setupParentRemovalProtection(): void {\n // Protect against removal from parent\n if (!this.#parentObserver && this.parentNode) {\n this.#parentObserver = new MutationObserver((mutations: MutationRecord[]) => {\n mutations.forEach((mutation: MutationRecord) => {\n if (mutation.type === 'childList') {\n mutation.removedNodes.forEach((node: Node) => {\n if (node === this) {\n console.debug('vaadin-pretrial removal detected - restoring');\n this.restoreSplashScreen(mutation.target);\n }\n });\n }\n });\n });\n\n this.#parentObserver.observe(this.parentNode, {\n childList: true,\n subtree: true\n });\n }\n }\n\n private protectStyles(): void {\n // Override style setters\n Object.defineProperty(this, 'style', {\n get(): object {\n // return an empty object to prevent programmatic changes\n return {};\n },\n set(_value: CSSStyleDeclaration): void {\n // prevent setting regular style object\n }\n });\n }\n\n private cleanup(): void {\n if (this.#parentObserver) {\n this.#parentObserver.disconnect();\n }\n }\n\n private restoreSplashScreen(maybeParentNode: Node | null): void {\n // Re-add the component if it's removed\n if (!maybeParentNode) {\n // Splash screen component not yet attached\n return;\n }\n setTimeout(() => {\n console.debug('Re-adding vaadin-pretrial component');\n const products = this.querySelector('[slot=\"products\"]');\n if ((maybeParentNode as ParentNode).contains(this)) {\n (maybeParentNode as Node).removeChild(this);\n }\n const splashScreen = document.createElement('vaadin-pretrial');\n if (this.#trialExpired) {\n splashScreen.setAttribute('expired', 'true');\n }\n if (this.#startFailed) {\n splashScreen.setAttribute('start-failure', this.#trialExpired ? 'expired' : '');\n }\n if (products) {\n splashScreen.appendChild(products.cloneNode(true));\n }\n (maybeParentNode as Element).appendChild(splashScreen);\n }, 0);\n }\n}\n\n// Register the custom element\ncustomElements.define('vaadin-pretrial', PreTrial);\n\nfunction primaryButtonClickListener(event: CustomEvent) {\n if (event.detail.expired) {\n tryAcquireLicense();\n } else {\n startPreTrial();\n }\n}\n\nfunction secondaryButtonClickListener() {\n tryAcquireLicense();\n}\n\nexport const showPreTrialSplashScreen = (shadowRoot: ShadowRoot | null, message: ProductAndMessage) => {\n if (shadowRoot && !shadowRoot.querySelector('vaadin-pretrial')) {\n const expiredPreTrial = message.preTrial?.trialState === 'EXPIRED';\n const preTrialElement = document.createElement('vaadin-pretrial');\n if (expiredPreTrial) {\n preTrialElement.setAttribute('expired', '');\n }\n const productsDiv = document.createElement('div');\n productsDiv.setAttribute('slot', 'products');\n productsDiv.innerHTML = `\n This application is using:\n
      \n
    • ${message.product.name}
      • \n
    \n `;\n preTrialElement.appendChild(productsDiv);\n\n preTrialElement.addEventListener('secondary-button-click', secondaryButtonClickListener as EventListener);\n preTrialElement.addEventListener('primary-button-click', primaryButtonClickListener as EventListener);\n\n shadowRoot.innerHTML = ``;\n shadowRoot.appendChild(preTrialElement);\n }\n};\nexport const preTrialStartFailed = (expired: boolean, shadowRoot: ShadowRoot | null) => {\n if (shadowRoot) {\n const element = shadowRoot.querySelector('vaadin-pretrial');\n element?.setAttribute('start-failure', expired ? 'expired' : '');\n }\n};\nexport const updateLicenseDownloadStatus = (\n action: 'started' | 'failed' | 'completed',\n shadowRoot: ShadowRoot | null\n) => {\n if (shadowRoot) {\n const element = shadowRoot.querySelector('vaadin-pretrial');\n element?.setAttribute('license-download', action);\n }\n};\n","import { ServerMessage } from './vaadin-dev-tools';\nimport { preTrialStartFailed, showPreTrialSplashScreen, updateLicenseDownloadStatus } from './pre-trial-splash-screen';\n\nconst noLicenseFallbackTimeout = 1000;\n\nexport interface Product {\n name: string;\n version: string;\n}\n\nexport interface PreTrial {\n trialName?: String;\n trialState: String;\n daysRemaining?: number;\n daysRemainingUntilRenewal?: number;\n}\n\nexport interface ProductAndMessage {\n message: string;\n messageHtml?: string;\n product: Product;\n preTrial?: PreTrial;\n}\n\nexport const findAll = (element: Element | ShadowRoot | Document, tags: string[]): Element[] => {\n const lightDom = Array.from(element.querySelectorAll(tags.join(', ')));\n const shadowDom = Array.from(element.querySelectorAll('*'))\n .filter((e) => e.shadowRoot)\n .flatMap((e) => findAll(e.shadowRoot!, tags));\n return [...lightDom, ...shadowDom];\n};\n\nlet licenseCheckListener = false;\n\nconst showNoLicenseFallback = (element: Element, productAndMessage: ProductAndMessage) => {\n if (!licenseCheckListener) {\n // When a license check has succeeded, refresh so that all elements are properly shown again\n window.addEventListener(\n 'message',\n (e) => {\n if (e.data === 'validate-license') {\n window.location.reload();\n }\n },\n false\n );\n licenseCheckListener = true;\n }\n const overlay = (element as any)._overlayElement;\n if (overlay) {\n if (overlay.shadowRoot) {\n const defaultSlot = overlay.shadowRoot.querySelector('slot:not([name])');\n if (defaultSlot && defaultSlot.assignedElements().length > 0) {\n showNoLicenseFallback(defaultSlot.assignedElements()[0], productAndMessage);\n return;\n }\n }\n showNoLicenseFallback(overlay, productAndMessage);\n return;\n }\n\n const htmlMessage = productAndMessage.messageHtml\n ? productAndMessage.messageHtml\n : `${productAndMessage.message}

    Component: ${productAndMessage.product.name} ${productAndMessage.product.version}

    `.replace(\n /https:([^ ]*)/g,\n \"https:$1\"\n );\n\n if (element.isConnected) {\n element.outerHTML = `
    ${htmlMessage}
    `;\n }\n};\n\nconst productTagNames: Record = {};\nconst productChecking: Record = {};\nconst productMissingLicense: Record = {};\nconst productCheckOk: Record = {};\n\nconst key = (product: Product): string => {\n return `${product.name}_${product.version}`;\n};\n\nconst checkLicenseIfNeeded = (cvdlElement: Element) => {\n const { cvdlName, version } = cvdlElement.constructor as CustomElementConstructor & {\n cvdlName: string;\n version: string;\n };\n const product: Product = { name: cvdlName, version };\n const tagName = cvdlElement.tagName.toLowerCase();\n productTagNames[cvdlName] = productTagNames[cvdlName] ?? [];\n productTagNames[cvdlName].push(tagName);\n\n const failedLicenseCheck = productMissingLicense[key(product)];\n if (failedLicenseCheck) {\n // Has been checked and the check failed\n setTimeout(() => showNoLicenseFallback(cvdlElement, failedLicenseCheck), noLicenseFallbackTimeout);\n }\n\n if (productMissingLicense[key(product)] || productCheckOk[key(product)]) {\n // Already checked\n } else if (!productChecking[key(product)]) {\n // Has not been checked\n productChecking[key(product)] = true;\n (window as any).Vaadin.devTools.checkLicense(product);\n }\n};\n\nexport const licenseCheckOk = (data: Product) => {\n productCheckOk[key(data)] = true;\n\n // eslint-disable-next-line no-console\n console.debug('License check ok for', data);\n};\n\nexport const licenseCheckFailed = (data: ProductAndMessage) => {\n const productName = data.product.name;\n productMissingLicense[key(data.product)] = data;\n // eslint-disable-next-line no-console\n console.error('License check failed for', productName);\n\n const tags = productTagNames[productName];\n if (tags?.length > 0) {\n findAll(document, tags).forEach((element) => {\n setTimeout(\n () => showNoLicenseFallback(element, productMissingLicense[key(data.product)]),\n noLicenseFallbackTimeout\n );\n });\n }\n};\n\nexport const licenseCheckNoKey = (data: ProductAndMessage) => {\n const keyUrl = data.message;\n\n const productName = data.product.name;\n data.messageHtml = `No license found. Go here to start a trial or retrieve your license.`;\n productMissingLicense[key(data.product)] = data;\n // eslint-disable-next-line no-console\n console.error('No license found when checking', productName);\n\n const tags = productTagNames[productName];\n if (tags?.length > 0) {\n findAll(document, tags).forEach((element) => {\n setTimeout(\n () => showNoLicenseFallback(element, productMissingLicense[key(data.product)]),\n noLicenseFallbackTimeout\n );\n });\n }\n};\n\nexport const handleLicenseMessage = (message: ServerMessage, bodyShadowRoot: ShadowRoot | null): boolean => {\n if (message.command === 'license-check-ok') {\n licenseCheckOk(message.data);\n return true;\n } else if (message.command === 'license-check-failed') {\n licenseCheckFailed(message.data);\n return true;\n } else if (message.command === 'license-check-nokey') {\n showPreTrialSplashScreen(bodyShadowRoot, message.data);\n licenseCheckNoKey(message.data);\n return true;\n } else if (message.command === 'license-pretrial-started') {\n console.debug('Pre-trial period started', message.data);\n window.location.reload();\n return true;\n } else if (message.command === 'license-pretrial-expired') {\n console.debug('Pre-trial period expired', message.data);\n preTrialStartFailed(true, bodyShadowRoot);\n return true;\n } else if (message.command === 'license-pretrial-failed') {\n console.debug('Pre-trial period start failed', message.data);\n preTrialStartFailed(false, bodyShadowRoot);\n return true;\n } else if (message.command === 'license-download-completed') {\n console.debug('License downloaded');\n window.location.reload();\n return true;\n } else if (message.command === 'license-download-started') {\n updateLicenseDownloadStatus('started', bodyShadowRoot);\n return true;\n } else if (message.command === 'license-download-failed') {\n updateLicenseDownloadStatus('failed', bodyShadowRoot);\n return true;\n }\n return false;\n};\n\nexport const startPreTrial = () => {\n (window as any).Vaadin.devTools.startPreTrial();\n};\nexport const tryAcquireLicense = () => {\n const products = Object.values(productMissingLicense);\n if (products.length > 0) {\n (window as any).Vaadin.devTools.downloadLicense(products[0].product);\n }\n};\n\nexport const licenseInit = () => {\n // Process already registered elements\n (window as any).Vaadin.devTools.createdCvdlElements.forEach((element: Element) => {\n checkLicenseIfNeeded(element);\n });\n\n // Handle new elements directly\n (window as any).Vaadin.devTools.createdCvdlElements = {\n push: (element: Element) => {\n checkLicenseIfNeeded(element);\n }\n };\n};\n","export enum ConnectionStatus {\n ACTIVE = 'active',\n INACTIVE = 'inactive',\n UNAVAILABLE = 'unavailable',\n ERROR = 'error'\n}\n\nexport abstract class Connection {\n static HEARTBEAT_INTERVAL = 180000;\n\n status: ConnectionStatus = ConnectionStatus.UNAVAILABLE;\n onHandshake() {\n // Intentionally empty\n }\n\n onConnectionError(_: string) {\n // Intentionally empty\n }\n\n onStatusChange(_: ConnectionStatus) {\n // Intentionally empty\n }\n\n setActive(yes: boolean) {\n if (!yes && this.status === ConnectionStatus.ACTIVE) {\n this.setStatus(ConnectionStatus.INACTIVE);\n } else if (yes && this.status === ConnectionStatus.INACTIVE) {\n this.setStatus(ConnectionStatus.ACTIVE);\n }\n }\n\n setStatus(status: ConnectionStatus) {\n if (this.status !== status) {\n this.status = status;\n this.onStatusChange(status);\n }\n }\n}\n","import { Connection, ConnectionStatus } from './connection.js';\n\nexport class LiveReloadConnection extends Connection {\n webSocket?: WebSocket;\n\n constructor(url: string) {\n super();\n this.webSocket = new WebSocket(url);\n this.webSocket.onmessage = (msg) => this.handleMessage(msg);\n this.webSocket.onerror = (err) => this.handleError(err);\n this.webSocket.onclose = (_) => {\n if (this.status !== ConnectionStatus.ERROR) {\n this.setStatus(ConnectionStatus.UNAVAILABLE);\n }\n this.webSocket = undefined;\n };\n\n setInterval(() => {\n if (this.webSocket && self.status !== ConnectionStatus.ERROR && this.status !== ConnectionStatus.UNAVAILABLE) {\n this.webSocket.send('');\n }\n }, Connection.HEARTBEAT_INTERVAL);\n }\n\n onReload(_strategy: string) {\n // Intentionally empty\n }\n\n handleMessage(msg: any) {\n let json;\n\n try {\n json = JSON.parse(msg.data);\n } catch (e: any) {\n this.handleError(`[${e.name}: ${e.message}`);\n return;\n }\n if (json.command === 'hello') {\n this.setStatus(ConnectionStatus.ACTIVE);\n this.onHandshake();\n } else if (json.command === 'reload') {\n if (this.status === ConnectionStatus.ACTIVE) {\n const strategy = json.strategy || 'reload';\n this.onReload(strategy);\n }\n } else {\n this.handleError(`Unknown message from the livereload server: ${msg}`);\n }\n }\n\n handleError(msg: any) {\n // eslint-disable-next-line no-console\n console.error(msg);\n this.setStatus(ConnectionStatus.ERROR);\n if (msg instanceof Event && this.webSocket) {\n this.onConnectionError(`Error in WebSocket connection to ${this.webSocket.url}`);\n } else {\n this.onConnectionError(msg);\n }\n }\n}\n","import { Connection, ConnectionStatus } from './connection';\n\nconst WEBSOCKET_FRAGMENT_SIZE = 16384; // This is PushConstants.WEBSOCKET_FRAGMENT_SIZE\n\nexport class WebSocketConnection extends Connection {\n static HEARTBEAT_INTERVAL = 180000;\n\n socket?: any;\n canSend = false;\n\n constructor(url: string) {\n super();\n if (!url) {\n return;\n }\n\n const config = {\n transport: 'websocket',\n fallbackTransport: 'websocket',\n url,\n contentType: 'application/json; charset=UTF-8',\n reconnectInterval: 5000,\n timeout: -1,\n maxReconnectOnClose: 10000000,\n trackMessageLength: true,\n enableProtocol: true,\n handleOnlineOffline: false,\n executeCallbackBeforeReconnect: true,\n messageDelimiter: '|',\n onMessage: (response: any) => {\n const message = { data: response.responseBody };\n this.handleMessage(message);\n },\n onError: (response: any) => {\n this.canSend = false;\n this.handleError(response);\n },\n onOpen: () => {\n this.canSend = true;\n },\n onClose: () => {\n this.canSend = false;\n },\n onClientTimeout: () => {\n this.canSend = false;\n },\n onReconnect: () => {\n this.canSend = false;\n },\n onReopen: () => {\n this.canSend = true;\n }\n };\n\n waitForPush().then((atmosphere) => {\n this.socket = atmosphere.subscribe(config);\n });\n }\n\n onReload(_strategy: string) {\n // Intentionally empty\n }\n\n onUpdate(_path: string, _content: string) {\n // Intentionally empty\n }\n\n onMessage(_message: any) {}\n\n handleMessage(msg: any) {\n let json;\n\n try {\n json = JSON.parse(msg.data);\n } catch (e: any) {\n this.handleError(`[${e.name}: ${e.message}`);\n return;\n }\n if (json.command === 'hello') {\n this.setStatus(ConnectionStatus.ACTIVE);\n this.onHandshake();\n } else if (json.command === 'reload') {\n if (this.status === ConnectionStatus.ACTIVE) {\n const strategy = json.strategy || 'reload';\n this.onReload(strategy);\n }\n } else if (json.command === 'update') {\n if (this.status === ConnectionStatus.ACTIVE) {\n this.onUpdate(json.path, json.content);\n }\n } else {\n this.onMessage(json);\n }\n }\n\n handleError(msg: any) {\n // eslint-disable-next-line no-console\n console.error(msg);\n this.setStatus(ConnectionStatus.ERROR);\n this.onConnectionError(msg);\n }\n\n public send(command: string, data: any) {\n if (!this.socket || !this.canSend) {\n waitFor(\n () => this.socket && this.canSend,\n (_atmosphere) => this.send(command, data)\n );\n return;\n }\n\n const message = JSON.stringify({ command, data });\n const payload = message.length + '|' + message;\n\n let remaining = payload;\n while (remaining.length) {\n this.socket.push(remaining.substring(0, WEBSOCKET_FRAGMENT_SIZE));\n remaining = remaining.substring(WEBSOCKET_FRAGMENT_SIZE);\n }\n }\n}\n\nfunction waitFor(check: () => T | undefined, callback: (value: T) => void) {\n const value = check();\n if (value) {\n callback(value);\n } else {\n setTimeout(() => waitFor(check, callback), 50);\n }\n}\n\nfunction waitForPush(): Promise {\n // Wait for window.vaadinPush.atmosphere to be defined and return it\n return new Promise((resolve, _reject) => {\n waitFor(() => (window as any)?.vaadinPush?.atmosphere, resolve);\n });\n}\n","import { css, html, LitElement } from 'lit';\nimport { customElement, property, query, state } from 'lit/decorators.js';\nimport { handleLicenseMessage, licenseCheckOk, licenseInit, Product } from './License';\nimport { ConnectionStatus } from './connection';\nimport { LiveReloadConnection } from './live-reload-connection';\nimport { WebSocketConnection } from './websocket-connection';\nimport { preTrialStartFailed, updateLicenseDownloadStatus } from './pre-trial-splash-screen';\n\n/**\n * Plugin API for the dev tools window.\n */\nexport interface DevToolsInterface {\n send(command: string, data: any): void;\n}\n\nexport interface MessageHandler {\n handleMessage(message: ServerMessage): boolean;\n}\n\nexport interface ServerMessage {\n /**\n * The command\n */\n command: string;\n /**\n * the data for the command\n */\n data: any;\n}\n\n/**\n * To create and register a plugin, use e.g.\n * @example\n * export class MyTab extends LitElement implements MessageHandler {\n * render() {\n * return html`
    Here I am
    `;\n * }\n * }\n * customElements.define('my-tab', MyTab);\n *\n * const plugin: DevToolsPlugin = {\n * init: function (devToolsInterface: DevToolsInterface): void {\n * devToolsInterface.addTab('Tab title', 'my-tab')\n * }\n * };\n *\n * (window as any).Vaadin.devToolsPlugins.push(plugin);\n */\nexport interface DevToolsPlugin {\n /**\n * Called once to initialize the plugin.\n *\n * @param devToolsInterface provides methods to interact with the dev tools\n */\n init(devToolsInterface: DevToolsInterface): void;\n}\n\nexport enum MessageType {\n LOG = 'log',\n INFORMATION = 'information',\n WARNING = 'warning',\n ERROR = 'error'\n}\n\ninterface Message {\n id: number;\n type: MessageType;\n message: string;\n details?: string;\n link?: string;\n persistentId?: string;\n dontShowAgain: boolean;\n dontShowAgainMessage?: string;\n deleted: boolean;\n}\n\ntype DevToolsConf = {\n enable: boolean;\n url: string;\n contextRelativePath: string;\n backend?: string;\n liveReloadPort?: number;\n token?: string;\n usageStatisticsEnabled?: boolean;\n};\n\n// @ts-ignore\nconst hmrClient: any = import.meta.hot ? import.meta.hot.hmrClient : undefined;\n\n@customElement('vaadin-dev-tools')\nexport class VaadinDevTools extends LitElement {\n unhandledMessages: ServerMessage[] = [];\n conf: DevToolsConf = { enable: false, url: '', contextRelativePath: '', liveReloadPort: -1 };\n bodyShadowRoot: ShadowRoot | null = null;\n\n static get styles() {\n return [\n css`\n :host {\n --dev-tools-font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen-Sans, Ubuntu, Cantarell,\n 'Helvetica Neue', sans-serif;\n --dev-tools-font-family-monospace: SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New',\n monospace;\n\n --dev-tools-font-size: 0.8125rem;\n --dev-tools-font-size-small: 0.75rem;\n\n --dev-tools-text-color: rgba(255, 255, 255, 0.8);\n --dev-tools-text-color-secondary: rgba(255, 255, 255, 0.65);\n --dev-tools-text-color-emphasis: rgba(255, 255, 255, 0.95);\n --dev-tools-text-color-active: rgba(255, 255, 255, 1);\n\n --dev-tools-background-color-inactive: rgba(45, 45, 45, 0.25);\n --dev-tools-background-color-active: rgba(45, 45, 45, 0.98);\n --dev-tools-background-color-active-blurred: rgba(45, 45, 45, 0.85);\n\n --dev-tools-border-radius: 0.5rem;\n --dev-tools-box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.05), 0 4px 12px -2px rgba(0, 0, 0, 0.4);\n\n --dev-tools-blue-hsl: 206, 100%, 70%;\n --dev-tools-blue-color: hsl(var(--dev-tools-blue-hsl));\n --dev-tools-green-hsl: 145, 80%, 42%;\n --dev-tools-green-color: hsl(var(--dev-tools-green-hsl));\n --dev-tools-grey-hsl: 0, 0%, 50%;\n --dev-tools-grey-color: hsl(var(--dev-tools-grey-hsl));\n --dev-tools-yellow-hsl: 38, 98%, 64%;\n --dev-tools-yellow-color: hsl(var(--dev-tools-yellow-hsl));\n --dev-tools-red-hsl: 355, 100%, 68%;\n --dev-tools-red-color: hsl(var(--dev-tools-red-hsl));\n\n /* Needs to be in ms, used in JavaScript as well */\n --dev-tools-transition-duration: 180ms;\n\n all: initial;\n\n direction: ltr;\n cursor: default;\n font: normal 400 var(--dev-tools-font-size) / 1.125rem var(--dev-tools-font-family);\n color: var(--dev-tools-text-color);\n -webkit-user-select: none;\n -moz-user-select: none;\n user-select: none;\n color-scheme: dark;\n\n position: fixed;\n z-index: 20000;\n pointer-events: none;\n bottom: 0;\n right: 0;\n width: 100%;\n height: 100%;\n display: flex;\n flex-direction: column-reverse;\n align-items: flex-end;\n }\n\n .dev-tools {\n pointer-events: auto;\n display: flex;\n align-items: center;\n position: fixed;\n z-index: inherit;\n right: 0.5rem;\n bottom: 0.5rem;\n min-width: 1.75rem;\n height: 1.75rem;\n max-width: 1.75rem;\n border-radius: 0.5rem;\n padding: 0.375rem;\n box-sizing: border-box;\n background-color: var(--dev-tools-background-color-inactive);\n box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.05);\n color: var(--dev-tools-text-color);\n transition: var(--dev-tools-transition-duration);\n white-space: nowrap;\n line-height: 1rem;\n }\n\n .dev-tools:hover,\n .dev-tools.active {\n background-color: var(--dev-tools-background-color-active);\n box-shadow: var(--dev-tools-box-shadow);\n }\n\n .dev-tools.active {\n max-width: calc(100% - 1rem);\n }\n\n .dev-tools .status-description {\n overflow: hidden;\n text-overflow: ellipsis;\n padding: 0 0.25rem;\n }\n\n .dev-tools.error {\n background-color: hsla(var(--dev-tools-red-hsl), 0.15);\n animation: bounce 0.5s;\n animation-iteration-count: 2;\n }\n\n .window.hidden {\n opacity: 0;\n transform: scale(0);\n position: absolute;\n }\n\n .window.visible {\n transform: none;\n opacity: 1;\n pointer-events: auto;\n }\n\n .window.visible ~ .dev-tools {\n opacity: 0;\n pointer-events: none;\n }\n\n .window.visible ~ .dev-tools .dev-tools-icon,\n .window.visible ~ .dev-tools .status-blip {\n transition: none;\n opacity: 0;\n }\n\n .window {\n border-radius: var(--dev-tools-border-radius);\n overflow: auto;\n margin: 0.5rem;\n min-width: 30rem;\n max-width: calc(100% - 1rem);\n max-height: calc(100vh - 1rem);\n flex-shrink: 1;\n background-color: var(--dev-tools-background-color-active);\n color: var(--dev-tools-text-color);\n transition: var(--dev-tools-transition-duration);\n transform-origin: bottom right;\n display: flex;\n flex-direction: column;\n box-shadow: var(--dev-tools-box-shadow);\n outline: none;\n }\n\n .window-toolbar {\n display: flex;\n flex: none;\n align-items: center;\n padding: 0.375rem;\n white-space: nowrap;\n order: 1;\n background-color: rgba(0, 0, 0, 0.2);\n gap: 0.5rem;\n }\n\n .ahreflike {\n font-weight: 500;\n color: var(--dev-tools-text-color-secondary);\n text-decoration: underline;\n cursor: pointer;\n }\n\n .ahreflike:hover {\n color: var(--dev-tools-text-color-emphasis);\n }\n\n .button {\n all: initial;\n font-family: inherit;\n font-size: var(--dev-tools-font-size-small);\n line-height: 1;\n white-space: nowrap;\n background-color: rgba(0, 0, 0, 0.2);\n color: inherit;\n font-weight: 600;\n padding: 0.25rem 0.375rem;\n border-radius: 0.25rem;\n }\n\n .button:focus,\n .button:hover {\n color: var(--dev-tools-text-color-emphasis);\n }\n\n .message.information {\n --dev-tools-notification-color: var(--dev-tools-blue-color);\n }\n\n .message.warning {\n --dev-tools-notification-color: var(--dev-tools-yellow-color);\n }\n\n .message.error {\n --dev-tools-notification-color: var(--dev-tools-red-color);\n }\n\n .message {\n display: flex;\n padding: 0.1875rem 0.75rem 0.1875rem 2rem;\n background-clip: padding-box;\n }\n\n .message.log {\n padding-left: 0.75rem;\n }\n\n .message-content {\n margin-right: 0.5rem;\n -webkit-user-select: text;\n -moz-user-select: text;\n user-select: text;\n }\n\n .message-heading {\n position: relative;\n display: flex;\n align-items: center;\n margin: 0.125rem 0;\n }\n\n .message.log {\n color: var(--dev-tools-text-color-secondary);\n }\n\n .message:not(.log) .message-heading {\n font-weight: 500;\n }\n\n .message.has-details .message-heading {\n color: var(--dev-tools-text-color-emphasis);\n font-weight: 600;\n }\n\n .message-heading::before {\n position: absolute;\n margin-left: -1.5rem;\n display: inline-block;\n text-align: center;\n font-size: 0.875em;\n font-weight: 600;\n line-height: calc(1.25em - 2px);\n width: 14px;\n height: 14px;\n box-sizing: border-box;\n border: 1px solid transparent;\n border-radius: 50%;\n }\n\n .message.information .message-heading::before {\n content: 'i';\n border-color: currentColor;\n color: var(--dev-tools-notification-color);\n }\n\n .message.warning .message-heading::before,\n .message.error .message-heading::before {\n content: '!';\n color: var(--dev-tools-background-color-active);\n background-color: var(--dev-tools-notification-color);\n }\n\n .features-tray {\n padding: 0.75rem;\n flex: auto;\n overflow: auto;\n animation: fade-in var(--dev-tools-transition-duration) ease-in;\n user-select: text;\n }\n\n .features-tray p {\n margin-top: 0;\n color: var(--dev-tools-text-color-secondary);\n }\n\n .features-tray .feature {\n display: flex;\n align-items: center;\n gap: 1rem;\n padding-bottom: 0.5em;\n }\n\n .message .message-details {\n font-weight: 400;\n color: var(--dev-tools-text-color-secondary);\n margin: 0.25rem 0;\n }\n\n .message .message-details[hidden] {\n display: none;\n }\n\n .message .message-details p {\n display: inline;\n margin: 0;\n margin-right: 0.375em;\n word-break: break-word;\n }\n\n .message .persist {\n color: var(--dev-tools-text-color-secondary);\n white-space: nowrap;\n margin: 0.375rem 0;\n display: flex;\n align-items: center;\n position: relative;\n -webkit-user-select: none;\n -moz-user-select: none;\n user-select: none;\n }\n\n .message .persist::before {\n content: '';\n width: 1em;\n height: 1em;\n border-radius: 0.2em;\n margin-right: 0.375em;\n background-color: rgba(255, 255, 255, 0.3);\n }\n\n .message .persist:hover::before {\n background-color: rgba(255, 255, 255, 0.4);\n }\n\n .message .persist.on::before {\n background-color: rgba(255, 255, 255, 0.9);\n }\n\n .message .persist.on::after {\n content: '';\n order: -1;\n position: absolute;\n width: 0.75em;\n height: 0.25em;\n border: 2px solid var(--dev-tools-background-color-active);\n border-width: 0 0 2px 2px;\n transform: translate(0.05em, -0.05em) rotate(-45deg) scale(0.8, 0.9);\n }\n\n .message .dismiss-message {\n font-weight: 600;\n align-self: stretch;\n display: flex;\n align-items: center;\n padding: 0 0.25rem;\n margin-left: 0.5rem;\n color: var(--dev-tools-text-color-secondary);\n }\n\n .message .dismiss-message:hover {\n color: var(--dev-tools-text-color);\n }\n\n .notification-tray {\n display: flex;\n flex-direction: column-reverse;\n align-items: flex-end;\n margin: 0.5rem;\n flex: none;\n }\n\n .window.hidden + .notification-tray {\n margin-bottom: 3rem;\n }\n\n .notification-tray .message {\n pointer-events: auto;\n background-color: var(--dev-tools-background-color-active);\n color: var(--dev-tools-text-color);\n max-width: 30rem;\n box-sizing: border-box;\n border-radius: var(--dev-tools-border-radius);\n margin-top: 0.5rem;\n transition: var(--dev-tools-transition-duration);\n transform-origin: bottom right;\n animation: slideIn var(--dev-tools-transition-duration);\n box-shadow: var(--dev-tools-box-shadow);\n padding-top: 0.25rem;\n padding-bottom: 0.25rem;\n }\n\n .notification-tray .message.animate-out {\n animation: slideOut forwards var(--dev-tools-transition-duration);\n }\n\n .notification-tray .message .message-details {\n max-height: 10em;\n overflow: hidden;\n }\n\n .message-tray {\n flex: auto;\n overflow: auto;\n max-height: 20rem;\n user-select: text;\n }\n\n .message-tray .message {\n animation: fade-in var(--dev-tools-transition-duration) ease-in;\n padding-left: 2.25rem;\n }\n\n .message-tray .message.warning {\n background-color: hsla(var(--dev-tools-yellow-hsl), 0.09);\n }\n\n .message-tray .message.error {\n background-color: hsla(var(--dev-tools-red-hsl), 0.09);\n }\n\n .message-tray .message.error .message-heading {\n color: hsl(var(--dev-tools-red-hsl));\n }\n\n .message-tray .message.warning .message-heading {\n color: hsl(var(--dev-tools-yellow-hsl));\n }\n\n .message-tray .message + .message {\n border-top: 1px solid rgba(255, 255, 255, 0.07);\n }\n\n .message-tray .dismiss-message,\n .message-tray .persist {\n display: none;\n }\n\n @keyframes slideIn {\n from {\n transform: translateX(100%);\n opacity: 0;\n }\n to {\n transform: translateX(0%);\n opacity: 1;\n }\n }\n\n @keyframes slideOut {\n from {\n transform: translateX(0%);\n opacity: 1;\n }\n to {\n transform: translateX(100%);\n opacity: 0;\n }\n }\n\n @keyframes fade-in {\n 0% {\n opacity: 0;\n }\n }\n\n @keyframes bounce {\n 0% {\n transform: scale(0.8);\n }\n 50% {\n transform: scale(1.5);\n background-color: hsla(var(--dev-tools-red-hsl), 1);\n }\n 100% {\n transform: scale(1);\n }\n }\n\n @supports (backdrop-filter: blur(1px)) {\n .dev-tools,\n .window,\n .notification-tray .message {\n backdrop-filter: blur(8px);\n }\n\n .dev-tools:hover,\n .dev-tools.active,\n .window,\n .notification-tray .message {\n background-color: var(--dev-tools-background-color-active-blurred);\n }\n }\n `\n ];\n }\n\n static DISMISSED_NOTIFICATIONS_IN_LOCAL_STORAGE = 'vaadin.live-reload.dismissedNotifications';\n static ACTIVE_KEY_IN_SESSION_STORAGE = 'vaadin.live-reload.active';\n static TRIGGERED_KEY_IN_SESSION_STORAGE = 'vaadin.live-reload.triggered';\n static TRIGGERED_COUNT_KEY_IN_SESSION_STORAGE = 'vaadin.live-reload.triggeredCount';\n\n static AUTO_DEMOTE_NOTIFICATION_DELAY = 5000;\n\n static HOTSWAP_AGENT = 'HOTSWAP_AGENT';\n static JREBEL = 'JREBEL';\n static SPRING_BOOT_DEVTOOLS = 'SPRING_BOOT_DEVTOOLS';\n static BACKEND_DISPLAY_NAME: Record = {\n HOTSWAP_AGENT: 'HotswapAgent',\n JREBEL: 'JRebel',\n SPRING_BOOT_DEVTOOLS: 'Spring Boot Devtools'\n };\n\n static get isActive() {\n const active = window.sessionStorage.getItem(VaadinDevTools.ACTIVE_KEY_IN_SESSION_STORAGE);\n return active === null || active !== 'false';\n }\n\n @property({ type: String, attribute: false })\n frontendStatus: ConnectionStatus = ConnectionStatus.UNAVAILABLE;\n\n @property({ type: String, attribute: false })\n javaStatus: ConnectionStatus = ConnectionStatus.UNAVAILABLE;\n\n @query('.window')\n private root!: HTMLElement;\n\n @state()\n componentPickActive: boolean = false;\n\n private javaConnection?: LiveReloadConnection;\n private frontendConnection?: WebSocketConnection;\n\n private nextMessageId: number = 1;\n\n private transitionDuration: number = 0;\n\n elementTelemetry() {\n let data = {};\n try {\n // localstorage data is collected by vaadin-usage-statistics.js\n const localStorageStatsString = localStorage.getItem('vaadin.statistics.basket');\n if (!localStorageStatsString) {\n // Do not send empty data\n return;\n }\n data = JSON.parse(localStorageStatsString);\n } catch (e) {\n // In case of parse errors don't send anything\n return;\n }\n\n if (this.frontendConnection) {\n this.frontendConnection.send('reportTelemetry', { browserData: data });\n }\n }\n\n openWebSocketConnection() {\n this.frontendStatus = ConnectionStatus.UNAVAILABLE;\n this.javaStatus = ConnectionStatus.UNAVAILABLE;\n if (!this.conf.token) {\n console.error(\n 'Dev tools functionality denied for this host. See Vaadin documentation on how to configure devmode.hostsAllowed property: https://vaadin.com/docs/latest/configuration/properties#properties'\n );\n return;\n }\n const onConnectionError = (msg: string) => console.error(msg);\n const onReload = (strategy: string = 'reload') => {\n if (strategy === 'refresh' || strategy === 'full-refresh') {\n const anyVaadin = window.Vaadin as any;\n // TODO: do it in Flow client. Maybe raise a custom vaadin-refresh-ui event\n // and handle it in Flow client?\n Object.keys(anyVaadin.Flow.clients)\n .filter((key) => key !== 'TypeScript')\n .map((id) => anyVaadin.Flow.clients[id])\n .forEach((client) => {\n if (client.sendEventMessage) {\n client.sendEventMessage(1, 'ui-refresh', {\n fullRefresh: strategy === 'full-refresh'\n });\n } else {\n console.warn('Ignoring ui-refresh event for application ', id);\n }\n });\n } else {\n const lastReload = window.sessionStorage.getItem(VaadinDevTools.TRIGGERED_COUNT_KEY_IN_SESSION_STORAGE);\n const nextReload = lastReload ? parseInt(lastReload, 10) + 1 : 1;\n window.sessionStorage.setItem(VaadinDevTools.TRIGGERED_COUNT_KEY_IN_SESSION_STORAGE, nextReload.toString());\n window.sessionStorage.setItem(VaadinDevTools.TRIGGERED_KEY_IN_SESSION_STORAGE, 'true');\n window.location.reload();\n }\n };\n const onUpdate = (path: string, content: string) => {\n const contextPathProtocol = 'context://';\n const pathWithNoProtocol = path.substring(contextPathProtocol.length);\n if (path.startsWith(contextPathProtocol)) {\n path = this.conf.contextRelativePath + pathWithNoProtocol;\n }\n\n if (content) {\n // change or add a new stylesheet\n let styleTag = document.head.querySelector(`style[data-file-path='${path}']`) as HTMLStyleElement | null;\n if (!styleTag) {\n styleTag = document.createElement('style');\n styleTag.setAttribute('data-file-path', path);\n document.head.appendChild(styleTag);\n this.removeOldLinks(pathWithNoProtocol);\n }\n styleTag.textContent = content;\n document.dispatchEvent(new CustomEvent('vaadin-theme-updated'));\n } else if (content === '' || content === null) {\n // remove inlined stylesheets or initial links with the given path\n const styleTag = document.head.querySelector(`style[data-file-path='${path}']`) as HTMLStyleElement | null;\n if (styleTag) {\n styleTag.remove();\n } else {\n this.removeOldLinks(pathWithNoProtocol);\n }\n document.dispatchEvent(new CustomEvent('vaadin-theme-updated'));\n }\n };\n\n const frontendConnection = new WebSocketConnection(this.getDedicatedWebSocketUrl());\n frontendConnection.onHandshake = () => {\n if (!VaadinDevTools.isActive) {\n frontendConnection.setActive(false);\n }\n if (this.conf.usageStatisticsEnabled === false) {\n localStorage.setItem('vaadin.statistics.optout', 'true');\n localStorage.removeItem('vaadin.statistics.basket');\n localStorage.removeItem('vaadin.statistics.firstuse');\n } else {\n localStorage.removeItem('vaadin.statistics.optout');\n }\n this.elementTelemetry();\n };\n frontendConnection.onConnectionError = onConnectionError;\n frontendConnection.onReload = onReload;\n frontendConnection.onUpdate = onUpdate;\n frontendConnection.onStatusChange = (status: ConnectionStatus) => {\n this.frontendStatus = status;\n };\n frontendConnection.onMessage = (message: any) => this.handleFrontendMessage(message);\n this.frontendConnection = frontendConnection;\n\n if (this.conf.backend === VaadinDevTools.SPRING_BOOT_DEVTOOLS && this.conf.liveReloadPort) {\n this.javaConnection = new LiveReloadConnection(this.getSpringBootWebSocketUrl(window.location));\n this.javaConnection.onHandshake = () => {\n if (!VaadinDevTools.isActive) {\n this.javaConnection!.setActive(false);\n }\n };\n this.javaConnection.onReload = onReload;\n this.javaConnection.onConnectionError = onConnectionError;\n this.javaConnection.onStatusChange = (status) => {\n this.javaStatus = status;\n };\n }\n }\n\n removeOldLinks(path: string) {\n // removes initially added links that are outdated after hot-reload and replaced by inlined styles\n const links = Array.from(document.head.querySelectorAll('link[rel=\"stylesheet\"]')) as HTMLLinkElement[];\n links.forEach((link) => {\n let filePath = link.getAttribute('data-file-path') || link.getAttribute('href');\n if (filePath && filePath.includes(path)) {\n link.remove();\n }\n });\n }\n\n tabHandleMessage(tabElement: HTMLElement, message: ServerMessage): boolean {\n const handler = tabElement as any as MessageHandler;\n return handler.handleMessage && handler.handleMessage.call(tabElement, message);\n }\n\n handleFrontendMessage(message: ServerMessage) {\n if (message.command === 'featureFlags') {\n } else if (handleLicenseMessage(message, this.bodyShadowRoot) || this.handleHmrMessage(message)) {\n } else {\n this.unhandledMessages.push(message);\n }\n }\n\n handleHmrMessage(message: ServerMessage): boolean {\n if (message.command !== 'hmr') {\n return false;\n }\n if (hmrClient) {\n hmrClient.notifyListeners(message.data.event, message.data.eventData);\n }\n return true;\n }\n\n getDedicatedWebSocketUrl(): string | undefined {\n function getAbsoluteUrl(relative: string) {\n // Use innerHTML to obtain an absolute URL\n const div = document.createElement('div');\n div.innerHTML = ``;\n return (div.firstChild as HTMLLinkElement).href;\n }\n\n if (this.conf.url === undefined) {\n return undefined;\n }\n const connectionBaseUrl = getAbsoluteUrl(this.conf.url!);\n\n if (!connectionBaseUrl.startsWith('http://') && !connectionBaseUrl.startsWith('https://')) {\n // eslint-disable-next-line no-console\n console.error('The protocol of the url should be http or https for live reload to work.');\n return undefined;\n }\n return `${connectionBaseUrl}?v-r=push&debug_window&token=${this.conf.token}`;\n }\n\n getSpringBootWebSocketUrl(location: any) {\n const { hostname } = location;\n const wsProtocol = location.protocol === 'https:' ? 'wss' : 'ws';\n if (hostname.endsWith('gitpod.io')) {\n // Gitpod uses `port-url` instead of `url:port`\n const hostnameWithoutPort = hostname.replace(/.*?-/, '');\n return `${wsProtocol}://${this.conf.liveReloadPort}-${hostnameWithoutPort}`;\n } else {\n return `${wsProtocol}://${hostname}:${this.conf.liveReloadPort}`;\n }\n }\n\n connectedCallback() {\n super.connectedCallback();\n\n this.bodyShadowRoot = document.body.attachShadow({ mode: 'closed' });\n this.bodyShadowRoot.innerHTML = '';\n\n this.conf = (window.Vaadin as any).devToolsConf || this.conf;\n\n const lastReload = window.sessionStorage.getItem(VaadinDevTools.TRIGGERED_KEY_IN_SESSION_STORAGE);\n if (lastReload) {\n const now = new Date();\n const reloaded = `${`0${now.getHours()}`.slice(-2)}:${`0${now.getMinutes()}`.slice(\n -2\n )}:${`0${now.getSeconds()}`.slice(-2)}`;\n window.sessionStorage.removeItem(VaadinDevTools.TRIGGERED_KEY_IN_SESSION_STORAGE);\n }\n\n this.transitionDuration = parseInt(\n window.getComputedStyle(this).getPropertyValue('--dev-tools-transition-duration'),\n 10\n );\n\n const windowAny = window as any;\n windowAny.Vaadin = windowAny.Vaadin || {};\n windowAny.Vaadin.devTools = Object.assign(this, windowAny.Vaadin.devTools);\n\n const anyVaadin = window.Vaadin as any;\n if (anyVaadin.devToolsPlugins) {\n Array.from(anyVaadin.devToolsPlugins as DevToolsPlugin[]).forEach((plugin) => this.initPlugin(plugin));\n anyVaadin.devToolsPlugins = { push: (plugin: DevToolsPlugin) => this.initPlugin(plugin) };\n }\n\n this.openWebSocketConnection();\n licenseInit();\n }\n\n async initPlugin(plugin: DevToolsPlugin) {\n const devTools = this;\n plugin.init({\n send: function (command: string, data: any): void {\n devTools.frontendConnection!.send(command, data);\n }\n });\n }\n\n format(o: any): string {\n return o.toString();\n }\n\n checkLicense(productInfo: Product) {\n if (this.frontendConnection) {\n this.frontendConnection.send('checkLicense', productInfo);\n } else {\n licenseCheckOk(productInfo);\n }\n }\n\n startPreTrial() {\n if (this.frontendConnection) {\n this.frontendConnection.send('startPreTrialLicense', {});\n } else {\n console.error('Cannot start pre-trial: no connection');\n preTrialStartFailed(false, this.bodyShadowRoot);\n }\n }\n\n downloadLicense(productInfo: Product) {\n if (this.frontendConnection) {\n this.frontendConnection.send('downloadLicense', productInfo);\n } else {\n updateLicenseDownloadStatus('failed', this.bodyShadowRoot);\n }\n }\n\n setActive(yes: boolean) {\n this.frontendConnection?.setActive(yes);\n this.javaConnection?.setActive(yes);\n window.sessionStorage.setItem(VaadinDevTools.ACTIVE_KEY_IN_SESSION_STORAGE, yes ? 'true' : 'false');\n }\n\n /* eslint-disable lit/no-template-map */\n render() {\n return html`
    `;\n }\n\n setJavaLiveReloadActive(active: boolean) {\n // Java reload either goes through the direct connection to live reload, or then through the shared websocket connection\n if (this.javaConnection) {\n this.javaConnection.setActive(active);\n } else {\n this.frontendConnection?.setActive(active);\n }\n }\n}\n"],"names":["__decorate","decorators","target","key","desc","c","d","i","PreTrial","#parentObserver","#shadowRoot","#trialExpired","#startFailed","#licenseDownloadStatus","commonStyles","name","oldValue","newValue","value","expired","originalRemove","currentParent","mutations","mutation","node","_value","maybeParentNode","products","splashScreen","primaryButtonClickListener","event","tryAcquireLicense","startPreTrial","secondaryButtonClickListener","showPreTrialSplashScreen","shadowRoot","message","expiredPreTrial","preTrialElement","productsDiv","preTrialStartFailed","updateLicenseDownloadStatus","action","noLicenseFallbackTimeout","findAll","element","tags","lightDom","shadowDom","e","licenseCheckListener","showNoLicenseFallback","productAndMessage","overlay","defaultSlot","htmlMessage","productTagNames","productChecking","productMissingLicense","productCheckOk","product","checkLicenseIfNeeded","cvdlElement","cvdlName","version","tagName","failedLicenseCheck","licenseCheckOk","data","licenseCheckFailed","productName","licenseCheckNoKey","keyUrl","handleLicenseMessage","bodyShadowRoot","licenseInit","ConnectionStatus","_Connection","_","yes","status","Connection","LiveReloadConnection","url","msg","err","_strategy","json","strategy","WEBSOCKET_FRAGMENT_SIZE","_WebSocketConnection","config","response","waitForPush","atmosphere","_path","_content","_message","command","waitFor","_atmosphere","remaining","WebSocketConnection","check","callback","resolve","_reject","MessageType","hmrClient","VaadinDevTools","_a","LitElement","css","active","VaadinDevTools_1","localStorageStatsString","onConnectionError","onReload","anyVaadin","id","client","lastReload","nextReload","onUpdate","path","content","contextPathProtocol","pathWithNoProtocol","styleTag","frontendConnection","link","filePath","tabElement","handler","getAbsoluteUrl","relative","div","connectionBaseUrl","location","hostname","wsProtocol","hostnameWithoutPort","now","windowAny","plugin","devTools","o","productInfo","html","property","query","state","customElement"],"mappings":"0IAsDO,SAASA,EAAWC,EAAYC,EAAQC,EAAKC,EAAM,CACxD,IAAIC,EAAI,UAAU,OAAQ,EAAIA,EAAI,EAAIH,EAASE,IAAS,KAAOA,EAAO,OAAO,yBAAyBF,EAAQC,CAAG,EAAIC,EAAME,EAC3H,GAAI,OAAO,SAAY,UAAY,OAAO,QAAQ,UAAa,WAAY,EAAI,QAAQ,SAASL,EAAYC,EAAQC,EAAKC,CAAI,MACxH,SAASG,EAAIN,EAAW,OAAS,EAAGM,GAAK,EAAGA,KAASD,EAAIL,EAAWM,CAAC,KAAG,GAAKF,EAAI,EAAIC,EAAE,CAAC,EAAID,EAAI,EAAIC,EAAEJ,EAAQC,EAAK,CAAC,EAAIG,EAAEJ,EAAQC,CAAG,IAAM,GAChJ,OAAOE,EAAI,GAAK,GAAK,OAAO,eAAeH,EAAQC,EAAK,CAAC,EAAG,CAC9D,CCzDA,MAAMK,UAAiB,WAAW,CAChCC,GACAC,GACAC,GACAC,GACAC,GAGA,aAAA,CACE,MAAA,EAEA,KAAKJ,GAAkB,KACvB,KAAKE,GAAgB,GACrB,KAAKC,GAAe,KACpB,KAAKC,GAAyB,KAG9B,KAAKH,GAAc,KAAK,aAAa,CAAE,KAAM,SAAU,EAGvD,KAAK,OAAA,EACL,KAAK,gBAAA,CACP,CAGA,WAAW,oBAAkB,CAC3B,MAAO,CAAC,UAAW,gBAAiB,kBAAkB,CACxD,CAEQ,QAAM,CAEZ,MAAMI,EAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,OA4JrB,KAAKJ,GAAY,UAAY;AAAA,MAC3BI,CAAY;AAAA;AAAA,QAGV,KAAKH,GACD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UA8BF,KAAK,iBAAiB;AAAA,kBACd,KAAKE,KAA2B,UAAY,WAAa,EAAE;AAAA;AAAA;AAAA;AAAA,UAKjE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UAgBF,KAAK,iBAAiB;AAAA,kBACd,KAAKA,KAA2B,UAAY,WAAa,EAAE;AAAA;AAAA;AAAA;AAAA,kBAI3D,KAAKA,KAA2B,UAAY,WAAa,EAAE;AAAA;AAAA;AAAA,SAIvE;AAAA,QAEE,KAAKD,GACD;AAAA;AAAA;AAAA;AAAA,gBAKA,EACN;AAAA,QAEE,KAAKC,KAA2B,UAC5B,0EACA,EACN;AAAA,QAEE,KAAKA,KAA2B,SAC5B,uFACA,EACN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAQoB,KAAKH,GAAY,cAAc,gBAAgB,GACtD,iBAAiB,QAAS,IAAK,CAC5C,KAAK,cACH,IAAI,YAAY,uBAAwB,CACtC,OAAQ,CACN,QAAS,KAAKC,EAAA,CACf,CACF,CAAC,CAEN,CAAC,EACuB,KAAKD,GAAY,cAAc,kBAAkB,GACxD,iBAAiB,QAAS,IAAK,CAC9C,KAAK,cAAc,IAAI,YAAY,wBAAwB,CAAC,CAC9D,CAAC,CACH,CAEQ,iBAAe,CACrB,MAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAgDT,CAEA,mBAAiB,CACf,KAAK,6BAAA,CACP,CAEA,sBAAoB,CAClB,KAAK,QAAA,CACP,CAEA,yBAAyBK,EAAcC,EAAyBC,EAAuB,CACjFF,IAAS,UACX,KAAK,oBAAoBE,IAAa,MAAQA,IAAa,OAAO,EACzDF,IAAS,gBAClB,KAAK,kBAAkBE,IAAa,SAAS,EACpCF,IAAS,oBAClB,KAAK,sBAAsBE,CAAQ,CAEvC,CAEQ,sBAAsBC,EAAoB,CAC5C,KAAKL,KAA2BK,IAClC,KAAKL,GAAyBK,EAC9B,KAAK,OAAA,EAET,CAEQ,oBAAoBA,EAAc,CACpC,KAAKP,KAAkBO,IACzB,KAAKP,GAAgBO,EACrB,KAAK,OAAA,EAET,CAEQ,kBAAkBC,EAAgB,EACpC,KAAKP,KAAiBO,GAAW,KAAKR,KAAkBQ,KAC1D,KAAKR,GAAgBQ,EACrB,KAAKP,GAAe,GACpB,KAAK,OAAA,EAET,CAEQ,iBAAe,CACrB,MAAMQ,EAAiB,QAAQ,UAAU,OACzC,KAAK,OAAS,UAAA,CACZ,QAAQ,MAAM,wDAAwD,EACtE,MAAMC,EAAgB,KAAK,WAE3BD,EAAe,MAAM,KAAM,SAAS,EAEpC,KAAK,oBAAoBC,CAAqB,CAChD,EAGA,KAAK,cAAA,CACP,CAEQ,8BAA4B,CAE9B,CAAC,KAAKZ,IAAmB,KAAK,aAChC,KAAKA,GAAkB,IAAI,iBAAkBa,GAA+B,CAC1EA,EAAU,QAASC,GAA4B,CACzCA,EAAS,OAAS,aACpBA,EAAS,aAAa,QAASC,GAAc,CACvCA,IAAS,OACX,QAAQ,MAAM,8CAA8C,EAC5D,KAAK,oBAAoBD,EAAS,MAAM,EAE5C,CAAC,CAEL,CAAC,CACH,CAAC,EAED,KAAKd,GAAgB,QAAQ,KAAK,WAAY,CAC5C,UAAW,GACX,QAAS,EAAA,CACV,EAEL,CAEQ,eAAa,CAEnB,OAAO,eAAe,KAAM,QAAS,CACnC,KAAG,CAED,MAAO,CAAA,CACT,EACA,IAAIgB,EAA2B,CAE/B,CAAA,CACD,CACH,CAEQ,SAAO,CACT,KAAKhB,IACP,KAAKA,GAAgB,WAAA,CAEzB,CAEQ,oBAAoBiB,EAA4B,CAEjDA,GAIL,WAAW,IAAK,CACd,QAAQ,MAAM,qCAAqC,EACnD,MAAMC,EAAW,KAAK,cAAc,mBAAmB,EAClDD,EAA+B,SAAS,IAAI,GAC9CA,EAAyB,YAAY,IAAI,EAE5C,MAAME,EAAe,SAAS,cAAc,iBAAiB,EACzD,KAAKjB,IACPiB,EAAa,aAAa,UAAW,MAAM,EAEzC,KAAKhB,IACPgB,EAAa,aAAa,gBAAiB,KAAKjB,GAAgB,UAAY,EAAE,EAE5EgB,GACFC,EAAa,YAAYD,EAAS,UAAU,EAAI,CAAC,EAElDD,EAA4B,YAAYE,CAAY,CACvD,EAAG,CAAC,CACN,CACD,CAGD,eAAe,OAAO,kBAAmBpB,CAAQ,EAEjD,SAASqB,EAA2BC,EAAkB,CAChDA,EAAM,OAAO,QACfC,EAAA,EAEAC,EAAA,CAEJ,CAEA,SAASC,GAA4B,CACnCF,EAAA,CACF,CAEO,MAAMG,EAA2B,CAACC,EAA+BC,IAA8B,CACpG,GAAID,GAAc,CAACA,EAAW,cAAc,iBAAiB,EAAG,CAC9D,MAAME,EAAkBD,EAAQ,UAAU,aAAe,UACnDE,EAAkB,SAAS,cAAc,iBAAiB,EAC5DD,GACFC,EAAgB,aAAa,UAAW,EAAE,EAE5C,MAAMC,EAAc,SAAS,cAAc,KAAK,EAChDA,EAAY,aAAa,OAAQ,UAAU,EAC3CA,EAAY,UAAY;AAAA;AAAA;AAAA,cAGdH,EAAQ,QAAQ,IAAI;AAAA;AAAA,MAG9BE,EAAgB,YAAYC,CAAW,EAEvCD,EAAgB,iBAAiB,yBAA0BL,CAA6C,EACxGK,EAAgB,iBAAiB,uBAAwBT,CAA2C,EAEpGM,EAAW,UAAY,gBACvBA,EAAW,YAAYG,CAAe,CACxC,CACF,EACaE,EAAsB,CAACrB,EAAkBgB,IAAiC,CACjFA,GACcA,EAAW,cAAc,iBAAiB,GACjD,aAAa,gBAAiBhB,EAAU,UAAY,EAAE,CAEnE,EACasB,EAA8B,CACzCC,EACAP,IACE,CACEA,GACcA,EAAW,cAAc,iBAAiB,GACjD,aAAa,mBAAoBO,CAAM,CAEpD,EC3gBMC,EAA2B,IAqBpBC,EAAU,CAACC,EAA0CC,IAA6B,CAC7F,MAAMC,EAAW,MAAM,KAAKF,EAAQ,iBAAiBC,EAAK,KAAK,IAAI,CAAC,CAAC,EAC/DE,EAAY,MAAM,KAAKH,EAAQ,iBAAiB,GAAG,CAAC,EACvD,OAAQI,GAAMA,EAAE,UAAU,EAC1B,QAASA,GAAML,EAAQK,EAAE,WAAaH,CAAI,CAAC,EAC9C,MAAO,CAAC,GAAGC,EAAU,GAAGC,CAAS,CACnC,EAEA,IAAIE,EAAuB,GAE3B,MAAMC,EAAwB,CAACN,EAAkBO,IAAwC,CAClFF,IAEH,OAAO,iBACL,UACCD,GAAK,CACAA,EAAE,OAAS,oBACb,OAAO,SAAS,OAAA,CAEpB,EACA,EAAK,EAEPC,EAAuB,IAEzB,MAAMG,EAAWR,EAAgB,gBACjC,GAAIQ,EAAS,CACX,GAAIA,EAAQ,WAAY,CACtB,MAAMC,EAAcD,EAAQ,WAAW,cAAc,kBAAkB,EACvE,GAAIC,GAAeA,EAAY,iBAAA,EAAmB,OAAS,EAAG,CAC5DH,EAAsBG,EAAY,iBAAA,EAAmB,CAAC,EAAGF,CAAiB,EAC1E,MACF,CACF,CACAD,EAAsBE,EAASD,CAAiB,EAChD,MACF,CAEA,MAAMG,EAAcH,EAAkB,YAClCA,EAAkB,YAClB,GAAGA,EAAkB,OAAO,kBAAkBA,EAAkB,QAAQ,IAAI,IAAIA,EAAkB,QAAQ,OAAO,OAAO,QACtH,iBACA,iCAAiC,EAGnCP,EAAQ,cACVA,EAAQ,UAAY,sGAAsGU,CAAW,sBAEzI,EAEMC,EAA4C,CAAA,EAC5CC,EAA2C,CAAA,EAC3CC,EAA2D,CAAA,EAC3DC,EAA0C,CAAA,EAE1CxD,EAAOyD,GACJ,GAAGA,EAAQ,IAAI,IAAIA,EAAQ,OAAO,GAGrCC,EAAwBC,GAAwB,CACpD,KAAM,CAAE,SAAAC,EAAU,QAAAC,CAAA,EAAYF,EAAY,YAIpCF,EAAmB,CAAE,KAAMG,EAAU,QAAAC,CAAA,EACrCC,EAAUH,EAAY,QAAQ,YAAA,EACpCN,EAAgBO,CAAQ,EAAIP,EAAgBO,CAAQ,GAAK,CAAA,EACzDP,EAAgBO,CAAQ,EAAE,KAAKE,CAAO,EAEtC,MAAMC,EAAqBR,EAAsBvD,EAAIyD,CAAO,CAAC,EACzDM,GAEF,WAAW,IAAMf,EAAsBW,EAAaI,CAAkB,EAAGvB,CAAwB,EAG/Fe,EAAsBvD,EAAIyD,CAAO,CAAC,GAAKD,EAAexD,EAAIyD,CAAO,CAAC,GAE1DH,EAAgBtD,EAAIyD,CAAO,CAAC,IAEtCH,EAAgBtD,EAAIyD,CAAO,CAAC,EAAI,GAC/B,OAAe,OAAO,SAAS,aAAaA,CAAO,EAExD,EAEaO,EAAkBC,GAAiB,CAC9CT,EAAexD,EAAIiE,CAAI,CAAC,EAAI,GAG5B,QAAQ,MAAM,uBAAwBA,CAAI,CAC5C,EAEaC,EAAsBD,GAA2B,CAC5D,MAAME,EAAcF,EAAK,QAAQ,KACjCV,EAAsBvD,EAAIiE,EAAK,OAAO,CAAC,EAAIA,EAE3C,QAAQ,MAAM,2BAA4BE,CAAW,EAErD,MAAMxB,EAAOU,EAAgBc,CAAW,EACpCxB,GAAM,OAAS,GACjBF,EAAQ,SAAUE,CAAI,EAAE,QAASD,GAAW,CAC1C,WACE,IAAMM,EAAsBN,EAASa,EAAsBvD,EAAIiE,EAAK,OAAO,CAAC,CAAC,EAC7EzB,CAAwB,CAE5B,CAAC,CAEL,EAEa4B,EAAqBH,GAA2B,CAC3D,MAAMI,EAASJ,EAAK,QAEdE,EAAcF,EAAK,QAAQ,KACjCA,EAAK,YAAc,sGAAsGI,CAAM,2DAC/Hd,EAAsBvD,EAAIiE,EAAK,OAAO,CAAC,EAAIA,EAE3C,QAAQ,MAAM,iCAAkCE,CAAW,EAE3D,MAAMxB,EAAOU,EAAgBc,CAAW,EACpCxB,GAAM,OAAS,GACjBF,EAAQ,SAAUE,CAAI,EAAE,QAASD,GAAW,CAC1C,WACE,IAAMM,EAAsBN,EAASa,EAAsBvD,EAAIiE,EAAK,OAAO,CAAC,CAAC,EAC7EzB,CAAwB,CAE5B,CAAC,CAEL,EAEa8B,EAAuB,CAACrC,EAAwBsC,IACvDtC,EAAQ,UAAY,oBACtB+B,EAAe/B,EAAQ,IAAI,EACpB,IACEA,EAAQ,UAAY,wBAC7BiC,EAAmBjC,EAAQ,IAAI,EACxB,IACEA,EAAQ,UAAY,uBAC7BF,EAAyBwC,EAAgBtC,EAAQ,IAAI,EACrDmC,EAAkBnC,EAAQ,IAAI,EACvB,IACEA,EAAQ,UAAY,4BAC7B,QAAQ,MAAM,2BAA4BA,EAAQ,IAAI,EACtD,OAAO,SAAS,OAAA,EACT,IACEA,EAAQ,UAAY,4BAC7B,QAAQ,MAAM,2BAA4BA,EAAQ,IAAI,EACtDI,EAAoB,GAAMkC,CAAc,EACjC,IACEtC,EAAQ,UAAY,2BAC7B,QAAQ,MAAM,gCAAiCA,EAAQ,IAAI,EAC3DI,EAAoB,GAAOkC,CAAc,EAClC,IACEtC,EAAQ,UAAY,8BAC7B,QAAQ,MAAM,oBAAoB,EAClC,OAAO,SAAS,OAAA,EACT,IACEA,EAAQ,UAAY,4BAC7BK,EAA4B,UAAWiC,CAAc,EAC9C,IACEtC,EAAQ,UAAY,2BAC7BK,EAA4B,SAAUiC,CAAc,EAC7C,IAEF,GAGI1C,EAAgB,IAAK,CAC/B,OAAe,OAAO,SAAS,cAAA,CAClC,EACaD,EAAoB,IAAK,CACpC,MAAMJ,EAAW,OAAO,OAAO+B,CAAqB,EAChD/B,EAAS,OAAS,GACnB,OAAe,OAAO,SAAS,gBAAgBA,EAAS,CAAC,EAAE,OAAO,CAEvE,EAEagD,EAAc,IAAK,CAE7B,OAAe,OAAO,SAAS,oBAAoB,QAAS9B,GAAoB,CAC/EgB,EAAqBhB,CAAO,CAC9B,CAAC,EAGA,OAAe,OAAO,SAAS,oBAAsB,CACpD,KAAOA,GAAoB,CACzBgB,EAAqBhB,CAAO,CAC9B,CAAA,CAEJ,EClNA,IAAY+B,GAAZ,SAAYA,EAAgB,CAC1BA,EAAA,OAAA,SACAA,EAAA,SAAA,WACAA,EAAA,YAAA,cACAA,EAAA,MAAA,OACF,GALYA,IAAAA,EAAgB,CAAA,EAAA,QAONC,QAAAA,CAAU,CAAhC,aAAA,CAGE,KAAA,OAA2BD,EAAiB,WA2B9C,CA1BE,aAAW,CAEX,CAEA,kBAAkBE,EAAS,CAE3B,CAEA,eAAeA,EAAmB,CAElC,CAEA,UAAUC,EAAY,CAChB,CAACA,GAAO,KAAK,SAAWH,EAAiB,OAC3C,KAAK,UAAUA,EAAiB,QAAQ,EAC/BG,GAAO,KAAK,SAAWH,EAAiB,UACjD,KAAK,UAAUA,EAAiB,MAAM,CAE1C,CAEA,UAAUI,EAAwB,CAC5B,KAAK,SAAWA,IAClB,KAAK,OAASA,EACd,KAAK,eAAeA,CAAM,EAE9B,GA5BOH,EAAA,mBAAqB,SADRI,ICLhB,MAAOC,UAA6BD,CAAU,CAGlD,YAAYE,EAAW,CACrB,MAAA,EACA,KAAK,UAAY,IAAI,UAAUA,CAAG,EAClC,KAAK,UAAU,UAAaC,GAAQ,KAAK,cAAcA,CAAG,EAC1D,KAAK,UAAU,QAAWC,GAAQ,KAAK,YAAYA,CAAG,EACtD,KAAK,UAAU,QAAWP,GAAK,CACzB,KAAK,SAAWF,EAAiB,OACnC,KAAK,UAAUA,EAAiB,WAAW,EAE7C,KAAK,UAAY,MACnB,EAEA,YAAY,IAAK,CACX,KAAK,WAAa,KAAK,SAAWA,EAAiB,OAAS,KAAK,SAAWA,EAAiB,aAC/F,KAAK,UAAU,KAAK,EAAE,CAE1B,EAAGK,EAAW,kBAAkB,CAClC,CAEA,SAASK,EAAiB,CAE1B,CAEA,cAAcF,EAAQ,CACpB,IAAIG,EAEJ,GAAI,CACFA,EAAO,KAAK,MAAMH,EAAI,IAAI,CAC5B,OAASnC,EAAQ,CACf,KAAK,YAAY,IAAIA,EAAE,IAAI,KAAKA,EAAE,OAAO,EAAE,EAC3C,MACF,CACA,GAAIsC,EAAK,UAAY,QACnB,KAAK,UAAUX,EAAiB,MAAM,EACtC,KAAK,YAAA,UACIW,EAAK,UAAY,UAC1B,GAAI,KAAK,SAAWX,EAAiB,OAAQ,CAC3C,MAAMY,EAAWD,EAAK,UAAY,SAClC,KAAK,SAASC,CAAQ,CACxB,OAEA,KAAK,YAAY,+CAA+CJ,CAAG,EAAE,CAEzE,CAEA,YAAYA,EAAQ,CAElB,QAAQ,MAAMA,CAAG,EACjB,KAAK,UAAUR,EAAiB,KAAK,EACjCQ,aAAe,OAAS,KAAK,UAC/B,KAAK,kBAAkB,oCAAoC,KAAK,UAAU,GAAG,EAAE,EAE/E,KAAK,kBAAkBA,CAAG,CAE9B,CACD,CC1DD,MAAMK,EAA0B,MAEnBC,EAAP,MAAOA,UAA4BT,CAAU,CAMjD,YAAYE,EAAW,CAErB,GADA,MAAA,EAHF,KAAA,QAAU,GAIJ,CAACA,EACH,OAGF,MAAMQ,EAAS,CACb,UAAW,YACX,kBAAmB,YACnB,IAAAR,EACA,YAAa,kCACb,kBAAmB,IACnB,QAAS,GACT,oBAAqB,IACrB,mBAAoB,GACpB,eAAgB,GAChB,oBAAqB,GACrB,+BAAgC,GAChC,iBAAkB,IAClB,UAAYS,GAAiB,CAC3B,MAAMxD,EAAU,CAAE,KAAMwD,EAAS,YAAA,EACjC,KAAK,cAAcxD,CAAO,CAC5B,EACA,QAAUwD,GAAiB,CACzB,KAAK,QAAU,GACf,KAAK,YAAYA,CAAQ,CAC3B,EACA,OAAQ,IAAK,CACX,KAAK,QAAU,EACjB,EACA,QAAS,IAAK,CACZ,KAAK,QAAU,EACjB,EACA,gBAAiB,IAAK,CACpB,KAAK,QAAU,EACjB,EACA,YAAa,IAAK,CAChB,KAAK,QAAU,EACjB,EACA,SAAU,IAAK,CACb,KAAK,QAAU,EACjB,CAAA,EAGFC,GAAA,EAAc,KAAMC,GAAc,CAChC,KAAK,OAASA,EAAW,UAAUH,CAAM,CAC3C,CAAC,CACH,CAEA,SAASL,EAAiB,CAE1B,CAEA,SAASS,EAAeC,EAAgB,CAExC,CAEA,UAAUC,EAAa,CAAG,CAE1B,cAAcb,EAAQ,CACpB,IAAIG,EAEJ,GAAI,CACFA,EAAO,KAAK,MAAMH,EAAI,IAAI,CAC5B,OAASnC,EAAQ,CACf,KAAK,YAAY,IAAIA,EAAE,IAAI,KAAKA,EAAE,OAAO,EAAE,EAC3C,MACF,CACA,GAAIsC,EAAK,UAAY,QACnB,KAAK,UAAUX,EAAiB,MAAM,EACtC,KAAK,YAAA,UACIW,EAAK,UAAY,UAC1B,GAAI,KAAK,SAAWX,EAAiB,OAAQ,CAC3C,MAAMY,EAAWD,EAAK,UAAY,SAClC,KAAK,SAASC,CAAQ,CACxB,OACSD,EAAK,UAAY,SACtB,KAAK,SAAWX,EAAiB,QACnC,KAAK,SAASW,EAAK,KAAMA,EAAK,OAAO,EAGvC,KAAK,UAAUA,CAAI,CAEvB,CAEA,YAAYH,EAAQ,CAElB,QAAQ,MAAMA,CAAG,EACjB,KAAK,UAAUR,EAAiB,KAAK,EACrC,KAAK,kBAAkBQ,CAAG,CAC5B,CAEO,KAAKc,EAAiB9B,EAAS,CACpC,GAAI,CAAC,KAAK,QAAU,CAAC,KAAK,QAAS,CACjC+B,EACE,IAAM,KAAK,QAAU,KAAK,QACzBC,GAAgB,KAAK,KAAKF,EAAS9B,CAAI,CAAC,EAE3C,MACF,CAEA,MAAMhC,EAAU,KAAK,UAAU,CAAE,QAAA8D,EAAS,KAAA9B,EAAM,EAGhD,IAAIiC,EAFYjE,EAAQ,OAAS,IAAMA,EAGvC,KAAOiE,EAAU,QACf,KAAK,OAAO,KAAKA,EAAU,UAAU,EAAGZ,CAAuB,CAAC,EAChEY,EAAYA,EAAU,UAAUZ,CAAuB,CAE3D,GAlHOC,EAAA,mBAAqB,KADxB,IAAOY,EAAPZ,EAsHN,SAASS,EAAWI,EAA4BC,EAA4B,CAC1E,MAAMtF,EAAQqF,EAAA,EACVrF,EACFsF,EAAStF,CAAK,EAEd,WAAW,IAAMiF,EAAQI,EAAOC,CAAQ,EAAG,EAAE,CAEjD,CAEA,SAASX,IAAW,CAElB,OAAO,IAAI,QAAa,CAACY,EAASC,IAAW,CAC3CP,EAAQ,IAAO,QAAgB,YAAY,WAAYM,CAAO,CAChE,CAAC,CACH,OC/EYE,GAAZ,SAAYA,EAAW,CACrBA,EAAA,IAAA,MACAA,EAAA,YAAA,cACAA,EAAA,QAAA,UACAA,EAAA,MAAA,OACF,GALYA,IAAAA,EAAW,CAAA,EAAA,EA8BvB,MAAMC,EAAiB,YAAA,IAAkB,YAAA,IAAgB,UAAY,aAG9D,IAAMC,GAANC,EAAA,cAA6BC,CAAU,CAAvC,aAAA,qBACL,KAAA,kBAAqC,CAAA,EACrC,KAAA,KAAqB,CAAE,OAAQ,GAAO,IAAK,GAAI,oBAAqB,GAAI,eAAgB,EAAA,EACxF,KAAA,eAAoC,KA+fpC,KAAA,eAAmCnC,EAAiB,YAGpD,KAAA,WAA+BA,EAAiB,YAMhD,KAAA,oBAA+B,GAKvB,KAAA,cAAwB,EAExB,KAAA,mBAA6B,CA6RvC,CA1yBE,WAAW,QAAM,CACf,MAAO,CACLoC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,OAAA,CAmeJ,CAkBA,WAAW,UAAQ,CACjB,MAAMC,EAAS,OAAO,eAAe,QAAQC,EAAe,6BAA6B,EACzF,OAAOD,IAAW,MAAQA,IAAW,OACvC,CAqBA,kBAAgB,CACd,IAAI7C,EAAO,CAAA,EACX,GAAI,CAEF,MAAM+C,EAA0B,aAAa,QAAQ,0BAA0B,EAC/E,GAAI,CAACA,EAEH,OAEF/C,EAAO,KAAK,MAAM+C,CAAuB,CAC3C,MAAY,CAEV,MACF,CAEI,KAAK,oBACP,KAAK,mBAAmB,KAAK,kBAAmB,CAAE,YAAa/C,EAAM,CAEzE,CAEA,yBAAuB,CAGrB,GAFA,KAAK,eAAiBQ,EAAiB,YACvC,KAAK,WAAaA,EAAiB,YAC/B,CAAC,KAAK,KAAK,MAAO,CACpB,QAAQ,MACN,8LAA8L,EAEhM,MACF,CACA,MAAMwC,EAAqBhC,GAAgB,QAAQ,MAAMA,CAAG,EACtDiC,EAAW,CAAC7B,EAAmB,WAAY,CAC/C,GAAIA,IAAa,WAAaA,IAAa,eAAgB,CACzD,MAAM8B,EAAY,OAAO,OAGzB,OAAO,KAAKA,EAAU,KAAK,OAAO,EAC/B,OAAQnH,GAAQA,IAAQ,YAAY,EACpC,IAAKoH,GAAOD,EAAU,KAAK,QAAQC,CAAE,CAAC,EACtC,QAASC,GAAU,CACdA,EAAO,iBACTA,EAAO,iBAAiB,EAAG,aAAc,CACvC,YAAahC,IAAa,cAAA,CAC3B,EAED,QAAQ,KAAK,6CAA8C,EAAE,CAEjE,CAAC,CACL,KAAO,CACL,MAAMiC,EAAa,OAAO,eAAe,QAAQP,EAAe,sCAAsC,EAChGQ,EAAaD,EAAa,SAASA,EAAY,EAAE,EAAI,EAAI,EAC/D,OAAO,eAAe,QAAQP,EAAe,uCAAwCQ,EAAW,UAAU,EAC1G,OAAO,eAAe,QAAQR,EAAe,iCAAkC,MAAM,EACrF,OAAO,SAAS,OAAA,CAClB,CACF,EACMS,EAAW,CAACC,EAAcC,IAAmB,CACjD,MAAMC,EAAsB,aACtBC,EAAqBH,EAAK,UAAUE,EAAoB,MAAM,EAKpE,GAJIF,EAAK,WAAWE,CAAmB,IACrCF,EAAO,KAAK,KAAK,oBAAsBG,GAGrCF,EAAS,CAEX,IAAIG,EAAW,SAAS,KAAK,cAAc,yBAAyBJ,CAAI,IAAI,EACvEI,IACHA,EAAW,SAAS,cAAc,OAAO,EACzCA,EAAS,aAAa,iBAAkBJ,CAAI,EAC5C,SAAS,KAAK,YAAYI,CAAQ,EAClC,KAAK,eAAeD,CAAkB,GAExCC,EAAS,YAAcH,EACvB,SAAS,cAAc,IAAI,YAAY,sBAAsB,CAAC,CAChE,SAAWA,IAAY,IAAMA,IAAY,KAAM,CAE7C,MAAMG,EAAW,SAAS,KAAK,cAAc,yBAAyBJ,CAAI,IAAI,EAC1EI,EACFA,EAAS,OAAA,EAET,KAAK,eAAeD,CAAkB,EAExC,SAAS,cAAc,IAAI,YAAY,sBAAsB,CAAC,CAChE,CACF,EAEME,EAAqB,IAAI3B,EAAoB,KAAK,0BAA0B,EAClF2B,EAAmB,YAAc,IAAK,CAC/Bf,EAAe,UAClBe,EAAmB,UAAU,EAAK,EAEhC,KAAK,KAAK,yBAA2B,IACvC,aAAa,QAAQ,2BAA4B,MAAM,EACvD,aAAa,WAAW,0BAA0B,EAClD,aAAa,WAAW,4BAA4B,GAEpD,aAAa,WAAW,0BAA0B,EAEpD,KAAK,iBAAA,CACP,EACAA,EAAmB,kBAAoBb,EACvCa,EAAmB,SAAWZ,EAC9BY,EAAmB,SAAWN,EAC9BM,EAAmB,eAAkBjD,GAA4B,CAC/D,KAAK,eAAiBA,CACxB,EACAiD,EAAmB,UAAa7F,GAAiB,KAAK,sBAAsBA,CAAO,EACnF,KAAK,mBAAqB6F,EAEtB,KAAK,KAAK,UAAYf,EAAe,sBAAwB,KAAK,KAAK,iBACzE,KAAK,eAAiB,IAAIhC,EAAqB,KAAK,0BAA0B,OAAO,QAAQ,CAAC,EAC9F,KAAK,eAAe,YAAc,IAAK,CAChCgC,EAAe,UAClB,KAAK,eAAgB,UAAU,EAAK,CAExC,EACA,KAAK,eAAe,SAAWG,EAC/B,KAAK,eAAe,kBAAoBD,EACxC,KAAK,eAAe,eAAkBpC,GAAU,CAC9C,KAAK,WAAaA,CACpB,EAEJ,CAEA,eAAe4C,EAAY,CAEX,MAAM,KAAK,SAAS,KAAK,iBAAiB,wBAAwB,CAAC,EAC3E,QAASM,GAAQ,CACrB,IAAIC,EAAWD,EAAK,aAAa,gBAAgB,GAAKA,EAAK,aAAa,MAAM,EAC1EC,GAAYA,EAAS,SAASP,CAAI,GACpCM,EAAK,OAAA,CAET,CAAC,CACH,CAEA,iBAAiBE,EAAyBhG,EAAsB,CAC9D,MAAMiG,EAAUD,EAChB,OAAOC,EAAQ,eAAiBA,EAAQ,cAAc,KAAKD,EAAYhG,CAAO,CAChF,CAEA,sBAAsBA,EAAsB,CACtCA,EAAQ,UAAY,gBACbqC,EAAqBrC,EAAS,KAAK,cAAc,GAAK,KAAK,iBAAiBA,CAAO,GAE5F,KAAK,kBAAkB,KAAKA,CAAO,CAEvC,CAEA,iBAAiBA,EAAsB,CACrC,OAAIA,EAAQ,UAAY,MACf,IAELwE,GACFA,EAAU,gBAAgBxE,EAAQ,KAAK,MAAOA,EAAQ,KAAK,SAAS,EAE/D,GACT,CAEA,0BAAwB,CACtB,SAASkG,EAAeC,EAAgB,CAEtC,MAAMC,EAAM,SAAS,cAAc,KAAK,EACxC,OAAAA,EAAI,UAAY,YAAYD,CAAQ,MAC5BC,EAAI,WAA+B,IAC7C,CAEA,GAAI,KAAK,KAAK,MAAQ,OACpB,OAEF,MAAMC,EAAoBH,EAAe,KAAK,KAAK,GAAI,EAEvD,GAAI,CAACG,EAAkB,WAAW,SAAS,GAAK,CAACA,EAAkB,WAAW,UAAU,EAAG,CAEzF,QAAQ,MAAM,0EAA0E,EACxF,MACF,CACA,MAAO,GAAGA,CAAiB,gCAAgC,KAAK,KAAK,KAAK,EAC5E,CAEA,0BAA0BC,EAAa,CACrC,KAAM,CAAE,SAAAC,GAAaD,EACfE,EAAaF,EAAS,WAAa,SAAW,MAAQ,KAC5D,GAAIC,EAAS,SAAS,WAAW,EAAG,CAElC,MAAME,EAAsBF,EAAS,QAAQ,OAAQ,EAAE,EACvD,MAAO,GAAGC,CAAU,MAAM,KAAK,KAAK,cAAc,IAAIC,CAAmB,EAC3E,KACE,OAAO,GAAGD,CAAU,MAAMD,CAAQ,IAAI,KAAK,KAAK,cAAc,EAElE,CAEA,mBAAiB,CASf,GARA,MAAM,kBAAA,EAEN,KAAK,eAAiB,SAAS,KAAK,aAAa,CAAE,KAAM,SAAU,EACnE,KAAK,eAAe,UAAY,gBAEhC,KAAK,KAAQ,OAAO,OAAe,cAAgB,KAAK,KAErC,OAAO,eAAe,QAAQzB,EAAe,gCAAgC,EAChF,CACd,MAAM4B,MAAU,KACI,OAAIA,EAAI,SAAA,CAAU,GAAG,MAAM,EAAE,IAAK,IAAIA,EAAI,YAAY,GAAG,MAC3E,EAAE,IACC,IAAIA,EAAI,WAAA,CAAY,GAAG,MAAM,EAAE,IACpC,OAAO,eAAe,WAAW5B,EAAe,gCAAgC,CAClF,CAEA,KAAK,mBAAqB,SACxB,OAAO,iBAAiB,IAAI,EAAE,iBAAiB,iCAAiC,EAChF,EAAE,EAGJ,MAAM6B,EAAY,OAClBA,EAAU,OAASA,EAAU,QAAU,CAAA,EACvCA,EAAU,OAAO,SAAW,OAAO,OAAO,KAAMA,EAAU,OAAO,QAAQ,EAEzE,MAAMzB,EAAY,OAAO,OACrBA,EAAU,kBACZ,MAAM,KAAKA,EAAU,eAAmC,EAAE,QAAS0B,GAAW,KAAK,WAAWA,CAAM,CAAC,EACrG1B,EAAU,gBAAkB,CAAE,KAAO0B,GAA2B,KAAK,WAAWA,CAAM,CAAA,GAGxF,KAAK,wBAAA,EACLrE,EAAA,CACF,CAEA,MAAM,WAAWqE,EAAsB,CACrC,MAAMC,EAAW,KACjBD,EAAO,KAAK,CACV,KAAM,SAAU9C,EAAiB9B,EAAS,CACxC6E,EAAS,mBAAoB,KAAK/C,EAAS9B,CAAI,CACjD,CAAA,CACD,CACH,CAEA,OAAO8E,EAAM,CACX,OAAOA,EAAE,SAAA,CACX,CAEA,aAAaC,EAAoB,CAC3B,KAAK,mBACP,KAAK,mBAAmB,KAAK,eAAgBA,CAAW,EAExDhF,EAAegF,CAAW,CAE9B,CAEA,eAAa,CACP,KAAK,mBACP,KAAK,mBAAmB,KAAK,uBAAwB,CAAA,CAAE,GAEvD,QAAQ,MAAM,uCAAuC,EACrD3G,EAAoB,GAAO,KAAK,cAAc,EAElD,CAEA,gBAAgB2G,EAAoB,CAC9B,KAAK,mBACP,KAAK,mBAAmB,KAAK,kBAAmBA,CAAW,EAE3D1G,EAA4B,SAAU,KAAK,cAAc,CAE7D,CAEA,UAAUsC,EAAY,CACpB,KAAK,oBAAoB,UAAUA,CAAG,EACtC,KAAK,gBAAgB,UAAUA,CAAG,EAClC,OAAO,eAAe,QAAQmC,EAAe,8BAA+BnC,EAAM,OAAS,OAAO,CACpG,CAGA,QAAM,CACJ,OAAOqE,uDACT,CAEA,wBAAwBnC,EAAe,CAEjC,KAAK,eACP,KAAK,eAAe,UAAUA,CAAM,EAEpC,KAAK,oBAAoB,UAAUA,CAAM,CAE7C,OAlUOH,EAAA,yCAA2C,4CAC3CA,EAAA,8BAAgC,4BAChCA,EAAA,iCAAmC,+BACnCA,EAAA,uCAAyC,oCAEzCA,EAAA,+BAAiC,IAEjCA,EAAA,cAAgB,gBAChBA,EAAA,OAAS,SACTA,EAAA,qBAAuB,uBACvBA,EAAA,qBAA+C,CACpD,cAAe,eACf,OAAQ,SACR,qBAAsB,sBAAA,EAzfnBA,GAkgBL9G,EAAA,CADCqJ,EAAS,CAAE,KAAM,OAAQ,UAAW,GAAO,CACoB,EAAAxC,EAAA,UAAA,iBAAA,MAAA,EAGhE7G,EAAA,CADCqJ,EAAS,CAAE,KAAM,OAAQ,UAAW,GAAO,CACgB,EAAAxC,EAAA,UAAA,aAAA,MAAA,EAGpD7G,EAAA,CADPsJ,EAAM,SAAS,CACW,EAAAzC,EAAA,UAAA,OAAA,MAAA,EAG3B7G,EAAA,CADCuJ,EAAA,CACoC,EAAA1C,EAAA,UAAA,sBAAA,MAAA,EA3gB1BA,EAAcK,EAAAlH,EAAA,CAD1BwJ,EAAc,kBAAkB,CACpB,EAAA3C,CAAc","x_google_ignoreList":[0]} \ No newline at end of file diff --git a/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/websocket-connection.d.ts b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/websocket-connection.d.ts new file mode 100644 index 0000000..818b250 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/vaadin-dev-tools/websocket-connection.d.ts @@ -0,0 +1,13 @@ +import { Connection } from './connection'; +export declare class WebSocketConnection extends Connection { + static HEARTBEAT_INTERVAL: number; + socket?: any; + canSend: boolean; + constructor(url: string); + onReload(_strategy: string): void; + onUpdate(_path: string, _content: string): void; + onMessage(_message: any): void; + handleMessage(msg: any): void; + handleError(msg: any): void; + send(command: string, data: any): void; +} diff --git a/backend/src/main/frontend/generated/jar-resources/vaadin-grid-flow-selection-column.js b/backend/src/main/frontend/generated/jar-resources/vaadin-grid-flow-selection-column.js new file mode 100644 index 0000000..5f1f1c8 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/vaadin-grid-flow-selection-column.js @@ -0,0 +1,97 @@ +import '@vaadin/grid/src/vaadin-grid-column.js'; +import { GridColumn } from '@vaadin/grid/src/vaadin-grid-column.js'; +import { GridSelectionColumnBaseMixin } from '@vaadin/grid/src/vaadin-grid-selection-column-base-mixin.js'; + +export class GridFlowSelectionColumn extends GridSelectionColumnBaseMixin(GridColumn) { + static get is() { + return 'vaadin-grid-flow-selection-column'; + } + + static get properties() { + return { + /** + * Override property to enable auto-width + */ + autoWidth: { + type: Boolean, + value: true + }, + + /** + * Override property to set custom width + */ + width: { + type: String, + value: '56px' + } + }; + } + + /** + * Override method from `GridSelectionColumnBaseMixin` to add ID to select all + * checkbox + * + * @override + */ + _defaultHeaderRenderer(root, _column) { + super._defaultHeaderRenderer(root, _column); + const checkbox = root.firstElementChild; + if (checkbox) { + checkbox.id = 'selectAllCheckbox'; + } + } + + /** + * Override a method from `GridSelectionColumnBaseMixin` to handle the user + * selecting all items. + * + * @protected + * @override + */ + _selectAll() { + this.selectAll = true; + this.$server.selectAll(); + } + + /** + * Override a method from `GridSelectionColumnBaseMixin` to handle the user + * deselecting all items. + * + * @protected + * @override + */ + _deselectAll() { + this.selectAll = false; + this.$server.deselectAll(); + } + + /** + * Override a method from `GridSelectionColumnBaseMixin` to handle the user + * selecting an item. + * + * @param {Object} item the item to select + * @protected + * @override + */ + _selectItem(item) { + this.$server.setShiftKeyDown(this._shiftKeyDown); + this._grid.$connector.doSelection([item], true); + } + + /** + * Override a method from `GridSelectionColumnBaseMixin` to handle the user + * deselecting an item. + * + * @param {Object} item the item to deselect + * @protected + * @override + */ + _deselectItem(item) { + this.$server.setShiftKeyDown(this._shiftKeyDown); + this._grid.$connector.doDeselection([item], true); + // Optimistically update select all state + this.selectAll = false; + } +} + +customElements.define(GridFlowSelectionColumn.is, GridFlowSelectionColumn); diff --git a/backend/src/main/frontend/generated/jar-resources/vaadin-popover/popover.ts b/backend/src/main/frontend/generated/jar-resources/vaadin-popover/popover.ts new file mode 100644 index 0000000..592fbf0 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/vaadin-popover/popover.ts @@ -0,0 +1,26 @@ +import { Popover } from '@vaadin/popover/src/vaadin-popover.js'; + +const _window = window as any; +_window.Vaadin ||= {}; +_window.Vaadin.Flow ||= {}; +_window.Vaadin.Flow.popover ||= {}; + +Object.assign(_window.Vaadin.Flow.popover, { + setDefaultHideDelay: (hideDelay: number) => Popover.setDefaultHideDelay(hideDelay), + setDefaultFocusDelay: (focusDelay: number) => Popover.setDefaultFocusDelay(focusDelay), + setDefaultHoverDelay: (hoverDelay: number) => Popover.setDefaultHoverDelay(hoverDelay) +}); + +const { defaultHideDelay, defaultFocusDelay, defaultHoverDelay } = _window.Vaadin.Flow.popover; + +if (defaultHideDelay) { + Popover.setDefaultHideDelay(defaultHideDelay); +} + +if (defaultFocusDelay) { + Popover.setDefaultFocusDelay(defaultFocusDelay); +} + +if (defaultHoverDelay) { + Popover.setDefaultHoverDelay(defaultHoverDelay); +} diff --git a/backend/src/main/frontend/generated/jar-resources/vaadin-time-picker/helpers.js b/backend/src/main/frontend/generated/jar-resources/vaadin-time-picker/helpers.js new file mode 100644 index 0000000..dd3c328 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/vaadin-time-picker/helpers.js @@ -0,0 +1,183 @@ +// map from unicode eastern arabic number characters to arabic numbers +const EASTERN_ARABIC_DIGIT_MAP = { + '\\u0660': '0', + '\\u0661': '1', + '\\u0662': '2', + '\\u0663': '3', + '\\u0664': '4', + '\\u0665': '5', + '\\u0666': '6', + '\\u0667': '7', + '\\u0668': '8', + '\\u0669': '9' +}; + +/** + * Escapes the given string so it can be safely used in a regexp. + * + * @param {string} string + * @return {string} + */ +function escapeRegExp(string) { + return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); +} + +/** + * Parses eastern arabic number characters to arabic numbers (0-9) + * + * @param {string} digits + * @return {string} + */ +function parseEasternArabicDigits(digits) { + return digits.replace(/[\u0660-\u0669]/g, function (char) { + const unicode = '\\u0' + char.charCodeAt(0).toString(16); + return EASTERN_ARABIC_DIGIT_MAP[unicode]; + }); +} + +/** + * @param {string} locale + * @param {Date} testTime + * @return {string | null} + */ +function getAmOrPmString(locale, testTime) { + const testTimeString = testTime.toLocaleTimeString(locale); + + // AM/PM string is anything from one letter in eastern arabic to standard two letters, + // to having space in between, dots ... + // cannot disqualify whitespace since some locales use a. m. / p. m. + // TODO when more scripts support is added (than Arabic), need to exclude those numbers too + const amOrPmRegExp = /[^\d\u0660-\u0669]/; + + const matches = + // In most locales, the time ends with AM/PM: + testTimeString.match(new RegExp(`${amOrPmRegExp.source}+$`, 'g')) || + // In some locales, the time starts with AM/PM e.g in Chinese: + testTimeString.match(new RegExp(`^${amOrPmRegExp.source}+`, 'g')); + + return matches && matches[0].trim(); +} + +/** + * @param {string} locale + * @return {string | null} + */ +export function getSeparator(locale) { + let timeString = TEST_PM_TIME.toLocaleTimeString(locale); + + // Since the next regex picks first non-number-whitespace, + // need to discard possible PM from beginning (eg. chinese locale) + const pmString = getPmString(locale); + if (pmString && timeString.startsWith(pmString)) { + timeString = timeString.replace(pmString, ''); + } + + const matches = timeString.match(/[^\u0660-\u0669\s\d]/); + return matches && matches[0]; +} + +/** + * Searches for either an AM or PM token in the given time string + * depending on what is provided in `amOrPmString`. + * + * The search is case and space insensitive. + * + * @example + * `searchAmOrPmToken('1 P M', 'PM')` => `'P M'` + * + * @example + * `searchAmOrPmToken('1 a.m.', 'A. M.')` => `a.m.` + * + * @param {string} timeString + * @param {string} amOrPmString + * @return {string | null} + */ +export function searchAmOrPmToken(timeString, amOrPmString) { + if (!amOrPmString) return null; + + // Create a regexp string for searching for AM/PM without space-sensitivity. + const tokenRegExpString = amOrPmString.split(/\s*/).map(escapeRegExp).join('\\s*'); + + // Create a regexp without case-sensitivity. + const tokenRegExp = new RegExp(tokenRegExpString, 'i'); + + // Match the regexp against the time string. + const tokenMatches = timeString.match(tokenRegExp); + if (tokenMatches) { + return tokenMatches[0]; + } +} + +export const TEST_PM_TIME = new Date('August 19, 1975 23:15:30'); + +export const TEST_AM_TIME = new Date('August 19, 1975 05:15:30'); + +/** + * @param {string} locale + * @return {string} + */ +export function getPmString(locale) { + return getAmOrPmString(locale, TEST_PM_TIME); +} + +/** + * @param {string} locale + * @return {string} + */ +export function getAmString(locale) { + return getAmOrPmString(locale, TEST_AM_TIME); +} + +/** + * @param {string} digits + * @return {number} + */ +export function parseDigitsIntoInteger(digits) { + return parseInt(parseEasternArabicDigits(digits)); +} + +/** + * @param {string} milliseconds + * @return {number} + */ +export function parseMillisecondsIntoInteger(milliseconds) { + milliseconds = parseEasternArabicDigits(milliseconds); + // digits are either .1 .01 or .001 so need to "shift" + if (milliseconds.length === 1) { + milliseconds += '00'; + } else if (milliseconds.length === 2) { + milliseconds += '0'; + } + return parseInt(milliseconds); +} + +/** + * @param {string} timeString + * @param {number} milliseconds + * @param {string} amString + * @param {string} pmString + * @return {string} + */ +export function formatMilliseconds(timeString, milliseconds, amString, pmString) { + // might need to inject milliseconds between seconds and AM/PM + let cleanedTimeString = timeString; + if (timeString.endsWith(amString)) { + cleanedTimeString = timeString.replace(' ' + amString, ''); + } else if (timeString.endsWith(pmString)) { + cleanedTimeString = timeString.replace(' ' + pmString, ''); + } + if (milliseconds) { + let millisecondsString = milliseconds < 10 ? '0' : ''; + millisecondsString += milliseconds < 100 ? '0' : ''; + millisecondsString += milliseconds; + cleanedTimeString += '.' + millisecondsString; + } else { + cleanedTimeString += '.000'; + } + if (timeString.endsWith(amString)) { + cleanedTimeString = cleanedTimeString + ' ' + amString; + } else if (timeString.endsWith(pmString)) { + cleanedTimeString = cleanedTimeString + ' ' + pmString; + } + return cleanedTimeString; +} diff --git a/backend/src/main/frontend/generated/jar-resources/vaadin-time-picker/timepickerConnector.js b/backend/src/main/frontend/generated/jar-resources/vaadin-time-picker/timepickerConnector.js new file mode 100644 index 0000000..dce8e7f --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/vaadin-time-picker/timepickerConnector.js @@ -0,0 +1,181 @@ +import { + TEST_PM_TIME, + formatMilliseconds, + parseMillisecondsIntoInteger, + parseDigitsIntoInteger, + getAmString, + getPmString, + getSeparator, + searchAmOrPmToken +} from './helpers.js'; +import { parseISOTime } from '@vaadin/time-picker/src/vaadin-time-picker-helper.js'; + +// Execute callback when predicate returns true. +// Try again later if predicate returns false. +function when(predicate, callback, timeout = 0) { + if (predicate()) { + callback(); + } else { + setTimeout(() => when(predicate, callback, 200), timeout); + } +} + +function parseISO(text) { + // The default i18n parser of the web component is ISO 8601 compliant. + const timeObject = parseISOTime(text); + + // The web component returns an object with string values + // while the connector expects number values. + return { + hours: parseInt(timeObject.hours || 0), + minutes: parseInt(timeObject.minutes || 0), + seconds: parseInt(timeObject.seconds || 0), + milliseconds: parseInt(timeObject.milliseconds || 0) + }; +} + +window.Vaadin.Flow.timepickerConnector = {}; +window.Vaadin.Flow.timepickerConnector.initLazy = (timepicker) => { + // Check whether the connector was already initialized for the timepicker + if (timepicker.$connector) { + return; + } + + timepicker.$connector = {}; + + timepicker.$connector.setLocale = (locale) => { + // capture previous value if any + let previousValueObject; + if (timepicker.value && timepicker.value !== '') { + previousValueObject = parseISO(timepicker.value); + } + + try { + // Check whether the locale is supported by the browser or not + TEST_PM_TIME.toLocaleTimeString(locale); + } catch (e) { + locale = 'en-US'; + // FIXME should do a callback for server to throw an exception ? + throw new Error( + 'vaadin-time-picker: The locale ' + locale + ' is not supported, falling back to default locale setting(en-US).' + ); + } + + // 1. 24 or 12 hour clock, if latter then what are the am/pm strings ? + const pmString = getPmString(locale); + const amString = getAmString(locale); + + // 2. What is the separator ? + const separator = getSeparator(locale); + + const includeSeconds = function () { + return timepicker.step && timepicker.step < 60; + }; + + const includeMilliSeconds = function () { + return timepicker.step && timepicker.step < 1; + }; + + let cachedTimeString; + let cachedTimeObject; + + timepicker.i18n = { + formatTime(timeObject) { + if (!timeObject) return; + + const timeToBeFormatted = new Date(); + timeToBeFormatted.setHours(timeObject.hours); + timeToBeFormatted.setMinutes(timeObject.minutes); + timeToBeFormatted.setSeconds(timeObject.seconds !== undefined ? timeObject.seconds : 0); + + // the web component expects the correct granularity used for the time string, + // thus need to format the time object in correct granularity by passing the format options + let localeTimeString = timeToBeFormatted.toLocaleTimeString(locale, { + hour: 'numeric', + minute: 'numeric', + second: includeSeconds() ? 'numeric' : undefined + }); + + // milliseconds not part of the time format API + if (includeMilliSeconds()) { + localeTimeString = formatMilliseconds(localeTimeString, timeObject.milliseconds, amString, pmString); + } + + return localeTimeString; + }, + + parseTime(timeString) { + if (timeString && timeString === cachedTimeString && cachedTimeObject) { + return cachedTimeObject; + } + + if (!timeString) { + // when nothing is returned, the component shows the invalid state for the input + return; + } + + const amToken = searchAmOrPmToken(timeString, amString); + const pmToken = searchAmOrPmToken(timeString, pmString); + + const numbersOnlyTimeString = timeString + .replace(amToken || '', '') + .replace(pmToken || '', '') + .trim(); + + // A regexp that allows to find the numbers with optional separator and continuing searching after it. + const numbersRegExp = new RegExp('([\\d\\u0660-\\u0669]){1,2}(?:' + separator + ')?', 'g'); + + let hours = numbersRegExp.exec(numbersOnlyTimeString); + if (hours) { + hours = parseDigitsIntoInteger(hours[0].replace(separator, '')); + // handle 12 am -> 0 + // do not do anything if am & pm are not used or if those are the same, + // as with locale bg-BG there is always ч. at the end of the time + if (amToken !== pmToken) { + if (hours === 12 && amToken) { + hours = 0; + } + if (hours !== 12 && pmToken) { + hours += 12; + } + } + const minutes = numbersRegExp.exec(numbersOnlyTimeString); + const seconds = minutes && numbersRegExp.exec(numbersOnlyTimeString); + // detecting milliseconds from input, expects am/pm removed from end, eg. .0 or .00 or .000 + const millisecondRegExp = /[[\.][\d\u0660-\u0669]{1,3}$/; + // reset to end or things can explode + let milliseconds = seconds && includeMilliSeconds() && millisecondRegExp.exec(numbersOnlyTimeString); + // handle case where last numbers are seconds and . is the separator (invalid regexp match) + if (milliseconds && milliseconds['index'] <= seconds['index']) { + milliseconds = undefined; + } + // hours is a number at this point, others are either arrays or null + // the string in [0] from the arrays includes the separator too + cachedTimeObject = hours !== undefined && { + hours: hours, + minutes: minutes ? parseDigitsIntoInteger(minutes[0].replace(separator, '')) : 0, + seconds: seconds ? parseDigitsIntoInteger(seconds[0].replace(separator, '')) : 0, + milliseconds: + minutes && seconds && milliseconds ? parseMillisecondsIntoInteger(milliseconds[0].replace('.', '')) : 0 + }; + cachedTimeString = timeString; + return cachedTimeObject; + } + } + }; + + if (previousValueObject) { + when( + () => timepicker.$, + () => { + const newValue = timepicker.i18n.formatTime(previousValueObject); + // FIXME works but uses private API, needs fixes in web component + if (timepicker.inputElement.value !== newValue) { + timepicker.inputElement.value = newValue; + timepicker.value = newValue; + } + } + ); + } + }; +}; diff --git a/backend/src/main/frontend/generated/jar-resources/virtualListConnector.js b/backend/src/main/frontend/generated/jar-resources/virtualListConnector.js new file mode 100644 index 0000000..b834e14 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/virtualListConnector.js @@ -0,0 +1,152 @@ +import { Debouncer } from '@vaadin/component-base/src/debounce.js'; +import { timeOut } from '@vaadin/component-base/src/async.js'; + +window.Vaadin.Flow.virtualListConnector = { + initLazy: function (list) { + // Check whether the connector was already initialized for the virtual list + if (list.$connector) { + return; + } + + const extraItemsBuffer = 20; + + let lastRequestedRange = [0, 0]; + + list.$connector = {}; + list.$connector.placeholderItem = { __placeholder: true }; + + list.itemAccessibleNameGenerator = (item) => item && item.accessibleName; + + const updateRequestedItem = function () { + /* + * TODO virtual list seems to do a small index adjustment after scrolling + * has stopped. This causes a redundant request to be sent to make a + * corresponding minimal change to the buffer. We should avoid these + * requests by making the logic skip doing a request if the available + * buffer is within some tolerance compared to the requested buffer. + */ + const visibleIndexes = [...list.children] + .filter((el) => '__virtualListIndex' in el) + .map((el) => el.__virtualListIndex); + const firstNeededItem = Math.min(...visibleIndexes); + const lastNeededItem = Math.max(...visibleIndexes); + + let first = Math.max(0, firstNeededItem - extraItemsBuffer); + let last = Math.min(lastNeededItem + extraItemsBuffer, list.items.length); + + if (lastRequestedRange[0] != first || lastRequestedRange[1] != last) { + lastRequestedRange = [first, last]; + const count = 1 + last - first; + list.$server.setViewportRange(first, count); + } + }; + + const scheduleUpdateRequest = function () { + list.__requestDebounce = Debouncer.debounce(list.__requestDebounce, timeOut.after(50), updateRequestedItem); + }; + + requestAnimationFrame(() => updateRequestedItem); + + // Add an observer function that will invoke on virtualList.renderer property + // change and then patches it with a wrapper renderer + list.patchVirtualListRenderer = function () { + if (!list.renderer || list.renderer.__virtualListConnectorPatched) { + // The list either doesn't have a renderer yet or it's already been patched + return; + } + + const originalRenderer = list.renderer; + + const renderer = (root, list, model) => { + root.__virtualListIndex = model.index; + + if (model.item === undefined) { + if (list.$connector.placeholderElement) { + // ComponentRenderer + if (!root.__hasComponentRendererPlaceholder) { + // The root was previously rendered by the ComponentRenderer. Clear and add a placeholder. + root.innerHTML = ''; + delete root._$litPart$; + root.appendChild(list.$connector.placeholderElement.cloneNode(true)); + root.__hasComponentRendererPlaceholder = true; + } + } else { + // LitRenderer + originalRenderer.call(list, root, list, { + ...model, + item: list.$connector.placeholderItem + }); + } + } else { + if (root.__hasComponentRendererPlaceholder) { + // The root was previously populated with a placeholder. Clear it. + root.innerHTML = ''; + root.__hasComponentRendererPlaceholder = false; + } + + originalRenderer.call(list, root, list, model); + } + + /* + * Check if we need to do anything once things have settled down. + * This method is called multiple times in sequence for the same user + * action, but we only want to do the check once. + */ + scheduleUpdateRequest(); + }; + renderer.__virtualListConnectorPatched = true; + renderer.__rendererId = originalRenderer.__rendererId; + + list.renderer = renderer; + }; + + list._createPropertyObserver('renderer', 'patchVirtualListRenderer', true); + list.patchVirtualListRenderer(); + + list.items = []; + + list.$connector.set = function (index, items) { + list.items.splice(index, items.length, ...items); + list.items = [...list.items]; + }; + + list.$connector.clear = function (index, length) { + // How many items, starting from "index", should be set as undefined + const clearCount = Math.min(length, list.items.length - index); + list.$connector.set(index, [...Array(clearCount)]); + }; + + list.$connector.updateData = function (items) { + const updatedItemsMap = items.reduce((map, item) => { + map[item.key] = item; + return map; + }, {}); + + list.items = list.items.map((item) => { + // Items can be undefined if they are outside the viewport + if (!item) { + return item; + } + // Replace existing item with updated item, + // return existing item as fallback if it was not updated + return updatedItemsMap[item.key] || item; + }); + }; + + list.$connector.updateSize = function (newSize) { + const delta = newSize - list.items.length; + if (delta > 0) { + list.items = [...list.items, ...Array(delta)]; + } else if (delta < 0) { + list.items = list.items.slice(0, newSize); + } + }; + + list.$connector.setPlaceholderItem = function (placeholderItem = {}, appId) { + placeholderItem.__placeholder = true; + list.$connector.placeholderItem = placeholderItem; + const nodeId = Object.entries(placeholderItem).find(([key]) => key.endsWith('_nodeid')); + list.$connector.placeholderElement = nodeId ? Vaadin.Flow.clients[appId].getByNodeId(nodeId[1]) : null; + }; + } +}; diff --git a/backend/src/main/frontend/generated/jsx-dev-transform/index.ts b/backend/src/main/frontend/generated/jsx-dev-transform/index.ts new file mode 100644 index 0000000..06a88f0 --- /dev/null +++ b/backend/src/main/frontend/generated/jsx-dev-transform/index.ts @@ -0,0 +1,3 @@ +import { createElement as reactCreateElement } from 'react'; + +export const createElement = reactCreateElement; diff --git a/backend/src/main/frontend/generated/jsx-dev-transform/jsx-dev-runtime.ts b/backend/src/main/frontend/generated/jsx-dev-transform/jsx-dev-runtime.ts new file mode 100644 index 0000000..d1f1045 --- /dev/null +++ b/backend/src/main/frontend/generated/jsx-dev-transform/jsx-dev-runtime.ts @@ -0,0 +1,29 @@ +import { JSXSource, Fragment as reactFragment, jsxDEV as reactJsxDEV } from 'react/jsx-dev-runtime'; + +export const Fragment = reactFragment; + +export function jsxDEV( + type: React.ElementType, + props: unknown, + key: React.Key | undefined, + isStatic: boolean, + source?: JSXSource, + self?: unknown +): React.ReactElement { + const realFreeze = Object.freeze; + try { + (Object as any).freeze = undefined; // prevent React from freezing the element + + const reactElement: any = reactJsxDEV(type, props, key, isStatic, source, self); + if (source && !reactElement._source) { + // When running with React 19, put the source information on the _debugInfo array, + // which will be transferred to the fiber node by React + reactElement._debugInfo ??= []; + reactElement._debugInfo.source = source; + } + realFreeze(reactElement); + return reactElement; + } finally { + (Object as any).freeze = realFreeze; + } +} diff --git a/backend/src/main/frontend/generated/jsx-dev-transform/jsx-runtime.ts b/backend/src/main/frontend/generated/jsx-dev-transform/jsx-runtime.ts new file mode 100644 index 0000000..592f4c4 --- /dev/null +++ b/backend/src/main/frontend/generated/jsx-dev-transform/jsx-runtime.ts @@ -0,0 +1,7 @@ +import { Fragment as reactFragment, jsx as reactJsx, jsxs as reactJsxs } from 'react/jsx-runtime'; + +export const Fragment = reactFragment; +export const jsx = reactJsx; +export const jsxs = reactJsxs; + +throw new Error('Do not use this transform for production builds. It is only meant for development.'); diff --git a/backend/src/main/frontend/generated/layouts.json b/backend/src/main/frontend/generated/layouts.json new file mode 100644 index 0000000..0637a08 --- /dev/null +++ b/backend/src/main/frontend/generated/layouts.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/backend/src/main/frontend/generated/routes.tsx b/backend/src/main/frontend/generated/routes.tsx new file mode 100644 index 0000000..718fe26 --- /dev/null +++ b/backend/src/main/frontend/generated/routes.tsx @@ -0,0 +1,19 @@ +/****************************************************************************** + * This file is auto-generated by Vaadin. + * It configures React Router automatically by adding server-side (Flow) routes, + * which is enough for Vaadin Flow applications. + * Once any `.tsx` or `.jsx` React routes are added into + * `src/main/frontend/views/` directory, this route configuration is + * re-generated automatically by Vaadin. + ******************************************************************************/ +import { createBrowserRouter, RouteObject } from 'react-router'; +import { serverSideRoutes } from 'Frontend/generated/flow/Flow'; + +function build() { + const routes = [...serverSideRoutes] as RouteObject[]; + return { + router: createBrowserRouter([...routes], { basename: new URL(document.baseURI).pathname }), + routes + }; +} +export const { router, routes } = build() diff --git a/backend/src/main/frontend/generated/vaadin-featureflags.js b/backend/src/main/frontend/generated/vaadin-featureflags.js new file mode 100644 index 0000000..ab1cec8 --- /dev/null +++ b/backend/src/main/frontend/generated/vaadin-featureflags.js @@ -0,0 +1,21 @@ +// @ts-nocheck +window.Vaadin = window.Vaadin || {}; +window.Vaadin.featureFlags = window.Vaadin.featureFlags || {}; +if (Object.keys(window.Vaadin.featureFlags).length === 0) { +window.Vaadin.featureFlags.collaborationEngineBackend = false; +window.Vaadin.featureFlags.flowFullstackSignals = false; +window.Vaadin.featureFlags.accessibleDisabledButtons = false; +window.Vaadin.featureFlags.themeComponentStyles = false; +window.Vaadin.featureFlags.copilotExperimentalFeatures = false; +window.Vaadin.featureFlags.tailwindCss = false; +window.Vaadin.featureFlags.fullstackSignals = false; +window.Vaadin.featureFlags.masterDetailLayoutComponent = false; +window.Vaadin.featureFlags.layoutComponentImprovements = false; +window.Vaadin.featureFlags.defaultAutoResponsiveFormLayout = false; +}; +if (window.Vaadin.featureFlagsUpdaters) { +const activator = (id) => window.Vaadin.featureFlags[id] = true; +window.Vaadin.featureFlagsUpdaters.forEach(updater => updater(activator)); +delete window.Vaadin.featureFlagsUpdaters; +} +export {}; \ No newline at end of file diff --git a/backend/src/main/frontend/generated/vaadin-react.tsx b/backend/src/main/frontend/generated/vaadin-react.tsx new file mode 100644 index 0000000..2f04415 --- /dev/null +++ b/backend/src/main/frontend/generated/vaadin-react.tsx @@ -0,0 +1,18 @@ +import { routes } from "Frontend/generated/routes.js"; +import { registerGlobalClickHandler } from "Frontend/generated/flow/Flow.js"; + +(window as any).Vaadin ??= {}; +(window as any).Vaadin.routesConfig = routes; +registerGlobalClickHandler(); + +export { routes as forHMROnly }; + +// @ts-ignore +if (import.meta.hot) { + // @ts-ignore + import.meta.hot.accept((module) => { + if (module?.forHMROnly) { + (window as any).Vaadin.routesConfig = module.forHMROnly; + } + }); +} diff --git a/backend/src/main/frontend/generated/vaadin.ts b/backend/src/main/frontend/generated/vaadin.ts new file mode 100644 index 0000000..f3ec4ff --- /dev/null +++ b/backend/src/main/frontend/generated/vaadin.ts @@ -0,0 +1,9 @@ +import './vaadin-featureflags.js'; + +import './index'; + +import './vaadin-react.js'; +import './app-shell-imports.js'; +import './css.generated.js'; +import { applyCss } from './css.generated.js'; +applyCss(document); diff --git a/backend/src/main/frontend/index.html b/backend/src/main/frontend/index.html new file mode 100644 index 0000000..eb0c53b --- /dev/null +++ b/backend/src/main/frontend/index.html @@ -0,0 +1,23 @@ + + + + + + + + + + + + +
    + + diff --git a/backend/src/main/java/de/assecutor/hha/backend/HhaBackendApplication.java b/backend/src/main/java/de/assecutor/hha/backend/HhaBackendApplication.java new file mode 100644 index 0000000..26f3ae1 --- /dev/null +++ b/backend/src/main/java/de/assecutor/hha/backend/HhaBackendApplication.java @@ -0,0 +1,17 @@ +package de.assecutor.hha.backend; + +import com.vaadin.flow.component.dependency.StyleSheet; +import com.vaadin.flow.component.page.AppShellConfigurator; +import com.vaadin.flow.theme.aura.Aura; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; + +@SpringBootApplication +@StyleSheet(Aura.STYLESHEET) +@StyleSheet("styles.css") +public class HhaBackendApplication implements AppShellConfigurator { + + public static void main(String[] args) { + SpringApplication.run(HhaBackendApplication.class, args); + } +} diff --git a/backend/src/main/java/de/assecutor/hha/backend/api/StatusController.java b/backend/src/main/java/de/assecutor/hha/backend/api/StatusController.java new file mode 100644 index 0000000..fdf14a9 --- /dev/null +++ b/backend/src/main/java/de/assecutor/hha/backend/api/StatusController.java @@ -0,0 +1,36 @@ +package de.assecutor.hha.backend.api; + +import java.time.Instant; +import java.util.List; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@RequestMapping("/api") +public class StatusController { + + @GetMapping("/status") + public BackendStatus status() { + return new BackendStatus( + "hha-backend", + "UP", + "HHA Backoffice", + "Vaadin UI und REST API verfuegbar", + List.of("app", "backend", "vaadin-ui"), + Instant.now(), + Runtime.version().toString() + ); + } + + public record BackendStatus( + String application, + String status, + String ui, + String message, + List modules, + Instant timestamp, + String javaVersion + ) { + } +} diff --git a/backend/src/main/java/de/assecutor/hha/backend/views/DashboardView.java b/backend/src/main/java/de/assecutor/hha/backend/views/DashboardView.java new file mode 100644 index 0000000..c47e295 --- /dev/null +++ b/backend/src/main/java/de/assecutor/hha/backend/views/DashboardView.java @@ -0,0 +1,116 @@ +package de.assecutor.hha.backend.views; + +import com.vaadin.flow.component.html.Anchor; +import com.vaadin.flow.component.html.Div; +import com.vaadin.flow.component.html.H2; +import com.vaadin.flow.component.html.H3; +import com.vaadin.flow.component.html.Paragraph; +import com.vaadin.flow.component.html.Span; +import com.vaadin.flow.router.PageTitle; +import com.vaadin.flow.router.Route; + +@PageTitle("Dashboard | HHA Backoffice") +@Route(value = "", layout = MainLayout.class) +public class DashboardView extends Div { + + public DashboardView() { + addClassName("content-view"); + add( + createHero(), + createSectionTitle("Module im Repository"), + createModuleGrid(), + createSectionTitle("Direkt verfuegbare Endpunkte"), + createEndpointGrid() + ); + } + + private Div createHero() { + Span eyebrow = new Span("Startpunkt"); + eyebrow.addClassName("eyebrow"); + + H2 title = new H2("Vaadin-Weboberflaeche und Spring-Boot-Backend sind jetzt Teil desselben Repositories."); + title.addClassName("hero-title"); + + Paragraph copy = new Paragraph( + "Das Web-Modul lebt isoliert unter /backend, kann separat gebaut werden und bildet die Grundlage fuer " + + "ein Backoffice, Monitoring-Ansichten oder spaetere APIs fuer die Flutter-App in /app."); + copy.addClassName("hero-copy"); + + Anchor apiLink = createExternalLink("/api/status", "API Status"); + Anchor healthLink = createExternalLink("/actuator/health", "Actuator Health"); + + Div actions = new Div(apiLink, healthLink); + actions.addClassName("action-row"); + + Div hero = new Div(eyebrow, title, copy, actions); + hero.addClassName("hero-card"); + return hero; + } + + private Div createModuleGrid() { + Div grid = new Div( + createInfoCard("Flutter App", "Mobile Client", + "Die bestehende Flutter-Anwendung liegt jetzt gekapselt im Modul /app."), + createInfoCard("Spring Boot", "Backend Runtime", + "Boot 4.0.3 liefert den Server, REST-Endpunkte und die Anwendungskonfiguration."), + createInfoCard("Vaadin", "Web UI", + "Vaadin 25.0.7 stellt die serverseitige Admin- und Backoffice-Oberflaeche bereit.") + ); + grid.addClassName("card-grid"); + return grid; + } + + private Div createEndpointGrid() { + Div grid = new Div( + createEndpointCard("/api/status", "JSON-Status fuer externe Clients"), + createEndpointCard("/actuator/health", "Health-Endpunkt fuer Betrieb und Monitoring"), + createEndpointCard("/", "Vaadin-Startseite fuer das Web-Backoffice") + ); + grid.addClassName("card-grid"); + return grid; + } + + private Div createSectionTitle(String text) { + H3 title = new H3(text); + title.addClassName("section-title"); + + Div wrapper = new Div(title); + wrapper.addClassName("section-header"); + return wrapper; + } + + private Div createInfoCard(String label, String title, String body) { + Span chip = new Span(label); + chip.addClassName("pill"); + + H3 heading = new H3(title); + heading.addClassName("card-title"); + + Paragraph copy = new Paragraph(body); + copy.addClassName("card-copy"); + + Div card = new Div(chip, heading, copy); + card.addClassName("info-card"); + return card; + } + + private Div createEndpointCard(String path, String description) { + Anchor link = createExternalLink(path, path); + link.addClassName("endpoint-link"); + + Paragraph copy = new Paragraph(description); + copy.addClassName("card-copy"); + + Div card = new Div(link, copy); + card.addClassName("info-card"); + return card; + } + + private Anchor createExternalLink(String href, String text) { + Anchor anchor = new Anchor(href, text); + anchor.getElement().setAttribute("router-ignore", true); + anchor.setTarget("_blank"); + anchor.addClassName("action-link"); + return anchor; + } +} diff --git a/backend/src/main/java/de/assecutor/hha/backend/views/IntegrationView.java b/backend/src/main/java/de/assecutor/hha/backend/views/IntegrationView.java new file mode 100644 index 0000000..2b14ae5 --- /dev/null +++ b/backend/src/main/java/de/assecutor/hha/backend/views/IntegrationView.java @@ -0,0 +1,95 @@ +package de.assecutor.hha.backend.views; + +import com.vaadin.flow.component.html.Anchor; +import com.vaadin.flow.component.html.Div; +import com.vaadin.flow.component.html.H2; +import com.vaadin.flow.component.html.H3; +import com.vaadin.flow.component.html.Paragraph; +import com.vaadin.flow.component.html.Pre; +import com.vaadin.flow.component.html.Span; +import com.vaadin.flow.router.PageTitle; +import com.vaadin.flow.router.Route; + +@PageTitle("Integration | HHA Backoffice") +@Route(value = "integration", layout = MainLayout.class) +public class IntegrationView extends Div { + + public IntegrationView() { + addClassName("content-view"); + add( + createIntro(), + createRepositoryCard(), + createNextStepsCard() + ); + } + + private Div createIntro() { + Span eyebrow = new Span("Struktur"); + eyebrow.addClassName("eyebrow"); + + H2 title = new H2("Das Repository ist jetzt fuer Mobile und Web vorbereitet."); + title.addClassName("hero-title"); + + Paragraph copy = new Paragraph( + "Das Flutter-Projekt lebt jetzt in /app. Das Web-Backoffice ist bewusst entkoppelt in /backend angelegt, " + + "damit Build, Runtime und Deployment separat steuerbar bleiben."); + copy.addClassName("hero-copy"); + + Div intro = new Div(eyebrow, title, copy); + intro.addClassName("hero-card"); + return intro; + } + + private Div createRepositoryCard() { + H3 title = new H3("Projektlayout"); + title.addClassName("card-title"); + + Pre layout = new Pre(""" + HHA/ + |- app/ + | |- lib/ Flutter-App + | |- android/ Flutter Android-Projekt + | `- pubspec.yaml + |- backend/ + | |- src/main/java/ Spring Boot + Vaadin + | |- src/main/resources/ + | |- src/test/java/ + | |- pom.xml + | |- mvnw + | `- .mvn/ + `- README.md + """); + layout.addClassName("repo-tree"); + + Div card = new Div(title, layout); + card.addClassName("wide-card"); + return card; + } + + private Div createNextStepsCard() { + H3 title = new H3("Naechste sinnvolle Schritte"); + title.addClassName("card-title"); + + Paragraph first = new Paragraph("1. Fachliche REST-Endpunkte unter /api aufbauen und von Flutter konsumieren."); + Paragraph second = new Paragraph("2. Vaadin-Views fuer Backoffice, Disposition oder Administration anlegen."); + Paragraph third = new Paragraph("3. Build und Deployment fuer Mobile und Backend getrennt in CI/CD ausrollen."); + + Anchor statusLink = createExternalLink("/api/status", "Status-Endpunkt pruefen"); + Anchor healthLink = createExternalLink("/actuator/health", "Health-Check pruefen"); + + Div actions = new Div(statusLink, healthLink); + actions.addClassName("action-row"); + + Div card = new Div(title, first, second, third, actions); + card.addClassName("wide-card"); + return card; + } + + private Anchor createExternalLink(String href, String text) { + Anchor anchor = new Anchor(href, text); + anchor.getElement().setAttribute("router-ignore", true); + anchor.setTarget("_blank"); + anchor.addClassName("action-link"); + return anchor; + } +} diff --git a/backend/src/main/java/de/assecutor/hha/backend/views/MainLayout.java b/backend/src/main/java/de/assecutor/hha/backend/views/MainLayout.java new file mode 100644 index 0000000..b6992dc --- /dev/null +++ b/backend/src/main/java/de/assecutor/hha/backend/views/MainLayout.java @@ -0,0 +1,71 @@ +package de.assecutor.hha.backend.views; + +import com.vaadin.flow.component.applayout.AppLayout; +import com.vaadin.flow.component.applayout.DrawerToggle; +import com.vaadin.flow.component.html.Div; +import com.vaadin.flow.component.html.H1; +import com.vaadin.flow.component.html.Paragraph; +import com.vaadin.flow.component.html.Span; +import com.vaadin.flow.component.icon.VaadinIcon; +import com.vaadin.flow.component.orderedlayout.FlexComponent; +import com.vaadin.flow.component.orderedlayout.VerticalLayout; +import com.vaadin.flow.component.sidenav.SideNav; +import com.vaadin.flow.component.sidenav.SideNavItem; + +public class MainLayout extends AppLayout { + + public MainLayout() { + addClassName("app-shell"); + setPrimarySection(Section.DRAWER); + addToNavbar(createHeader()); + addToDrawer(createDrawerContent()); + } + + private Div createHeader() { + DrawerToggle toggle = new DrawerToggle(); + + H1 title = new H1("HHA Backoffice"); + title.addClassName("app-title"); + + Paragraph subtitle = new Paragraph("Spring Boot 4 und Vaadin 25 im selben Repository wie die Flutter-App."); + subtitle.addClassName("app-subtitle"); + + Div brandBlock = new Div(title, subtitle); + brandBlock.addClassName("brand-block"); + + Div header = new Div(toggle, brandBlock); + header.addClassName("app-header"); + return header; + } + + private VerticalLayout createDrawerContent() { + Span eyebrow = new Span("Shared Repository"); + eyebrow.addClassName("drawer-eyebrow"); + + H1 heading = new H1("Web- und Mobile-Stack"); + heading.addClassName("drawer-title"); + + Paragraph copy = new Paragraph( + "Flutter lebt jetzt sauber im Modul /app. Das neue Backend liefert die Web-Oberflaeche und spaeter die API."); + copy.addClassName("drawer-copy"); + + Div intro = new Div(eyebrow, heading, copy); + intro.addClassName("drawer-intro"); + + SideNav navigation = new SideNav(); + navigation.addItem(new SideNavItem("Dashboard", DashboardView.class, VaadinIcon.DASHBOARD.create())); + navigation.addItem(new SideNavItem("Integration", IntegrationView.class, VaadinIcon.CONNECT.create())); + navigation.addClassName("drawer-nav"); + + Paragraph footer = new Paragraph("Module: /app und /backend"); + footer.addClassName("drawer-footer"); + + VerticalLayout drawer = new VerticalLayout(intro, navigation, footer); + drawer.setPadding(false); + drawer.setSpacing(false); + drawer.setSizeFull(); + drawer.setJustifyContentMode(FlexComponent.JustifyContentMode.BETWEEN); + drawer.addClassName("drawer-content"); + return drawer; + } +} diff --git a/backend/src/main/resources/META-INF/resources/styles.css b/backend/src/main/resources/META-INF/resources/styles.css new file mode 100644 index 0000000..882e757 --- /dev/null +++ b/backend/src/main/resources/META-INF/resources/styles.css @@ -0,0 +1,205 @@ +html { + --aura-accent-color: #e3001b; + --aura-background-color-light: #f4efe8; + --aura-font-family: "IBM Plex Sans", "Aptos", sans-serif; +} + +body { + background: + radial-gradient(circle at top left, rgba(227, 0, 27, 0.12), transparent 32%), + linear-gradient(180deg, #f7f2eb 0%, #efe5d7 100%); + color: #241d18; +} + +vaadin-app-layout::part(navbar) { + background: rgba(255, 248, 241, 0.88); + backdrop-filter: blur(16px); + border-bottom: 1px solid rgba(36, 29, 24, 0.12); +} + +vaadin-app-layout::part(drawer) { + background: linear-gradient(180deg, #fff7f1 0%, #f3e6d8 100%); + border-right: 1px solid rgba(36, 29, 24, 0.1); +} + +.app-header { + align-items: center; + display: flex; + gap: 1rem; + padding: 1rem 1.25rem; +} + +.brand-block { + display: flex; + flex-direction: column; + gap: 0.1rem; +} + +.app-title, +.drawer-title { + font-size: 1.2rem; + font-weight: 700; + letter-spacing: 0.01em; + margin: 0; +} + +.app-subtitle, +.drawer-copy, +.drawer-footer, +.hero-copy, +.card-copy { + color: rgba(36, 29, 24, 0.76); + line-height: 1.55; + margin: 0; +} + +.drawer-content { + box-sizing: border-box; + min-height: 100%; + padding: 1rem; +} + +.drawer-intro { + background: rgba(255, 255, 255, 0.62); + border: 1px solid rgba(36, 29, 24, 0.1); + border-radius: 1.25rem; + box-shadow: 0 18px 45px rgba(118, 92, 63, 0.08); + padding: 1rem; +} + +.drawer-eyebrow, +.eyebrow, +.pill { + align-items: center; + background: rgba(227, 0, 27, 0.1); + border-radius: 999px; + color: #970015; + display: inline-flex; + font-size: 0.78rem; + font-weight: 700; + letter-spacing: 0.04em; + padding: 0.35rem 0.7rem; + text-transform: uppercase; +} + +.drawer-nav { + margin-top: 1rem; +} + +.drawer-footer { + font-size: 0.9rem; + margin-top: 1rem; +} + +.content-view { + box-sizing: border-box; + display: flex; + flex-direction: column; + gap: 1.25rem; + margin: 0 auto; + max-width: 1100px; + padding: 1.25rem; +} + +.hero-card, +.info-card, +.wide-card { + background: rgba(255, 252, 248, 0.82); + border: 1px solid rgba(36, 29, 24, 0.1); + border-radius: 1.5rem; + box-shadow: 0 22px 55px rgba(118, 92, 63, 0.1); +} + +.hero-card { + padding: 1.5rem; +} + +.wide-card { + padding: 1.4rem; +} + +.hero-title, +.card-title, +.section-title { + margin: 0; +} + +.hero-title { + font-size: clamp(1.8rem, 2vw + 1rem, 2.8rem); + line-height: 1.1; + margin-top: 0.9rem; +} + +.section-header { + margin-top: 0.25rem; +} + +.section-title { + font-size: 1.05rem; + letter-spacing: 0.04em; + text-transform: uppercase; +} + +.card-grid { + display: flex; + flex-wrap: wrap; + gap: 1rem; +} + +.info-card { + box-sizing: border-box; + display: flex; + flex: 1 1 300px; + flex-direction: column; + gap: 0.8rem; + padding: 1.25rem; +} + +.action-row { + display: flex; + flex-wrap: wrap; + gap: 0.75rem; + margin-top: 1.2rem; +} + +.action-link { + align-items: center; + background: #241d18; + border-radius: 999px; + color: #fff8f1; + display: inline-flex; + font-weight: 700; + padding: 0.8rem 1rem; + text-decoration: none; +} + +.action-link:hover { + background: #e3001b; +} + +.endpoint-link { + font-family: "SF Mono", "Cascadia Code", monospace; + font-size: 0.98rem; +} + +.repo-tree { + background: #1f1b18; + border-radius: 1rem; + color: #fff4e7; + line-height: 1.5; + margin: 1rem 0 0; + overflow-x: auto; + padding: 1rem; +} + +@media (max-width: 800px) { + .content-view { + padding: 1rem; + } + + .hero-card, + .info-card, + .wide-card { + border-radius: 1.15rem; + } +} diff --git a/backend/src/main/resources/application.properties b/backend/src/main/resources/application.properties new file mode 100644 index 0000000..1bc5630 --- /dev/null +++ b/backend/src/main/resources/application.properties @@ -0,0 +1,10 @@ +spring.application.name=hha-backend +vaadin.launch-browser=false + +management.endpoints.web.exposure.include=health,info +management.endpoint.health.show-details=always + +info.app.name=HHA Backend +info.app.description=Spring Boot und Vaadin Backoffice im gemeinsamen Repository mit der Flutter-App +info.app.ui=Vaadin 25 +info.app.mobile=Flutter im Modul app diff --git a/backend/src/test/java/de/assecutor/hha/backend/HhaBackendApplicationTests.java b/backend/src/test/java/de/assecutor/hha/backend/HhaBackendApplicationTests.java new file mode 100644 index 0000000..844a638 --- /dev/null +++ b/backend/src/test/java/de/assecutor/hha/backend/HhaBackendApplicationTests.java @@ -0,0 +1,28 @@ +package de.assecutor.hha.backend; + +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc; +import org.springframework.test.web.servlet.MockMvc; + +@SpringBootTest +@AutoConfigureMockMvc +class HhaBackendApplicationTests { + + @Autowired + private MockMvc mockMvc; + + @Test + void statusEndpointReturnsOperationalPayload() throws Exception { + mockMvc.perform(get("/api/status")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.application").value("hha-backend")) + .andExpect(jsonPath("$.status").value("UP")) + .andExpect(jsonPath("$.ui").value("HHA Backoffice")); + } +}

    + * For internal use only. May be renamed or removed in a future release. + * + * @param id element identifier that callback is for + * @param readyCallback callback method to be informed on element ready state + * @internal + */ + public addReadyCallback(id: string, readyCallback: ReadyCallbackFunction) { + this.#readyCallback.set(id, readyCallback); + } + + public async disconnectedCallback() { + if (!this.#root) { + this.dispatchEvent( + new CustomEvent('flow-portal-remove', { + bubbles: true, + cancelable: true, + composed: true, + detail: { + children: this.#rendering, + domNode: this + } + }) + ); + } else { + this.#unmounting = Promise.resolve(); + await this.#unmounting; + this.#root.unmount(); + this.#root = undefined; + } + this.#rootRendered = false; + this.#rendering = undefined; + } + + /** + * A hook API for using stateful JS properties of the Web Component from + * the React `render()`. + * + * @typeParam T - Type of the state value + * + * @param key - Web Component property name, which is used for two-way + * value propagation from the server and back. + * @param initialValue - Fallback initial value (optional). Only applies if + * the Java component constructor does not invoke `setState`. + * @returns A tuple with two values: + * 1. The current state. + * 2. The `set` function for changing the state and triggering render + * @protected + */ + protected useState(key: string, initialValue?: T): [value: T, setValue: Dispatch] { + if (this.#stateSetters.has(key)) { + return [this.#state[key] as T, this.#stateSetters.get(key)!]; + } + + const value = ((this as Record)[key] as T) ?? initialValue!; + this.#state[key] = value; + Object.defineProperty(this, key, { + enumerable: true, + get(): T { + return this.#state[key]; + }, + set(nextValue: T) { + this.#state[key] = nextValue; + this.#dispatchFlowState({ type: 'stateKeyChanged', key, value }); + } + }); + + const dispatchChangedEvent = this.useCustomEvent<{ value: T }>(`${key}-changed`, { detail: { value } }); + const setValue = (value: T) => { + this.#state[key] = value; + dispatchChangedEvent({ value }); + this.#dispatchFlowState({ type: 'stateKeyChanged', key, value }); + }; + this.#stateSetters.set(key, setValue as Dispatch); + return [value, setValue]; + } + + /** + * A hook helper to simplify dispatching a `CustomEvent` on the Web + * Component from React. + * + * @typeParam T - The type for `event.detail` value (optional). + * + * @param type - The `CustomEvent` type string. + * @param options - The settings for the `CustomEvent`. + * @returns The `dispatch` function. The function parameters change + * depending on the `T` generic type: + * - For `undefined` type (default), has no parameters. + * - For other types, has one parameter for the `event.detail` value of that type. + * @protected + */ + protected useCustomEvent(type: string, options: CustomEventInit = {}): DispatchEvent { + if (!this.#customEvents.has(type)) { + const dispatch = ((detail?: T) => { + const eventInitDict = + detail === undefined + ? options + : { + ...options, + detail + }; + const event = new CustomEvent(type, eventInitDict); + return this.dispatchEvent(event); + }) as DispatchEvent; + this.#customEvents.set(type, dispatch as DispatchEvent); + return dispatch; + } + return this.#customEvents.get(type)! as DispatchEvent; + } + + /** + * The Web Component render function. To be implemented by users with React. + * + * @param hooks - the adapter APIs exposed for the implementation. + * @protected + */ + protected abstract render(hooks: RenderHooks): ReactElement | null; + + /** + * Prepare content container for Flow to bind server Element to. + * + * @param name container name attribute matching server name attribute + * @protected + */ + protected useContent(name: string): ReactElement | null { + useEffect(() => { + this.#readyCallback.get(name)?.(); + }, []); + return createElement('flow-content-container', { name, style: { display: 'contents' } }); + } + + #maybeRenderRoot() { + if (this.#rootRendered || !this.#root) { + return; + } + + this.#root.render(createElement(this.#Wrapper)); + this.#rootRendered = true; + } + + #renderWrapper(): ReactElement | null { + const [state, dispatchFlowState] = useReducer(stateReducer, this.#state); + this.#state = state; + this.#dispatchFlowState = dispatchFlowState; + return this.render(this.#renderHooks); + } + + #markAsUsed(): void { + // @ts-ignore + let vaadinObject = window.Vaadin || {}; + // @ts-ignore + if (vaadinObject.developmentMode) { + vaadinObject.registrations = vaadinObject.registrations || []; + vaadinObject.registrations.push({ + is: 'ReactAdapterElement', + version: '25.0.8' + }); + } + } +} diff --git a/backend/src/main/frontend/generated/flow/chunks/chunk-bb2f082c2d2806895673c8e73955a0121cc631902992dbe3083e4b276ee78c5f.js b/backend/src/main/frontend/generated/flow/chunks/chunk-bb2f082c2d2806895673c8e73955a0121cc631902992dbe3083e4b276ee78c5f.js new file mode 100644 index 0000000..754da33 --- /dev/null +++ b/backend/src/main/frontend/generated/flow/chunks/chunk-bb2f082c2d2806895673c8e73955a0121cc631902992dbe3083e4b276ee78c5f.js @@ -0,0 +1,10 @@ +import '@vaadin/app-layout/src/vaadin-app-layout.js'; +import '@vaadin/vertical-layout/src/vaadin-vertical-layout.js'; +import '@vaadin/app-layout/src/vaadin-drawer-toggle.js'; +import '@vaadin/button/src/vaadin-button.js'; +import '@vaadin/tooltip/src/vaadin-tooltip.js'; +import 'Frontend/generated/jar-resources/disableOnClickFunctions.js'; +import '@vaadin/side-nav/src/vaadin-side-nav.js'; +import '@vaadin/side-nav/src/vaadin-side-nav-item.js'; +import '@vaadin/icons/vaadin-iconset.js'; +import '@vaadin/icon/src/vaadin-icon.js'; \ No newline at end of file diff --git a/backend/src/main/frontend/generated/flow/generated-flow-imports.d.ts b/backend/src/main/frontend/generated/flow/generated-flow-imports.d.ts new file mode 100644 index 0000000..693da49 --- /dev/null +++ b/backend/src/main/frontend/generated/flow/generated-flow-imports.d.ts @@ -0,0 +1 @@ +export {} \ No newline at end of file diff --git a/backend/src/main/frontend/generated/flow/generated-flow-imports.js b/backend/src/main/frontend/generated/flow/generated-flow-imports.js new file mode 100644 index 0000000..d5dac25 --- /dev/null +++ b/backend/src/main/frontend/generated/flow/generated-flow-imports.js @@ -0,0 +1,29 @@ +import '@vaadin/app-layout/src/vaadin-app-layout.js'; +import '@vaadin/vertical-layout/src/vaadin-vertical-layout.js'; +import '@vaadin/app-layout/src/vaadin-drawer-toggle.js'; +import '@vaadin/button/src/vaadin-button.js'; +import '@vaadin/tooltip/src/vaadin-tooltip.js'; +import 'Frontend/generated/jar-resources/disableOnClickFunctions.js'; +import '@vaadin/side-nav/src/vaadin-side-nav.js'; +import '@vaadin/side-nav/src/vaadin-side-nav-item.js'; +import '@vaadin/icons/vaadin-iconset.js'; +import '@vaadin/icon/src/vaadin-icon.js'; +import '@vaadin/common-frontend/ConnectionIndicator.js'; +import 'Frontend/generated/jar-resources/ReactRouterOutletElement.tsx'; + +const loadOnDemand = (key) => { + const pending = []; + if (key === '1e3e1195126ded8f48ea9283d0ff579a0216bfc273c30bdac8e5152f029351ee') { + pending.push(import('./chunks/chunk-bb2f082c2d2806895673c8e73955a0121cc631902992dbe3083e4b276ee78c5f.js')); + } + return Promise.all(pending); +} + +window.Vaadin = window.Vaadin || {}; +window.Vaadin.Flow = window.Vaadin.Flow || {}; +window.Vaadin.Flow.loadOnDemand = loadOnDemand; +window.Vaadin.Flow.resetFocus = () => { + let ae=document.activeElement; + while(ae&&ae.shadowRoot) ae = ae.shadowRoot.activeElement; + return !ae || ae.blur() || ae.focus() || true; +} \ No newline at end of file diff --git a/backend/src/main/frontend/generated/flow/generated-flow-webcomponent-imports.js b/backend/src/main/frontend/generated/flow/generated-flow-webcomponent-imports.js new file mode 100644 index 0000000..073a9fc --- /dev/null +++ b/backend/src/main/frontend/generated/flow/generated-flow-webcomponent-imports.js @@ -0,0 +1,30 @@ +import { injectGlobalWebcomponentCss } from 'Frontend/generated/jar-resources/theme-util.js'; + +import '@vaadin/app-layout/src/vaadin-app-layout.js'; +import '@vaadin/vertical-layout/src/vaadin-vertical-layout.js'; +import '@vaadin/app-layout/src/vaadin-drawer-toggle.js'; +import '@vaadin/button/src/vaadin-button.js'; +import '@vaadin/tooltip/src/vaadin-tooltip.js'; +import 'Frontend/generated/jar-resources/disableOnClickFunctions.js'; +import '@vaadin/side-nav/src/vaadin-side-nav.js'; +import '@vaadin/side-nav/src/vaadin-side-nav-item.js'; +import '@vaadin/icons/vaadin-iconset.js'; +import '@vaadin/icon/src/vaadin-icon.js'; +import '@vaadin/common-frontend/ConnectionIndicator.js'; +import 'Frontend/generated/jar-resources/ReactRouterOutletElement.tsx'; + +const loadOnDemand = (key) => { + const pending = []; + if (key === '1e3e1195126ded8f48ea9283d0ff579a0216bfc273c30bdac8e5152f029351ee') { + pending.push(import('./chunks/chunk-bb2f082c2d2806895673c8e73955a0121cc631902992dbe3083e4b276ee78c5f.js')); + } + return Promise.all(pending); +} +window.Vaadin = window.Vaadin || {}; +window.Vaadin.Flow = window.Vaadin.Flow || {}; +window.Vaadin.Flow.loadOnDemand = loadOnDemand; +window.Vaadin.Flow.resetFocus = () => { + let ae=document.activeElement; + while(ae&&ae.shadowRoot) ae = ae.shadowRoot.activeElement; + return !ae || ae.blur() || ae.focus() || true; +} \ No newline at end of file diff --git a/backend/src/main/frontend/generated/index.tsx b/backend/src/main/frontend/generated/index.tsx new file mode 100644 index 0000000..8c8a71a --- /dev/null +++ b/backend/src/main/frontend/generated/index.tsx @@ -0,0 +1,26 @@ +/****************************************************************************** + * This file is auto-generated by Vaadin. + * If you want to customize the entry point, you can copy this file or create + * your own `index.tsx` in your frontend directory. + * By default, the `index.tsx` file should be in `./frontend/` folder. + * + * NOTE: + * - You need to restart the dev-server after adding the new `index.tsx` file. + * After that, all modifications to `index.tsx` are recompiled automatically. + * - `index.js` is also supported if you don't want to use TypeScript. + ******************************************************************************/ + +import { createElement } from 'react'; +import { createRoot } from 'react-dom/client'; +import { RouterProvider } from 'react-router'; +import { router } from 'Frontend/generated/routes.js'; + +function App() { + return ; +} + +const outlet = document.getElementById('outlet')!; +let root = (outlet as any)._root ?? createRoot(outlet); +(outlet as any)._root = root; +root.render(createElement(App)); + diff --git a/backend/src/main/frontend/generated/jar-resources/Flow.d.ts b/backend/src/main/frontend/generated/jar-resources/Flow.d.ts new file mode 100644 index 0000000..51e7731 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/Flow.d.ts @@ -0,0 +1,78 @@ +export interface FlowConfig { + imports?: () => Promise; +} +interface AppConfig { + productionMode: boolean; + appId: string; + uidl: any; +} +interface AppInitResponse { + appConfig: AppConfig; + pushScript?: string; +} +interface Router { + render: (ctx: NavigationParameters, shouldUpdateHistory: boolean) => Promise; +} +interface HTMLRouterContainer extends HTMLElement { + onBeforeEnter?: (ctx: NavigationParameters, cmd: PreventAndRedirectCommands, router: Router) => void | Promise; + onBeforeLeave?: (ctx: NavigationParameters, cmd: PreventCommands, router: Router) => void | Promise; + serverConnected?: (cancel: boolean, url?: NavigationParameters) => void; + serverPaused?: () => void; +} +interface FlowRoute { + action: (params: NavigationParameters) => Promise; + path: string; +} +export interface NavigationParameters { + pathname: string; + search?: string; +} +export interface PreventCommands { + prevent: () => any; + continue?: () => any; +} +export interface PreventAndRedirectCommands extends PreventCommands { + redirect: (route: string) => any; +} +/** + * Client API for flow UI operations. + */ +export declare class Flow { + config: FlowConfig; + response?: AppInitResponse; + pathname: string; + container: HTMLRouterContainer; + private isActive; + private baseRegex; + private appShellTitle; + private navigation; + constructor(config?: FlowConfig); + /** + * Return a `route` object for vaadin-router in an one-element array. + * + * The `FlowRoute` object `path` property handles any route, + * and the `action` returns the flow container without updating the content, + * delaying the actual Flow server call to the `onBeforeEnter` phase. + * + * This is a specific API for its use with `vaadin-router`. + */ + get serverSideRoutes(): [FlowRoute]; + loadingStarted(): void; + loadingFinished(): void; + private get action(); + private flowLeave; + private flowNavigate; + private getFlowRoutePath; + private getFlowRouteQuery; + private flowInit; + private loadScript; + private findNonce; + private injectAppIdScript; + private flowInitClient; + private flowInitUi; + private collectBrowserDetails; + private addConnectionIndicator; + private offlineStubAction; + private isFlowClientLoaded; +} +export {}; diff --git a/backend/src/main/frontend/generated/jar-resources/Flow.js b/backend/src/main/frontend/generated/jar-resources/Flow.js new file mode 100644 index 0000000..b27e74a --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/Flow.js @@ -0,0 +1,497 @@ +import { ConnectionIndicator, ConnectionState } from '@vaadin/common-frontend'; +class FlowUiInitializationError extends Error { +} +// flow uses body for keeping references +const flowRoot = window.document.body; +const $wnd = window; +const ROOT_NODE_ID = 1; // See StateTree.java +function getClients() { + return Object.keys($wnd.Vaadin.Flow.clients) + .filter((key) => key !== 'TypeScript') + .map((id) => $wnd.Vaadin.Flow.clients[id]); +} +function sendEvent(eventName, data) { + getClients().forEach((client) => client.sendEventMessage(ROOT_NODE_ID, eventName, data)); +} +// In the future could be replaced with RegExp.escape() +function escapeRegExp(pattern) { + return pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); +} +/** + * Client API for flow UI operations. + */ +export class Flow { + config; + response = undefined; + pathname = ''; + container; + // flag used to inform Testbench whether a server route is in progress + isActive = false; + baseRegex = /^\//; + appShellTitle; + navigation = ''; + constructor(config) { + // Set window.name early so @PreserveOnRefresh can use it to identify the browser tab + // Only set if not already set to preserve any existing value + if (!window.name) { + window.name = `v-${Math.random()}`; + } + flowRoot.$ = flowRoot.$ || []; + this.config = config || {}; + // TB checks for the existence of window.Vaadin.Flow in order + // to consider that TB needs to wait for `initFlow()`. + $wnd.Vaadin = $wnd.Vaadin || {}; + $wnd.Vaadin.Flow = $wnd.Vaadin.Flow || {}; + $wnd.Vaadin.Flow.clients = { + TypeScript: { + isActive: () => this.isActive + } + }; + // Set browser details collection function as global for use by refresh() + $wnd.Vaadin.Flow.getBrowserDetailsParameters = this.collectBrowserDetails.bind(this); + // Regular expression used to remove the app-context + const elm = document.head.querySelector('base'); + this.baseRegex = new RegExp(`^${ + // IE11 does not support document.baseURI + escapeRegExp(decodeURIComponent((document.baseURI || (elm && elm.href) || '/').replace(/^https?:\/\/[^/]+/i, '')))}`); + this.appShellTitle = document.title; + // Put a vaadin-connection-indicator in the dom + this.addConnectionIndicator(); + } + /** + * Return a `route` object for vaadin-router in an one-element array. + * + * The `FlowRoute` object `path` property handles any route, + * and the `action` returns the flow container without updating the content, + * delaying the actual Flow server call to the `onBeforeEnter` phase. + * + * This is a specific API for its use with `vaadin-router`. + */ + get serverSideRoutes() { + return [ + { + path: '(.*)', + action: this.action + } + ]; + } + loadingStarted() { + // Make Testbench know that server request is in progress + this.isActive = true; + $wnd.Vaadin.connectionState.loadingStarted(); + } + loadingFinished() { + // Make Testbench know that server request has finished + this.isActive = false; + $wnd.Vaadin.connectionState.loadingFinished(); + if ($wnd.Vaadin.listener) { + // Listeners registered, do not register again. + return; + } + $wnd.Vaadin.listener = {}; + // Listen for click on router-links -> 'link' navigation trigger + // and on nodes -> 'client' navigation trigger. + // Use capture phase to detect prevented / stopped events. + document.addEventListener('click', (_e) => { + if (_e.target) { + if (_e.composedPath().some((node) => node instanceof HTMLElement && node.hasAttribute('router-link'))) { + this.navigation = 'link'; + } + else if (_e.composedPath().some((node) => node.nodeName === 'A')) { + this.navigation = 'client'; + } + } + }, { + capture: true + }); + } + get action() { + // Return a function which is bound to the flow instance, thus we can use + // the syntax `...serverSideRoutes` in vaadin-router. + return async (params) => { + // Store last action pathname so as we can check it in events + this.pathname = params.pathname; + if ($wnd.Vaadin.connectionState.online) { + try { + await this.flowInit(); + } + catch (error) { + if (error instanceof FlowUiInitializationError) { + // error initializing Flow: assume connection lost + $wnd.Vaadin.connectionState.state = ConnectionState.CONNECTION_LOST; + return this.offlineStubAction(); + } + else { + throw error; + } + } + } + else { + // insert an offline stub + return this.offlineStubAction(); + } + // When an action happens, navigation will be resolved `onBeforeEnter` + this.container.onBeforeEnter = (ctx, cmd) => this.flowNavigate(ctx, cmd); + // For covering the 'server -> client' use case + this.container.onBeforeLeave = (ctx, cmd) => this.flowLeave(ctx, cmd); + return this.container; + }; + } + // Send a remote call to `JavaScriptBootstrapUI` to check + // whether navigation has to be cancelled. + async flowLeave(ctx, cmd) { + // server -> server, viewing offline stub, or browser is offline + const { connectionState } = $wnd.Vaadin; + if (this.pathname === ctx.pathname || !this.isFlowClientLoaded() || connectionState.offline) { + return Promise.resolve({}); + } + // 'server -> client' + return new Promise((resolve) => { + this.loadingStarted(); + // The callback to run from server side to cancel navigation + this.container.serverConnected = (cancel) => { + resolve(cmd && cancel ? cmd.prevent() : cmd?.continue?.()); + this.loadingFinished(); + }; + // Call server side to check whether we can leave the view + sendEvent('ui-leave-navigation', { route: this.getFlowRoutePath(ctx), query: this.getFlowRouteQuery(ctx) }); + }); + } + // Send the remote call to `JavaScriptBootstrapUI` to render the flow + // route specified by the context + async flowNavigate(ctx, cmd) { + if (this.response) { + return new Promise((resolve) => { + this.loadingStarted(); + // The callback to run from server side once the view is ready + this.container.serverConnected = (cancel, redirectContext) => { + if (cmd && cancel) { + resolve(cmd.prevent()); + } + else if (cmd && cmd.redirect && redirectContext) { + resolve(cmd.redirect(redirectContext.pathname)); + } + else { + cmd?.continue?.(); + this.container.style.display = ''; + resolve(this.container); + } + this.loadingFinished(); + }; + this.container.serverPaused = () => { + this.loadingFinished(); + }; + // Call server side to navigate to the given route + sendEvent('ui-navigate', { + route: this.getFlowRoutePath(ctx), + query: this.getFlowRouteQuery(ctx), + appShellTitle: this.appShellTitle, + historyState: history.state, + trigger: this.navigation + }); + // Default to history navigation trigger. + // Link and client cases are handled by click listener in loadingFinished(). + this.navigation = 'history'; + }); + } + else { + // No server response => offline or erroneous connection + return Promise.resolve(this.container); + } + } + getFlowRoutePath(context) { + return decodeURIComponent(context.pathname).replace(this.baseRegex, ''); + } + getFlowRouteQuery(context) { + return (context.search && context.search.substring(1)) || ''; + } + // import flow client modules and initialize UI in server side. + async flowInit() { + // Do not start flow twice + if (!this.isFlowClientLoaded()) { + $wnd.Vaadin.Flow.nonce = this.findNonce(); + // show flow progress indicator + this.loadingStarted(); + // Initialize server side UI + this.response = await this.flowInitUi(); + const { pushScript, appConfig } = this.response; + if (typeof pushScript === 'string') { + await this.loadScript(pushScript); + } + const { appId } = appConfig; + // we use a custom tag for the flow app container + // This must be created before bootstrapMod.init is called as that call + // can handle a UIDL from the server, which relies on the container being available + const tag = `flow-container-${appId.toLowerCase()}`; + const serverCreatedContainer = document.querySelector(tag); + if (serverCreatedContainer) { + this.container = serverCreatedContainer; + } + else { + this.container = document.createElement(tag); + this.container.id = appId; + } + flowRoot.$[appId] = this.container; + // Load bootstrap script with server side parameters + const bootstrapMod = await import('./FlowBootstrap'); + bootstrapMod.init(this.response); + // Load custom modules defined by user + if (typeof this.config.imports === 'function') { + this.injectAppIdScript(appId); + await this.config.imports(); + } + // Load flow-client module + const clientMod = await import('./FlowClient'); + await this.flowInitClient(clientMod); + // hide flow progress indicator + this.loadingFinished(); + } + // It might be that components created from server expect that their content has been rendered. + // Appending eagerly the container we avoid these kind of errors. + // Note that the client router will move this container to the outlet if the navigation succeed + if (this.container && !this.container.isConnected) { + this.container.style.display = 'none'; + document.body.appendChild(this.container); + } + return this.response; + } + async loadScript(url) { + return new Promise((resolve, reject) => { + const script = document.createElement('script'); + script.onload = () => resolve(); + script.onerror = reject; + script.src = url; + const { nonce } = $wnd.Vaadin.Flow; + if (nonce !== undefined) { + script.setAttribute('nonce', nonce); + } + document.body.appendChild(script); + }); + } + findNonce() { + let nonce; + const scriptTags = document.head.getElementsByTagName('script'); + for (const scriptTag of scriptTags) { + if (scriptTag.nonce) { + nonce = scriptTag.nonce; + break; + } + } + return nonce; + } + injectAppIdScript(appId) { + const appIdWithoutHashCode = appId.substring(0, appId.lastIndexOf('-')); + const scriptAppId = document.createElement('script'); + scriptAppId.type = 'module'; + scriptAppId.setAttribute('data-app-id', appIdWithoutHashCode); + const { nonce } = $wnd.Vaadin.Flow; + if (nonce !== undefined) { + scriptAppId.setAttribute('nonce', nonce); + } + document.body.append(scriptAppId); + } + // After the flow-client javascript module has been loaded, this initializes flow UI + // in the browser. + async flowInitClient(clientMod) { + clientMod.init(); + // client init is async, we need to loop until initialized + return new Promise((resolve) => { + const intervalId = setInterval(() => { + // client `isActive() == true` while initializing or processing + const initializing = getClients().reduce((prev, client) => prev || client.isActive(), false); + if (!initializing) { + clearInterval(intervalId); + resolve(); + } + }, 5); + }); + } + // Returns the `appConfig` object + async flowInitUi() { + // appConfig was sent in the index.html request + const initial = $wnd.Vaadin && $wnd.Vaadin.TypeScript && $wnd.Vaadin.TypeScript.initial; + if (initial) { + $wnd.Vaadin.TypeScript.initial = undefined; + return Promise.resolve(initial); + } + // send a request to the `JavaScriptBootstrapHandler` + return new Promise((resolve, reject) => { + const xhr = new XMLHttpRequest(); + const httpRequest = xhr; + // Collect browser details to send with init request as JSON + const browserDetails = this.collectBrowserDetails(); + const browserDetailsParam = browserDetails + ? `&v-browserDetails=${encodeURIComponent(JSON.stringify(browserDetails))}` + : ''; + const requestPath = `?v-r=init&location=${encodeURIComponent(this.getFlowRoutePath(location))}&query=${encodeURIComponent(this.getFlowRouteQuery(location))}${browserDetailsParam}`; + httpRequest.open('GET', requestPath); + httpRequest.onerror = () => reject(new FlowUiInitializationError(`Invalid server response when initializing Flow UI. + ${httpRequest.status} + ${httpRequest.responseText}`)); + httpRequest.onload = () => { + const contentType = httpRequest.getResponseHeader('content-type'); + if (contentType && contentType.indexOf('application/json') !== -1) { + resolve(JSON.parse(httpRequest.responseText)); + } + else { + httpRequest.onerror(); + } + }; + httpRequest.send(); + }); + } + // Collects browser details parameters + collectBrowserDetails() { + const params = {}; + /* Screen height and width */ + params['v-sh'] = $wnd.screen.height; + params['v-sw'] = $wnd.screen.width; + /* Browser window dimensions */ + params['v-wh'] = $wnd.innerHeight; + params['v-ww'] = $wnd.innerWidth; + /* Body element dimensions */ + params['v-bh'] = $wnd.document.body.clientHeight; + params['v-bw'] = $wnd.document.body.clientWidth; + /* Current time */ + const date = new Date(); + params['v-curdate'] = date.getTime(); + /* Current timezone offset (including DST shift) */ + const tzo1 = date.getTimezoneOffset(); + /* Compare the current tz offset with the first offset from the end + of the year that differs --- if less that, we are in DST, otherwise + we are in normal time */ + let dstDiff = 0; + let rawTzo = tzo1; + for (let m = 12; m > 0; m -= 1) { + date.setUTCMonth(m); + const tzo2 = date.getTimezoneOffset(); + if (tzo1 !== tzo2) { + dstDiff = tzo1 > tzo2 ? tzo1 - tzo2 : tzo2 - tzo1; + rawTzo = tzo1 > tzo2 ? tzo1 : tzo2; + break; + } + } + /* Time zone offset */ + params['v-tzo'] = tzo1; + /* DST difference */ + params['v-dstd'] = dstDiff; + /* Time zone offset without DST */ + params['v-rtzo'] = rawTzo; + /* DST in effect? */ + params['v-dston'] = tzo1 !== rawTzo; + /* Time zone id (if available) */ + try { + params['v-tzid'] = Intl.DateTimeFormat().resolvedOptions().timeZone; + } + catch (err) { + params['v-tzid'] = ''; + } + /* Window name */ + if ($wnd.name) { + params['v-wn'] = $wnd.name; + } + /* Detect touch device support */ + let supportsTouch = false; + try { + $wnd.document.createEvent('TouchEvent'); + supportsTouch = true; + } + catch (e) { + /* Chrome and IE10 touch detection */ + supportsTouch = 'ontouchstart' in $wnd || typeof $wnd.navigator.msMaxTouchPoints !== 'undefined'; + } + params['v-td'] = supportsTouch; + /* Device Pixel Ratio */ + params['v-pr'] = $wnd.devicePixelRatio; + if ($wnd.navigator.platform) { + params['v-np'] = $wnd.navigator.platform; + } + /* Color scheme from CSS color-scheme property */ + const colorScheme = getComputedStyle(document.documentElement).colorScheme.trim(); + // "normal" is the default value and means no color scheme is set + params['v-cs'] = colorScheme && colorScheme !== 'normal' ? colorScheme : ''; + /* Theme name - detect which theme is in use */ + const computedStyle = getComputedStyle(document.documentElement); + let themeName = ''; + if (computedStyle.getPropertyValue('--vaadin-lumo-theme').trim()) { + themeName = 'lumo'; + } + else if (computedStyle.getPropertyValue('--vaadin-aura-theme').trim()) { + themeName = 'aura'; + } + params['v-tn'] = themeName; + /* Stringify each value (they are parsed on the server side) */ + const stringParams = {}; + Object.keys(params).forEach((key) => { + const value = params[key]; + if (typeof value !== 'undefined') { + stringParams[key] = value.toString(); + } + }); + return stringParams; + } + // Create shared connection state store and connection indicator + addConnectionIndicator() { + // add connection indicator to DOM + ConnectionIndicator.create(); + // Listen to browser online/offline events and update the loading indicator accordingly. + // Note: if flow-client is loaded, it instead handles the state transitions. + $wnd.addEventListener('online', () => { + if (!this.isFlowClientLoaded()) { + // Send an HTTP HEAD request for sw.js to verify server reachability. + // We do not expect sw.js to be cached, so the request goes to the + // server rather than being served from local cache. + // Require network-level failure to revert the state to CONNECTION_LOST + // (HTTP error code is ok since it still verifies server's presence). + $wnd.Vaadin.connectionState.state = ConnectionState.RECONNECTING; + const http = new XMLHttpRequest(); + http.open('HEAD', 'sw.js'); + http.onload = () => { + $wnd.Vaadin.connectionState.state = ConnectionState.CONNECTED; + }; + http.onerror = () => { + $wnd.Vaadin.connectionState.state = ConnectionState.CONNECTION_LOST; + }; + // Postpone request to reduce potential net::ERR_INTERNET_DISCONNECTED + // errors that sometimes occurs even if browser says it is online + setTimeout(() => http.send(), 50); + } + }); + $wnd.addEventListener('offline', () => { + if (!this.isFlowClientLoaded()) { + $wnd.Vaadin.connectionState.state = ConnectionState.CONNECTION_LOST; + } + }); + } + async offlineStubAction() { + const offlineStub = document.createElement('iframe'); + const offlineStubPath = './offline-stub.html'; + offlineStub.setAttribute('src', offlineStubPath); + offlineStub.setAttribute('style', 'width: 100%; height: 100%; border: 0'); + this.response = undefined; + let onlineListener; + const removeOfflineStubAndOnlineListener = () => { + if (onlineListener !== undefined) { + $wnd.Vaadin.connectionState.removeStateChangeListener(onlineListener); + onlineListener = undefined; + } + }; + offlineStub.onBeforeEnter = (ctx, _cmds, router) => { + onlineListener = () => { + if ($wnd.Vaadin.connectionState.online) { + removeOfflineStubAndOnlineListener(); + router.render(ctx, false); + } + }; + $wnd.Vaadin.connectionState.addStateChangeListener(onlineListener); + }; + offlineStub.onBeforeLeave = (_ctx, _cmds, _router) => { + removeOfflineStubAndOnlineListener(); + }; + return offlineStub; + } + isFlowClientLoaded() { + return this.response !== undefined; + } +} +//# sourceMappingURL=Flow.js.map \ No newline at end of file diff --git a/backend/src/main/frontend/generated/jar-resources/Flow.js.map b/backend/src/main/frontend/generated/jar-resources/Flow.js.map new file mode 100644 index 0000000..a696944 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/Flow.js.map @@ -0,0 +1 @@ +{"version":3,"file":"Flow.js","sourceRoot":"","sources":["../../../../src/main/frontend/Flow.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAGhB,MAAM,yBAAyB,CAAC;AAMjC,MAAM,yBAA0B,SAAQ,KAAK;CAAG;AAgDhD,wCAAwC;AACxC,MAAM,QAAQ,GAAa,MAAM,CAAC,QAAQ,CAAC,IAAW,CAAC;AACvD,MAAM,IAAI,GAAG,MAOE,CAAC;AAChB,MAAM,YAAY,GAAG,CAAC,CAAC,CAAC,qBAAqB;AAE7C,SAAS,UAAU;IACjB,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC;SACzC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,KAAK,YAAY,CAAC;SACrC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC;AAC/C,CAAC;AAED,SAAS,SAAS,CAAC,SAAiB,EAAE,IAAS;IAC7C,UAAU,EAAE,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,gBAAgB,CAAC,YAAY,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC;AAC3F,CAAC;AAED,uDAAuD;AACvD,SAAS,YAAY,CAAC,OAAe;IACnC,OAAO,OAAO,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;AACxD,CAAC;AACD;;GAEG;AACH,MAAM,OAAO,IAAI;IACf,MAAM,CAAa;IACnB,QAAQ,GAAqB,SAAS,CAAC;IACvC,QAAQ,GAAG,EAAE,CAAC;IAEd,SAAS,CAAuB;IAEhC,sEAAsE;IAC9D,QAAQ,GAAG,KAAK,CAAC;IAEjB,SAAS,GAAG,KAAK,CAAC;IAClB,aAAa,CAAS;IAEtB,UAAU,GAAW,EAAE,CAAC;IAEhC,YAAY,MAAmB;QAC7B,qFAAqF;QACrF,6DAA6D;QAC7D,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;YACjB,MAAM,CAAC,IAAI,GAAG,KAAK,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;QACrC,CAAC;QAED,QAAQ,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;QAC9B,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QAE3B,6DAA6D;QAC7D,sDAAsD;QACtD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC;QAChC,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;QAC1C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,GAAG;YACzB,UAAU,EAAE;gBACV,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ;aAC9B;SACF,CAAC;QACF,yEAAyE;QACxE,IAAI,CAAC,MAAM,CAAC,IAAY,CAAC,2BAA2B,GAAG,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAE9F,oDAAoD;QACpD,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QAChD,IAAI,CAAC,SAAS,GAAG,IAAI,MAAM,CACzB,IAAI;QACF,yCAAyC;QACzC,YAAY,CACV,kBAAkB,CAAC,CAAC,QAAQ,CAAC,OAAO,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,OAAO,CAAC,oBAAoB,EAAE,EAAE,CAAC,CAAC,CAExG,EAAE,CACH,CAAC;QACF,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAC,KAAK,CAAC;QACpC,+CAA+C;QAC/C,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAED;;;;;;;;OAQG;IACH,IAAI,gBAAgB;QAClB,OAAO;YACL;gBACE,IAAI,EAAE,MAAM;gBACZ,MAAM,EAAE,IAAI,CAAC,MAAM;aACpB;SACF,CAAC;IACJ,CAAC;IAED,cAAc;QACZ,yDAAyD;QACzD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,cAAc,EAAE,CAAC;IAC/C,CAAC;IAED,eAAe;QACb,uDAAuD;QACvD,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,eAAe,EAAE,CAAC;QAE9C,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACzB,+CAA+C;YAC/C,OAAO;QACT,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,QAAQ,GAAG,EAAE,CAAC;QAC1B,gEAAgE;QAChE,mDAAmD;QACnD,0DAA0D;QAC1D,QAAQ,CAAC,gBAAgB,CACvB,OAAO,EACP,CAAC,EAAE,EAAE,EAAE;YACL,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC;gBACd,IAAI,EAAE,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,YAAY,WAAW,IAAI,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC;oBACtG,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC;gBAC3B,CAAC;qBAAM,IAAI,EAAE,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAE,IAAgB,CAAC,QAAQ,KAAK,GAAG,CAAC,EAAE,CAAC;oBAChF,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC;gBAC7B,CAAC;YACH,CAAC;QACH,CAAC,EACD;YACE,OAAO,EAAE,IAAI;SACd,CACF,CAAC;IACJ,CAAC;IAED,IAAY,MAAM;QAChB,yEAAyE;QACzE,qDAAqD;QACrD,OAAO,KAAK,EAAE,MAA4B,EAAE,EAAE;YAC5C,6DAA6D;YAC7D,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;YAEhC,IAAI,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC;gBACvC,IAAI,CAAC;oBACH,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACxB,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,IAAI,KAAK,YAAY,yBAAyB,EAAE,CAAC;wBAC/C,kDAAkD;wBAClD,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,GAAG,eAAe,CAAC,eAAe,CAAC;wBACpE,OAAO,IAAI,CAAC,iBAAiB,EAAE,CAAC;oBAClC,CAAC;yBAAM,CAAC;wBACN,MAAM,KAAK,CAAC;oBACd,CAAC;gBACH,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,yBAAyB;gBACzB,OAAO,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAClC,CAAC;YAED,sEAAsE;YACtE,IAAI,CAAC,SAAS,CAAC,aAAa,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YACzE,+CAA+C;YAC/C,IAAI,CAAC,SAAS,CAAC,aAAa,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YACtE,OAAO,IAAI,CAAC,SAAS,CAAC;QACxB,CAAC,CAAC;IACJ,CAAC;IAED,yDAAyD;IACzD,0CAA0C;IAClC,KAAK,CAAC,SAAS,CAAC,GAAyB,EAAE,GAAqB;QACtE,gEAAgE;QAChE,MAAM,EAAE,eAAe,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;QACxC,IAAI,IAAI,CAAC,QAAQ,KAAK,GAAG,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,eAAe,CAAC,OAAO,EAAE,CAAC;YAC5F,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAC7B,CAAC;QACD,qBAAqB;QACrB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC7B,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,4DAA4D;YAC5D,IAAI,CAAC,SAAS,CAAC,eAAe,GAAG,CAAC,MAAM,EAAE,EAAE;gBAC1C,OAAO,CAAC,GAAG,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;gBAC3D,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,CAAC,CAAC;YAEF,0DAA0D;YAC1D,SAAS,CAAC,qBAAqB,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC9G,CAAC,CAAC,CAAC;IACL,CAAC;IAED,qEAAqE;IACrE,iCAAiC;IACzB,KAAK,CAAC,YAAY,CAAC,GAAyB,EAAE,GAAgC;QACpF,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;gBAC7B,IAAI,CAAC,cAAc,EAAE,CAAC;gBACtB,8DAA8D;gBAC9D,IAAI,CAAC,SAAS,CAAC,eAAe,GAAG,CAAC,MAAM,EAAE,eAAsC,EAAE,EAAE;oBAClF,IAAI,GAAG,IAAI,MAAM,EAAE,CAAC;wBAClB,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;oBACzB,CAAC;yBAAM,IAAI,GAAG,IAAI,GAAG,CAAC,QAAQ,IAAI,eAAe,EAAE,CAAC;wBAClD,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC;oBAClD,CAAC;yBAAM,CAAC;wBACN,GAAG,EAAE,QAAQ,EAAE,EAAE,CAAC;wBAClB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,GAAG,EAAE,CAAC;wBAClC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;oBAC1B,CAAC;oBACD,IAAI,CAAC,eAAe,EAAE,CAAC;gBACzB,CAAC,CAAC;gBAEF,IAAI,CAAC,SAAS,CAAC,YAAY,GAAG,GAAG,EAAE;oBACjC,IAAI,CAAC,eAAe,EAAE,CAAC;gBACzB,CAAC,CAAC;gBAEF,kDAAkD;gBAClD,SAAS,CAAC,aAAa,EAAE;oBACvB,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC;oBACjC,KAAK,EAAE,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC;oBAClC,aAAa,EAAE,IAAI,CAAC,aAAa;oBACjC,YAAY,EAAE,OAAO,CAAC,KAAK;oBAC3B,OAAO,EAAE,IAAI,CAAC,UAAU;iBACzB,CAAC,CAAC;gBACH,yCAAyC;gBACzC,4EAA4E;gBAC5E,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;YAC9B,CAAC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,wDAAwD;YACxD,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IAEO,gBAAgB,CAAC,OAAwC;QAC/D,OAAO,kBAAkB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IAC1E,CAAC;IACO,iBAAiB,CAAC,OAAwC;QAChE,OAAO,CAAC,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC/D,CAAC;IAED,+DAA+D;IACvD,KAAK,CAAC,QAAQ;QACpB,0BAA0B;QAC1B,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC;YAC/B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YAE1C,+BAA+B;YAC/B,IAAI,CAAC,cAAc,EAAE,CAAC;YAEtB,4BAA4B;YAC5B,IAAI,CAAC,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;YAExC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC;YAEhD,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;gBACnC,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;YACpC,CAAC;YACD,MAAM,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC;YAE5B,iDAAiD;YACjD,uEAAuE;YACvE,mFAAmF;YACnF,MAAM,GAAG,GAAG,kBAAkB,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;YACpD,MAAM,sBAAsB,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;YAC3D,IAAI,sBAAsB,EAAE,CAAC;gBAC3B,IAAI,CAAC,SAAS,GAAG,sBAAqC,CAAC;YACzD,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;gBAC7C,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,KAAK,CAAC;YAC5B,CAAC;YACD,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC;YAEnC,oDAAoD;YACpD,MAAM,YAAY,GAAG,MAAM,MAAM,CAAC,iBAAiB,CAAC,CAAC;YACrD,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAEjC,sCAAsC;YACtC,IAAI,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;gBAC9C,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;gBAC9B,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YAC9B,CAAC;YAED,0BAA0B;YAC1B,MAAM,SAAS,GAAG,MAAM,MAAM,CAAC,cAAc,CAAC,CAAC;YAC/C,MAAM,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;YAErC,+BAA+B;YAC/B,IAAI,CAAC,eAAe,EAAE,CAAC;QACzB,CAAC;QAED,+FAA+F;QAC/F,iEAAiE;QACjE,+FAA+F;QAC/F,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC;YAClD,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;YACtC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC5C,CAAC;QACD,OAAO,IAAI,CAAC,QAAS,CAAC;IACxB,CAAC;IAEO,KAAK,CAAC,UAAU,CAAC,GAAW;QAClC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YAChD,MAAM,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC;YAChC,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC;YACxB,MAAM,CAAC,GAAG,GAAG,GAAG,CAAC;YACjB,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YACnC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;YACtC,CAAC;YACD,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QACpC,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,SAAS;QACf,IAAI,KAAK,CAAC;QACV,MAAM,UAAU,GAAG,QAAQ,CAAC,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC;QAChE,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,IAAI,SAAS,CAAC,KAAK,EAAE,CAAC;gBACpB,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC;gBACxB,MAAM;YACR,CAAC;QACH,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,iBAAiB,CAAC,KAAa;QACrC,MAAM,oBAAoB,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;QACxE,MAAM,WAAW,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QACrD,WAAW,CAAC,IAAI,GAAG,QAAQ,CAAC;QAC5B,WAAW,CAAC,YAAY,CAAC,aAAa,EAAE,oBAAoB,CAAC,CAAC;QAC9D,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;QACnC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,WAAW,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC3C,CAAC;QACD,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IACpC,CAAC;IAED,oFAAoF;IACpF,kBAAkB;IACV,KAAK,CAAC,cAAc,CAAC,SAAc;QACzC,SAAS,CAAC,IAAI,EAAE,CAAC;QACjB,0DAA0D;QAC1D,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC7B,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,EAAE;gBAClC,+DAA+D;gBAC/D,MAAM,YAAY,GAAG,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC,IAAI,IAAI,MAAM,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,CAAC;gBAC7F,IAAI,CAAC,YAAY,EAAE,CAAC;oBAClB,aAAa,CAAC,UAAU,CAAC,CAAC;oBAC1B,OAAO,EAAE,CAAC;gBACZ,CAAC;YACH,CAAC,EAAE,CAAC,CAAC,CAAC;QACR,CAAC,CAAC,CAAC;IACL,CAAC;IAED,iCAAiC;IACzB,KAAK,CAAC,UAAU;QACtB,+CAA+C;QAC/C,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC;QACxF,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,GAAG,SAAS,CAAC;YAC3C,OAAO,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAClC,CAAC;QAED,qDAAqD;QACrD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;YACjC,MAAM,WAAW,GAAG,GAAU,CAAC;YAE/B,4DAA4D;YAC5D,MAAM,cAAc,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;YACpD,MAAM,mBAAmB,GAAG,cAAc;gBACxC,CAAC,CAAC,qBAAqB,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,EAAE;gBAC3E,CAAC,CAAC,EAAE,CAAC;YAEP,MAAM,WAAW,GAAG,sBAAsB,kBAAkB,CAC1D,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAChC,UAAU,kBAAkB,CAAC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,GAAG,mBAAmB,EAAE,CAAC;YAExF,WAAW,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;YAErC,WAAW,CAAC,OAAO,GAAG,GAAG,EAAE,CACzB,MAAM,CACJ,IAAI,yBAAyB,CAC3B;UACF,WAAW,CAAC,MAAM;UAClB,WAAW,CAAC,YAAY,EAAE,CACzB,CACF,CAAC;YAEJ,WAAW,CAAC,MAAM,GAAG,GAAG,EAAE;gBACxB,MAAM,WAAW,GAAG,WAAW,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC;gBAClE,IAAI,WAAW,IAAI,WAAW,CAAC,OAAO,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;oBAClE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC;gBAChD,CAAC;qBAAM,CAAC;oBACN,WAAW,CAAC,OAAO,EAAE,CAAC;gBACxB,CAAC;YACH,CAAC,CAAC;YACF,WAAW,CAAC,IAAI,EAAE,CAAC;QACrB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,sCAAsC;IAC9B,qBAAqB;QAC3B,MAAM,MAAM,GAAwB,EAAE,CAAC;QAEvC,6BAA6B;QAC7B,MAAM,CAAC,MAAM,CAAC,GAAI,IAAY,CAAC,MAAM,CAAC,MAAM,CAAC;QAC7C,MAAM,CAAC,MAAM,CAAC,GAAI,IAAY,CAAC,MAAM,CAAC,KAAK,CAAC;QAC5C,+BAA+B;QAC/B,MAAM,CAAC,MAAM,CAAC,GAAI,IAAY,CAAC,WAAW,CAAC;QAC3C,MAAM,CAAC,MAAM,CAAC,GAAI,IAAY,CAAC,UAAU,CAAC;QAC1C,6BAA6B;QAC7B,MAAM,CAAC,MAAM,CAAC,GAAI,IAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC;QAC1D,MAAM,CAAC,MAAM,CAAC,GAAI,IAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC;QAEzD,kBAAkB;QAClB,MAAM,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QACxB,MAAM,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAErC,mDAAmD;QACnD,MAAM,IAAI,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAEtC;;mCAE2B;QAC3B,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,IAAI,MAAM,GAAG,IAAI,CAAC;QAClB,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YAC/B,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YACpB,MAAM,IAAI,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACtC,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;gBAClB,OAAO,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC;gBAClD,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;gBACnC,MAAM;YACR,CAAC;QACH,CAAC;QAED,sBAAsB;QACtB,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;QAEvB,oBAAoB;QACpB,MAAM,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC;QAE3B,kCAAkC;QAClC,MAAM,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC;QAE1B,oBAAoB;QACpB,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI,KAAK,MAAM,CAAC;QAEpC,iCAAiC;QACjC,IAAI,CAAC;YACH,MAAM,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC,eAAe,EAAE,CAAC,QAAQ,CAAC;QACtE,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;QACxB,CAAC;QAED,iBAAiB;QACjB,IAAK,IAAY,CAAC,IAAI,EAAE,CAAC;YACvB,MAAM,CAAC,MAAM,CAAC,GAAI,IAAY,CAAC,IAAI,CAAC;QACtC,CAAC;QAED,iCAAiC;QACjC,IAAI,aAAa,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC;YACF,IAAY,CAAC,QAAQ,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;YACjD,aAAa,GAAG,IAAI,CAAC;QACvB,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,qCAAqC;YACrC,aAAa,GAAG,cAAc,IAAI,IAAI,IAAI,OAAQ,IAAY,CAAC,SAAS,CAAC,gBAAgB,KAAK,WAAW,CAAC;QAC5G,CAAC;QACD,MAAM,CAAC,MAAM,CAAC,GAAG,aAAa,CAAC;QAE/B,wBAAwB;QACxB,MAAM,CAAC,MAAM,CAAC,GAAI,IAAY,CAAC,gBAAgB,CAAC;QAEhD,IAAK,IAAY,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;YACrC,MAAM,CAAC,MAAM,CAAC,GAAI,IAAY,CAAC,SAAS,CAAC,QAAQ,CAAC;QACpD,CAAC;QAED,iDAAiD;QACjD,MAAM,WAAW,GAAG,gBAAgB,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;QAClF,iEAAiE;QACjE,MAAM,CAAC,MAAM,CAAC,GAAG,WAAW,IAAI,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5E,+CAA+C;QAC/C,MAAM,aAAa,GAAG,gBAAgB,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;QACjE,IAAI,SAAS,GAAG,EAAE,CAAC;QACnB,IAAI,aAAa,CAAC,gBAAgB,CAAC,qBAAqB,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;YACjE,SAAS,GAAG,MAAM,CAAC;QACrB,CAAC;aAAM,IAAI,aAAa,CAAC,gBAAgB,CAAC,qBAAqB,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;YACxE,SAAS,GAAG,MAAM,CAAC;QACrB,CAAC;QACD,MAAM,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;QAE3B,+DAA+D;QAC/D,MAAM,YAAY,GAA2B,EAAE,CAAC;QAChD,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YAClC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YAC1B,IAAI,OAAO,KAAK,KAAK,WAAW,EAAE,CAAC;gBACjC,YAAY,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;YACvC,CAAC;QACH,CAAC,CAAC,CAAC;QACH,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,gEAAgE;IACxD,sBAAsB;QAC5B,kCAAkC;QAClC,mBAAmB,CAAC,MAAM,EAAE,CAAC;QAE7B,wFAAwF;QACxF,4EAA4E;QAC5E,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,GAAG,EAAE;YACnC,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC;gBAC/B,qEAAqE;gBACrE,kEAAkE;gBAClE,oDAAoD;gBACpD,uEAAuE;gBACvE,qEAAqE;gBACrE,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,GAAG,eAAe,CAAC,YAAY,CAAC;gBACjE,MAAM,IAAI,GAAG,IAAI,cAAc,EAAE,CAAC;gBAClC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAC3B,IAAI,CAAC,MAAM,GAAG,GAAG,EAAE;oBACjB,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,GAAG,eAAe,CAAC,SAAS,CAAC;gBAChE,CAAC,CAAC;gBACF,IAAI,CAAC,OAAO,GAAG,GAAG,EAAE;oBAClB,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,GAAG,eAAe,CAAC,eAAe,CAAC;gBACtE,CAAC,CAAC;gBACF,sEAAsE;gBACtE,iEAAiE;gBACjE,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;YACpC,CAAC;QACH,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,GAAG,EAAE;YACpC,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC;gBAC/B,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,GAAG,eAAe,CAAC,eAAe,CAAC;YACtE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,iBAAiB;QAC7B,MAAM,WAAW,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAwB,CAAC;QAC5E,MAAM,eAAe,GAAG,qBAAqB,CAAC;QAC9C,WAAW,CAAC,YAAY,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;QACjD,WAAW,CAAC,YAAY,CAAC,OAAO,EAAE,sCAAsC,CAAC,CAAC;QAC1E,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;QAE1B,IAAI,cAAyD,CAAC;QAC9D,MAAM,kCAAkC,GAAG,GAAG,EAAE;YAC9C,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;gBACjC,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,yBAAyB,CAAC,cAAc,CAAC,CAAC;gBACtE,cAAc,GAAG,SAAS,CAAC;YAC7B,CAAC;QACH,CAAC,CAAC;QAEF,WAAW,CAAC,aAAa,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;YACjD,cAAc,GAAG,GAAG,EAAE;gBACpB,IAAI,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC;oBACvC,kCAAkC,EAAE,CAAC;oBACrC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;gBAC5B,CAAC;YACH,CAAC,CAAC;YACF,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,sBAAsB,CAAC,cAAc,CAAC,CAAC;QACrE,CAAC,CAAC;QACF,WAAW,CAAC,aAAa,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;YACnD,kCAAkC,EAAE,CAAC;QACvC,CAAC,CAAC;QACF,OAAO,WAAW,CAAC;IACrB,CAAC;IAEO,kBAAkB;QACxB,OAAO,IAAI,CAAC,QAAQ,KAAK,SAAS,CAAC;IACrC,CAAC;CACF","sourcesContent":["import {\n ConnectionIndicator,\n ConnectionState,\n ConnectionStateChangeListener,\n ConnectionStateStore\n} from '@vaadin/common-frontend';\n\nexport interface FlowConfig {\n imports?: () => Promise;\n}\n\nclass FlowUiInitializationError extends Error {}\n\ninterface AppConfig {\n productionMode: boolean;\n appId: string;\n uidl: any;\n}\n\ninterface AppInitResponse {\n appConfig: AppConfig;\n pushScript?: string;\n}\n\ninterface Router {\n render: (ctx: NavigationParameters, shouldUpdateHistory: boolean) => Promise;\n}\n\ninterface HTMLRouterContainer extends HTMLElement {\n onBeforeEnter?: (ctx: NavigationParameters, cmd: PreventAndRedirectCommands, router: Router) => void | Promise;\n onBeforeLeave?: (ctx: NavigationParameters, cmd: PreventCommands, router: Router) => void | Promise;\n serverConnected?: (cancel: boolean, url?: NavigationParameters) => void;\n serverPaused?: () => void;\n}\n\ninterface FlowRoute {\n action: (params: NavigationParameters) => Promise;\n path: string;\n}\n\ninterface FlowRoot {\n $: any;\n $server: any;\n}\n\nexport interface NavigationParameters {\n pathname: string;\n search?: string;\n}\n\nexport interface PreventCommands {\n prevent: () => any;\n continue?: () => any;\n}\n\nexport interface PreventAndRedirectCommands extends PreventCommands {\n redirect: (route: string) => any;\n}\n\n// flow uses body for keeping references\nconst flowRoot: FlowRoot = window.document.body as any;\nconst $wnd = window as any as {\n Vaadin: {\n Flow: any;\n TypeScript: any;\n connectionState: ConnectionStateStore;\n listener: any;\n };\n} & EventTarget;\nconst ROOT_NODE_ID = 1; // See StateTree.java\n\nfunction getClients() {\n return Object.keys($wnd.Vaadin.Flow.clients)\n .filter((key) => key !== 'TypeScript')\n .map((id) => $wnd.Vaadin.Flow.clients[id]);\n}\n\nfunction sendEvent(eventName: string, data: any) {\n getClients().forEach((client) => client.sendEventMessage(ROOT_NODE_ID, eventName, data));\n}\n\n// In the future could be replaced with RegExp.escape()\nfunction escapeRegExp(pattern: string) {\n return pattern.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n/**\n * Client API for flow UI operations.\n */\nexport class Flow {\n config: FlowConfig;\n response?: AppInitResponse = undefined;\n pathname = '';\n\n container!: HTMLRouterContainer;\n\n // flag used to inform Testbench whether a server route is in progress\n private isActive = false;\n\n private baseRegex = /^\\//;\n private appShellTitle: string;\n\n private navigation: string = '';\n\n constructor(config?: FlowConfig) {\n // Set window.name early so @PreserveOnRefresh can use it to identify the browser tab\n // Only set if not already set to preserve any existing value\n if (!window.name) {\n window.name = `v-${Math.random()}`;\n }\n\n flowRoot.$ = flowRoot.$ || [];\n this.config = config || {};\n\n // TB checks for the existence of window.Vaadin.Flow in order\n // to consider that TB needs to wait for `initFlow()`.\n $wnd.Vaadin = $wnd.Vaadin || {};\n $wnd.Vaadin.Flow = $wnd.Vaadin.Flow || {};\n $wnd.Vaadin.Flow.clients = {\n TypeScript: {\n isActive: () => this.isActive\n }\n };\n // Set browser details collection function as global for use by refresh()\n ($wnd.Vaadin.Flow as any).getBrowserDetailsParameters = this.collectBrowserDetails.bind(this);\n\n // Regular expression used to remove the app-context\n const elm = document.head.querySelector('base');\n this.baseRegex = new RegExp(\n `^${\n // IE11 does not support document.baseURI\n escapeRegExp(\n decodeURIComponent((document.baseURI || (elm && elm.href) || '/').replace(/^https?:\\/\\/[^/]+/i, ''))\n )\n }`\n );\n this.appShellTitle = document.title;\n // Put a vaadin-connection-indicator in the dom\n this.addConnectionIndicator();\n }\n\n /**\n * Return a `route` object for vaadin-router in an one-element array.\n *\n * The `FlowRoute` object `path` property handles any route,\n * and the `action` returns the flow container without updating the content,\n * delaying the actual Flow server call to the `onBeforeEnter` phase.\n *\n * This is a specific API for its use with `vaadin-router`.\n */\n get serverSideRoutes(): [FlowRoute] {\n return [\n {\n path: '(.*)',\n action: this.action\n }\n ];\n }\n\n loadingStarted() {\n // Make Testbench know that server request is in progress\n this.isActive = true;\n $wnd.Vaadin.connectionState.loadingStarted();\n }\n\n loadingFinished() {\n // Make Testbench know that server request has finished\n this.isActive = false;\n $wnd.Vaadin.connectionState.loadingFinished();\n\n if ($wnd.Vaadin.listener) {\n // Listeners registered, do not register again.\n return;\n }\n $wnd.Vaadin.listener = {};\n // Listen for click on router-links -> 'link' navigation trigger\n // and on nodes -> 'client' navigation trigger.\n // Use capture phase to detect prevented / stopped events.\n document.addEventListener(\n 'click',\n (_e) => {\n if (_e.target) {\n if (_e.composedPath().some((node) => node instanceof HTMLElement && node.hasAttribute('router-link'))) {\n this.navigation = 'link';\n } else if (_e.composedPath().some((node) => (node as Element).nodeName === 'A')) {\n this.navigation = 'client';\n }\n }\n },\n {\n capture: true\n }\n );\n }\n\n private get action(): (params: NavigationParameters) => Promise {\n // Return a function which is bound to the flow instance, thus we can use\n // the syntax `...serverSideRoutes` in vaadin-router.\n return async (params: NavigationParameters) => {\n // Store last action pathname so as we can check it in events\n this.pathname = params.pathname;\n\n if ($wnd.Vaadin.connectionState.online) {\n try {\n await this.flowInit();\n } catch (error) {\n if (error instanceof FlowUiInitializationError) {\n // error initializing Flow: assume connection lost\n $wnd.Vaadin.connectionState.state = ConnectionState.CONNECTION_LOST;\n return this.offlineStubAction();\n } else {\n throw error;\n }\n }\n } else {\n // insert an offline stub\n return this.offlineStubAction();\n }\n\n // When an action happens, navigation will be resolved `onBeforeEnter`\n this.container.onBeforeEnter = (ctx, cmd) => this.flowNavigate(ctx, cmd);\n // For covering the 'server -> client' use case\n this.container.onBeforeLeave = (ctx, cmd) => this.flowLeave(ctx, cmd);\n return this.container;\n };\n }\n\n // Send a remote call to `JavaScriptBootstrapUI` to check\n // whether navigation has to be cancelled.\n private async flowLeave(ctx: NavigationParameters, cmd?: PreventCommands): Promise {\n // server -> server, viewing offline stub, or browser is offline\n const { connectionState } = $wnd.Vaadin;\n if (this.pathname === ctx.pathname || !this.isFlowClientLoaded() || connectionState.offline) {\n return Promise.resolve({});\n }\n // 'server -> client'\n return new Promise((resolve) => {\n this.loadingStarted();\n // The callback to run from server side to cancel navigation\n this.container.serverConnected = (cancel) => {\n resolve(cmd && cancel ? cmd.prevent() : cmd?.continue?.());\n this.loadingFinished();\n };\n\n // Call server side to check whether we can leave the view\n sendEvent('ui-leave-navigation', { route: this.getFlowRoutePath(ctx), query: this.getFlowRouteQuery(ctx) });\n });\n }\n\n // Send the remote call to `JavaScriptBootstrapUI` to render the flow\n // route specified by the context\n private async flowNavigate(ctx: NavigationParameters, cmd?: PreventAndRedirectCommands): Promise {\n if (this.response) {\n return new Promise((resolve) => {\n this.loadingStarted();\n // The callback to run from server side once the view is ready\n this.container.serverConnected = (cancel, redirectContext?: NavigationParameters) => {\n if (cmd && cancel) {\n resolve(cmd.prevent());\n } else if (cmd && cmd.redirect && redirectContext) {\n resolve(cmd.redirect(redirectContext.pathname));\n } else {\n cmd?.continue?.();\n this.container.style.display = '';\n resolve(this.container);\n }\n this.loadingFinished();\n };\n\n this.container.serverPaused = () => {\n this.loadingFinished();\n };\n\n // Call server side to navigate to the given route\n sendEvent('ui-navigate', {\n route: this.getFlowRoutePath(ctx),\n query: this.getFlowRouteQuery(ctx),\n appShellTitle: this.appShellTitle,\n historyState: history.state,\n trigger: this.navigation\n });\n // Default to history navigation trigger.\n // Link and client cases are handled by click listener in loadingFinished().\n this.navigation = 'history';\n });\n } else {\n // No server response => offline or erroneous connection\n return Promise.resolve(this.container);\n }\n }\n\n private getFlowRoutePath(context: NavigationParameters | Location): string {\n return decodeURIComponent(context.pathname).replace(this.baseRegex, '');\n }\n private getFlowRouteQuery(context: NavigationParameters | Location): string {\n return (context.search && context.search.substring(1)) || '';\n }\n\n // import flow client modules and initialize UI in server side.\n private async flowInit(): Promise {\n // Do not start flow twice\n if (!this.isFlowClientLoaded()) {\n $wnd.Vaadin.Flow.nonce = this.findNonce();\n\n // show flow progress indicator\n this.loadingStarted();\n\n // Initialize server side UI\n this.response = await this.flowInitUi();\n\n const { pushScript, appConfig } = this.response;\n\n if (typeof pushScript === 'string') {\n await this.loadScript(pushScript);\n }\n const { appId } = appConfig;\n\n // we use a custom tag for the flow app container\n // This must be created before bootstrapMod.init is called as that call\n // can handle a UIDL from the server, which relies on the container being available\n const tag = `flow-container-${appId.toLowerCase()}`;\n const serverCreatedContainer = document.querySelector(tag);\n if (serverCreatedContainer) {\n this.container = serverCreatedContainer as HTMLElement;\n } else {\n this.container = document.createElement(tag);\n this.container.id = appId;\n }\n flowRoot.$[appId] = this.container;\n\n // Load bootstrap script with server side parameters\n const bootstrapMod = await import('./FlowBootstrap');\n bootstrapMod.init(this.response);\n\n // Load custom modules defined by user\n if (typeof this.config.imports === 'function') {\n this.injectAppIdScript(appId);\n await this.config.imports();\n }\n\n // Load flow-client module\n const clientMod = await import('./FlowClient');\n await this.flowInitClient(clientMod);\n\n // hide flow progress indicator\n this.loadingFinished();\n }\n\n // It might be that components created from server expect that their content has been rendered.\n // Appending eagerly the container we avoid these kind of errors.\n // Note that the client router will move this container to the outlet if the navigation succeed\n if (this.container && !this.container.isConnected) {\n this.container.style.display = 'none';\n document.body.appendChild(this.container);\n }\n return this.response!;\n }\n\n private async loadScript(url: string): Promise {\n return new Promise((resolve, reject) => {\n const script = document.createElement('script');\n script.onload = () => resolve();\n script.onerror = reject;\n script.src = url;\n const { nonce } = $wnd.Vaadin.Flow;\n if (nonce !== undefined) {\n script.setAttribute('nonce', nonce);\n }\n document.body.appendChild(script);\n });\n }\n\n private findNonce(): string | undefined {\n let nonce;\n const scriptTags = document.head.getElementsByTagName('script');\n for (const scriptTag of scriptTags) {\n if (scriptTag.nonce) {\n nonce = scriptTag.nonce;\n break;\n }\n }\n return nonce;\n }\n\n private injectAppIdScript(appId: string) {\n const appIdWithoutHashCode = appId.substring(0, appId.lastIndexOf('-'));\n const scriptAppId = document.createElement('script');\n scriptAppId.type = 'module';\n scriptAppId.setAttribute('data-app-id', appIdWithoutHashCode);\n const { nonce } = $wnd.Vaadin.Flow;\n if (nonce !== undefined) {\n scriptAppId.setAttribute('nonce', nonce);\n }\n document.body.append(scriptAppId);\n }\n\n // After the flow-client javascript module has been loaded, this initializes flow UI\n // in the browser.\n private async flowInitClient(clientMod: any): Promise {\n clientMod.init();\n // client init is async, we need to loop until initialized\n return new Promise((resolve) => {\n const intervalId = setInterval(() => {\n // client `isActive() == true` while initializing or processing\n const initializing = getClients().reduce((prev, client) => prev || client.isActive(), false);\n if (!initializing) {\n clearInterval(intervalId);\n resolve();\n }\n }, 5);\n });\n }\n\n // Returns the `appConfig` object\n private async flowInitUi(): Promise {\n // appConfig was sent in the index.html request\n const initial = $wnd.Vaadin && $wnd.Vaadin.TypeScript && $wnd.Vaadin.TypeScript.initial;\n if (initial) {\n $wnd.Vaadin.TypeScript.initial = undefined;\n return Promise.resolve(initial);\n }\n\n // send a request to the `JavaScriptBootstrapHandler`\n return new Promise((resolve, reject) => {\n const xhr = new XMLHttpRequest();\n const httpRequest = xhr as any;\n\n // Collect browser details to send with init request as JSON\n const browserDetails = this.collectBrowserDetails();\n const browserDetailsParam = browserDetails\n ? `&v-browserDetails=${encodeURIComponent(JSON.stringify(browserDetails))}`\n : '';\n\n const requestPath = `?v-r=init&location=${encodeURIComponent(\n this.getFlowRoutePath(location)\n )}&query=${encodeURIComponent(this.getFlowRouteQuery(location))}${browserDetailsParam}`;\n\n httpRequest.open('GET', requestPath);\n\n httpRequest.onerror = () =>\n reject(\n new FlowUiInitializationError(\n `Invalid server response when initializing Flow UI.\n ${httpRequest.status}\n ${httpRequest.responseText}`\n )\n );\n\n httpRequest.onload = () => {\n const contentType = httpRequest.getResponseHeader('content-type');\n if (contentType && contentType.indexOf('application/json') !== -1) {\n resolve(JSON.parse(httpRequest.responseText));\n } else {\n httpRequest.onerror();\n }\n };\n httpRequest.send();\n });\n }\n\n // Collects browser details parameters\n private collectBrowserDetails(): Record {\n const params: Record = {};\n\n /* Screen height and width */\n params['v-sh'] = ($wnd as any).screen.height;\n params['v-sw'] = ($wnd as any).screen.width;\n /* Browser window dimensions */\n params['v-wh'] = ($wnd as any).innerHeight;\n params['v-ww'] = ($wnd as any).innerWidth;\n /* Body element dimensions */\n params['v-bh'] = ($wnd as any).document.body.clientHeight;\n params['v-bw'] = ($wnd as any).document.body.clientWidth;\n\n /* Current time */\n const date = new Date();\n params['v-curdate'] = date.getTime();\n\n /* Current timezone offset (including DST shift) */\n const tzo1 = date.getTimezoneOffset();\n\n /* Compare the current tz offset with the first offset from the end\n of the year that differs --- if less that, we are in DST, otherwise\n we are in normal time */\n let dstDiff = 0;\n let rawTzo = tzo1;\n for (let m = 12; m > 0; m -= 1) {\n date.setUTCMonth(m);\n const tzo2 = date.getTimezoneOffset();\n if (tzo1 !== tzo2) {\n dstDiff = tzo1 > tzo2 ? tzo1 - tzo2 : tzo2 - tzo1;\n rawTzo = tzo1 > tzo2 ? tzo1 : tzo2;\n break;\n }\n }\n\n /* Time zone offset */\n params['v-tzo'] = tzo1;\n\n /* DST difference */\n params['v-dstd'] = dstDiff;\n\n /* Time zone offset without DST */\n params['v-rtzo'] = rawTzo;\n\n /* DST in effect? */\n params['v-dston'] = tzo1 !== rawTzo;\n\n /* Time zone id (if available) */\n try {\n params['v-tzid'] = Intl.DateTimeFormat().resolvedOptions().timeZone;\n } catch (err) {\n params['v-tzid'] = '';\n }\n\n /* Window name */\n if (($wnd as any).name) {\n params['v-wn'] = ($wnd as any).name;\n }\n\n /* Detect touch device support */\n let supportsTouch = false;\n try {\n ($wnd as any).document.createEvent('TouchEvent');\n supportsTouch = true;\n } catch (e) {\n /* Chrome and IE10 touch detection */\n supportsTouch = 'ontouchstart' in $wnd || typeof ($wnd as any).navigator.msMaxTouchPoints !== 'undefined';\n }\n params['v-td'] = supportsTouch;\n\n /* Device Pixel Ratio */\n params['v-pr'] = ($wnd as any).devicePixelRatio;\n\n if (($wnd as any).navigator.platform) {\n params['v-np'] = ($wnd as any).navigator.platform;\n }\n\n /* Color scheme from CSS color-scheme property */\n const colorScheme = getComputedStyle(document.documentElement).colorScheme.trim();\n // \"normal\" is the default value and means no color scheme is set\n params['v-cs'] = colorScheme && colorScheme !== 'normal' ? colorScheme : '';\n /* Theme name - detect which theme is in use */\n const computedStyle = getComputedStyle(document.documentElement);\n let themeName = '';\n if (computedStyle.getPropertyValue('--vaadin-lumo-theme').trim()) {\n themeName = 'lumo';\n } else if (computedStyle.getPropertyValue('--vaadin-aura-theme').trim()) {\n themeName = 'aura';\n }\n params['v-tn'] = themeName;\n\n /* Stringify each value (they are parsed on the server side) */\n const stringParams: Record = {};\n Object.keys(params).forEach((key) => {\n const value = params[key];\n if (typeof value !== 'undefined') {\n stringParams[key] = value.toString();\n }\n });\n return stringParams;\n }\n\n // Create shared connection state store and connection indicator\n private addConnectionIndicator() {\n // add connection indicator to DOM\n ConnectionIndicator.create();\n\n // Listen to browser online/offline events and update the loading indicator accordingly.\n // Note: if flow-client is loaded, it instead handles the state transitions.\n $wnd.addEventListener('online', () => {\n if (!this.isFlowClientLoaded()) {\n // Send an HTTP HEAD request for sw.js to verify server reachability.\n // We do not expect sw.js to be cached, so the request goes to the\n // server rather than being served from local cache.\n // Require network-level failure to revert the state to CONNECTION_LOST\n // (HTTP error code is ok since it still verifies server's presence).\n $wnd.Vaadin.connectionState.state = ConnectionState.RECONNECTING;\n const http = new XMLHttpRequest();\n http.open('HEAD', 'sw.js');\n http.onload = () => {\n $wnd.Vaadin.connectionState.state = ConnectionState.CONNECTED;\n };\n http.onerror = () => {\n $wnd.Vaadin.connectionState.state = ConnectionState.CONNECTION_LOST;\n };\n // Postpone request to reduce potential net::ERR_INTERNET_DISCONNECTED\n // errors that sometimes occurs even if browser says it is online\n setTimeout(() => http.send(), 50);\n }\n });\n $wnd.addEventListener('offline', () => {\n if (!this.isFlowClientLoaded()) {\n $wnd.Vaadin.connectionState.state = ConnectionState.CONNECTION_LOST;\n }\n });\n }\n\n private async offlineStubAction() {\n const offlineStub = document.createElement('iframe') as HTMLRouterContainer;\n const offlineStubPath = './offline-stub.html';\n offlineStub.setAttribute('src', offlineStubPath);\n offlineStub.setAttribute('style', 'width: 100%; height: 100%; border: 0');\n this.response = undefined;\n\n let onlineListener: ConnectionStateChangeListener | undefined;\n const removeOfflineStubAndOnlineListener = () => {\n if (onlineListener !== undefined) {\n $wnd.Vaadin.connectionState.removeStateChangeListener(onlineListener);\n onlineListener = undefined;\n }\n };\n\n offlineStub.onBeforeEnter = (ctx, _cmds, router) => {\n onlineListener = () => {\n if ($wnd.Vaadin.connectionState.online) {\n removeOfflineStubAndOnlineListener();\n router.render(ctx, false);\n }\n };\n $wnd.Vaadin.connectionState.addStateChangeListener(onlineListener);\n };\n offlineStub.onBeforeLeave = (_ctx, _cmds, _router) => {\n removeOfflineStubAndOnlineListener();\n };\n return offlineStub;\n }\n\n private isFlowClientLoaded(): boolean {\n return this.response !== undefined;\n }\n}\n"]} \ No newline at end of file diff --git a/backend/src/main/frontend/generated/jar-resources/FlowBootstrap.d.ts b/backend/src/main/frontend/generated/jar-resources/FlowBootstrap.d.ts new file mode 100644 index 0000000..0398d57 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/FlowBootstrap.d.ts @@ -0,0 +1 @@ +export const init: (appInitResponse: any) => void; diff --git a/backend/src/main/frontend/generated/jar-resources/FlowBootstrap.js b/backend/src/main/frontend/generated/jar-resources/FlowBootstrap.js new file mode 100644 index 0000000..fcd80bf --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/FlowBootstrap.js @@ -0,0 +1,201 @@ +/* This is a copy of the regular `BootstrapHandler.js` in the flow-server + module, but with the following modifications: + - The main function is exported as an ES module for lazy initialization. + - Application configuration is passed as a parameter instead of using + replacement placeholders as in the regular bootstrapping. + - It reuses `Vaadin.Flow.clients` if exists. + - Fixed lint errors. + */ +const init = function (appInitResponse) { + window.Vaadin = window.Vaadin || {}; + window.Vaadin.Flow = window.Vaadin.Flow || {}; + + var apps = {}; + var widgetsets = {}; + + var log; + if (typeof window.console === undefined || !window.location.search.match(/[&?]debug(&|$)/)) { + /* If no console.log present, just use a no-op */ + log = function () {}; + } else if (typeof window.console.log === 'function') { + /* If it's a function, use it with apply */ + log = function () { + window.console.log.apply(window.console, arguments); + }; + } else { + /* In IE, its a native function for which apply is not defined, but it works + without a proper 'this' reference */ + log = window.console.log; + } + + var isInitializedInDom = function (appId) { + var appDiv = document.getElementById(appId); + if (!appDiv) { + return false; + } + for (var i = 0; i < appDiv.childElementCount; i++) { + var className = appDiv.childNodes[i].className; + /* If the app div contains a child with the class + 'v-app-loading' we have only received the HTML + but not yet started the widget set + (UIConnector removes the v-app-loading div). */ + if (className && className.indexOf('v-app-loading') != -1) { + return false; + } + } + return true; + }; + + /* + * Needed for Testbench compatibility, but prevents any Vaadin 7 app from + * bootstrapping unless the legacy vaadinBootstrap.js file is loaded before + * this script. + */ + window.Vaadin = window.Vaadin || {}; + window.Vaadin.Flow = window.Vaadin.Flow || {}; + + /* + * Needed for wrapping custom javascript functionality in the components (i.e. connectors) + */ + window.Vaadin.Flow.tryCatchWrapper = function (originalFunction, component) { + return function () { + try { + // eslint-disable-next-line + const result = originalFunction.apply(this, arguments); + return result; + } catch (error) { + console.error( + `There seems to be an error in ${component}: +${error.message} +Please submit an issue to https://github.com/vaadin/flow-components/issues/new/choose` + ); + } + }; + }; + + if (!window.Vaadin.Flow.initApplication) { + window.Vaadin.Flow.clients = window.Vaadin.Flow.clients || {}; + + window.Vaadin.Flow.initApplication = function (appId, config) { + var testbenchId = appId.replace(/-\d+$/, ''); + + if (apps[appId]) { + if ( + window.Vaadin && + window.Vaadin.Flow && + window.Vaadin.Flow.clients && + window.Vaadin.Flow.clients[testbenchId] && + window.Vaadin.Flow.clients[testbenchId].initializing + ) { + throw new Error('Application ' + appId + ' is already being initialized'); + } + if (isInitializedInDom(appId)) { + if (appInitResponse.appConfig.productionMode) { + throw new Error('Application ' + appId + ' already initialized'); + } + + // Remove old contents for Flow + var appDiv = document.getElementById(appId); + for (var i = 0; i < appDiv.childElementCount; i++) { + appDiv.childNodes[i].remove(); + } + + // For devMode reset app config and restart widgetset as client + // is up and running after hrm update. + const getConfig = function (name) { + return config[name]; + }; + + /* Export public data */ + const app = { + getConfig: getConfig + }; + apps[appId] = app; + + if (widgetsets['client'].callback) { + log('Starting from bootstrap', appId); + widgetsets['client'].callback(appId); + } else { + log('Setting pending startup', appId); + widgetsets['client'].pendingApps.push(appId); + } + return apps[appId]; + } + } + + log('init application', appId, config); + + window.Vaadin.Flow.clients[testbenchId] = { + isActive: function () { + return true; + }, + initializing: true, + productionMode: mode + }; + + var getConfig = function (name) { + var value = config[name]; + return value; + }; + + /* Export public data */ + var app = { + getConfig: getConfig + }; + apps[appId] = app; + + var widgetset = 'client'; + widgetsets[widgetset] = { + pendingApps: [] + }; + if (widgetsets[widgetset].callback) { + log('Starting from bootstrap', appId); + widgetsets[widgetset].callback(appId); + } else { + log('Setting pending startup', appId); + widgetsets[widgetset].pendingApps.push(appId); + } + + return app; + }; + window.Vaadin.Flow.getAppIds = function () { + var ids = []; + for (var id in apps) { + if (Object.prototype.hasOwnProperty.call(apps, id)) { + ids.push(id); + } + } + return ids; + }; + window.Vaadin.Flow.getApp = function (appId) { + return apps[appId]; + }; + window.Vaadin.Flow.registerWidgetset = function (widgetset, callback) { + log('Widgetset registered', widgetset); + var ws = widgetsets[widgetset]; + if (ws && ws.pendingApps) { + ws.callback = callback; + for (var i = 0; i < ws.pendingApps.length; i++) { + var appId = ws.pendingApps[i]; + log('Starting from register widgetset', appId); + callback(appId); + } + ws.pendingApps = null; + } + }; + } + + log('Flow bootstrap loaded'); + if (appInitResponse.appConfig.productionMode && typeof window.__gwtStatsEvent != 'function') { + window.Vaadin.Flow.gwtStatsEvents = []; + window.__gwtStatsEvent = function (event) { + window.Vaadin.Flow.gwtStatsEvents.push(event); + return true; + }; + } + var config = appInitResponse.appConfig; + var mode = appInitResponse.appConfig.productionMode; + window.Vaadin.Flow.initApplication(config.appId, config); +}; + +export { init }; diff --git a/backend/src/main/frontend/generated/jar-resources/FlowClient.d.ts b/backend/src/main/frontend/generated/jar-resources/FlowClient.d.ts new file mode 100644 index 0000000..7b21f90 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/FlowClient.d.ts @@ -0,0 +1 @@ +export const init: () => void; diff --git a/backend/src/main/frontend/generated/jar-resources/FlowClient.js b/backend/src/main/frontend/generated/jar-resources/FlowClient.js new file mode 100644 index 0000000..549b26f --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/FlowClient.js @@ -0,0 +1,1090 @@ +export function init() { +function client(){var Jb='',Kb=0,Lb='gwt.codesvr=',Mb='gwt.hosted=',Nb='gwt.hybrid',Ob='client',Pb='#',Qb='?',Rb='/',Sb=1,Tb='img',Ub='clear.cache.gif',Vb='baseUrl',Wb='script',Xb='client.nocache.js',Yb='base',Zb='//',$b='meta',_b='name',ac='gwt:property',bc='content',cc='=',dc='gwt:onPropertyErrorFn',ec='Bad handler "',fc='" for "gwt:onPropertyErrorFn"',gc='gwt:onLoadErrorFn',hc='" for "gwt:onLoadErrorFn"',ic='user.agent',jc='webkit',kc='safari',lc='msie',mc=10,nc=11,oc='ie10',pc=9,qc='ie9',rc=8,sc='ie8',tc='gecko',uc='gecko1_8',vc=2,wc=3,xc=4,yc='Single-script hosted mode not yet implemented. See issue ',zc='http://code.google.com/p/google-web-toolkit/issues/detail?id=2079',Ac='C2E23FD5F59B73D234B4676ED4A8FF10',Bc=':1',Cc=':',Dc='DOMContentLoaded',Ec=50;var l=Jb,m=Kb,n=Lb,o=Mb,p=Nb,q=Ob,r=Pb,s=Qb,t=Rb,u=Sb,v=Tb,w=Ub,A=Vb,B=Wb,C=Xb,D=Yb,F=Zb,G=$b,H=_b,I=ac,J=bc,K=cc,L=dc,M=ec,N=fc,O=gc,P=hc,Q=ic,R=jc,S=kc,T=lc,U=mc,V=nc,W=oc,X=pc,Y=qc,Z=rc,$=sc,_=tc,ab=uc,bb=vc,cb=wc,db=xc,eb=yc,fb=zc,gb=Ac,hb=Bc,ib=Cc,jb=Dc,kb=Ec;var lb=window,mb=document,nb,ob,pb=l,qb={},rb=[],sb=[],tb=[],ub=m,vb,wb;if(!lb.__gwt_stylesLoaded){lb.__gwt_stylesLoaded={}}if(!lb.__gwt_scriptsLoaded){lb.__gwt_scriptsLoaded={}}function xb(){var b=false;try{var c=lb.location.search;return (c.indexOf(n)!=-1||(c.indexOf(o)!=-1||lb.external&&lb.external.gwtOnLoad))&&c.indexOf(p)==-1}catch(a){}xb=function(){return b};return b} +function yb(){if(nb&&ob){nb(vb,q,pb,ub)}} +function zb(){function e(a){var b=a.lastIndexOf(r);if(b==-1){b=a.length}var c=a.indexOf(s);if(c==-1){c=a.length}var d=a.lastIndexOf(t,Math.min(c,b));return d>=m?a.substring(m,d+u):l} +function f(a){if(a.match(/^\w+:\/\//)){}else{var b=mb.createElement(v);b.src=a+w;a=e(b.src)}return a} +function g(){var a=Cb(A);if(a!=null){return a}return l} +function h(){var a=mb.getElementsByTagName(B);for(var b=m;bm){return a[a.length-u].href}return l} +function j(){var a=mb.location;return a.href==a.protocol+F+a.host+a.pathname+a.search+a.hash} +var k=g();if(k==l){k=h()}if(k==l){k=i()}if(k==l&&j()){k=e(mb.location.href)}k=f(k);return k} +function Ab(){var b=document.getElementsByTagName(G);for(var c=m,d=b.length;c=m){f=g.substring(m,i);h=g.substring(i+u)}else{f=g;h=l}qb[f]=h}}else if(f==L){g=e.getAttribute(J);if(g){try{wb=eval(g)}catch(a){alert(M+g+N)}}}else if(f==O){g=e.getAttribute(J);if(g){try{vb=eval(g)}catch(a){alert(M+g+P)}}}}}} +var Bb=function(a,b){return b in rb[a]};var Cb=function(a){var b=qb[a];return b==null?null:b};function Db(a,b){var c=tb;for(var d=m,e=a.length-u;d=U&&b=X&&b=Z&&b=V}())return ab;return S};rb[Q]={'gecko1_8':m,'ie10':u,'ie8':bb,'ie9':cb,'safari':db};client.onScriptLoad=function(a){client=null;nb=a;yb()};if(xb()){alert(eb+fb);return}zb();Ab();try{var Fb;Db([ab],gb);Db([S],gb+hb);Fb=tb[Eb(Q)];var Gb=Fb.indexOf(ib);if(Gb!=-1){ub=Number(Fb.substring(Gb+u))}}catch(a){return}var Hb;function Ib(){if(!ob){ob=true;yb();if(mb.removeEventListener){mb.removeEventListener(jb,Ib,false)}if(Hb){clearInterval(Hb)}}} +if(mb.addEventListener){mb.addEventListener(jb,function(){Ib()},false)}var Hb=setInterval(function(){if(/loaded|complete/.test(mb.readyState)){Ib()}},kb)} +client();(function () {var $gwt_version = "2.9.0";var $wnd = window;var $doc = $wnd.document;var $moduleName, $moduleBase;var $stats = $wnd.__gwtStatsEvent ? function(a) {$wnd.__gwtStatsEvent(a)} : null;var $strongName = 'C2E23FD5F59B73D234B4676ED4A8FF10';function I(){} +function Ij(){} +function dj(){} +function jj(){} +function Wj(){} +function $j(){} +function _i(){} +function nc(){} +function uc(){} +function Jk(){} +function Lk(){} +function Nk(){} +function kl(){} +function nl(){} +function pl(){} +function sl(){} +function Cl(){} +function Cr(){} +function Ar(){} +function Er(){} +function Gr(){} +function Pm(){} +function Rm(){} +function Tm(){} +function qn(){} +function sn(){} +function uo(){} +function Lo(){} +function uq(){} +function fs(){} +function js(){} +function ju(){} +function Uu(){} +function Jt(){} +function Nt(){} +function Qt(){} +function Nv(){} +function Rv(){} +function ew(){} +function nw(){} +function Wx(){} +function wy(){} +function yy(){} +function rz(){} +function xz(){} +function CA(){} +function kB(){} +function rC(){} +function VC(){} +function IE(){} +function eG(){} +function lH(){} +function wH(){} +function yH(){} +function AH(){} +function RH(){} +function iA(){fA()} +function T(a){S=a;Jb()} +function nk(a){throw a} +function yj(a,b){a.c=b} +function zj(a,b){a.d=b} +function Aj(a,b){a.e=b} +function Cj(a,b){a.g=b} +function Dj(a,b){a.h=b} +function Ej(a,b){a.i=b} +function Fj(a,b){a.j=b} +function Gj(a,b){a.k=b} +function Hj(a,b){a.l=b} +function tu(a,b){a.b=b} +function QH(a,b){a.a=b} +function bc(a){this.a=a} +function dc(a){this.a=a} +function Yj(a){this.a=a} +function tk(a){this.a=a} +function vk(a){this.a=a} +function Pk(a){this.a=a} +function il(a){this.a=a} +function wl(a){this.a=a} +function yl(a){this.a=a} +function Al(a){this.a=a} +function Il(a){this.a=a} +function Kl(a){this.a=a} +function nm(a){this.a=a} +function Vm(a){this.a=a} +function Zm(a){this.a=a} +function Zn(a){this.a=a} +function kn(a){this.a=a} +function vn(a){this.a=a} +function Vn(a){this.a=a} +function Yn(a){this.a=a} +function eo(a){this.a=a} +function so(a){this.a=a} +function xo(a){this.a=a} +function Ao(a){this.a=a} +function Co(a){this.a=a} +function Eo(a){this.a=a} +function Go(a){this.a=a} +function Io(a){this.a=a} +function Mo(a){this.a=a} +function So(a){this.a=a} +function kp(a){this.a=a} +function Bp(a){this.a=a} +function dq(a){this.a=a} +function sq(a){this.a=a} +function wq(a){this.a=a} +function yq(a){this.a=a} +function kq(a){this.b=a} +function fr(a){this.a=a} +function hr(a){this.a=a} +function jr(a){this.a=a} +function sr(a){this.a=a} +function vr(a){this.a=a} +function ls(a){this.a=a} +function ss(a){this.a=a} +function us(a){this.a=a} +function ws(a){this.a=a} +function Qs(a){this.a=a} +function Vs(a){this.a=a} +function ct(a){this.a=a} +function kt(a){this.a=a} +function mt(a){this.a=a} +function ot(a){this.a=a} +function qt(a){this.a=a} +function st(a){this.a=a} +function tt(a){this.a=a} +function xt(a){this.a=a} +function Ht(a){this.a=a} +function $t(a){this.a=a} +function hu(a){this.a=a} +function lu(a){this.a=a} +function xu(a){this.a=a} +function zu(a){this.a=a} +function Mu(a){this.a=a} +function Su(a){this.a=a} +function uu(a){this.c=a} +function lv(a){this.a=a} +function pv(a){this.a=a} +function Pv(a){this.a=a} +function tw(a){this.a=a} +function xw(a){this.a=a} +function Bw(a){this.a=a} +function Dw(a){this.a=a} +function Fw(a){this.a=a} +function Kw(a){this.a=a} +function Cy(a){this.a=a} +function Ey(a){this.a=a} +function Ry(a){this.a=a} +function Vy(a){this.a=a} +function Zy(a){this.a=a} +function _y(a){this.a=a} +function By(a){this.b=a} +function Bz(a){this.a=a} +function vz(a){this.a=a} +function zz(a){this.a=a} +function Fz(a){this.a=a} +function Nz(a){this.a=a} +function Pz(a){this.a=a} +function Rz(a){this.a=a} +function Tz(a){this.a=a} +function Vz(a){this.a=a} +function aA(a){this.a=a} +function cA(a){this.a=a} +function tA(a){this.a=a} +function wA(a){this.a=a} +function EA(a){this.a=a} +function GA(a){this.e=a} +function iB(a){this.a=a} +function mB(a){this.a=a} +function oB(a){this.a=a} +function KB(a){this.a=a} +function $B(a){this.a=a} +function aC(a){this.a=a} +function cC(a){this.a=a} +function nC(a){this.a=a} +function pC(a){this.a=a} +function FC(a){this.a=a} +function _C(a){this.a=a} +function EE(a){this.a=a} +function GE(a){this.a=a} +function JE(a){this.a=a} +function tF(a){this.a=a} +function UH(a){this.a=a} +function oG(a){this.b=a} +function CG(a){this.c=a} +function R(){this.a=xb()} +function uj(){this.a=++tj} +function ej(){sp();wp()} +function sp(){sp=_i;rp=[]} +function Si(a){return a.e} +function iv(a,b){b.ib(a)} +function zx(a,b){Sx(b,a)} +function Ex(a,b){Rx(b,a)} +function Jx(a,b){vx(b,a)} +function UA(a,b){Gv(b,a)} +function wt(a,b){zs(b.a,a)} +function Dt(a,b){QC(a.a,b)} +function CC(a){bB(a.a,a.b)} +function aE(b,a){b.data=a} +function iE(b,a){b.warn(a)} +function hE(b,a){b.log(a)} +function fE(b,a){b.debug(a)} +function gE(b,a){b.error(a)} +function Kp(a,b){a.push(b)} +function Bj(a,b){a.f=b;ik=b} +function Kr(a){a.i||Lr(a.a)} +function Z(a,b){a.e=b;W(a,b)} +function Yb(a){return a.B()} +function Om(a){return tm(a)} +function hc(a){gc();fc.D(a)} +function cl(a){Vk();this.a=a} +function kb(){ab.call(this)} +function PE(){ab.call(this)} +function NE(){kb.call(this)} +function AF(){kb.call(this)} +function JG(){kb.call(this)} +function fA(){fA=_i;eA=rA()} +function pb(){pb=_i;ob=new I} +function Qb(){Qb=_i;Pb=new Lo} +function cu(){cu=_i;bu=new ju} +function LA(){LA=_i;KA=new kB} +function pk(a){S=a;!!a&&Jb()} +function fm(a,b){a.a.add(b.d)} +function Mm(a,b,c){a.set(b,c)} +function cB(a,b,c){a.Qb(c,b)} +function em(a,b,c){_l(a,c,b)} +function my(a,b){b.forEach(a)} +function WD(b,a){b.display=a} +function QG(a){NG();this.a=a} +function fB(a){eB.call(this,a)} +function HB(a){eB.call(this,a)} +function XB(a){eB.call(this,a)} +function LE(a){lb.call(this,a)} +function rF(a){lb.call(this,a)} +function sF(a){lb.call(this,a)} +function CF(a){lb.call(this,a)} +function BF(a){nb.call(this,a)} +function ME(a){LE.call(this,a)} +function aG(a){LE.call(this,a)} +function gG(a){lb.call(this,a)} +function ZF(){JE.call(this,'')} +function $F(){JE.call(this,'')} +function Vi(){Ti==null&&(Ti=[])} +function Db(){Db=_i;!!(gc(),fc)} +function cG(){cG=_i;bG=new IE} +function YE(a){XE(a);return a.i} +function tE(b,a){return a in b} +function UE(a){return cI(a),a} +function pF(a){return cI(a),a} +function Q(a){return xb()-a.a} +function sE(a){return Object(a)} +function Wc(a,b){return $c(a,b)} +function xc(a,b){return eF(a,b)} +function cr(a,b){return a.a>b.a} +function dG(a){return Ic(a,5).e} +function Xz(a){Lx(a.b,a.a,a.c)} +function Xu(a,b){a.c.forEach(b)} +function jC(a,b){a.e||a.c.add(b)} +function In(a,b){a.e?Kn(b):dl()} +function Hm(a,b){xC(new hn(b,a))} +function Cx(a,b){xC(new Xy(b,a))} +function Dx(a,b){xC(new bz(b,a))} +function al(a,b){++Uk;b.cb(a,Rk)} +function LH(a,b,c){b.gb(dG(c))} +function eH(a,b,c){b.gb(a.a[c])} +function gy(a,b,c){lC(Yx(a,c,b))} +function VG(a,b){while(a.ic(b));} +function FH(a,b){BH(a);a.a.hc(b)} +function vH(a,b){Ic(a,105)._b(b)} +function jy(a,b){return Nl(a.b,b)} +function ly(a,b){return Ml(a.b,b)} +function Qy(a,b){return iy(a.a,b)} +function MA(a,b){return $A(a.a,b)} +function MB(a,b){return $A(a.a,b)} +function yB(a,b){return $A(a.a,b)} +function Hx(a,b){return hx(b.a,a)} +function fj(b,a){return b.exec(a)} +function Ub(a){return !!a.b||!!a.g} +function PA(a){dB(a.a);return a.h} +function TA(a){dB(a.a);return a.c} +function Ww(b,a){Pw();delete b[a]} +function ak(a,b){this.b=a;this.a=b} +function El(a,b){this.b=a;this.a=b} +function Gl(a,b){this.b=a;this.a=b} +function ul(a,b){this.a=a;this.b=b} +function Ul(a,b){this.a=a;this.b=b} +function Wl(a,b){this.a=a;this.b=b} +function jm(a,b){this.a=a;this.b=b} +function lm(a,b){this.a=a;this.b=b} +function _m(a,b){this.a=a;this.b=b} +function bn(a,b){this.a=a;this.b=b} +function dn(a,b){this.a=a;this.b=b} +function fn(a,b){this.a=a;this.b=b} +function hn(a,b){this.a=a;this.b=b} +function ao(a,b){this.a=a;this.b=b} +function go(a,b){this.b=a;this.a=b} +function io(a,b){this.b=a;this.a=b} +function Xm(a,b){this.b=a;this.a=b} +function Ir(a,b){this.b=a;this.a=b} +function Wo(a,b){this.b=a;this.c=b} +function os(a,b){this.a=a;this.b=b} +function qs(a,b){this.a=a;this.b=b} +function Rs(a,b){this.a=a;this.b=b} +function Au(a,b){this.b=a;this.a=b} +function Ou(a,b){this.a=a;this.b=b} +function Qu(a,b){this.a=a;this.b=b} +function jv(a,b){this.a=a;this.b=b} +function nv(a,b){this.a=a;this.b=b} +function rv(a,b){this.a=a;this.b=b} +function vw(a,b){this.a=a;this.b=b} +function ep(a,b){Wo.call(this,a,b)} +function qq(a,b){Wo.call(this,a,b)} +function oF(){lb.call(this,null)} +function Ob(){yb!=0&&(yb=0);Cb=-1} +function Eu(){this.a=new $wnd.Map} +function UC(){this.c=new $wnd.Map} +function Gy(a,b){this.b=a;this.a=b} +function Iy(a,b){this.b=a;this.a=b} +function Oy(a,b){this.b=a;this.a=b} +function Xy(a,b){this.b=a;this.a=b} +function bz(a,b){this.b=a;this.a=b} +function Hz(a,b){this.b=a;this.a=b} +function jz(a,b){this.a=a;this.b=b} +function nz(a,b){this.a=a;this.b=b} +function pz(a,b){this.a=a;this.b=b} +function Jz(a,b){this.a=a;this.b=b} +function $z(a,b){this.a=a;this.b=b} +function mA(a,b){this.a=a;this.b=b} +function qB(a,b){this.a=a;this.b=b} +function eC(a,b){this.a=a;this.b=b} +function DC(a,b){this.a=a;this.b=b} +function GC(a,b){this.a=a;this.b=b} +function oA(a,b){this.b=a;this.a=b} +function xB(a,b){this.d=a;this.e=b} +function oD(a,b){Wo.call(this,a,b)} +function yD(a,b){Wo.call(this,a,b)} +function FD(a,b){Wo.call(this,a,b)} +function ND(a,b){Wo.call(this,a,b)} +function CE(a,b){Wo.call(this,a,b)} +function sH(a,b){Wo.call(this,a,b)} +function uH(a,b){this.a=a;this.b=b} +function OH(a,b){this.a=a;this.b=b} +function VH(a,b){this.b=a;this.a=b} +function Bx(a,b,c){Px(a,b);qx(c.e)} +function Ut(a,b,c,d){Tt(a,b.d,c,d)} +function Mq(a,b){Eq(a,(br(),_q),b)} +function XH(a,b,c){a.splice(b,0,c)} +function jp(a,b){return hp(b,ip(a))} +function Yl(a,b){return Nc(a.b[b])} +function Yc(a){return typeof a===tI} +function qF(a){return ad((cI(a),a))} +function QF(a,b){return a.substr(b)} +function hA(a,b){mC(b);eA.delete(a)} +function kE(b,a){b.clearTimeout(a)} +function Nb(a){$wnd.clearTimeout(a)} +function lj(a){$wnd.clearTimeout(a)} +function jE(b,a){b.clearInterval(a)} +function qA(a){a.length=0;return a} +function WF(a,b){a.a+=''+b;return a} +function XF(a,b){a.a+=''+b;return a} +function YF(a,b){a.a+=''+b;return a} +function bd(a){fI(a==null);return a} +function JH(a,b,c){vH(b,c);return b} +function Tq(a,b){Eq(a,(br(),ar),b.a)} +function dm(a,b){return a.a.has(b.d)} +function H(a,b){return _c(a)===_c(b)} +function LF(a,b){return a.indexOf(b)} +function qE(a){return a&&a.valueOf()} +function rE(a){return a&&a.valueOf()} +function LG(a){return a!=null?O(a):0} +function _c(a){return a==null?null:a} +function NG(){NG=_i;MG=new QG(null)} +function gw(){gw=_i;fw=new $wnd.Map} +function Pw(){Pw=_i;Ow=new $wnd.Map} +function TE(){TE=_i;RE=false;SE=true} +function Wq(a){!!a.b&&Rq(a,(br(),ar))} +function Iq(a){!!a.b&&Rq(a,(br(),$q))} +function U(a){a.h=zc(ki,wI,31,0,0,1)} +function kj(a){$wnd.clearInterval(a)} +function qr(a){this.a=a;jj.call(this)} +function hs(a){this.a=a;jj.call(this)} +function at(a){this.a=a;jj.call(this)} +function Gt(a){this.a=new UC;this.c=a} +function hD(a){this.c=a.toLowerCase()} +function av(a,b){return a.h.delete(b)} +function cv(a,b){return a.b.delete(b)} +function bB(a,b){return a.a.delete(b)} +function hy(a,b,c){return Yx(a,c.a,b)} +function TH(a,b,c){return JH(a.a,b,c)} +function KH(a,b,c){QH(a,TH(b,a.a,c))} +function fl(a,b,c,d){Vk();En(a,c,d,b)} +function gl(a,b,c,d){Vk();Hn(a,c,d,b)} +function ky(a,b){return zm(a.b.root,b)} +function rA(){return new $wnd.WeakMap} +function VF(a){return a==null?AI:cj(a)} +function Nr(a){return wJ in a?a[wJ]:-1} +function Vr(a){Ko((Qb(),Pb),new ws(a))} +function Zk(a){Ko((Qb(),Pb),new Al(a))} +function Ap(a){Ko((Qb(),Pb),new Bp(a))} +function Pp(a){Ko((Qb(),Pb),new dq(a))} +function oy(a){Ko((Qb(),Pb),new Vz(a))} +function _F(a){JE.call(this,(cI(a),a))} +function ab(){U(this);V(this);this.w()} +function wG(){this.a=zc(ii,wI,1,0,5,1)} +function mI(){mI=_i;jI=new I;lI=new I} +function sk(a){rk()&&iE($wnd.console,a)} +function jk(a){rk()&&fE($wnd.console,a)} +function lk(a){rk()&&gE($wnd.console,a)} +function qk(a){rk()&&hE($wnd.console,a)} +function ko(a){rk()&&gE($wnd.console,a)} +function iI(a){return a.$H||(a.$H=++hI)} +function Sc(a,b){return a!=null&&Hc(a,b)} +function PG(a,b){return a.a!=null?a.a:b} +function on(a){return ''+pn(mn.lb()-a,3)} +function YD(a,b,c,d){return QD(a,b,c,d)} +function Gx(a,b){var c;c=hx(b,a);lC(c)} +function Xs(a,b){b.a.b==(dp(),cp)&&Zs(a)} +function AB(a,b){dB(a.a);a.c.forEach(b)} +function NB(a,b){dB(a.a);a.b.forEach(b)} +function kC(a){if(a.d||a.e){return}iC(a)} +function Ds(a){if(a.f){gj(a.f);a.f=null}} +function Zs(a){if(a.a){gj(a.a);a.a=null}} +function _H(a){if(!a){throw Si(new NE)}} +function aI(a){if(!a){throw Si(new JG)}} +function fI(a){if(!a){throw Si(new oF)}} +function XE(a){if(a.i!=null){return}iF(a)} +function tb(a){return a==null?null:a.name} +function ZD(a,b){return a.appendChild(b)} +function $D(b,a){return b.appendChild(a)} +function MF(a,b){return a.lastIndexOf(b)} +function RF(a,b,c){return a.substr(b,c-b)} +function el(a,b,c){Vk();return a.set(c,b)} +function XD(d,a,b,c){d.setProperty(a,b,c)} +function dB(a){var b;b=tC;!!b&&gC(b,a.b)} +function sB(a,b){GA.call(this,a);this.a=b} +function IH(a,b){DH.call(this,a);this.a=b} +function Jc(a){fI(a==null||Tc(a));return a} +function Kc(a){fI(a==null||Uc(a));return a} +function Lc(a){fI(a==null||Yc(a));return a} +function Pc(a){fI(a==null||Xc(a));return a} +function Xc(a){return typeof a==='string'} +function Uc(a){return typeof a==='number'} +function Tc(a){return typeof a==='boolean'} +function Vo(a){return a.b!=null?a.b:''+a.c} +function bE(b,a){return b.createElement(a)} +function VE(a,b){return cI(a),_c(a)===_c(b)} +function JF(a,b){return cI(a),_c(a)===_c(b)} +function $c(a,b){return a&&b&&a instanceof b} +function sb(a){return a==null?null:a.message} +function Eb(a,b,c){return a.apply(b,c);var d} +function kc(a){gc();return parseInt(a)||-1} +function pj(a,b){return $wnd.setTimeout(a,b)} +function lr(a,b){b.a.b==(dp(),cp)&&or(a,-1)} +function Xb(a,b){a.b=Zb(a.b,[b,false]);Vb(a)} +function mo(a,b){no(a,b,Ic(xk(a.a,td),7).j)} +function Ur(a,b){Fu(Ic(xk(a.i,Zf),86),b[yJ])} +function hl(a){Vk();Uk==0?a.C():Tk.push(a)} +function xC(a){uC==null&&(uC=[]);uC.push(a)} +function yC(a){wC==null&&(wC=[]);wC.push(a)} +function eB(a){this.a=new $wnd.Set;this.b=a} +function $l(){this.a=new $wnd.Map;this.b=[]} +function fq(a,b,c){this.a=a;this.c=b;this.b=c} +function dr(a,b,c){Wo.call(this,a,b);this.a=c} +function jw(a,b,c){this.c=a;this.d=b;this.j=c} +function Mw(a,b,c){this.b=a;this.a=b;this.c=c} +function Ky(a,b,c){this.c=a;this.b=b;this.a=c} +function My(a,b,c){this.b=a;this.c=b;this.a=c} +function Ty(a,b,c){this.a=a;this.b=b;this.c=c} +function dz(a,b,c){this.a=a;this.b=b;this.c=c} +function fz(a,b,c){this.a=a;this.b=b;this.c=c} +function hz(a,b,c){this.a=a;this.b=b;this.c=c} +function tz(a,b,c){this.c=a;this.b=b;this.a=c} +function Dz(a,b,c){this.b=a;this.a=b;this.c=c} +function Lz(a,b,c){this.b=a;this.c=b;this.a=c} +function Yz(a,b,c){this.b=a;this.a=b;this.c=c} +function Qo(){this.b=(dp(),ap);this.a=new UC} +function Vk(){Vk=_i;Tk=[];Rk=new kl;Sk=new pl} +function zF(){zF=_i;yF=zc(ei,wI,27,256,0,1)} +function pw(a){a.c?jE($wnd,a.d):kE($wnd,a.d)} +function oj(a,b){return $wnd.setInterval(a,b)} +function NF(a,b,c){return a.lastIndexOf(b,c)} +function _D(c,a,b){return c.insertBefore(a,b)} +function VD(b,a){return b.getPropertyValue(a)} +function mj(a,b){return qI(function(){a.H(b)})} +function rk(){if(!ik){return true}return mk()} +function nE(a){if(a==null){return 0}return +a} +function Ic(a,b){fI(a==null||Hc(a,b));return a} +function Oc(a,b){fI(a==null||$c(a,b));return a} +function cF(a,b){var c;c=_E(a,b);c.e=2;return c} +function rG(a,b){a.a[a.a.length]=b;return true} +function sG(a,b){bI(b,a.a.length);return a.a[b]} +function Vu(a,b){a.b.add(b);return new rv(a,b)} +function Wu(a,b){a.h.add(b);return new nv(a,b)} +function Ns(a,b){$wnd.navigator.sendBeacon(a,b)} +function WA(a,b){a.d=true;NA(a,b);yC(new mB(a))} +function mC(a){a.e=true;iC(a);a.c.clear();hC(a)} +function vp(a){return $wnd.Vaadin.Flow.getApp(a)} +function Hw(a,b){return Iw(new Kw(a),b,19,true)} +function im(a,b,c){return a.set(c,(dB(b.a),b.h))} +function jt(a,b,c){a.set(c,(dB(b.a),Pc(b.h)))} +function yr(a,b,c){a.gb(xF(QA(Ic(c.e,17),b)))} +function Bk(a,b,c){Ak(a,b,c.bb());a.b.set(b,c)} +function PC(a,b,c,d){var e;e=RC(a,b,c);e.push(d)} +function NC(a,b){a.a==null&&(a.a=[]);a.a.push(b)} +function Yq(a,b){this.a=a;this.b=b;jj.call(this)} +function Os(a,b){this.a=a;this.b=b;jj.call(this)} +function ru(a,b){this.a=a;this.b=b;jj.call(this)} +function lb(a){U(this);this.g=a;V(this);this.w()} +function gu(a){cu();this.c=[];this.a=bu;this.d=a} +function qj(a){a.onreadystatechange=function(){}} +function bl(a){++Uk;In(Ic(xk(a.a,te),54),new sl)} +function Ts(a,b){var c;c=ad(pF(Kc(b.a)));Ys(a,c)} +function cE(c,a,b){return c.createElementNS(a,b)} +function UD(b,a){return b.getPropertyPriority(a)} +function Zc(a){return typeof a===rI||typeof a===tI} +function Bc(a){return Array.isArray(a)&&a.lc===dj} +function Rc(a){return !Array.isArray(a)&&a.lc===dj} +function Vc(a){return a!=null&&Zc(a)&&!(a.lc===dj)} +function HG(a){return new IH(null,GG(a,a.length))} +function GG(a,b){return WG(b,a.length),new fH(a,b)} +function Jm(a,b,c){return a.push(MA(c,new fn(c,b)))} +function TG(a){NG();return a==null?MG:new QG(cI(a))} +function qx(a){var b;b=a.a;dv(a,null);dv(a,b);dw(a)} +function aF(a,b,c){var d;d=_E(a,b);mF(c,d);return d} +function _E(a,b){var c;c=new ZE;c.f=a;c.d=b;return c} +function Zb(a,b){!a&&(a=[]);a[a.length]=b;return a} +function yk(a,b,c){a.a.delete(c);a.a.set(c,b.bb())} +function TD(a,b,c,d){a.removeEventListener(b,c,d)} +function vv(a,b){var c;c=b;return Ic(a.a.get(c),6)} +function Jb(){Db();if(zb){return}zb=true;Kb(false)} +function BH(a){if(!a.b){CH(a);a.c=true}else{BH(a.b)}} +function _G(a,b){cI(b);while(a.c=0){a.a=new at(a);ij(a.a,b)}} +function DH(a){if(!a){this.b=null;new wG}else{this.b=a}} +function dE(a,b,c,d){this.b=a;this.c=b;this.a=c;this.d=d} +function ms(a,b,c,d){this.a=a;this.d=b;this.b=c;this.c=d} +function fH(a,b){this.c=0;this.d=b;this.b=17488;this.a=a} +function $G(a,b){this.d=a;this.c=(b&64)!=0?b|16384:b} +function $s(a){this.b=a;Oo(Ic(xk(a,Ge),13),new ct(this))} +function Dq(a,b){oo(Ic(xk(a.c,Be),23),'',b,'',null,null)} +function no(a,b,c){oo(a,c.caption,c.message,b,c.url,null)} +function Dv(a,b,c,d){yv(a,b)&&Ut(Ic(xk(a.c,Kf),33),b,c,d)} +function Xt(a,b){var c;c=Ic(xk(a.a,Of),37);du(c,b);fu(c)} +function AC(a,b){var c;c=tC;tC=a;try{b.C()}finally{tC=c}} +function $(a,b){var c;c=YE(a.jc);return b==null?c:c+': '+b} +function WC(a,b,c){this.a=a;this.d=b;this.c=null;this.b=c} +function ek(){this.a=new hD($wnd.navigator.userAgent);dk()} +function Nc(a){fI(a==null||Zc(a)&&!(a.lc===dj));return a} +function Am(a){var b;b=a.f;while(!!b&&!b.a){b=b.f}return b} +function Pn(a,b,c){this.b=a;this.d=b;this.c=c;this.a=new R} +function Nm(a,b,c,d,e){a.splice.apply(a,[b,c,d].concat(e))} +function er(){br();return Dc(xc(Te,1),wI,67,0,[$q,_q,ar])} +function fp(){dp();return Dc(xc(Fe,1),wI,65,0,[ap,bp,cp])} +function OD(){MD();return Dc(xc(Ih,1),wI,46,0,[KD,JD,LD])} +function tH(){rH();return Dc(xc(Ei,1),wI,52,0,[oH,pH,qH])} +function ry(a){return VE((TE(),RE),PA(OB($u(a,0),LJ)))} +function Qc(a){return a.jc||Array.isArray(a)&&xc(ed,1)||ed} +function mE(c,a,b){return c.setTimeout(qI(a.Ub).bind(a),b)} +function BA(a){if(!zA){return a}return $wnd.Polymer.dom(a)} +function EH(a,b){var c;return HH(a,new wG,(c=new UH(b),c))} +function dI(a,b){if(a<0||a>b){throw Si(new LE(CK+a+DK+b))}} +function SD(a,b){Rc(a)?a.U(b):(a.handleEvent(b),undefined)} +function bv(a,b){_c(b.V(a))===_c((TE(),SE))&&a.b.delete(b)} +function zw(a,b){vA(b).forEach(aj(Dw.prototype.gb,Dw,[a]))} +function bI(a,b){if(a<0||a>=b){throw Si(new LE(CK+a+DK+b))}} +function eI(a,b){if(a<0||a>=b){throw Si(new aG(CK+a+DK+b))}} +function zr(a){gk('applyDefaultTheme',(TE(),a?true:false))} +function qo(a){FH(HG(Ic(xk(a.a,td),7).c),new uo);a.b=false} +function gc(){gc=_i;var a,b;b=!mc();a=new uc;fc=b?new nc:a} +function Rn(a,b,c){this.a=a;this.c=b;this.b=c;jj.call(this)} +function Tn(a,b,c){this.a=a;this.c=b;this.b=c;jj.call(this)} +function OE(a,b){U(this);this.f=b;this.g=a;V(this);this.w()} +function lE(c,a,b){return c.setInterval(qI(a.Ub).bind(a),b)} +function qm(a,b){a.updateComplete.then(qI(function(){b.I()}))} +function Kx(a,b,c){return a.set(c,OA(OB($u(b.e,1),c),b.b[c]))} +function yA(a,b,c,d){return a.splice.apply(a,[b,c].concat(d))} +function rq(){pq();return Dc(xc(Me,1),wI,57,0,[mq,lq,oq,nq])} +function GD(){ED();return Dc(xc(Hh,1),wI,48,0,[DD,BD,CD,AD])} +function Es(a){if(Cs(a)){a.b.a=zc(ii,wI,1,0,5,1);Ds(a);Gs(a)}} +function gF(a){if(a.$b()){return null}var b=a.h;return Yi[b]} +function eu(a){a.a=bu;if(!a.b){return}Gs(Ic(xk(a.d,tf),16))} +function NA(a,b){if(!a.b&&a.c&&KG(b,a.h)){return}XA(a,b,true)} +function ww(a,b){vA(b).forEach(aj(Bw.prototype.gb,Bw,[a.a]))} +function eF(a,b){var c=a.a=a.a||[];return c[b]||(c[b]=a.Vb(b))} +function Up(a){$wnd.vaadinPush.atmosphere.unsubscribeUrl(a)} +function np(a){a?($wnd.location=a):$wnd.location.reload(false)} +function BC(a){this.a=a;this.b=[];this.c=new $wnd.Set;iC(this)} +function rb(a){pb();nb.call(this,a);this.a='';this.b=a;this.a=''} +function BG(a){aI(a.a-1} +function mp(a){var b;b=$doc.createElement('a');b.href=a;return b.href} +function wB(a){var b;if(Sc(a,6)){b=Ic(a,6);return Yu(b)}else{return a}} +function Gb(b){Db();return function(){return Hb(b,this,arguments);var a}} +function zD(){xD();return Dc(xc(Eh,1),wI,35,0,[wD,vD,qD,sD,uD,tD,rD])} +function xb(){if(Date.now){return Date.now()}return (new Date).getTime()} +function _A(a,b){if(!b){debugger;throw Si(new PE)}return $A(a,a.Rb(b))} +function Bu(a,b){if(b==null){debugger;throw Si(new PE)}return a.a.get(b)} +function Cu(a,b){if(b==null){debugger;throw Si(new PE)}return a.a.has(b)} +function MH(a,b){$G.call(this,b.gc(),b.fc()&-6);cI(a);this.a=a;this.b=b} +function iH(a,b){!a.a?(a.a=new _F(a.d)):YF(a.a,a.b);WF(a.a,b);return a} +function uG(a){var b;b=(bI(0,a.a.length),a.a[0]);a.a.splice(0,1);return b} +function vA(a){var b;b=[];a.forEach(aj(wA.prototype.cb,wA,[b]));return b} +function BB(a,b){var c;c=a.c.splice(0,b);aB(a.a,new IA(a,0,c,[],false))} +function Ax(a,b){var c;c=b.f;vy(Ic(xk(b.e.e.g.c,td),7),a,c,(dB(b.a),b.h))} +function Im(a,b,c){var d;d=c.a;a.push(MA(d,new bn(d,b)));xC(new Xm(d,b))} +function Us(a,b){var c,d;c=$u(a,8);d=OB(c,'pollInterval');MA(d,new Vs(b))} +function SB(a,b){xB.call(this,a,b);this.b=new $wnd.Map;this.a=new XB(this)} +function nb(a){U(this);V(this);this.e=a;W(this,a);this.g=a==null?AI:cj(a)} +function mb(a){U(this);this.g=!a?null:$(a,a.v());this.f=a;V(this);this.w()} +function as(a){this.j=new $wnd.Set;this.g=[];this.c=new hs(this);this.i=a} +function jH(){this.b=', ';this.d='[';this.e=']';this.c=this.d+(''+this.e)} +function Ms(a){this.b=new wG;this.e=a;At(Ic(xk(this.e,Gf),12),new Qs(this))} +function ht(a){this.a=a;MA(OB($u(Ic(xk(this.a,cg),8).e,5),jJ),new kt(this))} +function Lu(a){Ic(xk(a.a,Ge),13).b==(dp(),cp)||Po(Ic(xk(a.a,Ge),13),cp)} +function QB(a,b){if(!a.b.has(b)){return false}return TA(Ic(a.b.get(b),17))} +function aH(a,b){cI(b);if(a.ca||a>b){throw Si(new ME('fromIndex: 0, toIndex: '+a+', length: '+b))}} +function ij(a,b){if(b<=0){throw Si(new rF(II))}!!a.f&&gj(a);a.e=true;a.f=xF(oj(mj(a,a.d),b))} +function hj(a,b){if(b<0){throw Si(new rF(HI))}!!a.f&&gj(a);a.e=false;a.f=xF(pj(mj(a,a.d),b))} +function YA(a,b,c){LA();this.a=new fB(this);this.g=(NG(),NG(),MG);this.f=a;this.e=b;this.b=c} +function EF(a,b,c){if(a==null){debugger;throw Si(new PE)}this.a=GI;this.d=a;this.b=b;this.c=c} +function Ev(a,b,c,d,e,f){if(!tv(a,b)){debugger;throw Si(new PE)}Vt(Ic(xk(a.c,Kf),33),b,c,d,e,f)} +function yx(a,b,c,d){var e,f,g;g=c[MJ];e="path='"+wb(g)+"'";f=new nz(a,g);px(a,b,d,f,null,e)} +function JC(a,b){var c,d,e,f;e=[];for(d=0;d=0&&or(Ic(xk(a.c,_e),28),Ic(xk(a.c,td),7).d);Eq(a,(br(),$q),null)} +function pu(a){this.a=a;QD($wnd,'beforeunload',new xu(this),false);Bt(Ic(xk(a,Gf),12),new zu(this))} +function Is(a){var b,c,d;b=[];c={};c['UNLOAD']=Object(true);d=Bs(a,b,c);Ns(nu(Ic(xk(a.e,Uf),62)),pE(d))} +function Tt(a,b,c,d){var e;e={};e[QI]=GJ;e[HJ]=Object(b);e[GJ]=c;!!d&&(e['data']=d,undefined);Xt(a,e)} +function Dc(a,b,c,d,e){e.jc=a;e.kc=b;e.lc=dj;e.__elementTypeId$=c;e.__elementTypeCategory$=d;return e} +function Y(a){var b,c,d,e;for(b=(a.h==null&&(a.h=(gc(),e=fc.F(a),ic(e))),a.h),c=0,d=b.length;c-129&&a<128){b=a+128;c=(zF(),yF)[b];!c&&(c=yF[b]=new tF(a));return c}return new tF(a)} +function aB(a,b){var c;if(b.Ob()!=a.b){debugger;throw Si(new PE)}c=sA(a.a);c.forEach(aj(GC.prototype.gb,GC,[a,b]))} +function uy(a,b,c,d){if(d==null){!!c&&(delete c['for'],undefined)}else{!c&&(c={});c['for']=d}Dv(a.g,a,b,c)} +function Op(a,b,c){KF(b,'true')||KF(b,'false')?(a.a[c]=KF(b,'true'),undefined):(a.a[c]=b,undefined)} +function Oq(a,b){rk()&&($wnd.console.debug('Reopening push connection'),undefined);Mp(b)&&Eq(a,(br(),_q),null)} +function Cq(a){a.b=null;Ic(xk(a.c,Gf),12).b&&Ct(Ic(xk(a.c,Gf),12));hk('connection-lost');or(Ic(xk(a.c,_e),28),0)} +function sm(a,b){var c;rm==null&&(rm=rA());c=Oc(rm.get(a),$wnd.Set);if(c==null){c=new $wnd.Set;rm.set(a,c)}c.add(b)} +function rw(a,b){if(b<=0){throw Si(new rF(II))}a.c?jE($wnd,a.d):kE($wnd,a.d);a.c=true;a.d=lE($wnd,new GE(a),b)} +function qw(a,b){if(b<0){throw Si(new rF(HI))}a.c?jE($wnd,a.d):kE($wnd,a.d);a.c=false;a.d=mE($wnd,new EE(a),b)} +function gx(a){if(!a.b){debugger;throw Si(new QE('Cannot bind client delegate methods to a Node'))}return Hw(a.b,a.e)} +function hx(a,b){var c,d;d=a.f;if(b.c.has(d)){debugger;throw Si(new PE)}c=new BC(new Dz(a,b,d));b.c.set(d,c);return c} +function Yw(a){var b;b=Lc(Ow.get(a));if(b==null){b=Lc(new $wnd.Function(GJ,ZJ,'return ('+a+')'));Ow.set(a,b)}return b} +function RA(a){var b;dB(a.a);if(a.c){b=(dB(a.a),a.h);if(b==null){return null}return dB(a.a),Pc(a.h)}else{return null}} +function Ln(a,b,c){var d;d=Mc(c.get(a));if(d==null){d=[];d.push(b);c.set(a,d);return true}else{d.push(b);return false}} +function Qq(a){var b;b=fj(new RegExp('Vaadin-Refresh(:\\s*(.*?))?(\\s|$)'),a);if(b){np(b[2]);return true}return false} +function wv(a,b){var c,d,e;e=vA(a.a);for(c=0;c0){c=Ic(a.b.splice(0,1)[0],17);gm(c,b)||Gv(Ic(xk(a.c,cg),8),c);zC()}} +function SC(a,b){var c,d;d=Oc(a.c.get(b),$wnd.Map);if(d==null){return []}c=Mc(d.get(null));if(c==null){return []}return c} +function cj(a){var b;if(Array.isArray(a)&&a.lc===dj){return YE(M(a))+'@'+(b=O(a)>>>0,b.toString(16))}return a.toString()} +function Nl(b,c){return Array.from(b.querySelectorAll('[name]')).find(function(a){return a.getAttribute('name')==c})} +function Vw(c){Pw();var b=c['}p'].promises;b!==undefined&&b.forEach(function(a){a[1](Error('Client is resynchronizing'))})} +function Mb(a,b){Db();var c;c=S;if(c){if(c==Ab){return}c.q(a);return}if(b){Lb(Sc(a,32)?Ic(a,32).A():a)}else{cG();X(a,bG,'')}} +function TC(a){var b,c;if(a.a!=null){try{for(c=0;c1} +function ED(){ED=_i;DD=new FD('STYLESHEET',0);BD=new FD('JAVASCRIPT',1);CD=new FD('JS_MODULE',2);AD=new FD('DYNAMIC_IMPORT',3)} +function nD(){nD=_i;lD=new oD('UNKNOWN',0);iD=new oD('GECKO',1);mD=new oD('WEBKIT',2);jD=new oD('PRESTO',3);kD=new oD('TRIDENT',4)} +function xm(a){var b;if(rm==null){return}b=Oc(rm.get(a),$wnd.Set);if(b!=null){rm.delete(a);b.forEach(aj(Tm.prototype.gb,Tm,[]))}} +function iC(a){var b;a.d=true;hC(a);a.e||xC(new nC(a));if(a.c.size!=0){b=a.c;a.c=new $wnd.Set;b.forEach(aj(rC.prototype.gb,rC,[]))}} +function mw(a,b,c,d){gw();JF(WJ,a)?c.forEach(aj(Fw.prototype.cb,Fw,[d])):vA(c).forEach(aj(nw.prototype.gb,nw,[]));uy(b.b,b.c,b.a,a)} +function Yt(a,b,c,d,e){var f;f={};f[QI]='mSync';f[HJ]=sE(b.d);f['feature']=Object(c);f['property']=d;f[YI]=e==null?null:e;Xt(a,f)} +function Vj(a,b,c){var d;if(a==c.d){d=new $wnd.Function('callback','callback();');d.call(null,b);return TE(),true}return TE(),false} +function mc(){if(Error.stackTraceLimit>0){$wnd.Error.stackTraceLimit=Error.stackTraceLimit=64;return true}return 'stack' in new Error} +function Xq(a){this.c=a;Oo(Ic(xk(a,Ge),13),new fr(this));QD($wnd,'offline',new hr(this),false);QD($wnd,'online',new jr(this),false)} +function OB(a,b){var c;c=Ic(a.b.get(b),17);if(!c){c=new YA(b,a,JF('innerHTML',b)&&a.d==1);a.b.set(b,c);aB(a.a,new sB(a,c))}return c} +function Zu(a,b){var c,d;d=b;c=Ic(a.c.get(d),34);if(!c){c=new DB(b,a);a.c.set(d,c)}if(!Sc(c,30)){debugger;throw Si(new PE)}return Ic(c,30)} +function $u(a,b){var c,d;d=b;c=Ic(a.c.get(d),34);if(!c){c=new SB(b,a);a.c.set(d,c)}if(!Sc(c,45)){debugger;throw Si(new PE)}return Ic(c,45)} +function Rl(a,b){var c,d;d=$u(a,1);if(!a.a){Em(Pc(PA(OB($u(a,0),'tag'))),new Ul(a,b));return}for(c=0;cd&&Cc(b,d,null);return b} +function kx(a){var b;if(!a.b){debugger;throw Si(new QE('Cannot bind shadow root to a Node'))}b=$u(a.e,20);cx(a);return MB(b,new aA(a))} +function Ak(a,b,c){if(a.a.has(b)){debugger;throw Si(new QE((XE(b),'Registry already has a class of type '+b.i+' registered')))}a.a.set(b,c)} +function KF(a,b){cI(a);if(b==null){return false}if(JF(a,b)){return true}return a.length==b.length&&JF(a.toLowerCase(),b.toLowerCase())} +function wo(a){rk()&&($wnd.console.debug('Re-establish PUSH connection'),undefined);Ks(Ic(xk(a.a.a,tf),16),true);Ko((Qb(),Pb),new Co(a))} +function pq(){pq=_i;mq=new qq('CONNECT_PENDING',0);lq=new qq('CONNECTED',1);oq=new qq('DISCONNECT_PENDING',2);nq=new qq('DISCONNECTED',3)} +function Wt(a,b,c,d,e){var f;f={};f[QI]='attachExistingElementById';f[HJ]=sE(b.d);f[IJ]=Object(c);f[JJ]=Object(d);f['attachId']=e;Xt(a,f)} +function Bv(a){AB(Zu(a.e,24),aj(Nv.prototype.gb,Nv,[]));Xu(a.e,aj(Rv.prototype.cb,Rv,[]));a.a.forEach(aj(Pv.prototype.cb,Pv,[a]));a.d=true} +function $k(a){rk()&&($wnd.console.debug('Finished loading eager dependencies, loading lazy.'),undefined);a.forEach(aj(Cl.prototype.cb,Cl,[]))} +function Aw(a,b){if(b.e){!!b.b&&mw(WJ,b.b,b.a,null)}else{mw(XJ,b.b,b.a,null);rw(b.f,ad(b.j))}if(b.b){rG(a,b.b);b.b=null;b.a=null;b.i=null}} +function oI(a){mI();var b,c,d;c=':'+a;d=lI[c];if(d!=null){return ad((cI(d),d))}d=jI[c];b=d==null?nI(a):ad((cI(d),d));pI();lI[c]=b;return b} +function O(a){return Xc(a)?oI(a):Uc(a)?ad((cI(a),a)):Tc(a)?(cI(a),a)?1231:1237:Rc(a)?a.o():Bc(a)?iI(a):!!a&&!!a.hashCode?a.hashCode():iI(a)} +function Qx(a,b){var c,d;d=OB(b,bK);dB(d.a);d.c||WA(d,a.getAttribute(bK));c=OB(b,cK);Fm(a)&&(dB(c.a),!c.c)&&!!a.style&&WA(c,a.style.display)} +function Pl(a,b,c,d){var e,f;if(!d){f=Ic(xk(a.g.c,Wd),64);e=Ic(f.a.get(c),27);if(!e){f.b[b]=c;f.a.set(c,xF(b));return xF(b)}return e}return d} +function by(a,b){var c,d;while(b!=null){for(c=a.length-1;c>-1;c--){d=Ic(a[c],6);if(b.isSameNode(d.a)){return d.d}}b=BA(b.parentNode)}return -1} +function Sl(a,b,c){var d;if(Ql(a.a,c)){d=Ic(a.e.get(Yg),79);if(!d||!d.a.has(c)){return}OA(OB(b,c),a.a[c]).I()}else{QB(b,c)||WA(OB(b,c),null)}} +function _l(a,b,c){var d,e;e=vv(Ic(xk(a.c,cg),8),ad((cI(b),b)));if(e.c.has(1)){d=new $wnd.Map;NB($u(e,1),aj(nm.prototype.cb,nm,[d]));c.set(b,d)}} +function RC(a,b,c){var d,e;e=Oc(a.c.get(b),$wnd.Map);if(e==null){e=new $wnd.Map;a.c.set(b,e)}d=Mc(e.get(c));if(d==null){d=[];e.set(c,d)}return d} +function ay(a){var b;$w==null&&($w=new $wnd.Map);b=Lc($w.get(a));if(b==null){b=Lc(new $wnd.Function(GJ,ZJ,'return ('+a+')'));$w.set(a,b)}return b} +function bs(){if($wnd.performance&&$wnd.performance.timing){return (new Date).getTime()-$wnd.performance.timing.responseStart}else{return -1}} +function bw(a,b){aw();var c;if(a.g.f){debugger;throw Si(new QE('Binding state node while processing state tree changes'))}c=cw(a);c.Ib(a,b,$v)} +function Iv(a,b){if(!tv(a,b)){debugger;throw Si(new PE)}if(b==a.e){debugger;throw Si(new QE("Root node can't be unregistered"))}a.a.delete(b.d);ev(b)} +function IA(a,b,c,d,e){this.e=a;if(c==null){debugger;throw Si(new PE)}if(d==null){debugger;throw Si(new PE)}this.c=b;this.d=c;this.a=d;this.b=e} +function Yx(a,b,c){var d,e;e=b.f;if(c.has(e)){debugger;throw Si(new QE("There's already a binding for "+e))}d=new BC(new Oy(a,b));c.set(e,d);return d} +function xk(a,b){if(!a.a.has(b)){debugger;throw Si(new QE((XE(b),'Tried to lookup type '+b.i+' but no instance has been registered')))}return a.a.get(b)} +function Jw(a,b,c,d){var e,f,g,h,i;i=Nc(a.bb());h=d.d;for(g=0;g0?NC(a,new WC(a,b,c)):(d=RC(a,b,null),d.push(c));return new VC} +function wm(a,b){var c,d,e,f,g;f=a.f;d=a.e.e;g=Am(d);if(!g){sk(aJ+d.d+bJ);return}c=tm((dB(a.a),a.h));if(Gm(g.a)){e=Cm(g,d,f);e!=null&&Mm(g.a,e,c);return}b[f]=c} +function et(a){var b,c,d,e;b=OB($u(Ic(xk(a.a,cg),8).e,5),'parameters');e=(dB(b.a),Ic(b.h,6));d=$u(e,6);c=new $wnd.Map;NB(d,aj(qt.prototype.cb,qt,[c]));return c} +function px(a,b,c,d,e,f){var g,h;if(!Ux(a.e,b,e,f)){return}g=Nc(d.bb());if(Vx(g,b,e,f,a)){if(!c){h=Ic(xk(b.g.c,Yd),55);h.a.add(b.d);bm(h)}dv(b,g);dw(b)}c||zC()} +function Gv(a,b){var c,d;if(!b){debugger;throw Si(new PE)}d=b.e;c=d.e;if(cm(Ic(xk(a.c,Yd),55),b)||!yv(a,c)){return}Yt(Ic(xk(a.c,Kf),33),c,d.d,b.f,(dB(b.a),b.h))} +function mr(a){if(a.a>0){jk('Scheduling heartbeat in '+a.a+' seconds');hj(a.c,a.a*1000)}else{rk()&&($wnd.console.debug('Disabling heartbeat'),undefined);gj(a.c)}} +function zn(){var a,b,c,d;b=$doc.head.childNodes;c=b.length;for(d=0;d=0;d--){if(JF(a[d].d,b)||JF(a[d].d,c)){a.length>=d+1&&a.splice(0,d+1);break}}return a} +function Rq(a,b){if(a.b!=b){return}a.b=null;a.a=0;if(a.d){gj(a.d);a.d=null}hk('connected');rk()&&($wnd.console.debug('Re-established connection to server'),undefined)} +function Vt(a,b,c,d,e,f){var g;g={};g[QI]='attachExistingElement';g[HJ]=sE(b.d);g[IJ]=Object(c);g[JJ]=Object(d);g['attachTagName']=e;g['attachIndex']=Object(f);Xt(a,g)} +function Gm(a){var b=typeof $wnd.Polymer===tI&&$wnd.Polymer.Element&&a instanceof $wnd.Polymer.Element;var c=a.constructor.polymerElementVersion!==undefined;return b||c} +function xD(){xD=_i;wD=new yD('UNKNOWN',0);vD=new yD('SAFARI',1);qD=new yD('CHROME',2);sD=new yD('FIREFOX',3);uD=new yD('OPERA',4);tD=new yD('IE',5);rD=new yD('EDGE',6)} +function Iw(a,b,c,d){var e,f,g,h;h=Zu(b,c);dB(h.a);if(h.c.length>0){f=Nc(a.bb());for(e=0;e<(dB(h.a),h.c.length);e++){g=Pc(h.c[e]);Qw(f,g,b,d)}}return yB(h,new Mw(a,b,d))} +function _x(a,b){var c,d,e,f,g;c=BA(b).childNodes;for(e=0;e but none was found. Appending instead."),undefined);_D($doc.head,a,b)} +function SF(a){var b,c,d;c=a.length;d=0;while(dd&&(eI(b-1,a.length),a.charCodeAt(b-1)<=32)){--b}return d>0||b=65536){b=55296+(a-65536>>10&1023)&65535;c=56320+(a-65536&1023)&65535;return String.fromCharCode(b)+(''+String.fromCharCode(c))}else{return String.fromCharCode(a&65535)}} +function Ib(a){a&&Sb((Qb(),Pb));--yb;if(yb<0){debugger;throw Si(new QE('Negative entryDepth value at exit '+yb))}if(a){if(yb!=0){debugger;throw Si(new QE('Depth not 0'+yb))}if(Cb!=-1){Nb(Cb);Cb=-1}}} +function Bs(a,b,c){var d,e,f,g,h,i,j,k;i={};d=Ic(xk(a.e,pf),22).b;JF(d,'init')||(i['csrfToken']=d,undefined);i['rpc']=b;if(c){for(f=(j=uE(c),j),g=0,h=f.length;g2000){Bb=a;Cb=$wnd.setTimeout(Ob,10)}}if(yb++==0){Rb((Qb(),Pb));return true}return false} +function jq(a){var b,c,d;if(a.a>=a.b.length){debugger;throw Si(new PE)}if(a.a==0){c=''+a.b.length+'|';b=4095-c.length;d=c+RF(a.b,0,$wnd.Math.min(a.b.length,b));a.a+=b}else{d=iq(a,a.a,a.a+4095);a.a+=4095}return d} +function Sq(a,b){var c;if(a.a==1){rk()&&fE($wnd.console,'Immediate reconnect attempt for '+b);Bq(a,b)}else{a.d=new Yq(a,b);hj(a.d,QA((c=$u(Ic(xk(Ic(xk(a.c,Df),39).a,cg),8).e,9),OB(c,'reconnectInterval')),5000))}} +function Rr(a){var b,c,d,e;if(a.g.length==0){return false}e=-1;for(b=0;b=0;d--){YF((g.a+=i,g),Pc(c[d]));i='.'}return g.a} +function Ip(a,b){if(!b){debugger;throw Si(new PE)}switch(a.f.c){case 0:a.f=(pq(),oq);a.b=b;break;case 1:rk()&&($wnd.console.debug('Closing push connection'),undefined);Up(a.c);a.f=(pq(),nq);b.C();break;case 2:case 3:throw Si(new sF('Can not disconnect more than once'));}} +function Sp(a,b){var c,d,e,f,g;if(Wp()){Pp(b.a)}else{f=(Ic(xk(a.d,td),7).f?(e='VAADIN/static/push/vaadinPush-min.js'):(e='VAADIN/static/push/vaadinPush.js'),e);rk()&&fE($wnd.console,'Loading '+f);d=Ic(xk(a.d,te),54);g=Ic(xk(a.d,td),7).h+f;c=new fq(a,f,b);Gn(d,g,c,false,VI)}} +function Or(a,b){var c,d,e,f,g;rk()&&($wnd.console.debug('Handling dependencies'),undefined);c=new $wnd.Map;for(e=(MD(),Dc(xc(Ih,1),wI,46,0,[KD,JD,LD])),f=0,g=e.length;f0){k=tx(a,b);d=!k?null:BA(k.a).nextSibling}else{d=null}for(g=0;g0}else if(navigator&&'msMaxTouchPoints' in navigator){return navigator.msMaxTouchPoints>0}else{var b=$wnd.matchMedia&&matchMedia(NI);if(b&&b.media===NI){return !!b.matches}}try{$doc.createEvent('TouchEvent');return true}catch(a){return false}} +function sx(b,c){var d,e,f,g,h;if(!c){return -1}try{h=BA(Nc(c));f=[];f.push(b);for(e=0;e0){d=h.length;while(d>0&&h[d-1]==''){--d}d=14&&c<=16));case 11:return b!=null&&Yc(b);case 12:return b!=null&&(typeof b===rI||typeof b==tI);case 0:return Hc(b,a.__elementTypeId$);case 2:return Zc(b)&&!(b.lc===dj);case 1:return Zc(b)&&!(b.lc===dj)||Hc(b,a.__elementTypeId$);default:return true;}} +function Ml(b,c){if(document.body.$&&document.body.$.hasOwnProperty&&document.body.$.hasOwnProperty(c)){return document.body.$[c]}else if(b.shadowRoot){return b.shadowRoot.getElementById(c)}else if(b.getElementById){return b.getElementById(c)}else if(c&&c.match('^[a-zA-Z0-9-_]*$')){return b.querySelector('#'+c)}else{return Array.from(b.querySelectorAll('[id]')).find(function(a){return a.id==c})}} +function Rp(a,b){var c,d;if(!Mp(a)){throw Si(new sF('This server to client push connection should not be used to send client to server messages'))}if(a.f==(pq(),lq)){d=op(b);jk('Sending push ('+a.g+') message to server: '+d);if(JF(a.g,oJ)){c=new kq(d);while(c.a=QA((d=$u(Ic(xk(Ic(xk(a.c,Df),39).a,cg),8).e,9),OB(d,'reconnectAttempts')),10000)?Cq(a):Sq(a,c)} +function Ol(a,b,c,d){var e,f,g,h,i,j,k,l,m,n,o,p,q,r;j=null;g=BA(a.a).childNodes;o=new $wnd.Map;e=!b;i=-1;for(m=0;ma.a){a.a==0?rk()&&fE($wnd.console,'Updating client-to-server id to '+b+' based on server'):sk('Server expects next client-to-server id to be '+b+' but we were going to use '+a.a+'. Will use '+b+'.');a.a=b}} +function Zv(a,b){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q;n=ad(rE(a[TJ]));m=Zu(b,n);i=ad(rE(a['index']));UJ in a?(o=ad(rE(a[UJ]))):(o=0);if('add' in a){d=a['add'];c=(j=Mc(d),j);CB(m,i,o,c)}else if('addNodes' in a){e=a['addNodes'];l=e.length;c=[];q=b.g;for(h=0;h=f){debugger;throw Si(new PE)}return g.length==0?null:g}else{return a}} +function Qr(a,b){var c,d;if(!b){throw Si(new rF('The json to handle cannot be null'))}if((wJ in b?b[wJ]:-1)==-1){c=b['meta'];(!c||!(DJ in c))&&rk()&&($wnd.console.error("Response didn't contain a server id. Please verify that the server is up-to-date and that the response data has not been modified in transmission."),undefined)}d=Ic(xk(a.i,Ge),13).b;if(d==(dp(),ap)){d=bp;Po(Ic(xk(a.i,Ge),13),d)}d==bp?Pr(a,b):rk()&&($wnd.console.warn('Ignored received message because application has already been stopped'),undefined)} +function cy(a,b,c,d,e){var f,g,h;h=vv(e,ad(a));if(!h.c.has(1)){return}if(!Zx(h,b)){debugger;throw Si(new QE('Host element is not a parent of the node whose property has changed. This is an implementation error. Most likely it means that there are several StateTrees on the same page (might be possible with portlets) and the target StateTree should not be passed into the method as an argument but somehow detected from the host element. Another option is that host element is calculated incorrectly.'))}f=$u(h,1);g=OB(f,c);OA(g,d).I()} +function lo(a,b,c,d){var e,f,g,h,i,j;h=$doc;j=h.createElement('div');j.className='v-system-error';if(a!=null){f=h.createElement('div');f.className='caption';f.textContent=a;j.appendChild(f);rk()&&gE($wnd.console,a)}if(b!=null){i=h.createElement('div');i.className='message';i.textContent=b;j.appendChild(i);rk()&&gE($wnd.console,b)}if(c!=null){g=h.createElement('div');g.className='details';g.textContent=c;j.appendChild(g);rk()&&gE($wnd.console,c)}if(d!=null){e=h.querySelector(d);!!e&&ZD(Nc(PG(TG(e.shadowRoot),e)),j)}else{$D(h.body,j)}return j} +function yp(a,b){var c,d,e;c=Gp(b,'serviceUrl');Hj(a,Ep(b,'webComponentMode'));if(c==null){Dj(a,mp('.'));xj(a,mp(Gp(b,lJ)))}else{a.h=c;xj(a,mp(c+(''+Gp(b,lJ))))}Gj(a,Fp(b,'v-uiId').a);zj(a,Fp(b,'heartbeatInterval').a);Aj(a,Fp(b,'maxMessageSuspendTimeout').a);Ej(a,(d=b.getConfig(mJ),d?d.vaadinVersion:null));e=b.getConfig(mJ);Dp();Fj(a,b.getConfig('sessExpMsg'));Bj(a,!Ep(b,'debug'));Cj(a,Ep(b,'requestTiming'));yj(a,b.getConfig('webcomponents'));Ep(b,'devToolsEnabled');Gp(b,'liveReloadUrl');Gp(b,'liveReloadBackend');Gp(b,'springBootLiveReloadPort')} +function qc(a,b){var c,d,e,f,g,h,i,j,k;j='';if(b.length==0){return a.G(GI,EI,-1,-1)}k=SF(b);JF(k.substr(0,3),'at ')&&(k=k.substr(3));k=k.replace(/\[.*?\]/g,'');g=k.indexOf('(');if(g==-1){g=k.indexOf('@');if(g==-1){j=k;k=''}else{j=SF(k.substr(g+1));k=SF(k.substr(0,g))}}else{c=k.indexOf(')',g);j=k.substr(g+1,c-(g+1));k=SF(k.substr(0,g))}g=LF(k,TF(46));g!=-1&&(k=k.substr(g+1));(k.length==0||JF(k,'Anonymous function'))&&(k=EI);h=MF(j,TF(58));e=NF(j,TF(58),h-1);i=-1;d=-1;f=GI;if(h!=-1&&e!=-1){f=j.substr(0,e);i=kc(j.substr(e+1,h-(e+1)));d=kc(j.substr(h+1))}return a.G(f,k,i,d)} +function bx(a,b){var c,d,e,f,g,h;g=(e=$u(b,0),Nc(PA(OB(e,MJ))));h=g[QI];if(JF('inMemory',h)){dw(b);return}if(!a.b){debugger;throw Si(new QE('Unexpected html node. The node is supposed to be a custom element'))}if(JF('@id',h)){if(pm(a.b)){qm(a.b,new dz(a,b,g));return}else if(!(typeof a.b.$!=CI)){sm(a.b,new fz(a,b,g));return}wx(a,b,g,true)}else if(JF(NJ,h)){if(!a.b.root){sm(a.b,new hz(a,b,g));return}yx(a,b,g,true)}else if(JF('@name',h)){f=g[MJ];c="name='"+f+"'";d=new jz(a,f);if(!jy(d.a,d.b)){un(a.b,f,new lz(a,b,d,f,c));return}px(a,b,true,d,f,c)}else{debugger;throw Si(new QE('Unexpected payload type '+h))}} +function Ik(a,b){var c;this.a=new $wnd.Map;this.b=new $wnd.Map;Ak(this,yd,a);Ak(this,td,b);Ak(this,te,new Jn(this));Ak(this,He,new kp(this));Ak(this,Td,new cl(this));Ak(this,Be,new so(this));Bk(this,Ge,new Jk);Ak(this,cg,new Jv(this));Ak(this,Gf,new Gt(this));Ak(this,pf,new as(this));Ak(this,tf,new Ms(this));Ak(this,Of,new gu(this));Ak(this,Kf,new $t(this));Ak(this,Zf,new Mu(this));Bk(this,Vf,new Lk);Bk(this,Wd,new Nk);Ak(this,Yd,new hm(this));c=new Pk(this);Ak(this,_e,new pr(c.a));this.b.set(_e,c);Ak(this,Re,new Xq(this));Ak(this,Uf,new pu(this));Ak(this,Bf,new ht(this));Ak(this,Df,new st(this));Ak(this,xf,new $s(this))} +function wb(b){var c=function(a){return typeof a!=CI};var d=function(a){return a.replace(/\r\n/g,'')};if(c(b.outerHTML))return d(b.outerHTML);c(b.innerHTML)&&b.cloneNode&&$doc.createElement('div').appendChild(b.cloneNode(true)).innerHTML;if(c(b.nodeType)&&b.nodeType==3){return "'"+b.data.replace(/ /g,'\u25AB').replace(/\u00A0/,'\u25AA')+"'"}if(typeof c(b.htmlText)&&b.collapse){var e=b.htmlText;if(e){return 'IETextRange ['+d(e)+']'}else{var f=b.duplicate();f.pasteHTML('|');var g='IETextRange '+d(b.parentElement().outerHTML);f.moveStart('character',-1);f.pasteHTML('');return g}}return b.toString?b.toString():'[JavaScriptObject]'} +function Lm(a,b,c){var d,e,f;f=[];if(a.c.has(1)){if(!Sc(b,45)){debugger;throw Si(new QE('Received an inconsistent NodeFeature for a node that has a ELEMENT_PROPERTIES feature. It should be NodeMap, but it is: '+b))}e=Ic(b,45);NB(e,aj(dn.prototype.cb,dn,[f,c]));f.push(MB(e,new _m(f,c)))}else if(a.c.has(16)){if(!Sc(b,30)){debugger;throw Si(new QE('Received an inconsistent NodeFeature for a node that has a TEMPLATE_MODELLIST feature. It should be NodeList, but it is: '+b))}d=Ic(b,30);f.push(yB(d,new Vm(c)))}if(f.length==0){debugger;throw Si(new QE('Node should have ELEMENT_PROPERTIES or TEMPLATE_MODELLIST feature'))}f.push(Wu(a,new Zm(f)))} +function MC(a,b){var c,d,e,f,g,h,i,j,k,l,m,n,o;if(oE(b)==(BE(),zE)){f=b;l=f['@v-node'];if(l){if(oE(l)!=yE){throw Si(new rF(hK+oE(l)+iK+pE(b)))}k=ad(nE(l));e=(g=k,Ic(a.a.get(g),6)).a;return e}m=f['@v-return'];if(m){if(oE(m)!=vE){throw Si(new rF('@v-return value must be an array, got '+oE(m)+iK+pE(b)))}c=m;if(c.length<2){throw Si(new rF('@v-return array must have at least 2 elements, got '+c.length+iK+pE(b)))}n=ad(rE(c[0]));d=ad(rE(c[1]));return IC(n,d,Ic(xk(a.c,Kf),33))}for(h=(o=uE(f),o),i=0,j=h.length;i0&&JF('window.location.reload();',c[0])){rk()&&($wnd.console.warn('Executing forced page reload while a resync request is ongoing.'),undefined);$wnd.location.reload();return}}}rk()&&($wnd.console.warn('Queueing message from the server as a resync request is ongoing.'),undefined);a.g.push(new ls(b));return}Ic(xk(a.i,tf),16).g=0;if(e&&!Sr(a,j)){jk('Received resync message with id '+j+' while waiting for '+(a.f+1));a.f=j-1;Zr(a)}i=a.j.size!=0;if(i||!Sr(a,j)){if(i){rk()&&($wnd.console.debug('Postponing UIDL handling due to lock...'),undefined)}else{if(j<=a.f){sk(zJ+j+' but have already seen '+a.f+'. Ignoring it');Tr(b)&&Ct(Ic(xk(a.i,Gf),12));return}jk(zJ+j+' but expected '+(a.f+1)+'. Postponing handling until the missing message(s) have been received')}a.g.push(new ls(b));if(!a.c.f){m=Ic(xk(a.i,td),7).e;hj(a.c,m)}return}xJ in b&&Bv(Ic(xk(a.i,cg),8));l=xb();h=new I;a.j.add(h);rk()&&($wnd.console.debug('Handling message from server'),undefined);Dt(Ic(xk(a.i,Gf),12),new Qt);if(AJ in b){k=b[AJ];Js(Ic(xk(a.i,tf),16),k,xJ in b)}j!=-1&&(a.f=j);if('redirect' in b){n=b['redirect']['url'];rk()&&fE($wnd.console,'redirecting to '+n);np(n);return}BJ in b&&(a.b=b[BJ]);CJ in b&&(a.h=b[CJ]);Or(a,b);a.d||bl(Ic(xk(a.i,Td),74));'timings' in b&&(a.k=b['timings']);hl(new fs);hl(new ms(a,b,h,l))} +var rI='object',sI='[object Array]',tI='function',uI='java.lang',vI='com.google.gwt.core.client',wI={3:1},xI='__noinit__',yI='msie',zI={3:1,10:1,9:1,5:1},AI='null',BI='com.google.gwt.core.client.impl',CI='undefined',DI='Working array length changed ',EI='anonymous',FI='fnStack',GI='Unknown',HI='must be non-negative',II='must be positive',JI='com.google.web.bindery.event.shared',KI='com.vaadin.client',LI='visible',MI={61:1},NI='(pointer:coarse)',OI={26:1},QI='type',RI={51:1},SI={25:1},TI={15:1},UI={29:1},VI='text/javascript',WI='constructor',XI='properties',YI='value',ZI='com.vaadin.client.flow.reactive',$I={18:1},_I='nodeId',aJ='Root node for node ',bJ=' could not be found',cJ=' is not an Element',dJ={68:1},eJ={83:1},fJ={50:1},gJ='script',hJ='stylesheet',iJ='data-id',jJ='pushMode',kJ='com.vaadin.flow.shared',lJ='contextRootUrl',mJ='versionInfo',nJ='v-uiId=',oJ='websocket',pJ='transport',qJ='application/json; charset=UTF-8',rJ='VAADIN/push',sJ='com.vaadin.client.communication',tJ={93:1},uJ='dialogText',vJ='dialogTextGaveUp',wJ='syncId',xJ='resynchronize',yJ='execute',zJ='Received message with server id ',AJ='clientId',BJ='Vaadin-Security-Key',CJ='Vaadin-Push-ID',DJ='sessionExpired',EJ='stylesheetRemovals',FJ='pushServletMapping',GJ='event',HJ='node',IJ='attachReqId',JJ='attachAssignedId',KJ='com.vaadin.client.flow',LJ='bound',MJ='payload',NJ='subTemplate',OJ={49:1},PJ='Node is null',QJ='Node is not created for this tree',RJ='Node id is not registered with this tree',SJ='$server',TJ='feat',UJ='remove',VJ='com.vaadin.client.flow.binding',WJ='trailing',XJ='intermediate',YJ='elemental.util',ZJ='element',$J='shadowRoot',_J='The HTML node for the StateNode with id=',aK='An error occurred when Flow tried to find a state node matching the element ',bK='hidden',cK='styleDisplay',dK='Element addressed by the ',eK='dom-repeat',fK='dom-change',gK='com.vaadin.client.flow.nodefeature',hK='@v-node value must be a number, got ',iK=' in ',jK='com.vaadin.client.gwt.com.google.web.bindery.event.shared',kK=' edge/',lK=' edg/',mK=' edga/',nK=' edgios/',oK=' chrome/',pK=' crios/',qK=' headlesschrome/',rK=' opr/',sK='opera',tK='webtv',uK='trident/',vK=' firefox/',wK='fxios/',xK='safari',yK='com.vaadin.flow.shared.ui',zK='java.io',AK='java.util',BK='java.util.stream',CK='Index: ',DK=', Size: ',EK='user.agent';var _,Yi,Ti,Qi=-1;$wnd.goog=$wnd.goog||{};$wnd.goog.global=$wnd.goog.global||$wnd;Zi();$i(1,null,{},I);_.m=function J(a){return H(this,a)};_.n=function L(){return this.jc};_.o=function N(){return iI(this)};_.p=function P(){var a;return YE(M(this))+'@'+(a=O(this)>>>0,a.toString(16))};_.equals=function(a){return this.m(a)};_.hashCode=function(){return this.o()};_.toString=function(){return this.p()};var Ec,Fc,Gc;$i(70,1,{70:1},ZE);_.Vb=function $E(a){var b;b=new ZE;b.e=4;a>1?(b.c=eF(this,a-1)):(b.c=this);return b};_.Wb=function dF(){XE(this);return this.b};_.Xb=function fF(){return YE(this)};_.Yb=function hF(){XE(this);return this.g};_.Zb=function jF(){return (this.e&4)!=0};_.$b=function kF(){return (this.e&1)!=0};_.p=function nF(){return ((this.e&2)!=0?'interface ':(this.e&1)!=0?'':'class ')+(XE(this),this.i)};_.e=0;var WE=1;var ii=aF(uI,'Object',1);var Yh=aF(uI,'Class',70);$i(97,1,{},R);_.a=0;var cd=aF(vI,'Duration',97);var S=null;$i(5,1,{3:1,5:1});_.r=function bb(a){return new Error(a)};_.s=function db(){return this.e};_.t=function eb(){var a;return a=Ic(EH(GH(HG((this.i==null&&(this.i=zc(pi,wI,5,0,0,1)),this.i)),new eG),nH(new yH,new wH,new AH,Dc(xc(Ei,1),wI,52,0,[(rH(),pH)]))),94),vG(a,zc(ii,wI,1,a.a.length,5,1))};_.u=function fb(){return this.f};_.v=function gb(){return this.g};_.w=function hb(){Z(this,cb(this.r($(this,this.g))));hc(this)};_.p=function jb(){return $(this,this.v())};_.e=xI;_.j=true;var pi=aF(uI,'Throwable',5);$i(10,5,{3:1,10:1,5:1});var ai=aF(uI,'Exception',10);$i(9,10,zI,mb);var ji=aF(uI,'RuntimeException',9);$i(60,9,zI,nb);var fi=aF(uI,'JsException',60);$i(121,60,zI);var gd=aF(BI,'JavaScriptExceptionBase',121);$i(32,121,{32:1,3:1,10:1,9:1,5:1},rb);_.v=function ub(){return qb(this),this.c};_.A=function vb(){return _c(this.b)===_c(ob)?null:this.b};var ob;var dd=aF(vI,'JavaScriptException',32);var ed=aF(vI,'JavaScriptObject$',0);$i(316,1,{});var fd=aF(vI,'Scheduler',316);var yb=0,zb=false,Ab,Bb=0,Cb=-1;$i(131,316,{});_.e=false;_.i=false;var Pb;var kd=aF(BI,'SchedulerImpl',131);$i(132,1,{},bc);_.B=function cc(){this.a.e=true;Tb(this.a);this.a.e=false;return this.a.i=Ub(this.a)};var hd=aF(BI,'SchedulerImpl/Flusher',132);$i(133,1,{},dc);_.B=function ec(){this.a.e&&_b(this.a.f,1);return this.a.i};var jd=aF(BI,'SchedulerImpl/Rescuer',133);var fc;$i(327,1,{});var od=aF(BI,'StackTraceCreator/Collector',327);$i(122,327,{},nc);_.D=function oc(a){var b={},j;var c=[];a[FI]=c;var d=arguments.callee.caller;while(d){var e=(gc(),d.name||(d.name=jc(d.toString())));c.push(e);var f=':'+e;var g=b[f];if(g){var h,i;for(h=0,i=g.length;h0){Bn(this.b,this.c);return false}else if(a==0){An(this.b,this.c);return true}else if(Q(this.a)>60000){An(this.b,this.c);return false}else{return true}};var ie=aF(KI,'ResourceLoader/1',193);$i(194,40,{},Rn);_.I=function Sn(){this.a.c.has(this.c)||An(this.a,this.b)};var je=aF(KI,'ResourceLoader/2',194);$i(198,40,{},Tn);_.I=function Un(){this.a.c.has(this.c)?Bn(this.a,this.b):An(this.a,this.b)};var ke=aF(KI,'ResourceLoader/3',198);$i(199,1,SI,Vn);_.db=function Wn(a){An(this.a,a)};_.eb=function Xn(a){Bn(this.a,a)};var le=aF(KI,'ResourceLoader/4',199);$i(66,1,{},Yn);var me=aF(KI,'ResourceLoader/ResourceLoadEvent',66);$i(101,1,SI,Zn);_.db=function $n(a){An(this.a,a)};_.eb=function _n(a){Bn(this.a,a)};var oe=aF(KI,'ResourceLoader/SimpleLoadListener',101);$i(192,1,SI,ao);_.db=function bo(a){An(this.a,a)};_.eb=function co(a){var b;if(bD((!ck&&(ck=new ek),ck).a)||dD((!ck&&(ck=new ek),ck).a)||cD((!ck&&(ck=new ek),ck).a)){b=Nn(this.b);if(b==0){An(this.a,a);return}}Bn(this.a,a)};var pe=aF(KI,'ResourceLoader/StyleSheetLoadListener',192);$i(195,1,OI,eo);_.bb=function fo(){return this.a.call(null)};var qe=aF(KI,'ResourceLoader/lambda$0$Type',195);$i(196,1,TI,go);_.I=function ho(){this.b.eb(this.a)};var re=aF(KI,'ResourceLoader/lambda$1$Type',196);$i(197,1,TI,io);_.I=function jo(){this.b.db(this.a)};var se=aF(KI,'ResourceLoader/lambda$2$Type',197);$i(23,1,{23:1},so);_.b=false;var Be=aF(KI,'SystemErrorHandler',23);$i(167,1,{},uo);_.gb=function vo(a){po(Pc(a))};var ue=aF(KI,'SystemErrorHandler/0methodref$recreateNodes$Type',167);$i(163,1,{},xo);_.mb=function yo(a,b){var c;or(Ic(xk(this.a.a,_e),28),Ic(xk(this.a.a,td),7).d);c=b;ko(c.v())};_.nb=function zo(a){var b,c,d,e;qk('Received xhr HTTP session resynchronization message: '+a.responseText);or(Ic(xk(this.a.a,_e),28),-1);e=Ic(xk(this.a.a,td),7).k;b=ds(es(a.responseText));c=b['uiId'];if(c!=e){rk()&&fE($wnd.console,'UI ID switched from '+e+' to '+c+' after resynchronization');Gj(Ic(xk(this.a.a,td),7),c)}zk(this.a.a);Po(Ic(xk(this.a.a,Ge),13),(dp(),bp));Qr(Ic(xk(this.a.a,pf),22),b);d=it(PA(OB($u(Ic(xk(Ic(xk(this.a.a,Bf),38).a,cg),8).e,5),jJ)));d?Ko((Qb(),Pb),new Ao(this)):Ko((Qb(),Pb),new Eo(this))};var ye=aF(KI,'SystemErrorHandler/1',163);$i(165,1,{},Ao);_.C=function Bo(){wo(this.a)};var ve=aF(KI,'SystemErrorHandler/1/lambda$0$Type',165);$i(164,1,{},Co);_.C=function Do(){qo(this.a.a)};var we=aF(KI,'SystemErrorHandler/1/lambda$1$Type',164);$i(166,1,{},Eo);_.C=function Fo(){qo(this.a.a)};var xe=aF(KI,'SystemErrorHandler/1/lambda$2$Type',166);$i(161,1,{},Go);_.U=function Ho(a){np(this.a)};var ze=aF(KI,'SystemErrorHandler/lambda$0$Type',161);$i(162,1,{},Io);_.U=function Jo(a){to(this.a,a)};var Ae=aF(KI,'SystemErrorHandler/lambda$1$Type',162);$i(135,131,{},Lo);_.a=0;var De=aF(KI,'TrackingScheduler',135);$i(136,1,{},Mo);_.C=function No(){this.a.a--};var Ce=aF(KI,'TrackingScheduler/lambda$0$Type',136);$i(13,1,{13:1},Qo);var Ge=aF(KI,'UILifecycle',13);$i(171,334,{},So);_.K=function To(a){Ic(a,93).ob(this)};_.L=function Uo(){return Ro};var Ro=null;var Ee=aF(KI,'UILifecycle/StateChangeEvent',171);$i(14,1,{3:1,21:1,14:1});_.m=function Yo(a){return this===a};_.o=function Zo(){return iI(this)};_.p=function $o(){return this.b!=null?this.b:''+this.c};_.c=0;var $h=aF(uI,'Enum',14);$i(65,14,{65:1,3:1,21:1,14:1},ep);var ap,bp,cp;var Fe=bF(KI,'UILifecycle/UIState',65,fp);$i(333,1,wI);var Gh=aF(kJ,'VaadinUriResolver',333);$i(53,333,{53:1,3:1},kp);_.pb=function lp(a){return jp(this,a)};var He=aF(KI,'URIResolver',53);var qp=false,rp;$i(115,1,{},Bp);_.C=function Cp(){xp(this.a)};var Ie=aF('com.vaadin.client.bootstrap','Bootstrapper/lambda$0$Type',115);$i(89,1,{},Tp);_.qb=function Vp(){return Ic(xk(this.d,pf),22).f};_.rb=function Xp(a){this.f=(pq(),nq);oo(Ic(xk(Ic(xk(this.d,Re),20).c,Be),23),'','Client unexpectedly disconnected. Ensure client timeout is disabled.','',null,null)};_.sb=function Yp(a){this.f=(pq(),mq);Ic(xk(this.d,Re),20);rk()&&($wnd.console.debug('Push connection closed'),undefined)};_.tb=function Zp(a){this.f=(pq(),nq);Dq(Ic(xk(this.d,Re),20),'Push connection using '+a[pJ]+' failed!')};_.ub=function $p(a){var b,c;c=a['responseBody'];b=ds(es(c));if(!b){Lq(Ic(xk(this.d,Re),20),this,c);return}else{jk('Received push ('+this.g+') message: '+c);Qr(Ic(xk(this.d,pf),22),b)}};_.vb=function _p(a){jk('Push connection established using '+a[pJ]);Qp(this,a)};_.wb=function aq(a,b){this.f==(pq(),lq)&&(this.f=mq);Oq(Ic(xk(this.d,Re),20),this)};_.xb=function bq(a){jk('Push connection re-established using '+a[pJ]);Qp(this,a)};_.yb=function cq(){sk('Push connection using primary method ('+this.a[pJ]+') failed. Trying with '+this.a['fallbackTransport'])};var Qe=aF(sJ,'AtmospherePushConnection',89);$i(250,1,{},dq);_.C=function eq(){Hp(this.a)};var Je=aF(sJ,'AtmospherePushConnection/0methodref$connect$Type',250);$i(252,1,SI,fq);_.db=function gq(a){Pq(Ic(xk(this.a.d,Re),20),a.a)};_.eb=function hq(a){if(Wp()){jk(this.c+' loaded');Pp(this.b.a)}else{Pq(Ic(xk(this.a.d,Re),20),a.a)}};var Ke=aF(sJ,'AtmospherePushConnection/1',252);$i(247,1,{},kq);_.a=0;var Le=aF(sJ,'AtmospherePushConnection/FragmentedMessage',247);$i(57,14,{57:1,3:1,21:1,14:1},qq);var lq,mq,nq,oq;var Me=bF(sJ,'AtmospherePushConnection/State',57,rq);$i(249,1,tJ,sq);_.ob=function tq(a){Np(this.a,a)};var Ne=aF(sJ,'AtmospherePushConnection/lambda$0$Type',249);$i(248,1,UI,uq);_.C=function vq(){};var Oe=aF(sJ,'AtmospherePushConnection/lambda$1$Type',248);$i(366,$wnd.Function,{},wq);_.cb=function xq(a,b){Op(this.a,Pc(a),Pc(b))};$i(251,1,UI,yq);_.C=function zq(){Pp(this.a)};var Pe=aF(sJ,'AtmospherePushConnection/lambda$3$Type',251);var Re=cF(sJ,'ConnectionStateHandler');$i(221,1,{20:1},Xq);_.a=0;_.b=null;var Xe=aF(sJ,'DefaultConnectionStateHandler',221);$i(223,40,{},Yq);_.I=function Zq(){!!this.a.d&&gj(this.a.d);this.a.d=null;jk('Scheduled reconnect attempt '+this.a.a+' for '+this.b);Bq(this.a,this.b)};var Se=aF(sJ,'DefaultConnectionStateHandler/1',223);$i(67,14,{67:1,3:1,21:1,14:1},dr);_.a=0;var $q,_q,ar;var Te=bF(sJ,'DefaultConnectionStateHandler/Type',67,er);$i(222,1,tJ,fr);_.ob=function gr(a){Jq(this.a,a)};var Ue=aF(sJ,'DefaultConnectionStateHandler/lambda$0$Type',222);$i(224,1,{},hr);_.U=function ir(a){Cq(this.a)};var Ve=aF(sJ,'DefaultConnectionStateHandler/lambda$1$Type',224);$i(225,1,{},jr);_.U=function kr(a){Kq(this.a)};var We=aF(sJ,'DefaultConnectionStateHandler/lambda$2$Type',225);$i(28,1,{28:1},pr);_.a=-1;var _e=aF(sJ,'Heartbeat',28);$i(218,40,{},qr);_.I=function rr(){nr(this.a)};var Ye=aF(sJ,'Heartbeat/1',218);$i(220,1,{},sr);_.mb=function tr(a,b){!b?this.a.a<0?rk()&&($wnd.console.debug('Heartbeat terminated, ignoring failure.'),undefined):Hq(Ic(xk(this.a.b,Re),20),a):Gq(Ic(xk(this.a.b,Re),20),b);mr(this.a)};_.nb=function ur(a){Iq(Ic(xk(this.a.b,Re),20));mr(this.a)};var Ze=aF(sJ,'Heartbeat/2',220);$i(219,1,tJ,vr);_.ob=function wr(a){lr(this.a,a)};var $e=aF(sJ,'Heartbeat/lambda$0$Type',219);$i(173,1,{},Ar);_.gb=function Br(a){gk('firstDelay',xF(Ic(a,27).a))};var af=aF(sJ,'LoadingIndicatorConfigurator/0methodref$setFirstDelay$Type',173);$i(174,1,{},Cr);_.gb=function Dr(a){gk('secondDelay',xF(Ic(a,27).a))};var bf=aF(sJ,'LoadingIndicatorConfigurator/1methodref$setSecondDelay$Type',174);$i(175,1,{},Er);_.gb=function Fr(a){gk('thirdDelay',xF(Ic(a,27).a))};var cf=aF(sJ,'LoadingIndicatorConfigurator/2methodref$setThirdDelay$Type',175);$i(176,1,fJ,Gr);_.kb=function Hr(a){zr(SA(Ic(a.e,17)))};var df=aF(sJ,'LoadingIndicatorConfigurator/lambda$3$Type',176);$i(177,1,fJ,Ir);_.kb=function Jr(a){yr(this.b,this.a,a)};_.a=0;var ef=aF(sJ,'LoadingIndicatorConfigurator/lambda$4$Type',177);$i(22,1,{22:1},as);_.a=0;_.b='init';_.d=false;_.e=0;_.f=-1;_.h=null;_.l=0;var pf=aF(sJ,'MessageHandler',22);$i(184,1,UI,fs);_.C=function gs(){!AA&&$wnd.Polymer!=null&&JF($wnd.Polymer.version.substr(0,'1.'.length),'1.')&&(AA=true,rk()&&($wnd.console.debug('Polymer micro is now loaded, using Polymer DOM API'),undefined),zA=new CA,undefined)};var ff=aF(sJ,'MessageHandler/0methodref$updateApiImplementation$Type',184);$i(183,40,{},hs);_.I=function is(){Mr(this.a)};var gf=aF(sJ,'MessageHandler/1',183);$i(354,$wnd.Function,{},js);_.gb=function ks(a){Kr(Ic(a,6))};$i(56,1,{56:1},ls);var hf=aF(sJ,'MessageHandler/PendingUIDLMessage',56);$i(185,1,UI,ms);_.C=function ns(){Xr(this.a,this.d,this.b,this.c)};_.c=0;var jf=aF(sJ,'MessageHandler/lambda$1$Type',185);$i(187,1,$I,os);_.fb=function ps(){yC(new qs(this.a,this.b))};var kf=aF(sJ,'MessageHandler/lambda$3$Type',187);$i(186,1,$I,qs);_.fb=function rs(){Ur(this.a,this.b)};var lf=aF(sJ,'MessageHandler/lambda$4$Type',186);$i(188,1,{},ss);_.B=function ts(){return mo(Ic(xk(this.a.i,Be),23),null),false};var mf=aF(sJ,'MessageHandler/lambda$5$Type',188);$i(190,1,$I,us);_.fb=function vs(){Vr(this.a)};var nf=aF(sJ,'MessageHandler/lambda$6$Type',190);$i(189,1,{},ws);_.C=function xs(){this.a.forEach(aj(js.prototype.gb,js,[]))};var of=aF(sJ,'MessageHandler/lambda$7$Type',189);$i(16,1,{16:1},Ms);_.a=0;_.g=0;var tf=aF(sJ,'MessageSender',16);$i(180,40,{},Os);_.I=function Ps(){hj(this.a.f,Ic(xk(this.a.e,td),7).e+500);if(!Ic(xk(this.a.e,Gf),12).b){Ft(Ic(xk(this.a.e,Gf),12));ou(Ic(xk(this.a.e,Uf),62),this.b)}};var qf=aF(sJ,'MessageSender/1',180);$i(179,1,{338:1},Qs);var rf=aF(sJ,'MessageSender/lambda$0$Type',179);$i(100,1,UI,Rs);_.C=function Ss(){As(this.a,this.b)};_.b=false;var sf=aF(sJ,'MessageSender/lambda$1$Type',100);$i(168,1,fJ,Vs);_.kb=function Ws(a){Ts(this.a,a)};var uf=aF(sJ,'PollConfigurator/lambda$0$Type',168);$i(75,1,{75:1},$s);_.zb=function _s(){var a;a=Ic(xk(this.b,cg),8);Dv(a,a.e,'ui-poll',null)};_.a=null;var xf=aF(sJ,'Poller',75);$i(170,40,{},at);_.I=function bt(){var a;a=Ic(xk(this.a.b,cg),8);Dv(a,a.e,'ui-poll',null)};var vf=aF(sJ,'Poller/1',170);$i(169,1,tJ,ct);_.ob=function dt(a){Xs(this.a,a)};var wf=aF(sJ,'Poller/lambda$0$Type',169);$i(38,1,{38:1},ht);var Bf=aF(sJ,'PushConfiguration',38);$i(231,1,fJ,kt);_.kb=function lt(a){gt(this.a,a)};var yf=aF(sJ,'PushConfiguration/0methodref$onPushModeChange$Type',231);$i(232,1,$I,mt);_.fb=function nt(){Ks(Ic(xk(this.a.a,tf),16),true)};var zf=aF(sJ,'PushConfiguration/lambda$1$Type',232);$i(233,1,$I,ot);_.fb=function pt(){Ks(Ic(xk(this.a.a,tf),16),false)};var Af=aF(sJ,'PushConfiguration/lambda$2$Type',233);$i(360,$wnd.Function,{},qt);_.cb=function rt(a,b){jt(this.a,Ic(a,17),Pc(b))};$i(39,1,{39:1},st);var Df=aF(sJ,'ReconnectConfiguration',39);$i(172,1,UI,tt);_.C=function ut(){Aq(this.a)};var Cf=aF(sJ,'ReconnectConfiguration/lambda$0$Type',172);$i(181,334,{},xt);_.K=function yt(a){wt(this,Ic(a,338))};_.L=function zt(){return vt};_.a=0;var vt=null;var Ef=aF(sJ,'ReconnectionAttemptEvent',181);$i(12,1,{12:1},Gt);_.b=false;var Gf=aF(sJ,'RequestResponseTracker',12);$i(182,1,{},Ht);_.C=function It(){Et(this.a)};var Ff=aF(sJ,'RequestResponseTracker/lambda$0$Type',182);$i(246,334,{},Jt);_.K=function Kt(a){bd(a);null.mc()};_.L=function Lt(){return null};var Hf=aF(sJ,'RequestStartingEvent',246);$i(230,334,{},Nt);_.K=function Ot(a){Ic(a,339).a.b=false};_.L=function Pt(){return Mt};var Mt;var If=aF(sJ,'ResponseHandlingEndedEvent',230);$i(290,334,{},Qt);_.K=function Rt(a){bd(a);null.mc()};_.L=function St(){return null};var Jf=aF(sJ,'ResponseHandlingStartedEvent',290);$i(33,1,{33:1},$t);_.Ab=function _t(a,b,c){Tt(this,a,b,c)};_.Bb=function au(a,b,c){var d;d={};d[QI]='channel';d[HJ]=Object(a);d['channel']=Object(b);d['args']=c;Xt(this,d)};var Kf=aF(sJ,'ServerConnector',33);$i(37,1,{37:1},gu);_.b=false;var bu;var Of=aF(sJ,'ServerRpcQueue',37);$i(212,1,TI,hu);_.I=function iu(){eu(this.a)};var Lf=aF(sJ,'ServerRpcQueue/0methodref$doFlush$Type',212);$i(211,1,TI,ju);_.I=function ku(){cu()};var Mf=aF(sJ,'ServerRpcQueue/lambda$0$Type',211);$i(213,1,{},lu);_.C=function mu(){this.a.a.I()};var Nf=aF(sJ,'ServerRpcQueue/lambda$2$Type',213);$i(62,1,{62:1},pu);_.b=false;var Uf=aF(sJ,'XhrConnection',62);$i(229,40,{},ru);_.I=function su(){qu(this.b)&&this.a.b&&hj(this,250)};var Pf=aF(sJ,'XhrConnection/1',229);$i(226,1,{},uu);_.mb=function vu(a,b){var c;c=new Au(a,this.a);if(!b){Vq(Ic(xk(this.c.a,Re),20),c);return}else{Tq(Ic(xk(this.c.a,Re),20),c)}};_.nb=function wu(a){var b,c;jk('Server visit took '+on(this.b)+'ms');c=a.responseText;b=ds(es(c));if(!b){Uq(Ic(xk(this.c.a,Re),20),new Au(a,this.a));return}Wq(Ic(xk(this.c.a,Re),20));rk()&&fE($wnd.console,'Received xhr message: '+c);Qr(Ic(xk(this.c.a,pf),22),b)};_.b=0;var Qf=aF(sJ,'XhrConnection/XhrResponseHandler',226);$i(227,1,{},xu);_.U=function yu(a){this.a.b=true};var Rf=aF(sJ,'XhrConnection/lambda$0$Type',227);$i(228,1,{339:1},zu);var Sf=aF(sJ,'XhrConnection/lambda$1$Type',228);$i(104,1,{},Au);var Tf=aF(sJ,'XhrConnectionError',104);$i(63,1,{63:1},Eu);var Vf=aF(KJ,'ConstantPool',63);$i(86,1,{86:1},Mu);_.Cb=function Nu(){return Ic(xk(this.a,td),7).a};var Zf=aF(KJ,'ExecuteJavaScriptProcessor',86);$i(215,1,MI,Ou);_.V=function Pu(a){var b;return yC(new Qu(this.a,(b=this.b,b))),TE(),true};var Wf=aF(KJ,'ExecuteJavaScriptProcessor/lambda$0$Type',215);$i(214,1,$I,Qu);_.fb=function Ru(){Hu(this.a,this.b)};var Xf=aF(KJ,'ExecuteJavaScriptProcessor/lambda$1$Type',214);$i(216,1,TI,Su);_.I=function Tu(){Lu(this.a)};var Yf=aF(KJ,'ExecuteJavaScriptProcessor/lambda$2$Type',216);$i(307,1,{},Uu);var $f=aF(KJ,'NodeUnregisterEvent',307);$i(6,1,{6:1},fv);_.Db=function gv(){return Yu(this)};_.Eb=function hv(){return this.g};_.d=0;_.i=false;var bg=aF(KJ,'StateNode',6);$i(347,$wnd.Function,{},jv);_.cb=function kv(a,b){_u(this.a,this.b,Ic(a,34),Kc(b))};$i(348,$wnd.Function,{},lv);_.gb=function mv(a){iv(this.a,Ic(a,106))};var Jh=cF('elemental.events','EventRemover');$i(153,1,OJ,nv);_.Fb=function ov(){av(this.a,this.b)};var _f=aF(KJ,'StateNode/lambda$2$Type',153);$i(349,$wnd.Function,{},pv);_.gb=function qv(a){bv(this.a,Ic(a,61))};$i(154,1,OJ,rv);_.Fb=function sv(){cv(this.a,this.b)};var ag=aF(KJ,'StateNode/lambda$4$Type',154);$i(8,1,{8:1},Jv);_.Gb=function Kv(){return this.e};_.Hb=function Mv(a,b,c,d){var e;if(yv(this,a)){e=Nc(c);Zt(Ic(xk(this.c,Kf),33),a,b,e,d)}};_.d=false;_.f=false;var cg=aF(KJ,'StateTree',8);$i(352,$wnd.Function,{},Nv);_.gb=function Ov(a){Xu(Ic(a,6),aj(Rv.prototype.cb,Rv,[]))};$i(353,$wnd.Function,{},Pv);_.cb=function Qv(a,b){var c;Av(this.a,(c=Ic(a,6),Kc(b),c))};$i(337,$wnd.Function,{},Rv);_.cb=function Sv(a,b){Lv(Ic(a,34),Kc(b))};var $v,_v;$i(178,1,{},ew);var dg=aF(VJ,'Binder/BinderContextImpl',178);var eg=cF(VJ,'BindingStrategy');$i(81,1,{81:1},jw);_.j=0;var fw;var hg=aF(VJ,'Debouncer',81);$i(383,$wnd.Function,{},nw);_.gb=function ow(a){Ic(a,15).I()};$i(336,1,{});_.c=false;_.d=0;var Oh=aF(YJ,'Timer',336);$i(310,336,{},tw);var fg=aF(VJ,'Debouncer/1',310);$i(311,336,{},vw);var gg=aF(VJ,'Debouncer/2',311);$i(384,$wnd.Function,{},xw);_.cb=function yw(a,b){var c;ww(this,(c=Oc(a,$wnd.Map),Nc(b),c))};$i(385,$wnd.Function,{},Bw);_.gb=function Cw(a){zw(this.a,Oc(a,$wnd.Map))};$i(386,$wnd.Function,{},Dw);_.gb=function Ew(a){Aw(this.a,Ic(a,81))};$i(382,$wnd.Function,{},Fw);_.cb=function Gw(a,b){lw(this.a,Ic(a,15),Pc(b))};$i(304,1,OI,Kw);_.bb=function Lw(){return Xw(this.a)};var ig=aF(VJ,'ServerEventHandlerBinder/lambda$0$Type',304);$i(305,1,dJ,Mw);_.hb=function Nw(a){Jw(this.b,this.a,this.c,a)};_.c=false;var jg=aF(VJ,'ServerEventHandlerBinder/lambda$1$Type',305);var Ow;$i(253,1,{314:1},Wx);_.Ib=function Xx(a,b,c){dx(this,a,b,c)};_.Jb=function $x(a){return nx(a)};_.Lb=function dy(a,b){var c,d,e;d=Object.keys(a);e=new Yz(d,a,b);c=Ic(b.e.get(lg),78);!c?Lx(e.b,e.a,e.c):(c.a=e)};_.Mb=function ey(r,s){var t=this;var u=s._propertiesChanged;u&&(s._propertiesChanged=function(a,b,c){qI(function(){t.Lb(b,r)})();u.apply(this,arguments)});var v=r.Eb();var w=s.ready;s.ready=function(){w.apply(this,arguments);xm(s);var q=function(){var o=s.root.querySelector(eK);if(o){s.removeEventListener(fK,q)}else{return}if(!o.constructor.prototype.$propChangedModified){o.constructor.prototype.$propChangedModified=true;var p=o.constructor.prototype._propertiesChanged;o.constructor.prototype._propertiesChanged=function(a,b,c){p.apply(this,arguments);var d=Object.getOwnPropertyNames(b);var e='items.';var f;for(f=0;f0){var i=h.substr(0,g);var j=h.substr(g+1);var k=a.items[i];if(k&&k.nodeId){var l=k.nodeId;var m=k[j];var n=this.__dataHost;while(!n.localName||n.__dataHost){n=n.__dataHost}qI(function(){cy(l,n,j,m,v)})()}}}}}}};s.root&&s.root.querySelector(eK)?q():s.addEventListener(fK,q)}};_.Kb=function fy(a){if(a.c.has(0)){return true}return !!a.g&&K(a,a.g.e)};var Zw,$w;var Tg=aF(VJ,'SimpleElementBindingStrategy',253);$i(371,$wnd.Function,{},wy);_.gb=function xy(a){Ic(a,49).Fb()};$i(375,$wnd.Function,{},yy);_.gb=function zy(a){Ic(a,15).I()};$i(102,1,{},Ay);var kg=aF(VJ,'SimpleElementBindingStrategy/BindingContext',102);$i(78,1,{78:1},By);var lg=aF(VJ,'SimpleElementBindingStrategy/InitialPropertyUpdate',78);$i(254,1,{},Cy);_.Nb=function Dy(a){zx(this.a,a)};var mg=aF(VJ,'SimpleElementBindingStrategy/lambda$0$Type',254);$i(255,1,{},Ey);_.Nb=function Fy(a){Ax(this.a,a)};var ng=aF(VJ,'SimpleElementBindingStrategy/lambda$1$Type',255);$i(367,$wnd.Function,{},Gy);_.cb=function Hy(a,b){var c;gy(this.b,this.a,(c=Ic(a,17),Pc(b),c))};$i(264,1,eJ,Iy);_.jb=function Jy(a){hy(this.b,this.a,a)};var og=aF(VJ,'SimpleElementBindingStrategy/lambda$11$Type',264);$i(265,1,fJ,Ky);_.kb=function Ly(a){Tx(this.c,this.b,this.a)};var pg=aF(VJ,'SimpleElementBindingStrategy/lambda$12$Type',265);$i(266,1,$I,My);_.fb=function Ny(){Bx(this.b,this.c,this.a)};var qg=aF(VJ,'SimpleElementBindingStrategy/lambda$13$Type',266);$i(267,1,UI,Oy);_.C=function Py(){this.b.Nb(this.a)};var rg=aF(VJ,'SimpleElementBindingStrategy/lambda$14$Type',267);$i(268,1,MI,Ry);_.V=function Sy(a){return Qy(this,a)};var sg=aF(VJ,'SimpleElementBindingStrategy/lambda$15$Type',268);$i(269,1,UI,Ty);_.C=function Uy(){this.a[this.b]=tm(this.c)};var tg=aF(VJ,'SimpleElementBindingStrategy/lambda$16$Type',269);$i(271,1,dJ,Vy);_.hb=function Wy(a){Cx(this.a,a)};var ug=aF(VJ,'SimpleElementBindingStrategy/lambda$17$Type',271);$i(270,1,$I,Xy);_.fb=function Yy(){ux(this.b,this.a)};var vg=aF(VJ,'SimpleElementBindingStrategy/lambda$18$Type',270);$i(273,1,dJ,Zy);_.hb=function $y(a){Dx(this.a,a)};var wg=aF(VJ,'SimpleElementBindingStrategy/lambda$19$Type',273);$i(256,1,{},_y);_.Nb=function az(a){Ex(this.a,a)};var xg=aF(VJ,'SimpleElementBindingStrategy/lambda$2$Type',256);$i(272,1,$I,bz);_.fb=function cz(){Fx(this.b,this.a)};var yg=aF(VJ,'SimpleElementBindingStrategy/lambda$20$Type',272);$i(274,1,TI,dz);_.I=function ez(){wx(this.a,this.b,this.c,false)};var zg=aF(VJ,'SimpleElementBindingStrategy/lambda$21$Type',274);$i(275,1,TI,fz);_.I=function gz(){wx(this.a,this.b,this.c,false)};var Ag=aF(VJ,'SimpleElementBindingStrategy/lambda$22$Type',275);$i(276,1,TI,hz);_.I=function iz(){yx(this.a,this.b,this.c,false)};var Bg=aF(VJ,'SimpleElementBindingStrategy/lambda$23$Type',276);$i(277,1,OI,jz);_.bb=function kz(){return jy(this.a,this.b)};var Cg=aF(VJ,'SimpleElementBindingStrategy/lambda$24$Type',277);$i(278,1,TI,lz);_.I=function mz(){px(this.b,this.e,false,this.c,this.d,this.a)};var Dg=aF(VJ,'SimpleElementBindingStrategy/lambda$25$Type',278);$i(279,1,OI,nz);_.bb=function oz(){return ky(this.a,this.b)};var Eg=aF(VJ,'SimpleElementBindingStrategy/lambda$26$Type',279);$i(280,1,OI,pz);_.bb=function qz(){return ly(this.a,this.b)};var Fg=aF(VJ,'SimpleElementBindingStrategy/lambda$27$Type',280);$i(368,$wnd.Function,{},rz);_.cb=function sz(a,b){var c;mC((c=Ic(a,76),Pc(b),c))};$i(257,1,{106:1},tz);_.ib=function uz(a){Mx(this.c,this.b,this.a)};var Gg=aF(VJ,'SimpleElementBindingStrategy/lambda$3$Type',257);$i(369,$wnd.Function,{},vz);_.gb=function wz(a){my(this.a,Oc(a,$wnd.Map))};$i(370,$wnd.Function,{},xz);_.cb=function yz(a,b){var c;(c=Ic(a,49),Pc(b),c).Fb()};$i(372,$wnd.Function,{},zz);_.cb=function Az(a,b){var c;Gx(this.a,(c=Ic(a,17),Pc(b),c))};$i(281,1,eJ,Bz);_.jb=function Cz(a){Hx(this.a,a)};var Hg=aF(VJ,'SimpleElementBindingStrategy/lambda$34$Type',281);$i(282,1,UI,Dz);_.C=function Ez(){Ix(this.b,this.a,this.c)};var Ig=aF(VJ,'SimpleElementBindingStrategy/lambda$35$Type',282);$i(283,1,{},Fz);_.U=function Gz(a){Jx(this.a,a)};var Jg=aF(VJ,'SimpleElementBindingStrategy/lambda$36$Type',283);$i(373,$wnd.Function,{},Hz);_.gb=function Iz(a){ny(this.b,this.a,Pc(a))};$i(374,$wnd.Function,{},Jz);_.gb=function Kz(a){Kx(this.a,this.b,Pc(a))};$i(284,1,{},Lz);_.gb=function Mz(a){uy(this.b,this.c,this.a,Pc(a))};var Kg=aF(VJ,'SimpleElementBindingStrategy/lambda$39$Type',284);$i(259,1,$I,Nz);_.fb=function Oz(){oy(this.a)};var Lg=aF(VJ,'SimpleElementBindingStrategy/lambda$4$Type',259);$i(285,1,dJ,Pz);_.hb=function Qz(a){py(this.a,a)};var Mg=aF(VJ,'SimpleElementBindingStrategy/lambda$41$Type',285);$i(286,1,OI,Rz);_.bb=function Sz(){return this.a.b};var Ng=aF(VJ,'SimpleElementBindingStrategy/lambda$42$Type',286);$i(376,$wnd.Function,{},Tz);_.gb=function Uz(a){this.a.push(Ic(a,6))};$i(258,1,{},Vz);_.C=function Wz(){qy(this.a)};var Og=aF(VJ,'SimpleElementBindingStrategy/lambda$5$Type',258);$i(261,1,TI,Yz);_.I=function Zz(){Xz(this)};var Pg=aF(VJ,'SimpleElementBindingStrategy/lambda$6$Type',261);$i(260,1,OI,$z);_.bb=function _z(){return this.a[this.b]};var Qg=aF(VJ,'SimpleElementBindingStrategy/lambda$7$Type',260);$i(263,1,eJ,aA);_.jb=function bA(a){xC(new cA(this.a))};var Rg=aF(VJ,'SimpleElementBindingStrategy/lambda$8$Type',263);$i(262,1,$I,cA);_.fb=function dA(){cx(this.a)};var Sg=aF(VJ,'SimpleElementBindingStrategy/lambda$9$Type',262);$i(287,1,{314:1},iA);_.Ib=function jA(a,b,c){gA(a,b)};_.Jb=function kA(a){return $doc.createTextNode('')};_.Kb=function lA(a){return a.c.has(7)};var eA;var Wg=aF(VJ,'TextBindingStrategy',287);$i(288,1,UI,mA);_.C=function nA(){fA();aE(this.a,Pc(PA(this.b)))};var Ug=aF(VJ,'TextBindingStrategy/lambda$0$Type',288);$i(289,1,{106:1},oA);_.ib=function pA(a){hA(this.b,this.a)};var Vg=aF(VJ,'TextBindingStrategy/lambda$1$Type',289);$i(346,$wnd.Function,{},tA);_.gb=function uA(a){this.a.add(a)};$i(350,$wnd.Function,{},wA);_.cb=function xA(a,b){this.a.push(a)};var zA,AA=false;$i(296,1,{},CA);var Xg=aF('com.vaadin.client.flow.dom','PolymerDomApiImpl',296);$i(79,1,{79:1},DA);var Yg=aF('com.vaadin.client.flow.model','UpdatableModelProperties',79);$i(381,$wnd.Function,{},EA);_.gb=function FA(a){this.a.add(Pc(a))};$i(90,1,{});_.Ob=function HA(){return this.e};var xh=aF(ZI,'ReactiveValueChangeEvent',90);$i(59,90,{59:1},IA);_.Ob=function JA(){return Ic(this.e,30)};_.b=false;_.c=0;var Zg=aF(gK,'ListSpliceEvent',59);$i(17,1,{17:1,315:1},YA);_.Pb=function ZA(a){return _A(this.a,a)};_.b=false;_.c=false;_.d=false;var KA;var hh=aF(gK,'MapProperty',17);$i(88,1,{});var wh=aF(ZI,'ReactiveEventRouter',88);$i(239,88,{},fB);_.Qb=function gB(a,b){Ic(a,50).kb(Ic(b,80))};_.Rb=function hB(a){return new iB(a)};var _g=aF(gK,'MapProperty/1',239);$i(240,1,fJ,iB);_.kb=function jB(a){kC(this.a)};var $g=aF(gK,'MapProperty/1/0methodref$onValueChange$Type',240);$i(238,1,TI,kB);_.I=function lB(){LA()};var ah=aF(gK,'MapProperty/lambda$0$Type',238);$i(241,1,$I,mB);_.fb=function nB(){this.a.d=false};var bh=aF(gK,'MapProperty/lambda$1$Type',241);$i(242,1,$I,oB);_.fb=function pB(){this.a.d=false};var dh=aF(gK,'MapProperty/lambda$2$Type',242);$i(243,1,TI,qB);_.I=function rB(){UA(this.a,this.b)};var eh=aF(gK,'MapProperty/lambda$3$Type',243);$i(91,90,{91:1},sB);_.Ob=function tB(){return Ic(this.e,45)};var fh=aF(gK,'MapPropertyAddEvent',91);$i(80,90,{80:1},uB);_.Ob=function vB(){return Ic(this.e,17)};var gh=aF(gK,'MapPropertyChangeEvent',80);$i(34,1,{34:1});_.d=0;var ih=aF(gK,'NodeFeature',34);$i(30,34,{34:1,30:1,315:1},DB);_.Pb=function EB(a){return _A(this.a,a)};_.Sb=function FB(a){var b,c,d;c=[];for(b=0;b=0?':'+this.c:'')+')'};_.c=0;var ki=aF(uI,'StackTraceElement',31);Gc={3:1,112:1,21:1,2:1};var ni=aF(uI,'String',2);$i(71,85,{112:1},ZF,$F,_F);var li=aF(uI,'StringBuilder',71);$i(125,72,zI,aG);var mi=aF(uI,'StringIndexOutOfBoundsException',125);$i(490,1,{});var bG;$i(107,1,MI,eG);_.V=function fG(a){return dG(a)};var oi=aF(uI,'Throwable/lambda$0$Type',107);$i(96,9,zI,gG);var qi=aF(uI,'UnsupportedOperationException',96);$i(331,1,{105:1});_._b=function hG(a){throw Si(new gG('Add not supported on this collection'))};_.p=function iG(){var a,b,c;c=new jH;for(b=this.ac();b.dc();){a=b.ec();iH(c,a===this?'(this Collection)':a==null?AI:cj(a))}return !c.a?c.c:c.e.length==0?c.a.a:c.a.a+(''+c.e)};var ri=aF(AK,'AbstractCollection',331);$i(332,331,{105:1,94:1});_.cc=function jG(a,b){throw Si(new gG('Add not supported on this list'))};_._b=function kG(a){this.cc(this.bc(),a);return true};_.m=function lG(a){var b,c,d,e,f;if(a===this){return true}if(!Sc(a,36)){return false}f=Ic(a,94);if(this.a.length!=f.a.length){return false}e=new CG(f);for(c=new CG(this);c.a; + } + +} + +customElements.define('react-router-outlet', ReactRouterOutletElement); diff --git a/backend/src/main/frontend/generated/jar-resources/comboBoxConnector.js b/backend/src/main/frontend/generated/jar-resources/comboBoxConnector.js new file mode 100644 index 0000000..8d316a2 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/comboBoxConnector.js @@ -0,0 +1,284 @@ +import { Debouncer } from '@vaadin/component-base/src/debounce.js'; +import { timeOut } from '@vaadin/component-base/src/async.js'; +import { ComboBoxPlaceholder } from '@vaadin/combo-box/src/vaadin-combo-box-placeholder.js'; + +window.Vaadin.Flow.comboBoxConnector = {}; +window.Vaadin.Flow.comboBoxConnector.initLazy = (comboBox) => { + // Check whether the connector was already initialized for the ComboBox + if (comboBox.$connector) { + return; + } + + comboBox.$connector = {}; + + // holds pageIndex -> callback pairs of subsequent indexes (current active range) + const pageCallbacks = {}; + let cache = {}; + let lastFilter = ''; + const placeHolder = new window.Vaadin.ComboBoxPlaceholder(); + + const serverFacade = (() => { + // Private variables + let lastFilterSentToServer = ''; + let dataCommunicatorResetNeeded = false; + + // Public methods + const needsDataCommunicatorReset = () => (dataCommunicatorResetNeeded = true); + const getLastFilterSentToServer = () => lastFilterSentToServer; + const requestData = (startIndex, endIndex, params) => { + const count = endIndex - startIndex; + const filter = params.filter; + + comboBox.$server.setViewportRange(startIndex, count, filter); + lastFilterSentToServer = filter; + if (dataCommunicatorResetNeeded) { + comboBox.$server.resetDataCommunicator(); + dataCommunicatorResetNeeded = false; + } + }; + + return { + needsDataCommunicatorReset, + getLastFilterSentToServer, + requestData + }; + })(); + + const clearPageCallbacks = (pages = Object.keys(pageCallbacks)) => { + // Flush and empty the existing requests + pages.forEach((page) => { + pageCallbacks[page]([], comboBox.size); + delete pageCallbacks[page]; + + // Empty the comboBox's internal cache without invoking observers by filling + // the filteredItems array with placeholders (comboBox will request for data when it + // encounters a placeholder) + const pageStart = parseInt(page) * comboBox.pageSize; + const pageEnd = pageStart + comboBox.pageSize; + const end = Math.min(pageEnd, comboBox.filteredItems.length); + for (let i = pageStart; i < end; i++) { + comboBox.filteredItems[i] = placeHolder; + } + }); + }; + + comboBox.dataProvider = function (params, callback) { + if (params.pageSize != comboBox.pageSize) { + throw 'Invalid pageSize'; + } + + if (comboBox._clientSideFilter) { + // For clientside filter we first make sure we have all data which we also + // filter based on comboBox.filter. While later we only filter clientside data. + + if (cache[0]) { + performClientSideFilter(cache[0], params.filter, callback); + return; + } else { + // If client side filter is enabled then we need to first ask all data + // and filter it on client side, otherwise next time when user will + // input another filter, eg. continue to type, the local cache will be only + // what was received for the first filter, which may not be the whole + // data from server (keep in mind that client side filter is enabled only + // when the items count does not exceed one page). + params.filter = ''; + } + } + + const filterChanged = params.filter !== lastFilter; + if (filterChanged) { + cache = {}; + lastFilter = params.filter; + comboBox._filterDebouncer = Debouncer.debounce(comboBox._filterDebouncer, timeOut.after(500), () => { + if (serverFacade.getLastFilterSentToServer() === params.filter) { + // Fixes the case when the filter changes + // to something else and back to the original value + // within debounce timeout, and the + // DataCommunicator thinks it doesn't need to send data + serverFacade.needsDataCommunicatorReset(); + } + if (params.filter !== lastFilter) { + throw new Error("Expected params.filter to be '" + lastFilter + "' but was '" + params.filter + "'"); + } + // Remove the debouncer before clearing page callbacks. + // This makes sure that they are executed. + comboBox._filterDebouncer = undefined; + // Call the method again after debounce. + clearPageCallbacks(); + comboBox.dataProvider(params, callback); + }); + return; + } + + // Postpone the execution of new callbacks if there is an active debouncer. + // They will be executed when the page callbacks are cleared within the debouncer. + if (comboBox._filterDebouncer) { + pageCallbacks[params.page] = callback; + return; + } + + if (cache[params.page]) { + // This may happen after skipping pages by scrolling fast + commitPage(params.page, callback); + } else { + pageCallbacks[params.page] = callback; + const maxRangeCount = Math.max(params.pageSize * 2, 500); // Max item count in active range + const activePages = Object.keys(pageCallbacks).map((page) => parseInt(page)); + const rangeMin = Math.min(...activePages); + const rangeMax = Math.max(...activePages); + + if (activePages.length * params.pageSize > maxRangeCount) { + if (params.page === rangeMin) { + clearPageCallbacks([String(rangeMax)]); + } else { + clearPageCallbacks([String(rangeMin)]); + } + comboBox.dataProvider(params, callback); + } else if (rangeMax - rangeMin + 1 !== activePages.length) { + // Wasn't a sequential page index, clear the cache so combo-box will request for new pages + clearPageCallbacks(); + } else { + // The requested page was sequential, extend the requested range + const startIndex = params.pageSize * rangeMin; + const endIndex = params.pageSize * (rangeMax + 1); + + serverFacade.requestData(startIndex, endIndex, params); + } + } + }; + + comboBox.$connector.clear = (start, length) => { + const firstPageToClear = Math.floor(start / comboBox.pageSize); + const numberOfPagesToClear = Math.ceil(length / comboBox.pageSize); + + for (let i = firstPageToClear; i < firstPageToClear + numberOfPagesToClear; i++) { + delete cache[i]; + } + }; + + comboBox.$connector.filter = (item, filter) => { + filter = filter ? filter.toString().toLowerCase() : ''; + return comboBox._getItemLabel(item, comboBox.itemLabelPath).toString().toLowerCase().indexOf(filter) > -1; + }; + + comboBox.$connector.set = (index, items, filter) => { + if (filter != serverFacade.getLastFilterSentToServer()) { + return; + } + + if (index % comboBox.pageSize != 0) { + throw 'Got new data to index ' + index + ' which is not aligned with the page size of ' + comboBox.pageSize; + } + + if (index === 0 && items.length === 0 && pageCallbacks[0]) { + // Makes sure that the dataProvider callback is called even when server + // returns empty data set (no items match the filter). + cache[0] = []; + return; + } + + const firstPageToSet = index / comboBox.pageSize; + const updatedPageCount = Math.ceil(items.length / comboBox.pageSize); + + for (let i = 0; i < updatedPageCount; i++) { + let page = firstPageToSet + i; + let slice = items.slice(i * comboBox.pageSize, (i + 1) * comboBox.pageSize); + + cache[page] = slice; + } + }; + + comboBox.$connector.updateData = (items) => { + const itemsMap = new Map(items.map((item) => [item.key, item])); + + comboBox.filteredItems = comboBox.filteredItems.map((item) => { + return itemsMap.get(item.key) || item; + }); + }; + + comboBox.$connector.updateSize = function (newSize) { + if (!comboBox._clientSideFilter) { + // FIXME: It may be that this size set is unnecessary, since when + // providing data to combobox via callback we may use data's size. + // However, if this size reflect the whole data size, including + // data not fetched yet into client side, and combobox expect it + // to be set as such, the at least, we don't need it in case the + // filter is clientSide only, since it'll increase the height of + // the popup at only at first user filter to this size, while the + // filtered items count are less. + comboBox.size = newSize; + } + }; + + comboBox.$connector.reset = function () { + // Cancel pending requests, as clearCache below will set the combo + // in a state where it will always request new data, regardless + // what is in the cache already. + if (comboBox._filterDebouncer) { + comboBox._filterDebouncer.cancel(); + comboBox._filterDebouncer = undefined; + } + clearPageCallbacks(); + cache = {}; + comboBox.clearCache(); + }; + + comboBox.$connector.confirm = function (id, filter) { + if (filter != serverFacade.getLastFilterSentToServer()) { + return; + } + + // We're done applying changes from this batch, resolve pending + // callbacks + let activePages = Object.getOwnPropertyNames(pageCallbacks); + for (let i = 0; i < activePages.length; i++) { + let page = activePages[i]; + + if (cache[page]) { + commitPage(page, pageCallbacks[page]); + } + } + + // Let server know we're done + comboBox.$server.confirmUpdate(id); + }; + + const commitPage = function (page, callback) { + let data = cache[page]; + + if (comboBox._clientSideFilter) { + performClientSideFilter(data, comboBox.filter, callback); + } else { + // Remove the data if server-side filtering, but keep it for client-side + // filtering + delete cache[page]; + + // FIXME: It may be that we ought to provide data.length instead of + // comboBox.size and remove updateSize function. + callback(data, comboBox.size); + } + }; + + // Perform filter on client side (here) using the items from specified page + // and submitting the filtered items to specified callback. + // The filter used is the one from combobox, not the lastFilter stored since + // that may not reflect user's input. + const performClientSideFilter = function (page, filter, callback) { + let filteredItems = page; + + if (filter) { + filteredItems = page.filter((item) => comboBox.$connector.filter(item, filter)); + } + + callback(filteredItems, filteredItems.length); + }; + + // Prevent setting the custom value as the 'value'-prop automatically + comboBox.addEventListener('custom-value-set', (e) => e.preventDefault()); + + comboBox.itemClassNameGenerator = function (item) { + return item.className || ''; + }; +}; + +window.Vaadin.ComboBoxPlaceholder = ComboBoxPlaceholder; diff --git a/backend/src/main/frontend/generated/jar-resources/contextMenuConnector.js b/backend/src/main/frontend/generated/jar-resources/contextMenuConnector.js new file mode 100644 index 0000000..351c4a6 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/contextMenuConnector.js @@ -0,0 +1,122 @@ +function getContainer(appId, nodeId) { + try { + return window.Vaadin.Flow.clients[appId].getByNodeId(nodeId); + } catch (error) { + console.error('Could not get node %s from app %s', nodeId, appId); + console.error(error); + } +} + +/** + * Initializes the connector for a context menu element. + * + * @param {HTMLElement} contextMenu + * @param {string} appId + */ +function initLazy(contextMenu, appId) { + if (contextMenu.$connector) { + return; + } + + contextMenu.$connector = { + /** + * Generates and assigns the items to the context menu. + * + * @param {number} nodeId + */ + generateItems(nodeId) { + const items = generateItemsTree(appId, nodeId); + + contextMenu.items = items; + } + }; +} + +/** + * Generates an items tree compatible with the context-menu web component + * by traversing the given Flow DOM tree of context menu item nodes + * whose root node is identified by the `nodeId` argument. + * + * The app id is required to access the store of Flow DOM nodes. + * + * @param {string} appId + * @param {number} nodeId + */ +function generateItemsTree(appId, nodeId) { + const container = getContainer(appId, nodeId); + if (!container) { + return; + } + + return Array.from(container.children).map((child) => { + const item = { + component: child, + checked: child._checked, + keepOpen: child._keepOpen, + className: child.className, + theme: child.__theme + }; + // Do not hardcode tag name to allow `vaadin-menu-bar-item` + if (child._hasVaadinItemMixin && child._containerNodeId) { + item.children = generateItemsTree(appId, child._containerNodeId); + } + child._item = item; + return item; + }); +} + +/** + * Sets the checked state for a context menu item. + * + * This method is supposed to be called when the context menu item is closed, + * so there is no need for triggering a re-render eagarly. + * + * @param {HTMLElement} component + * @param {boolean} checked + */ +function setChecked(component, checked) { + if (component._item) { + component._item.checked = checked; + + // Set the attribute in the connector to show the checkmark + // without having to re-render the whole menu while opened. + if (component._item.keepOpen) { + component.toggleAttribute('menu-item-checked', checked); + } + } +} + +/** + * Sets the keep open state for a context menu item. + * + * @param {HTMLElement} component + * @param {boolean} keepOpen + */ +function setKeepOpen(component, keepOpen) { + if (component._item) { + component._item.keepOpen = keepOpen; + } +} + +/** + * Sets the theme for a context menu item. + * + * This method is supposed to be called when the context menu item is closed, + * so there is no need for triggering a re-render eagarly. + * + * @param {HTMLElement} component + * @param {string | undefined | null} theme + */ +function setTheme(component, theme) { + if (component._item) { + component._item.theme = theme; + } +} + +window.Vaadin.Flow.contextMenuConnector = { + initLazy, + generateItemsTree, + setChecked, + setKeepOpen, + setTheme +}; diff --git a/backend/src/main/frontend/generated/jar-resources/contextMenuTargetConnector.js b/backend/src/main/frontend/generated/jar-resources/contextMenuTargetConnector.js new file mode 100644 index 0000000..1580b06 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/contextMenuTargetConnector.js @@ -0,0 +1,62 @@ +import * as Gestures from '@vaadin/component-base/src/gestures.js'; + +function init(target) { + if (target.$contextMenuTargetConnector) { + return; + } + + target.$contextMenuTargetConnector = { + openOnHandler(e) { + // used by Grid to prevent context menu on selection column click + if (target.preventContextMenu && target.preventContextMenu(e)) { + return; + } + e.preventDefault(); + e.stopPropagation(); + this.$contextMenuTargetConnector.openEvent = e; + let detail = {}; + if (target.getContextMenuBeforeOpenDetail) { + detail = target.getContextMenuBeforeOpenDetail(e); + } + target.dispatchEvent( + new CustomEvent('vaadin-context-menu-before-open', { + detail: detail + }) + ); + }, + + updateOpenOn(eventType) { + this.removeListener(); + this.openOnEventType = eventType; + + customElements.whenDefined('vaadin-context-menu').then(() => { + if (Gestures.gestures[eventType]) { + Gestures.addListener(target, eventType, this.openOnHandler); + } else { + target.addEventListener(eventType, this.openOnHandler); + } + }); + }, + + removeListener() { + if (this.openOnEventType) { + if (Gestures.gestures[this.openOnEventType]) { + Gestures.removeListener(target, this.openOnEventType, this.openOnHandler); + } else { + target.removeEventListener(this.openOnEventType, this.openOnHandler); + } + } + }, + + openMenu(contextMenu) { + contextMenu.open(this.openEvent); + }, + + removeConnector() { + this.removeListener(); + target.$contextMenuTargetConnector = undefined; + } + }; +} + +window.Vaadin.Flow.contextMenuTargetConnector = { init }; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot-version.js b/backend/src/main/frontend/generated/jar-resources/copilot-version.js new file mode 100644 index 0000000..7586ce3 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot-version.js @@ -0,0 +1 @@ +// Full cdn version: 25.0.7-undefined \ No newline at end of file diff --git a/backend/src/main/frontend/generated/jar-resources/copilot.d.ts b/backend/src/main/frontend/generated/jar-resources/copilot.d.ts new file mode 100644 index 0000000..2ea7939 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot.d.ts @@ -0,0 +1,3 @@ +export { registerImporter, createChildrenDefinitions } from './copilot/figma-public/figma-api'; +export type { FigmaNode, ImportMetadata } from './copilot/figma-public/figma-api'; +export type { ComponentDefinition, ComponentDefinitionProperties } from './copilot/shared/flow-utils'; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot.js b/backend/src/main/frontend/generated/jar-resources/copilot.js new file mode 100644 index 0000000..92abc3d --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot.js @@ -0,0 +1,5 @@ +import { aB as a, aA as i } from "./copilot/copilot-BvIxHaRg.js"; +export { + a as createChildrenDefinitions, + i as registerImporter +}; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/base-panel-C5as2IDv.js b/backend/src/main/frontend/generated/jar-resources/copilot/base-panel-C5as2IDv.js new file mode 100644 index 0000000..2eca477 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/base-panel-C5as2IDv.js @@ -0,0 +1,36 @@ +import { M as t, w as n, j as a, ay as i, b as o } from "./copilot-BvIxHaRg.js"; +class l extends t { + constructor() { + super(...arguments), this.eventBusRemovers = [], this.messageHandlers = {}, this.handleESC = (e) => { + const s = n.getPanelByTag(this.tagName); + !a.active && s && !s.individual || e.key === "Escape" && i(this); + }; + } + createRenderRoot() { + return this; + } + onEventBus(e, s) { + this.eventBusRemovers.push(o.on(e, s)); + } + connectedCallback() { + super.connectedCallback(), this.addESCListener(); + } + disconnectedCallback() { + super.disconnectedCallback(), this.eventBusRemovers.forEach((e) => e()), this.removeESCListener(); + } + addESCListener() { + document.addEventListener("keydown", this.handleESC); + } + removeESCListener() { + document.removeEventListener("keydown", this.handleESC); + } + onCommand(e, s) { + this.messageHandlers[e] = s; + } + handleMessage(e) { + return this.messageHandlers[e.command] ? (this.messageHandlers[e.command].call(this, e), !0) : !1; + } +} +export { + l as B +}; diff --git a/backend/src/main/frontend/generated/jar-resources/copilot/copilot-BvIxHaRg.js b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-BvIxHaRg.js new file mode 100644 index 0000000..c92a7d2 --- /dev/null +++ b/backend/src/main/frontend/generated/jar-resources/copilot/copilot-BvIxHaRg.js @@ -0,0 +1,6357 @@ +class Xa { + constructor() { + this.eventBuffer = [], this.handledTypes = [], this.copilotMain = null, this.debug = !1, this.eventProxy = { + functionCallQueue: [], + dispatchEvent(...t) { + return this.functionCallQueue.push({ name: "dispatchEvent", args: t }), !0; + }, + removeEventListener(...t) { + this.functionCallQueue.push({ name: "removeEventListener", args: t }); + }, + addEventListener(...t) { + this.functionCallQueue.push({ name: "addEventListener", args: t }); + }, + processQueue(t) { + this.functionCallQueue.forEach((r) => { + t[r.name].call(t, ...r.args); + }), this.functionCallQueue = []; + } + }; + } + getEventTarget() { + return this.copilotMain ? this.copilotMain : (this.copilotMain = document.querySelector("copilot-main"), this.copilotMain ? (this.eventProxy.processQueue(this.copilotMain), this.copilotMain) : this.eventProxy); + } + on(t, r) { + const n = r; + return this.getEventTarget().addEventListener(t, n), this.handledTypes.push(t), this.flush(t), () => this.off(t, n); + } + once(t, r) { + this.getEventTarget().addEventListener(t, r, { once: !0 }); + } + off(t, r) { + this.getEventTarget().removeEventListener(t, r); + const n = this.handledTypes.indexOf(t, 0); + n > -1 && this.handledTypes.splice(n, 1); + } + emit(t, r) { + const n = new CustomEvent(t, { detail: r, cancelable: !0 }); + return this.handledTypes.includes(t) || this.eventBuffer.push(n), this.debug && console.debug("Emit event", n), this.getEventTarget().dispatchEvent(n), n.defaultPrevented; + } + emitUnsafe({ type: t, data: r }) { + return this.emit(t, r); + } + // Communication with server via eventbus + send(t, r) { + const n = new CustomEvent("copilot-send", { detail: { command: t, data: r } }); + this.getEventTarget().dispatchEvent(n); + } + // Listeners for Copilot itself + onSend(t) { + this.on("copilot-send", t); + } + offSend(t) { + this.off("copilot-send", t); + } + flush(t) { + const r = []; + this.eventBuffer.filter((n) => n.type === t).forEach((n) => { + this.getEventTarget().dispatchEvent(n), r.push(n); + }), this.eventBuffer = this.eventBuffer.filter((n) => !r.includes(n)); + } +} +var Ja = { + 0: "Invalid value for configuration 'enforceActions', expected 'never', 'always' or 'observed'", + 1: function(t, r) { + return "Cannot apply '" + t + "' to '" + r.toString() + "': Field not found."; + }, + /* + 2(prop) { + return `invalid decorator for '${prop.toString()}'` + }, + 3(prop) { + return `Cannot decorate '${prop.toString()}': action can only be used on properties with a function value.` + }, + 4(prop) { + return `Cannot decorate '${prop.toString()}': computed can only be used on getter properties.` + }, + */ + 5: "'keys()' can only be used on observable objects, arrays, sets and maps", + 6: "'values()' can only be used on observable objects, arrays, sets and maps", + 7: "'entries()' can only be used on observable objects, arrays and maps", + 8: "'set()' can only be used on observable objects, arrays and maps", + 9: "'remove()' can only be used on observable objects, arrays and maps", + 10: "'has()' can only be used on observable objects, arrays and maps", + 11: "'get()' can only be used on observable objects, arrays and maps", + 12: "Invalid annotation", + 13: "Dynamic observable objects cannot be frozen. If you're passing observables to 3rd party component/function that calls Object.freeze, pass copy instead: toJS(observable)", + 14: "Intercept handlers should return nothing or a change object", + 15: "Observable arrays cannot be frozen. If you're passing observables to 3rd party component/function that calls Object.freeze, pass copy instead: toJS(observable)", + 16: "Modification exception: the internal structure of an observable array was changed.", + 17: function(t, r) { + return "[mobx.array] Index out of bounds, " + t + " is larger than " + r; + }, + 18: "mobx.map requires Map polyfill for the current browser. Check babel-polyfill or core-js/es6/map.js", + 19: function(t) { + return "Cannot initialize from classes that inherit from Map: " + t.constructor.name; + }, + 20: function(t) { + return "Cannot initialize map from " + t; + }, + 21: function(t) { + return "Cannot convert to map from '" + t + "'"; + }, + 22: "mobx.set requires Set polyfill for the current browser. Check babel-polyfill or core-js/es6/set.js", + 23: "It is not possible to get index atoms from arrays", + 24: function(t) { + return "Cannot obtain administration from " + t; + }, + 25: function(t, r) { + return "the entry '" + t + "' does not exist in the observable map '" + r + "'"; + }, + 26: "please specify a property", + 27: function(t, r) { + return "no observable property '" + t.toString() + "' found on the observable object '" + r + "'"; + }, + 28: function(t) { + return "Cannot obtain atom from " + t; + }, + 29: "Expecting some object", + 30: "invalid action stack. did you forget to finish an action?", + 31: "missing option for computed: get", + 32: function(t, r) { + return "Cycle detected in computation " + t + ": " + r; + }, + 33: function(t) { + return "The setter of computed value '" + t + "' is trying to update itself. Did you intend to update an _observable_ value, instead of the computed property?"; + }, + 34: function(t) { + return "[ComputedValue '" + t + "'] It is not possible to assign a new value to a computed value."; + }, + 35: "There are multiple, different versions of MobX active. Make sure MobX is loaded only once or use `configure({ isolateGlobalState: true })`", + 36: "isolateGlobalState should be called before MobX is running any reactions", + 37: function(t) { + return "[mobx] `observableArray." + t + "()` mutates the array in-place, which is not allowed inside a derivation. Use `array.slice()." + t + "()` instead"; + }, + 38: "'ownKeys()' can only be used on observable objects", + 39: "'defineProperty()' can only be used on observable objects" +}, Ga = process.env.NODE_ENV !== "production" ? Ja : {}; +function f(e) { + for (var t = arguments.length, r = new Array(t > 1 ? t - 1 : 0), n = 1; n < t; n++) + r[n - 1] = arguments[n]; + if (process.env.NODE_ENV !== "production") { + var i = typeof e == "string" ? e : Ga[e]; + throw typeof i == "function" && (i = i.apply(null, r)), new Error("[MobX] " + i); + } + throw new Error(typeof e == "number" ? "[MobX] minified error nr: " + e + (r.length ? " " + r.map(String).join(",") : "") + ". Find the full error at: https://github.com/mobxjs/mobx/blob/main/packages/mobx/src/errors.ts" : "[MobX] " + e); +} +var Ya = {}; +function Hr() { + return typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : Ya; +} +var gi = Object.assign, Ht = Object.getOwnPropertyDescriptor, _ = Object.defineProperty, lr = Object.prototype, Xt = []; +Object.freeze(Xt); +var Xr = {}; +Object.freeze(Xr); +var Qa = typeof Proxy < "u", _a = /* @__PURE__ */ Object.toString(); +function mi() { + Qa || f(process.env.NODE_ENV !== "production" ? "`Proxy` objects are not available in the current environment. Please configure MobX to enable a fallback implementation.`" : "Proxy not available"); +} +function at(e) { + process.env.NODE_ENV !== "production" && p.verifyProxies && f("MobX is currently configured to be able to run in ES5 mode, but in ES5 MobX won't be able to " + e); +} +function F() { + return ++p.mobxGuid; +} +function Jr(e) { + var t = !1; + return function() { + if (!t) + return t = !0, e.apply(this, arguments); + }; +} +var Fe = function() { +}; +function k(e) { + return typeof e == "function"; +} +function Pe(e) { + var t = typeof e; + switch (t) { + case "string": + case "symbol": + case "number": + return !0; + } + return !1; +} +function cr(e) { + return e !== null && typeof e == "object"; +} +function D(e) { + if (!cr(e)) + return !1; + var t = Object.getPrototypeOf(e); + if (t == null) + return !0; + var r = Object.hasOwnProperty.call(t, "constructor") && t.constructor; + return typeof r == "function" && r.toString() === _a; +} +function bi(e) { + var t = e?.constructor; + return t ? t.name === "GeneratorFunction" || t.displayName === "GeneratorFunction" : !1; +} +function dr(e, t, r) { + _(e, t, { + enumerable: !1, + writable: !0, + configurable: !0, + value: r + }); +} +function yi(e, t, r) { + _(e, t, { + enumerable: !1, + writable: !1, + configurable: !0, + value: r + }); +} +function Ue(e, t) { + var r = "isMobX" + e; + return t.prototype[r] = !0, function(n) { + return cr(n) && n[r] === !0; + }; +} +function Qe(e) { + return e != null && Object.prototype.toString.call(e) === "[object Map]"; +} +function $a(e) { + var t = Object.getPrototypeOf(e), r = Object.getPrototypeOf(t), n = Object.getPrototypeOf(r); + return n === null; +} +function ne(e) { + return e != null && Object.prototype.toString.call(e) === "[object Set]"; +} +var wi = typeof Object.getOwnPropertySymbols < "u"; +function eo(e) { + var t = Object.keys(e); + if (!wi) + return t; + var r = Object.getOwnPropertySymbols(e); + return r.length ? [].concat(t, r.filter(function(n) { + return lr.propertyIsEnumerable.call(e, n); + })) : t; +} +var mt = typeof Reflect < "u" && Reflect.ownKeys ? Reflect.ownKeys : wi ? function(e) { + return Object.getOwnPropertyNames(e).concat(Object.getOwnPropertySymbols(e)); +} : ( + /* istanbul ignore next */ + Object.getOwnPropertyNames +); +function Vr(e) { + return typeof e == "string" ? e : typeof e == "symbol" ? e.toString() : new String(e).toString(); +} +function xi(e) { + return e === null ? null : typeof e == "object" ? "" + e : e; +} +function W(e, t) { + return lr.hasOwnProperty.call(e, t); +} +var to = Object.getOwnPropertyDescriptors || function(t) { + var r = {}; + return mt(t).forEach(function(n) { + r[n] = Ht(t, n); + }), r; +}; +function T(e, t) { + return !!(e & t); +} +function V(e, t, r) { + return r ? e |= t : e &= ~t, e; +} +function pn(e, t) { + (t == null || t > e.length) && (t = e.length); + for (var r = 0, n = Array(t); r < t; r++) n[r] = e[r]; + return n; +} +function ro(e, t) { + for (var r = 0; r < t.length; r++) { + var n = t[r]; + n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, io(n.key), n); + } +} +function _e(e, t, r) { + return t && ro(e.prototype, t), Object.defineProperty(e, "prototype", { + writable: !1 + }), e; +} +function Ze(e, t) { + var r = typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"]; + if (r) return (r = r.call(e)).next.bind(r); + if (Array.isArray(e) || (r = ao(e)) || t) { + r && (e = r); + var n = 0; + return function() { + return n >= e.length ? { + done: !0 + } : { + done: !1, + value: e[n++] + }; + }; + } + throw new TypeError(`Invalid attempt to iterate non-iterable instance. +In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`); +} +function ve() { + return ve = Object.assign ? Object.assign.bind() : function(e) { + for (var t = 1; t < arguments.length; t++) { + var r = arguments[t]; + for (var n in r) ({}).hasOwnProperty.call(r, n) && (e[n] = r[n]); + } + return e; + }, ve.apply(null, arguments); +} +function Oi(e, t) { + e.prototype = Object.create(t.prototype), e.prototype.constructor = e, Ir(e, t); +} +function Ir(e, t) { + return Ir = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(r, n) { + return r.__proto__ = n, r; + }, Ir(e, t); +} +function no(e, t) { + if (typeof e != "object" || !e) return e; + var r = e[Symbol.toPrimitive]; + if (r !== void 0) { + var n = r.call(e, t); + if (typeof n != "object") return n; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return String(e); +} +function io(e) { + var t = no(e, "string"); + return typeof t == "symbol" ? t : t + ""; +} +function ao(e, t) { + if (e) { + if (typeof e == "string") return pn(e, t); + var r = {}.toString.call(e).slice(8, -1); + return r === "Object" && e.constructor && (r = e.constructor.name), r === "Map" || r === "Set" ? Array.from(e) : r === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r) ? pn(e, t) : void 0; + } +} +var ie = /* @__PURE__ */ Symbol("mobx-stored-annotations"); +function $(e) { + function t(r, n) { + if (At(n)) + return e.decorate_20223_(r, n); + Ct(r, n, e); + } + return Object.assign(t, e); +} +function Ct(e, t, r) { + if (W(e, ie) || dr(e, ie, ve({}, e[ie])), process.env.NODE_ENV !== "production" && Jt(r) && !W(e[ie], t)) { + var n = e.constructor.name + ".prototype." + t.toString(); + f("'" + n + "' is decorated with 'override', but no such decorated member was found on prototype."); + } + oo(e, r, t), Jt(r) || (e[ie][t] = r); +} +function oo(e, t, r) { + if (process.env.NODE_ENV !== "production" && !Jt(t) && W(e[ie], r)) { + var n = e.constructor.name + ".prototype." + r.toString(), i = e[ie][r].annotationType_, a = t.annotationType_; + f("Cannot apply '@" + a + "' to '" + n + "':" + (` +The field is already decorated with '@` + i + "'.") + ` +Re-decorating fields is not allowed. +Use '@override' decorator for methods overridden by subclass.`); + } +} +function At(e) { + return typeof e == "object" && typeof e.kind == "string"; +} +function ur(e, t) { + process.env.NODE_ENV !== "production" && !t.includes(e.kind) && f("The decorator applied to '" + String(e.name) + "' cannot be used on a " + e.kind + " element"); +} +var g = /* @__PURE__ */ Symbol("mobx administration"), me = /* @__PURE__ */ function() { + function e(r) { + r === void 0 && (r = process.env.NODE_ENV !== "production" ? "Atom@" + F() : "Atom"), this.name_ = void 0, this.flags_ = 0, this.observers_ = /* @__PURE__ */ new Set(), this.lastAccessedBy_ = 0, this.lowestObserverState_ = w.NOT_TRACKING_, this.onBOL = void 0, this.onBUOL = void 0, this.name_ = r; + } + var t = e.prototype; + return t.onBO = function() { + this.onBOL && this.onBOL.forEach(function(n) { + return n(); + }); + }, t.onBUO = function() { + this.onBUOL && this.onBUOL.forEach(function(n) { + return n(); + }); + }, t.reportObserved = function() { + return ji(this); + }, t.reportChanged = function() { + R(), Ri(this), q(); + }, t.toString = function() { + return this.name_; + }, _e(e, [{ + key: "isBeingObserved", + get: function() { + return T(this.flags_, e.isBeingObservedMask_); + }, + set: function(n) { + this.flags_ = V(this.flags_, e.isBeingObservedMask_, n); + } + }, { + key: "isPendingUnobservation", + get: function() { + return T(this.flags_, e.isPendingUnobservationMask_); + }, + set: function(n) { + this.flags_ = V(this.flags_, e.isPendingUnobservationMask_, n); + } + }, { + key: "diffValue", + get: function() { + return T(this.flags_, e.diffValueMask_) ? 1 : 0; + }, + set: function(n) { + this.flags_ = V(this.flags_, e.diffValueMask_, n === 1); + } + }]); +}(); +me.isBeingObservedMask_ = 1; +me.isPendingUnobservationMask_ = 2; +me.diffValueMask_ = 4; +var Gr = /* @__PURE__ */ Ue("Atom", me); +function Ei(e, t, r) { + t === void 0 && (t = Fe), r === void 0 && (r = Fe); + var n = new me(e); + return t !== Fe && ms(n, t), r !== Fe && Ji(n, r), n; +} +function so(e, t) { + return oa(e, t); +} +function lo(e, t) { + return Object.is ? Object.is(e, t) : e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t; +} +var Xe = { + structural: so, + default: lo +}; +function De(e, t, r) { + return wt(e) ? e : Array.isArray(e) ? C.array(e, { + name: r + }) : D(e) ? C.object(e, void 0, { + name: r + }) : Qe(e) ? C.map(e, { + name: r + }) : ne(e) ? C.set(e, { + name: r + }) : typeof e == "function" && !Ve(e) && !yt(e) ? bi(e) ? Je(e) : bt(r, e) : e; +} +function co(e, t, r) { + if (e == null || tt(e) || br(e) || be(e) || Y(e)) + return e; + if (Array.isArray(e)) + return C.array(e, { + name: r, + deep: !1 + }); + if (D(e)) + return C.object(e, void 0, { + name: r, + deep: !1 + }); + if (Qe(e)) + return C.map(e, { + name: r, + deep: !1 + }); + if (ne(e)) + return C.set(e, { + name: r, + deep: !1 + }); + process.env.NODE_ENV !== "production" && f("The shallow modifier / decorator can only used in combination with arrays, objects, maps and sets"); +} +function pr(e) { + return e; +} +function uo(e, t) { + return process.env.NODE_ENV !== "production" && wt(e) && f("observable.struct should not be used with observable values"), oa(e, t) ? t : e; +} +var po = "override"; +function Jt(e) { + return e.annotationType_ === po; +} +function St(e, t) { + return { + annotationType_: e, + options_: t, + make_: fo, + extend_: vo, + decorate_20223_: ho + }; +} +function fo(e, t, r, n) { + var i; + if ((i = this.options_) != null && i.bound) + return this.extend_(e, t, r, !1) === null ? 0 : 1; + if (n === e.target_) + return this.extend_(e, t, r, !1) === null ? 0 : 2; + if (Ve(r.value)) + return 1; + var a = ki(e, this, t, r, !1); + return _(n, t, a), 2; +} +function vo(e, t, r, n) { + var i = ki(e, this, t, r); + return e.defineProperty_(t, i, n); +} +function ho(e, t) { + process.env.NODE_ENV !== "production" && ur(t, ["method", "field"]); + var r = t.kind, n = t.name, i = t.addInitializer, a = this, o = function(c) { + var d, u, v, h; + return Ne((d = (u = a.options_) == null ? void 0 : u.name) != null ? d : n.toString(), c, (v = (h = a.options_) == null ? void 0 : h.autoAction) != null ? v : !1); + }; + if (r == "field") + return function(l) { + var c, d = l; + return Ve(d) || (d = o(d)), (c = a.options_) != null && c.bound && (d = d.bind(this), d.isMobxAction = !0), d; + }; + if (r == "method") { + var s; + return Ve(e) || (e = o(e)), (s = this.options_) != null && s.bound && i(function() { + var l = this, c = l[n].bind(l); + c.isMobxAction = !0, l[n] = c; + }), e; + } + f("Cannot apply '" + a.annotationType_ + "' to '" + String(n) + "' (kind: " + r + "):" + (` +'` + a.annotationType_ + "' can only be used on properties with a function value.")); +} +function go(e, t, r, n) { + var i = t.annotationType_, a = n.value; + process.env.NODE_ENV !== "production" && !k(a) && f("Cannot apply '" + i + "' to '" + e.name_ + "." + r.toString() + "':" + (` +'` + i + "' can only be used on properties with a function value.")); +} +function ki(e, t, r, n, i) { + var a, o, s, l, c, d, u; + i === void 0 && (i = p.safeDescriptors), go(e, t, r, n); + var v = n.value; + if ((a = t.options_) != null && a.bound) { + var h; + v = v.bind((h = e.proxy_) != null ? h : e.target_); + } + return { + value: Ne( + (o = (s = t.options_) == null ? void 0 : s.name) != null ? o : r.toString(), + v, + (l = (c = t.options_) == null ? void 0 : c.autoAction) != null ? l : !1, + // https://github.com/mobxjs/mobx/discussions/3140 + (d = t.options_) != null && d.bound ? (u = e.proxy_) != null ? u : e.target_ : void 0 + ), + // Non-configurable for classes + // prevents accidental field redefinition in subclass + configurable: i ? e.isPlainObject_ : !0, + // https://github.com/mobxjs/mobx/pull/2641#issuecomment-737292058 + enumerable: !1, + // Non-obsevable, therefore non-writable + // Also prevents rewriting in subclass constructor + writable: !i + }; +} +function Ci(e, t) { + return { + annotationType_: e, + options_: t, + make_: mo, + extend_: bo, + decorate_20223_: yo + }; +} +function mo(e, t, r, n) { + var i; + if (n === e.target_) + return this.extend_(e, t, r, !1) === null ? 0 : 2; + if ((i = this.options_) != null && i.bound && (!W(e.target_, t) || !yt(e.target_[t])) && this.extend_(e, t, r, !1) === null) + return 0; + if (yt(r.value)) + return 1; + var a = Ai(e, this, t, r, !1, !1); + return _(n, t, a), 2; +} +function bo(e, t, r, n) { + var i, a = Ai(e, this, t, r, (i = this.options_) == null ? void 0 : i.bound); + return e.defineProperty_(t, a, n); +} +function yo(e, t) { + var r; + process.env.NODE_ENV !== "production" && ur(t, ["method"]); + var n = t.name, i = t.addInitializer; + return yt(e) || (e = Je(e)), (r = this.options_) != null && r.bound && i(function() { + var a = this, o = a[n].bind(a); + o.isMobXFlow = !0, a[n] = o; + }), e; +} +function wo(e, t, r, n) { + var i = t.annotationType_, a = n.value; + process.env.NODE_ENV !== "production" && !k(a) && f("Cannot apply '" + i + "' to '" + e.name_ + "." + r.toString() + "':" + (` +'` + i + "' can only be used on properties with a generator function value.")); +} +function Ai(e, t, r, n, i, a) { + a === void 0 && (a = p.safeDescriptors), wo(e, t, r, n); + var o = n.value; + if (yt(o) || (o = Je(o)), i) { + var s; + o = o.bind((s = e.proxy_) != null ? s : e.target_), o.isMobXFlow = !0; + } + return { + value: o, + // Non-configurable for classes + // prevents accidental field redefinition in subclass + configurable: a ? e.isPlainObject_ : !0, + // https://github.com/mobxjs/mobx/pull/2641#issuecomment-737292058 + enumerable: !1, + // Non-obsevable, therefore non-writable + // Also prevents rewriting in subclass constructor + writable: !a + }; +} +function Yr(e, t) { + return { + annotationType_: e, + options_: t, + make_: xo, + extend_: Oo, + decorate_20223_: Eo + }; +} +function xo(e, t, r) { + return this.extend_(e, t, r, !1) === null ? 0 : 1; +} +function Oo(e, t, r, n) { + return ko(e, this, t, r), e.defineComputedProperty_(t, ve({}, this.options_, { + get: r.get, + set: r.set + }), n); +} +function Eo(e, t) { + process.env.NODE_ENV !== "production" && ur(t, ["getter"]); + var r = this, n = t.name, i = t.addInitializer; + return i(function() { + var a = et(this)[g], o = ve({}, r.options_, { + get: e, + context: this + }); + o.name || (o.name = process.env.NODE_ENV !== "production" ? a.name_ + "." + n.toString() : "ObservableObject." + n.toString()), a.values_.set(n, new B(o)); + }), function() { + return this[g].getObservablePropValue_(n); + }; +} +function ko(e, t, r, n) { + var i = t.annotationType_, a = n.get; + process.env.NODE_ENV !== "production" && !a && f("Cannot apply '" + i + "' to '" + e.name_ + "." + r.toString() + "':" + (` +'` + i + "' can only be used on getter(+setter) properties.")); +} +function fr(e, t) { + return { + annotationType_: e, + options_: t, + make_: Co, + extend_: Ao, + decorate_20223_: So + }; +} +function Co(e, t, r) { + return this.extend_(e, t, r, !1) === null ? 0 : 1; +} +function Ao(e, t, r, n) { + var i, a; + return Po(e, this, t, r), e.defineObservableProperty_(t, r.value, (i = (a = this.options_) == null ? void 0 : a.enhancer) != null ? i : De, n); +} +function So(e, t) { + if (process.env.NODE_ENV !== "production") { + if (t.kind === "field") + throw f("Please use `@observable accessor " + String(t.name) + "` instead of `@observable " + String(t.name) + "`"); + ur(t, ["accessor"]); + } + var r = this, n = t.kind, i = t.name, a = /* @__PURE__ */ new WeakSet(); + function o(s, l) { + var c, d, u = et(s)[g], v = new Se(l, (c = (d = r.options_) == null ? void 0 : d.enhancer) != null ? c : De, process.env.NODE_ENV !== "production" ? u.name_ + "." + i.toString() : "ObservableObject." + i.toString(), !1); + u.values_.set(i, v), a.add(s); + } + if (n == "accessor") + return { + get: function() { + return a.has(this) || o(this, e.get.call(this)), this[g].getObservablePropValue_(i); + }, + set: function(l) { + return a.has(this) || o(this, l), this[g].setObservablePropValue_(i, l); + }, + init: function(l) { + return a.has(this) || o(this, l), l; + } + }; +} +function Po(e, t, r, n) { + var i = t.annotationType_; + process.env.NODE_ENV !== "production" && !("value" in n) && f("Cannot apply '" + i + "' to '" + e.name_ + "." + r.toString() + "':" + (` +'` + i + "' cannot be used on getter/setter properties")); +} +var Do = "true", No = /* @__PURE__ */ Si(); +function Si(e) { + return { + annotationType_: Do, + options_: e, + make_: To, + extend_: Vo, + decorate_20223_: Io + }; +} +function To(e, t, r, n) { + var i, a; + if (r.get) + return vr.make_(e, t, r, n); + if (r.set) { + var o = Ve(r.set) ? r.set : Ne(t.toString(), r.set); + return n === e.target_ ? e.defineProperty_(t, { + configurable: p.safeDescriptors ? e.isPlainObject_ : !0, + set: o + }) === null ? 0 : 2 : (_(n, t, { + configurable: !0, + set: o + }), 2); + } + if (n !== e.target_ && typeof r.value == "function") { + var s; + if (bi(r.value)) { + var l, c = (l = this.options_) != null && l.autoBind ? Je.bound : Je; + return c.make_(e, t, r, n); + } + var d = (s = this.options_) != null && s.autoBind ? bt.bound : bt; + return d.make_(e, t, r, n); + } + var u = ((i = this.options_) == null ? void 0 : i.deep) === !1 ? C.ref : C; + if (typeof r.value == "function" && (a = this.options_) != null && a.autoBind) { + var v; + r.value = r.value.bind((v = e.proxy_) != null ? v : e.target_); + } + return u.make_(e, t, r, n); +} +function Vo(e, t, r, n) { + var i, a; + if (r.get) + return vr.extend_(e, t, r, n); + if (r.set) + return e.defineProperty_(t, { + configurable: p.safeDescriptors ? e.isPlainObject_ : !0, + set: Ne(t.toString(), r.set) + }, n); + if (typeof r.value == "function" && (i = this.options_) != null && i.autoBind) { + var o; + r.value = r.value.bind((o = e.proxy_) != null ? o : e.target_); + } + var s = ((a = this.options_) == null ? void 0 : a.deep) === !1 ? C.ref : C; + return s.extend_(e, t, r, n); +} +function Io(e, t) { + f("'" + this.annotationType_ + "' cannot be used as a decorator"); +} +var zo = "observable", Uo = "observable.ref", Lo = "observable.shallow", Mo = "observable.struct", Pi = { + deep: !0, + name: void 0, + defaultDecorator: void 0, + proxy: !0 +}; +Object.freeze(Pi); +function Vt(e) { + return e || Pi; +} +var zr = /* @__PURE__ */ fr(zo), jo = /* @__PURE__ */ fr(Uo, { + enhancer: pr +}), Ro = /* @__PURE__ */ fr(Lo, { + enhancer: co +}), qo = /* @__PURE__ */ fr(Mo, { + enhancer: uo +}), Di = /* @__PURE__ */ $(zr); +function It(e) { + return e.deep === !0 ? De : e.deep === !1 ? pr : Bo(e.defaultDecorator); +} +function Ko(e) { + var t; + return e ? (t = e.defaultDecorator) != null ? t : Si(e) : void 0; +} +function Bo(e) { + var t, r; + return e && (t = (r = e.options_) == null ? void 0 : r.enhancer) != null ? t : De; +} +function Ni(e, t, r) { + if (At(t)) + return zr.decorate_20223_(e, t); + if (Pe(t)) { + Ct(e, t, zr); + return; + } + return wt(e) ? e : D(e) ? C.object(e, t, r) : Array.isArray(e) ? C.array(e, t) : Qe(e) ? C.map(e, t) : ne(e) ? C.set(e, t) : typeof e == "object" && e !== null ? e : C.box(e, t); +} +gi(Ni, Di); +var Fo = { + box: function(t, r) { + var n = Vt(r); + return new Se(t, It(n), n.name, !0, n.equals); + }, + array: function(t, r) { + var n = Vt(r); + return (p.useProxies === !1 || n.proxy === !1 ? Rs : Ds)(t, It(n), n.name); + }, + map: function(t, r) { + var n = Vt(r); + return new ea(t, It(n), n.name); + }, + set: function(t, r) { + var n = Vt(r); + return new ta(t, It(n), n.name); + }, + object: function(t, r, n) { + return Me(function() { + return Yi(p.useProxies === !1 || n?.proxy === !1 ? et({}, n) : As({}, n), t, r); + }); + }, + ref: /* @__PURE__ */ $(jo), + shallow: /* @__PURE__ */ $(Ro), + deep: Di, + struct: /* @__PURE__ */ $(qo) +}, C = /* @__PURE__ */ gi(Ni, Fo), Ti = "computed", Zo = "computed.struct", Ur = /* @__PURE__ */ Yr(Ti), Wo = /* @__PURE__ */ Yr(Zo, { + equals: Xe.structural +}), vr = function(t, r) { + if (At(r)) + return Ur.decorate_20223_(t, r); + if (Pe(r)) + return Ct(t, r, Ur); + if (D(t)) + return $(Yr(Ti, t)); + process.env.NODE_ENV !== "production" && (k(t) || f("First argument to `computed` should be an expression."), k(r) && f("A setter as second argument is no longer supported, use `{ set: fn }` option instead")); + var n = D(r) ? r : {}; + return n.get = t, n.name || (n.name = t.name || ""), new B(n); +}; +Object.assign(vr, Ur); +vr.struct = /* @__PURE__ */ $(Wo); +var fn, vn, Gt = 0, Ho = 1, Xo = (fn = (vn = /* @__PURE__ */ Ht(function() { +}, "name")) == null ? void 0 : vn.configurable) != null ? fn : !1, hn = { + value: "action", + configurable: !0, + writable: !1, + enumerable: !1 +}; +function Ne(e, t, r, n) { + r === void 0 && (r = !1), process.env.NODE_ENV !== "production" && (k(t) || f("`action` can only be invoked on functions"), (typeof e != "string" || !e) && f("actions should have valid names, got: '" + e + "'")); + function i() { + return Vi(e, r, t, n || this, arguments); + } + return i.isMobxAction = !0, i.toString = function() { + return t.toString(); + }, Xo && (hn.value = e, _(i, "name", hn)), i; +} +function Vi(e, t, r, n, i) { + var a = Jo(e, t, n, i); + try { + return r.apply(n, i); + } catch (o) { + throw a.error_ = o, o; + } finally { + Go(a); + } +} +function Jo(e, t, r, n) { + var i = process.env.NODE_ENV !== "production" && P() && !!e, a = 0; + if (process.env.NODE_ENV !== "production" && i) { + a = Date.now(); + var o = n ? Array.from(n) : Xt; + I({ + type: _r, + name: e, + object: r, + arguments: o + }); + } + var s = p.trackingDerivation, l = !t || !s; + R(); + var c = p.allowStateChanges; + l && (Le(), c = hr(!0)); + var d = Qr(!0), u = { + runAsAction_: l, + prevDerivation_: s, + prevAllowStateChanges_: c, + prevAllowStateReads_: d, + notifySpy_: i, + startTime_: a, + actionId_: Ho++, + parentActionId_: Gt + }; + return Gt = u.actionId_, u; +} +function Go(e) { + Gt !== e.actionId_ && f(30), Gt = e.parentActionId_, e.error_ !== void 0 && (p.suppressReactionErrors = !0), gr(e.prevAllowStateChanges_), ft(e.prevAllowStateReads_), q(), e.runAsAction_ && oe(e.prevDerivation_), process.env.NODE_ENV !== "production" && e.notifySpy_ && z({ + time: Date.now() - e.startTime_ + }), p.suppressReactionErrors = !1; +} +function Yo(e, t) { + var r = hr(e); + try { + return t(); + } finally { + gr(r); + } +} +function hr(e) { + var t = p.allowStateChanges; + return p.allowStateChanges = e, t; +} +function gr(e) { + p.allowStateChanges = e; +} +var Qo = "create", Se = /* @__PURE__ */ function(e) { + function t(n, i, a, o, s) { + var l; + if (a === void 0 && (a = process.env.NODE_ENV !== "production" ? "ObservableValue@" + F() : "ObservableValue"), o === void 0 && (o = !0), s === void 0 && (s = Xe.default), l = e.call(this, a) || this, l.enhancer = void 0, l.name_ = void 0, l.equals = void 0, l.hasUnreportedChange_ = !1, l.interceptors_ = void 0, l.changeListeners_ = void 0, l.value_ = void 0, l.dehancer = void 0, l.enhancer = i, l.name_ = a, l.equals = s, l.value_ = i(n, void 0, a), process.env.NODE_ENV !== "production" && o && P()) { + var c; + Te({ + type: Qo, + object: l, + observableKind: "value", + debugObjectName: l.name_, + newValue: "" + ((c = l.value_) == null ? void 0 : c.toString()) + }); + } + return l; + } + Oi(t, e); + var r = t.prototype; + return r.dehanceValue = function(i) { + return this.dehancer !== void 0 ? this.dehancer(i) : i; + }, r.set = function(i) { + var a = this.value_; + if (i = this.prepareNewValue_(i), i !== p.UNCHANGED) { + var o = P(); + process.env.NODE_ENV !== "production" && o && I({ + type: Z, + object: this, + observableKind: "value", + debugObjectName: this.name_, + newValue: i, + oldValue: a + }), this.setNewValue_(i), process.env.NODE_ENV !== "production" && o && z(); + } + }, r.prepareNewValue_ = function(i) { + if (Q(this), M(this)) { + var a = j(this, { + object: this, + type: Z, + newValue: i + }); + if (!a) + return p.UNCHANGED; + i = a.newValue; + } + return i = this.enhancer(i, this.value_, this.name_), this.equals(this.value_, i) ? p.UNCHANGED : i; + }, r.setNewValue_ = function(i) { + var a = this.value_; + this.value_ = i, this.reportChanged(), H(this) && X(this, { + type: Z, + object: this, + newValue: i, + oldValue: a + }); + }, r.get = function() { + return this.reportObserved(), this.dehanceValue(this.value_); + }, r.intercept_ = function(i) { + return Pt(this, i); + }, r.observe_ = function(i, a) { + return a && i({ + observableKind: "value", + debugObjectName: this.name_, + object: this, + type: Z, + newValue: this.value_, + oldValue: void 0 + }), Dt(this, i); + }, r.raw = function() { + return this.value_; + }, r.toJSON = function() { + return this.get(); + }, r.toString = function() { + return this.name_ + "[" + this.value_ + "]"; + }, r.valueOf = function() { + return xi(this.get()); + }, r[Symbol.toPrimitive] = function() { + return this.valueOf(); + }, t; +}(me), B = /* @__PURE__ */ function() { + function e(r) { + this.dependenciesState_ = w.NOT_TRACKING_, this.observing_ = [], this.newObserving_ = null, this.observers_ = /* @__PURE__ */ new Set(), this.runId_ = 0, this.lastAccessedBy_ = 0, this.lowestObserverState_ = w.UP_TO_DATE_, this.unboundDepsCount_ = 0, this.value_ = new Yt(null), this.name_ = void 0, this.triggeredBy_ = void 0, this.flags_ = 0, this.derivation = void 0, this.setter_ = void 0, this.isTracing_ = K.NONE, this.scope_ = void 0, this.equals_ = void 0, this.requiresReaction_ = void 0, this.keepAlive_ = void 0, this.onBOL = void 0, this.onBUOL = void 0, r.get || f(31), this.derivation = r.get, this.name_ = r.name || (process.env.NODE_ENV !== "production" ? "ComputedValue@" + F() : "ComputedValue"), r.set && (this.setter_ = Ne(process.env.NODE_ENV !== "production" ? this.name_ + "-setter" : "ComputedValue-setter", r.set)), this.equals_ = r.equals || (r.compareStructural || r.struct ? Xe.structural : Xe.default), this.scope_ = r.context, this.requiresReaction_ = r.requiresReaction, this.keepAlive_ = !!r.keepAlive; + } + var t = e.prototype; + return t.onBecomeStale_ = function() { + ns(this); + }, t.onBO = function() { + this.onBOL && this.onBOL.forEach(function(n) { + return n(); + }); + }, t.onBUO = function() { + this.onBUOL && this.onBUOL.forEach(function(n) { + return n(); + }); + }, t.get = function() { + if (this.isComputing && f(32, this.name_, this.derivation), p.inBatch === 0 && // !globalState.trackingDerivatpion && + this.observers_.size === 0 && !this.keepAlive_) + Lr(this) && (this.warnAboutUntrackedRead_(), R(), this.value_ = this.computeValue_(!1), q()); + else if (ji(this), Lr(this)) { + var n = p.trackingContext; + this.keepAlive_ && !n && (p.trackingContext = this), this.trackAndCompute() && rs(this), p.trackingContext = n; + } + var i = this.value_; + if (Kt(i)) + throw i.cause; + return i; + }, t.set = function(n) { + if (this.setter_) { + this.isRunningSetter && f(33, this.name_), this.isRunningSetter = !0; + try { + this.setter_.call(this.scope_, n); + } finally { + this.isRunningSetter = !1; + } + } else + f(34, this.name_); + }, t.trackAndCompute = function() { + var n = this.value_, i = ( + /* see #1208 */ + this.dependenciesState_ === w.NOT_TRACKING_ + ), a = this.computeValue_(!0), o = i || Kt(n) || Kt(a) || !this.equals_(n, a); + return o && (this.value_ = a, process.env.NODE_ENV !== "production" && P() && Te({ + observableKind: "computed", + debugObjectName: this.name_, + object: this.scope_, + type: "update", + oldValue: n, + newValue: a + })), o; + }, t.computeValue_ = function(n) { + this.isComputing = !0; + var i = hr(!1), a; + if (n) + a = Ii(this, this.derivation, this.scope_); + else if (p.disableErrorBoundaries === !0) + a = this.derivation.call(this.scope_); + else + try { + a = this.derivation.call(this.scope_); + } catch (o) { + a = new Yt(o); + } + return gr(i), this.isComputing = !1, a; + }, t.suspend_ = function() { + this.keepAlive_ || (Mr(this), this.value_ = void 0, process.env.NODE_ENV !== "production" && this.isTracing_ !== K.NONE && console.log("[mobx.trace] Computed value '" + this.name_ + "' was suspended and it will recompute on the next access.")); + }, t.observe_ = function(n, i) { + var a = this, o = !0, s = void 0; + return Hi(function() { + var l = a.get(); + if (!o || i) { + var c = Le(); + n({ + observableKind: "computed", + debugObjectName: a.name_, + type: Z, + object: a, + newValue: l, + oldValue: s + }), oe(c); + } + o = !1, s = l; + }); + }, t.warnAboutUntrackedRead_ = function() { + process.env.NODE_ENV !== "production" && (this.isTracing_ !== K.NONE && console.log("[mobx.trace] Computed value '" + this.name_ + "' is being read outside a reactive context. Doing a full recompute."), (typeof this.requiresReaction_ == "boolean" ? this.requiresReaction_ : p.computedRequiresReaction) && console.warn("[mobx] Computed value '" + this.name_ + "' is being read outside a reactive context. Doing a full recompute.")); + }, t.toString = function() { + return this.name_ + "[" + this.derivation.toString() + "]"; + }, t.valueOf = function() { + return xi(this.get()); + }, t[Symbol.toPrimitive] = function() { + return this.valueOf(); + }, _e(e, [{ + key: "isComputing", + get: function() { + return T(this.flags_, e.isComputingMask_); + }, + set: function(n) { + this.flags_ = V(this.flags_, e.isComputingMask_, n); + } + }, { + key: "isRunningSetter", + get: function() { + return T(this.flags_, e.isRunningSetterMask_); + }, + set: function(n) { + this.flags_ = V(this.flags_, e.isRunningSetterMask_, n); + } + }, { + key: "isBeingObserved", + get: function() { + return T(this.flags_, e.isBeingObservedMask_); + }, + set: function(n) { + this.flags_ = V(this.flags_, e.isBeingObservedMask_, n); + } + }, { + key: "isPendingUnobservation", + get: function() { + return T(this.flags_, e.isPendingUnobservationMask_); + }, + set: function(n) { + this.flags_ = V(this.flags_, e.isPendingUnobservationMask_, n); + } + }, { + key: "diffValue", + get: function() { + return T(this.flags_, e.diffValueMask_) ? 1 : 0; + }, + set: function(n) { + this.flags_ = V(this.flags_, e.diffValueMask_, n === 1); + } + }]); +}(); +B.isComputingMask_ = 1; +B.isRunningSetterMask_ = 2; +B.isBeingObservedMask_ = 4; +B.isPendingUnobservationMask_ = 8; +B.diffValueMask_ = 16; +var mr = /* @__PURE__ */ Ue("ComputedValue", B), w; +(function(e) { + e[e.NOT_TRACKING_ = -1] = "NOT_TRACKING_", e[e.UP_TO_DATE_ = 0] = "UP_TO_DATE_", e[e.POSSIBLY_STALE_ = 1] = "POSSIBLY_STALE_", e[e.STALE_ = 2] = "STALE_"; +})(w || (w = {})); +var K; +(function(e) { + e[e.NONE = 0] = "NONE", e[e.LOG = 1] = "LOG", e[e.BREAK = 2] = "BREAK"; +})(K || (K = {})); +var Yt = function(t) { + this.cause = void 0, this.cause = t; +}; +function Kt(e) { + return e instanceof Yt; +} +function Lr(e) { + switch (e.dependenciesState_) { + case w.UP_TO_DATE_: + return !1; + case w.NOT_TRACKING_: + case w.STALE_: + return !0; + case w.POSSIBLY_STALE_: { + for (var t = Qr(!0), r = Le(), n = e.observing_, i = n.length, a = 0; a < i; a++) { + var o = n[a]; + if (mr(o)) { + if (p.disableErrorBoundaries) + o.get(); + else + try { + o.get(); + } catch { + return oe(r), ft(t), !0; + } + if (e.dependenciesState_ === w.STALE_) + return oe(r), ft(t), !0; + } + } + return Ui(e), oe(r), ft(t), !1; + } + } +} +function Q(e) { + if (process.env.NODE_ENV !== "production") { + var t = e.observers_.size > 0; + !p.allowStateChanges && (t || p.enforceActions === "always") && console.warn("[MobX] " + (p.enforceActions ? "Since strict-mode is enabled, changing (observed) observable values without using an action is not allowed. Tried to modify: " : "Side effects like changing state are not allowed at this point. Are you trying to modify state from, for example, a computed value or the render function of a React component? You can wrap side effects in 'runInAction' (or decorate functions with 'action') if needed. Tried to modify: ") + e.name_); + } +} +function _o(e) { + process.env.NODE_ENV !== "production" && !p.allowStateReads && p.observableRequiresReaction && console.warn("[mobx] Observable '" + e.name_ + "' being read outside a reactive context."); +} +function Ii(e, t, r) { + var n = Qr(!0); + Ui(e), e.newObserving_ = new Array( + // Reserve constant space for initial dependencies, dynamic space otherwise. + // See https://github.com/mobxjs/mobx/pull/3833 + e.runId_ === 0 ? 100 : e.observing_.length + ), e.unboundDepsCount_ = 0, e.runId_ = ++p.runId; + var i = p.trackingDerivation; + p.trackingDerivation = e, p.inBatch++; + var a; + if (p.disableErrorBoundaries === !0) + a = t.call(r); + else + try { + a = t.call(r); + } catch (o) { + a = new Yt(o); + } + return p.inBatch--, p.trackingDerivation = i, es(e), $o(e), ft(n), a; +} +function $o(e) { + process.env.NODE_ENV !== "production" && e.observing_.length === 0 && (typeof e.requiresObservable_ == "boolean" ? e.requiresObservable_ : p.reactionRequiresObservable) && console.warn("[mobx] Derivation '" + e.name_ + "' is created/updated without reading any observable value."); +} +function es(e) { + for (var t = e.observing_, r = e.observing_ = e.newObserving_, n = w.UP_TO_DATE_, i = 0, a = e.unboundDepsCount_, o = 0; o < a; o++) { + var s = r[o]; + s.diffValue === 0 && (s.diffValue = 1, i !== o && (r[i] = s), i++), s.dependenciesState_ > n && (n = s.dependenciesState_); + } + for (r.length = i, e.newObserving_ = null, a = t.length; a--; ) { + var l = t[a]; + l.diffValue === 0 && Li(l, e), l.diffValue = 0; + } + for (; i--; ) { + var c = r[i]; + c.diffValue === 1 && (c.diffValue = 0, ts(c, e)); + } + n !== w.UP_TO_DATE_ && (e.dependenciesState_ = n, e.onBecomeStale_()); +} +function Mr(e) { + var t = e.observing_; + e.observing_ = []; + for (var r = t.length; r--; ) + Li(t[r], e); + e.dependenciesState_ = w.NOT_TRACKING_; +} +function zi(e) { + var t = Le(); + try { + return e(); + } finally { + oe(t); + } +} +function Le() { + var e = p.trackingDerivation; + return p.trackingDerivation = null, e; +} +function oe(e) { + p.trackingDerivation = e; +} +function Qr(e) { + var t = p.allowStateReads; + return p.allowStateReads = e, t; +} +function ft(e) { + p.allowStateReads = e; +} +function Ui(e) { + if (e.dependenciesState_ !== w.UP_TO_DATE_) { + e.dependenciesState_ = w.UP_TO_DATE_; + for (var t = e.observing_, r = t.length; r--; ) + t[r].lowestObserverState_ = w.UP_TO_DATE_; + } +} +var Or = function() { + this.version = 6, this.UNCHANGED = {}, this.trackingDerivation = null, this.trackingContext = null, this.runId = 0, this.mobxGuid = 0, this.inBatch = 0, this.pendingUnobservations = [], this.pendingReactions = [], this.isRunningReactions = !1, this.allowStateChanges = !1, this.allowStateReads = !0, this.enforceActions = !0, this.spyListeners = [], this.globalReactionErrorHandlers = [], this.computedRequiresReaction = !1, this.reactionRequiresObservable = !1, this.observableRequiresReaction = !1, this.disableErrorBoundaries = !1, this.suppressReactionErrors = !1, this.useProxies = !0, this.verifyProxies = !1, this.safeDescriptors = !0; +}, Er = !0, p = /* @__PURE__ */ function() { + var e = /* @__PURE__ */ Hr(); + return e.__mobxInstanceCount > 0 && !e.__mobxGlobals && (Er = !1), e.__mobxGlobals && e.__mobxGlobals.version !== new Or().version && (Er = !1), Er ? e.__mobxGlobals ? (e.__mobxInstanceCount += 1, e.__mobxGlobals.UNCHANGED || (e.__mobxGlobals.UNCHANGED = {}), e.__mobxGlobals) : (e.__mobxInstanceCount = 1, e.__mobxGlobals = /* @__PURE__ */ new Or()) : (setTimeout(function() { + f(35); + }, 1), new Or()); +}(); +function ts(e, t) { + e.observers_.add(t), e.lowestObserverState_ > t.dependenciesState_ && (e.lowestObserverState_ = t.dependenciesState_); +} +function Li(e, t) { + e.observers_.delete(t), e.observers_.size === 0 && Mi(e); +} +function Mi(e) { + e.isPendingUnobservation === !1 && (e.isPendingUnobservation = !0, p.pendingUnobservations.push(e)); +} +function R() { + p.inBatch++; +} +function q() { + if (--p.inBatch === 0) { + Bi(); + for (var e = p.pendingUnobservations, t = 0; t < e.length; t++) { + var r = e[t]; + r.isPendingUnobservation = !1, r.observers_.size === 0 && (r.isBeingObserved && (r.isBeingObserved = !1, r.onBUO()), r instanceof B && r.suspend_()); + } + p.pendingUnobservations = []; + } +} +function ji(e) { + _o(e); + var t = p.trackingDerivation; + return t !== null ? (t.runId_ !== e.lastAccessedBy_ && (e.lastAccessedBy_ = t.runId_, t.newObserving_[t.unboundDepsCount_++] = e, !e.isBeingObserved && p.trackingContext && (e.isBeingObserved = !0, e.onBO())), e.isBeingObserved) : (e.observers_.size === 0 && p.inBatch > 0 && Mi(e), !1); +} +function Ri(e) { + e.lowestObserverState_ !== w.STALE_ && (e.lowestObserverState_ = w.STALE_, e.observers_.forEach(function(t) { + t.dependenciesState_ === w.UP_TO_DATE_ && (process.env.NODE_ENV !== "production" && t.isTracing_ !== K.NONE && qi(t, e), t.onBecomeStale_()), t.dependenciesState_ = w.STALE_; + })); +} +function rs(e) { + e.lowestObserverState_ !== w.STALE_ && (e.lowestObserverState_ = w.STALE_, e.observers_.forEach(function(t) { + t.dependenciesState_ === w.POSSIBLY_STALE_ ? (t.dependenciesState_ = w.STALE_, process.env.NODE_ENV !== "production" && t.isTracing_ !== K.NONE && qi(t, e)) : t.dependenciesState_ === w.UP_TO_DATE_ && (e.lowestObserverState_ = w.UP_TO_DATE_); + })); +} +function ns(e) { + e.lowestObserverState_ === w.UP_TO_DATE_ && (e.lowestObserverState_ = w.POSSIBLY_STALE_, e.observers_.forEach(function(t) { + t.dependenciesState_ === w.UP_TO_DATE_ && (t.dependenciesState_ = w.POSSIBLY_STALE_, t.onBecomeStale_()); + })); +} +function qi(e, t) { + if (console.log("[mobx.trace] '" + e.name_ + "' is invalidated due to a change in: '" + t.name_ + "'"), e.isTracing_ === K.BREAK) { + var r = []; + Ki(bs(e), r, 1), new Function(`debugger; +/* +Tracing '` + e.name_ + `' + +You are entering this break point because derivation '` + e.name_ + "' is being traced and '" + t.name_ + `' is now forcing it to update. +Just follow the stacktrace you should now see in the devtools to see precisely what piece of your code is causing this update +The stackframe you are looking for is at least ~6-8 stack-frames up. + +` + (e instanceof B ? e.derivation.toString().replace(/[*]\//g, "/") : "") + ` + +The dependencies for this derivation are: + +` + r.join(` +`) + ` +*/ + `)(); + } +} +function Ki(e, t, r) { + if (t.length >= 1e3) { + t.push("(and many more)"); + return; + } + t.push("" + " ".repeat(r - 1) + e.name), e.dependencies && e.dependencies.forEach(function(n) { + return Ki(n, t, r + 1); + }); +} +var ee = /* @__PURE__ */ function() { + function e(r, n, i, a) { + r === void 0 && (r = process.env.NODE_ENV !== "production" ? "Reaction@" + F() : "Reaction"), this.name_ = void 0, this.onInvalidate_ = void 0, this.errorHandler_ = void 0, this.requiresObservable_ = void 0, this.observing_ = [], this.newObserving_ = [], this.dependenciesState_ = w.NOT_TRACKING_, this.runId_ = 0, this.unboundDepsCount_ = 0, this.flags_ = 0, this.isTracing_ = K.NONE, this.name_ = r, this.onInvalidate_ = n, this.errorHandler_ = i, this.requiresObservable_ = a; + } + var t = e.prototype; + return t.onBecomeStale_ = function() { + this.schedule_(); + }, t.schedule_ = function() { + this.isScheduled || (this.isScheduled = !0, p.pendingReactions.push(this), Bi()); + }, t.runReaction_ = function() { + if (!this.isDisposed) { + R(), this.isScheduled = !1; + var n = p.trackingContext; + if (p.trackingContext = this, Lr(this)) { + this.isTrackPending = !0; + try { + this.onInvalidate_(), process.env.NODE_ENV !== "production" && this.isTrackPending && P() && Te({ + name: this.name_, + type: "scheduled-reaction" + }); + } catch (i) { + this.reportExceptionInDerivation_(i); + } + } + p.trackingContext = n, q(); + } + }, t.track = function(n) { + if (!this.isDisposed) { + R(); + var i = P(), a; + process.env.NODE_ENV !== "production" && i && (a = Date.now(), I({ + name: this.name_, + type: "reaction" + })), this.isRunning = !0; + var o = p.trackingContext; + p.trackingContext = this; + var s = Ii(this, n, void 0); + p.trackingContext = o, this.isRunning = !1, this.isTrackPending = !1, this.isDisposed && Mr(this), Kt(s) && this.reportExceptionInDerivation_(s.cause), process.env.NODE_ENV !== "production" && i && z({ + time: Date.now() - a + }), q(); + } + }, t.reportExceptionInDerivation_ = function(n) { + var i = this; + if (this.errorHandler_) { + this.errorHandler_(n, this); + return; + } + if (p.disableErrorBoundaries) + throw n; + var a = process.env.NODE_ENV !== "production" ? "[mobx] Encountered an uncaught exception that was thrown by a reaction or observer component, in: '" + this + "'" : "[mobx] uncaught error in '" + this + "'"; + p.suppressReactionErrors ? process.env.NODE_ENV !== "production" && console.warn("[mobx] (error in reaction '" + this.name_ + "' suppressed, fix error of causing action below)") : console.error(a, n), process.env.NODE_ENV !== "production" && P() && Te({ + type: "error", + name: this.name_, + message: a, + error: "" + n + }), p.globalReactionErrorHandlers.forEach(function(o) { + return o(n, i); + }); + }, t.dispose = function() { + this.isDisposed || (this.isDisposed = !0, this.isRunning || (R(), Mr(this), q())); + }, t.getDisposer_ = function(n) { + var i = this, a = function o() { + i.dispose(), n == null || n.removeEventListener == null || n.removeEventListener("abort", o); + }; + return n == null || n.addEventListener == null || n.addEventListener("abort", a), a[g] = this, "dispose" in Symbol && typeof Symbol.dispose == "symbol" && (a[Symbol.dispose] = a), a; + }, t.toString = function() { + return "Reaction[" + this.name_ + "]"; + }, t.trace = function(n) { + n === void 0 && (n = !1), Es(this, n); + }, _e(e, [{ + key: "isDisposed", + get: function() { + return T(this.flags_, e.isDisposedMask_); + }, + set: function(n) { + this.flags_ = V(this.flags_, e.isDisposedMask_, n); + } + }, { + key: "isScheduled", + get: function() { + return T(this.flags_, e.isScheduledMask_); + }, + set: function(n) { + this.flags_ = V(this.flags_, e.isScheduledMask_, n); + } + }, { + key: "isTrackPending", + get: function() { + return T(this.flags_, e.isTrackPendingMask_); + }, + set: function(n) { + this.flags_ = V(this.flags_, e.isTrackPendingMask_, n); + } + }, { + key: "isRunning", + get: function() { + return T(this.flags_, e.isRunningMask_); + }, + set: function(n) { + this.flags_ = V(this.flags_, e.isRunningMask_, n); + } + }, { + key: "diffValue", + get: function() { + return T(this.flags_, e.diffValueMask_) ? 1 : 0; + }, + set: function(n) { + this.flags_ = V(this.flags_, e.diffValueMask_, n === 1); + } + }]); +}(); +ee.isDisposedMask_ = 1; +ee.isScheduledMask_ = 2; +ee.isTrackPendingMask_ = 4; +ee.isRunningMask_ = 8; +ee.diffValueMask_ = 16; +function is(e) { + return p.globalReactionErrorHandlers.push(e), function() { + var t = p.globalReactionErrorHandlers.indexOf(e); + t >= 0 && p.globalReactionErrorHandlers.splice(t, 1); + }; +} +var gn = 100, as = function(t) { + return t(); +}; +function Bi() { + p.inBatch > 0 || p.isRunningReactions || as(os); +} +function os() { + p.isRunningReactions = !0; + for (var e = p.pendingReactions, t = 0; e.length > 0; ) { + ++t === gn && (console.error(process.env.NODE_ENV !== "production" ? "Reaction doesn't converge to a stable state after " + gn + " iterations." + (" Probably there is a cycle in the reactive function: " + e[0]) : "[mobx] cycle in reaction: " + e[0]), e.splice(0)); + for (var r = e.splice(0), n = 0, i = r.length; n < i; n++) + r[n].runReaction_(); + } + p.isRunningReactions = !1; +} +var Qt = /* @__PURE__ */ Ue("Reaction", ee); +function P() { + return process.env.NODE_ENV !== "production" && !!p.spyListeners.length; +} +function Te(e) { + if (process.env.NODE_ENV !== "production" && p.spyListeners.length) + for (var t = p.spyListeners, r = 0, n = t.length; r < n; r++) + t[r](e); +} +function I(e) { + if (process.env.NODE_ENV !== "production") { + var t = ve({}, e, { + spyReportStart: !0 + }); + Te(t); + } +} +var ss = { + type: "report-end", + spyReportEnd: !0 +}; +function z(e) { + process.env.NODE_ENV !== "production" && Te(e ? ve({}, e, { + type: "report-end", + spyReportEnd: !0 + }) : ss); +} +function ls(e) { + return process.env.NODE_ENV === "production" ? (console.warn("[mobx.spy] Is a no-op in production builds"), function() { + }) : (p.spyListeners.push(e), Jr(function() { + p.spyListeners = p.spyListeners.filter(function(t) { + return t !== e; + }); + })); +} +var _r = "action", cs = "action.bound", Fi = "autoAction", ds = "autoAction.bound", Zi = "", jr = /* @__PURE__ */ St(_r), us = /* @__PURE__ */ St(cs, { + bound: !0 +}), Rr = /* @__PURE__ */ St(Fi, { + autoAction: !0 +}), ps = /* @__PURE__ */ St(ds, { + autoAction: !0, + bound: !0 +}); +function Wi(e) { + var t = function(n, i) { + if (k(n)) + return Ne(n.name || Zi, n, e); + if (k(i)) + return Ne(n, i, e); + if (At(i)) + return (e ? Rr : jr).decorate_20223_(n, i); + if (Pe(i)) + return Ct(n, i, e ? Rr : jr); + if (Pe(n)) + return $(St(e ? Fi : _r, { + name: n, + autoAction: e + })); + process.env.NODE_ENV !== "production" && f("Invalid arguments for `action`"); + }; + return t; +} +var Ce = /* @__PURE__ */ Wi(!1); +Object.assign(Ce, jr); +var bt = /* @__PURE__ */ Wi(!0); +Object.assign(bt, Rr); +Ce.bound = /* @__PURE__ */ $(us); +bt.bound = /* @__PURE__ */ $(ps); +function Nd(e) { + return Vi(e.name || Zi, !1, e, this, void 0); +} +function Ve(e) { + return k(e) && e.isMobxAction === !0; +} +function Hi(e, t) { + var r, n, i, a; + t === void 0 && (t = Xr), process.env.NODE_ENV !== "production" && (k(e) || f("Autorun expects a function as first argument"), Ve(e) && f("Autorun does not accept actions since actions are untrackable")); + var o = (r = (n = t) == null ? void 0 : n.name) != null ? r : process.env.NODE_ENV !== "production" ? e.name || "Autorun@" + F() : "Autorun", s = !t.scheduler && !t.delay, l; + if (s) + l = new ee(o, function() { + this.track(u); + }, t.onError, t.requiresObservable); + else { + var c = Xi(t), d = !1; + l = new ee(o, function() { + d || (d = !0, c(function() { + d = !1, l.isDisposed || l.track(u); + })); + }, t.onError, t.requiresObservable); + } + function u() { + e(l); + } + return (i = t) != null && (i = i.signal) != null && i.aborted || l.schedule_(), l.getDisposer_((a = t) == null ? void 0 : a.signal); +} +var fs = function(t) { + return t(); +}; +function Xi(e) { + return e.scheduler ? e.scheduler : e.delay ? function(t) { + return setTimeout(t, e.delay); + } : fs; +} +function $r(e, t, r) { + var n, i, a; + r === void 0 && (r = Xr), process.env.NODE_ENV !== "production" && ((!k(e) || !k(t)) && f("First and second argument to reaction should be functions"), D(r) || f("Third argument of reactions should be an object")); + var o = (n = r.name) != null ? n : process.env.NODE_ENV !== "production" ? "Reaction@" + F() : "Reaction", s = Ce(o, r.onError ? vs(r.onError, t) : t), l = !r.scheduler && !r.delay, c = Xi(r), d = !0, u = !1, v, h = r.compareStructural ? Xe.structural : r.equals || Xe.default, m = new ee(o, function() { + d || l ? O() : u || (u = !0, c(O)); + }, r.onError, r.requiresObservable); + function O() { + if (u = !1, !m.isDisposed) { + var A = !1, G = v; + m.track(function() { + var je = Yo(!1, function() { + return e(m); + }); + A = d || !h(v, je), v = je; + }), (d && r.fireImmediately || !d && A) && s(v, G, m), d = !1; + } + } + return (i = r) != null && (i = i.signal) != null && i.aborted || m.schedule_(), m.getDisposer_((a = r) == null ? void 0 : a.signal); +} +function vs(e, t) { + return function() { + try { + return t.apply(this, arguments); + } catch (r) { + e.call(this, r); + } + }; +} +var hs = "onBO", gs = "onBUO"; +function ms(e, t, r) { + return Gi(hs, e, t, r); +} +function Ji(e, t, r) { + return Gi(gs, e, t, r); +} +function Gi(e, t, r, n) { + var i = Ge(t), a = k(n) ? n : r, o = e + "L"; + return i[o] ? i[o].add(a) : i[o] = /* @__PURE__ */ new Set([a]), function() { + var s = i[o]; + s && (s.delete(a), s.size === 0 && delete i[o]); + }; +} +function Yi(e, t, r, n) { + process.env.NODE_ENV !== "production" && (arguments.length > 4 && f("'extendObservable' expected 2-4 arguments"), typeof e != "object" && f("'extendObservable' expects an object as first argument"), be(e) && f("'extendObservable' should not be used on maps, use map.merge instead"), D(t) || f("'extendObservable' only accepts plain objects as second argument"), (wt(t) || wt(r)) && f("Extending an object with another observable (object) is not supported")); + var i = to(t); + return Me(function() { + var a = et(e, n)[g]; + mt(i).forEach(function(o) { + a.extend_( + o, + i[o], + // must pass "undefined" for { key: undefined } + r && o in r ? r[o] : !0 + ); + }); + }), e; +} +function bs(e, t) { + return Qi(Ge(e, t)); +} +function Qi(e) { + var t = { + name: e.name_ + }; + return e.observing_ && e.observing_.length > 0 && (t.dependencies = ys(e.observing_).map(Qi)), t; +} +function ys(e) { + return Array.from(new Set(e)); +} +var ws = 0; +function _i() { + this.message = "FLOW_CANCELLED"; +} +_i.prototype = /* @__PURE__ */ Object.create(Error.prototype); +var kr = /* @__PURE__ */ Ci("flow"), xs = /* @__PURE__ */ Ci("flow.bound", { + bound: !0 +}), Je = /* @__PURE__ */ Object.assign(function(t, r) { + if (At(r)) + return kr.decorate_20223_(t, r); + if (Pe(r)) + return Ct(t, r, kr); + process.env.NODE_ENV !== "production" && arguments.length !== 1 && f("Flow expects single argument with generator function"); + var n = t, i = n.name || "", a = function() { + var s = this, l = arguments, c = ++ws, d = Ce(i + " - runid: " + c + " - init", n).apply(s, l), u, v = void 0, h = new Promise(function(m, O) { + var A = 0; + u = O; + function G(N) { + v = void 0; + var de; + try { + de = Ce(i + " - runid: " + c + " - yield " + A++, d.next).call(d, N); + } catch (we) { + return O(we); + } + it(de); + } + function je(N) { + v = void 0; + var de; + try { + de = Ce(i + " - runid: " + c + " - yield " + A++, d.throw).call(d, N); + } catch (we) { + return O(we); + } + it(de); + } + function it(N) { + if (k(N?.then)) { + N.then(it, O); + return; + } + return N.done ? m(N.value) : (v = Promise.resolve(N.value), v.then(G, je)); + } + G(void 0); + }); + return h.cancel = Ce(i + " - runid: " + c + " - cancel", function() { + try { + v && mn(v); + var m = d.return(void 0), O = Promise.resolve(m.value); + O.then(Fe, Fe), mn(O), u(new _i()); + } catch (A) { + u(A); + } + }), h; + }; + return a.isMobXFlow = !0, a; +}, kr); +Je.bound = /* @__PURE__ */ $(xs); +function mn(e) { + k(e.cancel) && e.cancel(); +} +function yt(e) { + return e?.isMobXFlow === !0; +} +function Os(e, t) { + return e ? tt(e) || !!e[g] || Gr(e) || Qt(e) || mr(e) : !1; +} +function wt(e) { + return process.env.NODE_ENV !== "production" && arguments.length !== 1 && f("isObservable expects only 1 argument. Use isObservableProp to inspect the observability of a property"), Os(e); +} +function Es() { + if (process.env.NODE_ENV !== "production") { + for (var e = !1, t = arguments.length, r = new Array(t), n = 0; n < t; n++) + r[n] = arguments[n]; + typeof r[r.length - 1] == "boolean" && (e = r.pop()); + var i = ks(r); + if (!i) + return f("'trace(break?)' can only be used inside a tracked computed value or a Reaction. Consider passing in the computed value or reaction explicitly"); + i.isTracing_ === K.NONE && console.log("[mobx.trace] '" + i.name_ + "' tracing enabled"), i.isTracing_ = e ? K.BREAK : K.LOG; + } +} +function ks(e) { + switch (e.length) { + case 0: + return p.trackingDerivation; + case 1: + return Ge(e[0]); + case 2: + return Ge(e[0], e[1]); + } +} +function ae(e, t) { + t === void 0 && (t = void 0), R(); + try { + return e.apply(t); + } finally { + q(); + } +} +function xe(e) { + return e[g]; +} +var Cs = { + has: function(t, r) { + return process.env.NODE_ENV !== "production" && p.trackingDerivation && at("detect new properties using the 'in' operator. Use 'has' from 'mobx' instead."), xe(t).has_(r); + }, + get: function(t, r) { + return xe(t).get_(r); + }, + set: function(t, r, n) { + var i; + return Pe(r) ? (process.env.NODE_ENV !== "production" && !xe(t).values_.has(r) && at("add a new observable property through direct assignment. Use 'set' from 'mobx' instead."), (i = xe(t).set_(r, n, !0)) != null ? i : !0) : !1; + }, + deleteProperty: function(t, r) { + var n; + return process.env.NODE_ENV !== "production" && at("delete properties from an observable object. Use 'remove' from 'mobx' instead."), Pe(r) ? (n = xe(t).delete_(r, !0)) != null ? n : !0 : !1; + }, + defineProperty: function(t, r, n) { + var i; + return process.env.NODE_ENV !== "production" && at("define property on an observable object. Use 'defineProperty' from 'mobx' instead."), (i = xe(t).defineProperty_(r, n)) != null ? i : !0; + }, + ownKeys: function(t) { + return process.env.NODE_ENV !== "production" && p.trackingDerivation && at("iterate keys to detect added / removed properties. Use 'keys' from 'mobx' instead."), xe(t).ownKeys_(); + }, + preventExtensions: function(t) { + f(13); + } +}; +function As(e, t) { + var r, n; + return mi(), e = et(e, t), (n = (r = e[g]).proxy_) != null ? n : r.proxy_ = new Proxy(e, Cs); +} +function M(e) { + return e.interceptors_ !== void 0 && e.interceptors_.length > 0; +} +function Pt(e, t) { + var r = e.interceptors_ || (e.interceptors_ = []); + return r.push(t), Jr(function() { + var n = r.indexOf(t); + n !== -1 && r.splice(n, 1); + }); +} +function j(e, t) { + var r = Le(); + try { + for (var n = [].concat(e.interceptors_ || []), i = 0, a = n.length; i < a && (t = n[i](t), t && !t.type && f(14), !!t); i++) + ; + return t; + } finally { + oe(r); + } +} +function H(e) { + return e.changeListeners_ !== void 0 && e.changeListeners_.length > 0; +} +function Dt(e, t) { + var r = e.changeListeners_ || (e.changeListeners_ = []); + return r.push(t), Jr(function() { + var n = r.indexOf(t); + n !== -1 && r.splice(n, 1); + }); +} +function X(e, t) { + var r = Le(), n = e.changeListeners_; + if (n) { + n = n.slice(); + for (var i = 0, a = n.length; i < a; i++) + n[i](t); + oe(r); + } +} +var Cr = /* @__PURE__ */ Symbol("mobx-keys"); +function $e(e, t, r) { + return process.env.NODE_ENV !== "production" && (!D(e) && !D(Object.getPrototypeOf(e)) && f("'makeAutoObservable' can only be used for classes that don't have a superclass"), tt(e) && f("makeAutoObservable can only be used on objects not already made observable")), D(e) ? Yi(e, e, t, r) : (Me(function() { + var n = et(e, r)[g]; + if (!e[Cr]) { + var i = Object.getPrototypeOf(e), a = new Set([].concat(mt(e), mt(i))); + a.delete("constructor"), a.delete(g), dr(i, Cr, a); + } + e[Cr].forEach(function(o) { + return n.make_( + o, + // must pass "undefined" for { key: undefined } + t && o in t ? t[o] : !0 + ); + }); + }), e); +} +var bn = "splice", Z = "update", Ss = 1e4, Ps = { + get: function(t, r) { + var n = t[g]; + return r === g ? n : r === "length" ? n.getArrayLength_() : typeof r == "string" && !isNaN(r) ? n.get_(parseInt(r)) : W(_t, r) ? _t[r] : t[r]; + }, + set: function(t, r, n) { + var i = t[g]; + return r === "length" && i.setArrayLength_(n), typeof r == "symbol" || isNaN(r) ? t[r] = n : i.set_(parseInt(r), n), !0; + }, + preventExtensions: function() { + f(15); + } +}, en = /* @__PURE__ */ function() { + function e(r, n, i, a) { + r === void 0 && (r = process.env.NODE_ENV !== "production" ? "ObservableArray@" + F() : "ObservableArray"), this.owned_ = void 0, this.legacyMode_ = void 0, this.atom_ = void 0, this.values_ = [], this.interceptors_ = void 0, this.changeListeners_ = void 0, this.enhancer_ = void 0, this.dehancer = void 0, this.proxy_ = void 0, this.lastKnownLength_ = 0, this.owned_ = i, this.legacyMode_ = a, this.atom_ = new me(r), this.enhancer_ = function(o, s) { + return n(o, s, process.env.NODE_ENV !== "production" ? r + "[..]" : "ObservableArray[..]"); + }; + } + var t = e.prototype; + return t.dehanceValue_ = function(n) { + return this.dehancer !== void 0 ? this.dehancer(n) : n; + }, t.dehanceValues_ = function(n) { + return this.dehancer !== void 0 && n.length > 0 ? n.map(this.dehancer) : n; + }, t.intercept_ = function(n) { + return Pt(this, n); + }, t.observe_ = function(n, i) { + return i === void 0 && (i = !1), i && n({ + observableKind: "array", + object: this.proxy_, + debugObjectName: this.atom_.name_, + type: "splice", + index: 0, + added: this.values_.slice(), + addedCount: this.values_.length, + removed: [], + removedCount: 0 + }), Dt(this, n); + }, t.getArrayLength_ = function() { + return this.atom_.reportObserved(), this.values_.length; + }, t.setArrayLength_ = function(n) { + (typeof n != "number" || isNaN(n) || n < 0) && f("Out of range: " + n); + var i = this.values_.length; + if (n !== i) + if (n > i) { + for (var a = new Array(n - i), o = 0; o < n - i; o++) + a[o] = void 0; + this.spliceWithArray_(i, 0, a); + } else + this.spliceWithArray_(n, i - n); + }, t.updateArrayLength_ = function(n, i) { + n !== this.lastKnownLength_ && f(16), this.lastKnownLength_ += i, this.legacyMode_ && i > 0 && ia(n + i + 1); + }, t.spliceWithArray_ = function(n, i, a) { + var o = this; + Q(this.atom_); + var s = this.values_.length; + if (n === void 0 ? n = 0 : n > s ? n = s : n < 0 && (n = Math.max(0, s + n)), arguments.length === 1 ? i = s - n : i == null ? i = 0 : i = Math.max(0, Math.min(i, s - n)), a === void 0 && (a = Xt), M(this)) { + var l = j(this, { + object: this.proxy_, + type: bn, + index: n, + removedCount: i, + added: a + }); + if (!l) + return Xt; + i = l.removedCount, a = l.added; + } + if (a = a.length === 0 ? a : a.map(function(u) { + return o.enhancer_(u, void 0); + }), this.legacyMode_ || process.env.NODE_ENV !== "production") { + var c = a.length - i; + this.updateArrayLength_(s, c); + } + var d = this.spliceItemsIntoValues_(n, i, a); + return (i !== 0 || a.length !== 0) && this.notifyArraySplice_(n, a, d), this.dehanceValues_(d); + }, t.spliceItemsIntoValues_ = function(n, i, a) { + if (a.length < Ss) { + var o; + return (o = this.values_).splice.apply(o, [n, i].concat(a)); + } else { + var s = this.values_.slice(n, n + i), l = this.values_.slice(n + i); + this.values_.length += a.length - i; + for (var c = 0; c < a.length; c++) + this.values_[n + c] = a[c]; + for (var d = 0; d < l.length; d++) + this.values_[n + a.length + d] = l[d]; + return s; + } + }, t.notifyArrayChildUpdate_ = function(n, i, a) { + var o = !this.owned_ && P(), s = H(this), l = s || o ? { + observableKind: "array", + object: this.proxy_, + type: Z, + debugObjectName: this.atom_.name_, + index: n, + newValue: i, + oldValue: a + } : null; + process.env.NODE_ENV !== "production" && o && I(l), this.atom_.reportChanged(), s && X(this, l), process.env.NODE_ENV !== "production" && o && z(); + }, t.notifyArraySplice_ = function(n, i, a) { + var o = !this.owned_ && P(), s = H(this), l = s || o ? { + observableKind: "array", + object: this.proxy_, + debugObjectName: this.atom_.name_, + type: bn, + index: n, + removed: a, + added: i, + removedCount: a.length, + addedCount: i.length + } : null; + process.env.NODE_ENV !== "production" && o && I(l), this.atom_.reportChanged(), s && X(this, l), process.env.NODE_ENV !== "production" && o && z(); + }, t.get_ = function(n) { + if (this.legacyMode_ && n >= this.values_.length) { + console.warn(process.env.NODE_ENV !== "production" ? "[mobx.array] Attempt to read an array index (" + n + ") that is out of bounds (" + this.values_.length + "). Please check length first. Out of bound indices will not be tracked by MobX" : "[mobx] Out of bounds read: " + n); + return; + } + return this.atom_.reportObserved(), this.dehanceValue_(this.values_[n]); + }, t.set_ = function(n, i) { + var a = this.values_; + if (this.legacyMode_ && n > a.length && f(17, n, a.length), n < a.length) { + Q(this.atom_); + var o = a[n]; + if (M(this)) { + var s = j(this, { + type: Z, + object: this.proxy_, + // since "this" is the real array we need to pass its proxy + index: n, + newValue: i + }); + if (!s) + return; + i = s.newValue; + } + i = this.enhancer_(i, o); + var l = i !== o; + l && (a[n] = i, this.notifyArrayChildUpdate_(n, i, o)); + } else { + for (var c = new Array(n + 1 - a.length), d = 0; d < c.length - 1; d++) + c[d] = void 0; + c[c.length - 1] = i, this.spliceWithArray_(a.length, 0, c); + } + }, e; +}(); +function Ds(e, t, r, n) { + return r === void 0 && (r = process.env.NODE_ENV !== "production" ? "ObservableArray@" + F() : "ObservableArray"), n === void 0 && (n = !1), mi(), Me(function() { + var i = new en(r, t, n, !1); + yi(i.values_, g, i); + var a = new Proxy(i.values_, Ps); + return i.proxy_ = a, e && e.length && i.spliceWithArray_(0, 0, e), a; + }); +} +var _t = { + clear: function() { + return this.splice(0); + }, + replace: function(t) { + var r = this[g]; + return r.spliceWithArray_(0, r.values_.length, t); + }, + // Used by JSON.stringify + toJSON: function() { + return this.slice(); + }, + /* + * functions that do alter the internal structure of the array, (based on lib.es6.d.ts) + * since these functions alter the inner structure of the array, the have side effects. + * Because the have side effects, they should not be used in computed function, + * and for that reason the do not call dependencyState.notifyObserved + */ + splice: function(t, r) { + for (var n = arguments.length, i = new Array(n > 2 ? n - 2 : 0), a = 2; a < n; a++) + i[a - 2] = arguments[a]; + var o = this[g]; + switch (arguments.length) { + case 0: + return []; + case 1: + return o.spliceWithArray_(t); + case 2: + return o.spliceWithArray_(t, r); + } + return o.spliceWithArray_(t, r, i); + }, + spliceWithArray: function(t, r, n) { + return this[g].spliceWithArray_(t, r, n); + }, + push: function() { + for (var t = this[g], r = arguments.length, n = new Array(r), i = 0; i < r; i++) + n[i] = arguments[i]; + return t.spliceWithArray_(t.values_.length, 0, n), t.values_.length; + }, + pop: function() { + return this.splice(Math.max(this[g].values_.length - 1, 0), 1)[0]; + }, + shift: function() { + return this.splice(0, 1)[0]; + }, + unshift: function() { + for (var t = this[g], r = arguments.length, n = new Array(r), i = 0; i < r; i++) + n[i] = arguments[i]; + return t.spliceWithArray_(0, 0, n), t.values_.length; + }, + reverse: function() { + return p.trackingDerivation && f(37, "reverse"), this.replace(this.slice().reverse()), this; + }, + sort: function() { + p.trackingDerivation && f(37, "sort"); + var t = this.slice(); + return t.sort.apply(t, arguments), this.replace(t), this; + }, + remove: function(t) { + var r = this[g], n = r.dehanceValues_(r.values_).indexOf(t); + return n > -1 ? (this.splice(n, 1), !0) : !1; + } +}; +x("at", U); +x("concat", U); +x("flat", U); +x("includes", U); +x("indexOf", U); +x("join", U); +x("lastIndexOf", U); +x("slice", U); +x("toString", U); +x("toLocaleString", U); +x("toSorted", U); +x("toSpliced", U); +x("with", U); +x("every", J); +x("filter", J); +x("find", J); +x("findIndex", J); +x("findLast", J); +x("findLastIndex", J); +x("flatMap", J); +x("forEach", J); +x("map", J); +x("some", J); +x("toReversed", J); +x("reduce", $i); +x("reduceRight", $i); +function x(e, t) { + typeof Array.prototype[e] == "function" && (_t[e] = t(e)); +} +function U(e) { + return function() { + var t = this[g]; + t.atom_.reportObserved(); + var r = t.dehanceValues_(t.values_); + return r[e].apply(r, arguments); + }; +} +function J(e) { + return function(t, r) { + var n = this, i = this[g]; + i.atom_.reportObserved(); + var a = i.dehanceValues_(i.values_); + return a[e](function(o, s) { + return t.call(r, o, s, n); + }); + }; +} +function $i(e) { + return function() { + var t = this, r = this[g]; + r.atom_.reportObserved(); + var n = r.dehanceValues_(r.values_), i = arguments[0]; + return arguments[0] = function(a, o, s) { + return i(a, o, s, t); + }, n[e].apply(n, arguments); + }; +} +var Ns = /* @__PURE__ */ Ue("ObservableArrayAdministration", en); +function br(e) { + return cr(e) && Ns(e[g]); +} +var Ts = {}, pe = "add", $t = "delete", ea = /* @__PURE__ */ function() { + function e(r, n, i) { + var a = this; + n === void 0 && (n = De), i === void 0 && (i = process.env.NODE_ENV !== "production" ? "ObservableMap@" + F() : "ObservableMap"), this.enhancer_ = void 0, this.name_ = void 0, this[g] = Ts, this.data_ = void 0, this.hasMap_ = void 0, this.keysAtom_ = void 0, this.interceptors_ = void 0, this.changeListeners_ = void 0, this.dehancer = void 0, this.enhancer_ = n, this.name_ = i, k(Map) || f(18), Me(function() { + a.keysAtom_ = Ei(process.env.NODE_ENV !== "production" ? a.name_ + ".keys()" : "ObservableMap.keys()"), a.data_ = /* @__PURE__ */ new Map(), a.hasMap_ = /* @__PURE__ */ new Map(), r && a.merge(r); + }); + } + var t = e.prototype; + return t.has_ = function(n) { + return this.data_.has(n); + }, t.has = function(n) { + var i = this; + if (!p.trackingDerivation) + return this.has_(n); + var a = this.hasMap_.get(n); + if (!a) { + var o = a = new Se(this.has_(n), pr, process.env.NODE_ENV !== "production" ? this.name_ + "." + Vr(n) + "?" : "ObservableMap.key?", !1); + this.hasMap_.set(n, o), Ji(o, function() { + return i.hasMap_.delete(n); + }); + } + return a.get(); + }, t.set = function(n, i) { + var a = this.has_(n); + if (M(this)) { + var o = j(this, { + type: a ? Z : pe, + object: this, + newValue: i, + name: n + }); + if (!o) + return this; + i = o.newValue; + } + return a ? this.updateValue_(n, i) : this.addValue_(n, i), this; + }, t.delete = function(n) { + var i = this; + if (Q(this.keysAtom_), M(this)) { + var a = j(this, { + type: $t, + object: this, + name: n + }); + if (!a) + return !1; + } + if (this.has_(n)) { + var o = P(), s = H(this), l = s || o ? { + observableKind: "map", + debugObjectName: this.name_, + type: $t, + object: this, + oldValue: this.data_.get(n).value_, + name: n + } : null; + return process.env.NODE_ENV !== "production" && o && I(l), ae(function() { + var c; + i.keysAtom_.reportChanged(), (c = i.hasMap_.get(n)) == null || c.setNewValue_(!1); + var d = i.data_.get(n); + d.setNewValue_(void 0), i.data_.delete(n); + }), s && X(this, l), process.env.NODE_ENV !== "production" && o && z(), !0; + } + return !1; + }, t.updateValue_ = function(n, i) { + var a = this.data_.get(n); + if (i = a.prepareNewValue_(i), i !== p.UNCHANGED) { + var o = P(), s = H(this), l = s || o ? { + observableKind: "map", + debugObjectName: this.name_, + type: Z, + object: this, + oldValue: a.value_, + name: n, + newValue: i + } : null; + process.env.NODE_ENV !== "production" && o && I(l), a.setNewValue_(i), s && X(this, l), process.env.NODE_ENV !== "production" && o && z(); + } + }, t.addValue_ = function(n, i) { + var a = this; + Q(this.keysAtom_), ae(function() { + var c, d = new Se(i, a.enhancer_, process.env.NODE_ENV !== "production" ? a.name_ + "." + Vr(n) : "ObservableMap.key", !1); + a.data_.set(n, d), i = d.value_, (c = a.hasMap_.get(n)) == null || c.setNewValue_(!0), a.keysAtom_.reportChanged(); + }); + var o = P(), s = H(this), l = s || o ? { + observableKind: "map", + debugObjectName: this.name_, + type: pe, + object: this, + name: n, + newValue: i + } : null; + process.env.NODE_ENV !== "production" && o && I(l), s && X(this, l), process.env.NODE_ENV !== "production" && o && z(); + }, t.get = function(n) { + return this.has(n) ? this.dehanceValue_(this.data_.get(n).get()) : this.dehanceValue_(void 0); + }, t.dehanceValue_ = function(n) { + return this.dehancer !== void 0 ? this.dehancer(n) : n; + }, t.keys = function() { + return this.keysAtom_.reportObserved(), this.data_.keys(); + }, t.values = function() { + var n = this, i = this.keys(); + return yn({ + next: function() { + var o = i.next(), s = o.done, l = o.value; + return { + done: s, + value: s ? void 0 : n.get(l) + }; + } + }); + }, t.entries = function() { + var n = this, i = this.keys(); + return yn({ + next: function() { + var o = i.next(), s = o.done, l = o.value; + return { + done: s, + value: s ? void 0 : [l, n.get(l)] + }; + } + }); + }, t[Symbol.iterator] = function() { + return this.entries(); + }, t.forEach = function(n, i) { + for (var a = Ze(this), o; !(o = a()).done; ) { + var s = o.value, l = s[0], c = s[1]; + n.call(i, c, l, this); + } + }, t.merge = function(n) { + var i = this; + return be(n) && (n = new Map(n)), ae(function() { + D(n) ? eo(n).forEach(function(a) { + return i.set(a, n[a]); + }) : Array.isArray(n) ? n.forEach(function(a) { + var o = a[0], s = a[1]; + return i.set(o, s); + }) : Qe(n) ? ($a(n) || f(19, n), n.forEach(function(a, o) { + return i.set(o, a); + })) : n != null && f(20, n); + }), this; + }, t.clear = function() { + var n = this; + ae(function() { + zi(function() { + for (var i = Ze(n.keys()), a; !(a = i()).done; ) { + var o = a.value; + n.delete(o); + } + }); + }); + }, t.replace = function(n) { + var i = this; + return ae(function() { + for (var a = Vs(n), o = /* @__PURE__ */ new Map(), s = !1, l = Ze(i.data_.keys()), c; !(c = l()).done; ) { + var d = c.value; + if (!a.has(d)) { + var u = i.delete(d); + if (u) + s = !0; + else { + var v = i.data_.get(d); + o.set(d, v); + } + } + } + for (var h = Ze(a.entries()), m; !(m = h()).done; ) { + var O = m.value, A = O[0], G = O[1], je = i.data_.has(A); + if (i.set(A, G), i.data_.has(A)) { + var it = i.data_.get(A); + o.set(A, it), je || (s = !0); + } + } + if (!s) + if (i.data_.size !== o.size) + i.keysAtom_.reportChanged(); + else + for (var N = i.data_.keys(), de = o.keys(), we = N.next(), un = de.next(); !we.done; ) { + if (we.value !== un.value) { + i.keysAtom_.reportChanged(); + break; + } + we = N.next(), un = de.next(); + } + i.data_ = o; + }), this; + }, t.toString = function() { + return "[object ObservableMap]"; + }, t.toJSON = function() { + return Array.from(this); + }, t.observe_ = function(n, i) { + return process.env.NODE_ENV !== "production" && i === !0 && f("`observe` doesn't support fireImmediately=true in combination with maps."), Dt(this, n); + }, t.intercept_ = function(n) { + return Pt(this, n); + }, _e(e, [{ + key: "size", + get: function() { + return this.keysAtom_.reportObserved(), this.data_.size; + } + }, { + key: Symbol.toStringTag, + get: function() { + return "Map"; + } + }]); +}(), be = /* @__PURE__ */ Ue("ObservableMap", ea); +function yn(e) { + return e[Symbol.toStringTag] = "MapIterator", rn(e); +} +function Vs(e) { + if (Qe(e) || be(e)) + return e; + if (Array.isArray(e)) + return new Map(e); + if (D(e)) { + var t = /* @__PURE__ */ new Map(); + for (var r in e) + t.set(r, e[r]); + return t; + } else + return f(21, e); +} +var Is = {}, ta = /* @__PURE__ */ function() { + function e(r, n, i) { + var a = this; + n === void 0 && (n = De), i === void 0 && (i = process.env.NODE_ENV !== "production" ? "ObservableSet@" + F() : "ObservableSet"), this.name_ = void 0, this[g] = Is, this.data_ = /* @__PURE__ */ new Set(), this.atom_ = void 0, this.changeListeners_ = void 0, this.interceptors_ = void 0, this.dehancer = void 0, this.enhancer_ = void 0, this.name_ = i, k(Set) || f(22), this.enhancer_ = function(o, s) { + return n(o, s, i); + }, Me(function() { + a.atom_ = Ei(a.name_), r && a.replace(r); + }); + } + var t = e.prototype; + return t.dehanceValue_ = function(n) { + return this.dehancer !== void 0 ? this.dehancer(n) : n; + }, t.clear = function() { + var n = this; + ae(function() { + zi(function() { + for (var i = Ze(n.data_.values()), a; !(a = i()).done; ) { + var o = a.value; + n.delete(o); + } + }); + }); + }, t.forEach = function(n, i) { + for (var a = Ze(this), o; !(o = a()).done; ) { + var s = o.value; + n.call(i, s, s, this); + } + }, t.add = function(n) { + var i = this; + if (Q(this.atom_), M(this)) { + var a = j(this, { + type: pe, + object: this, + newValue: n + }); + if (!a) + return this; + n = a.newValue; + } + if (!this.has(n)) { + ae(function() { + i.data_.add(i.enhancer_(n, void 0)), i.atom_.reportChanged(); + }); + var o = process.env.NODE_ENV !== "production" && P(), s = H(this), l = s || o ? { + observableKind: "set", + debugObjectName: this.name_, + type: pe, + object: this, + newValue: n + } : null; + o && process.env.NODE_ENV !== "production" && I(l), s && X(this, l), o && process.env.NODE_ENV !== "production" && z(); + } + return this; + }, t.delete = function(n) { + var i = this; + if (M(this)) { + var a = j(this, { + type: $t, + object: this, + oldValue: n + }); + if (!a) + return !1; + } + if (this.has(n)) { + var o = process.env.NODE_ENV !== "production" && P(), s = H(this), l = s || o ? { + observableKind: "set", + debugObjectName: this.name_, + type: $t, + object: this, + oldValue: n + } : null; + return o && process.env.NODE_ENV !== "production" && I(l), ae(function() { + i.atom_.reportChanged(), i.data_.delete(n); + }), s && X(this, l), o && process.env.NODE_ENV !== "production" && z(), !0; + } + return !1; + }, t.has = function(n) { + return this.atom_.reportObserved(), this.data_.has(this.dehanceValue_(n)); + }, t.entries = function() { + var n = this.values(); + return wn({ + next: function() { + var a = n.next(), o = a.value, s = a.done; + return s ? { + value: void 0, + done: s + } : { + value: [o, o], + done: s + }; + } + }); + }, t.keys = function() { + return this.values(); + }, t.values = function() { + this.atom_.reportObserved(); + var n = this, i = this.data_.values(); + return wn({ + next: function() { + var o = i.next(), s = o.value, l = o.done; + return l ? { + value: void 0, + done: l + } : { + value: n.dehanceValue_(s), + done: l + }; + } + }); + }, t.intersection = function(n) { + if (ne(n) && !Y(n)) + return n.intersection(this); + var i = new Set(this); + return i.intersection(n); + }, t.union = function(n) { + if (ne(n) && !Y(n)) + return n.union(this); + var i = new Set(this); + return i.union(n); + }, t.difference = function(n) { + return new Set(this).difference(n); + }, t.symmetricDifference = function(n) { + if (ne(n) && !Y(n)) + return n.symmetricDifference(this); + var i = new Set(this); + return i.symmetricDifference(n); + }, t.isSubsetOf = function(n) { + return new Set(this).isSubsetOf(n); + }, t.isSupersetOf = function(n) { + return new Set(this).isSupersetOf(n); + }, t.isDisjointFrom = function(n) { + if (ne(n) && !Y(n)) + return n.isDisjointFrom(this); + var i = new Set(this); + return i.isDisjointFrom(n); + }, t.replace = function(n) { + var i = this; + return Y(n) && (n = new Set(n)), ae(function() { + Array.isArray(n) ? (i.clear(), n.forEach(function(a) { + return i.add(a); + })) : ne(n) ? (i.clear(), n.forEach(function(a) { + return i.add(a); + })) : n != null && f("Cannot initialize set from " + n); + }), this; + }, t.observe_ = function(n, i) { + return process.env.NODE_ENV !== "production" && i === !0 && f("`observe` doesn't support fireImmediately=true in combination with sets."), Dt(this, n); + }, t.intercept_ = function(n) { + return Pt(this, n); + }, t.toJSON = function() { + return Array.from(this); + }, t.toString = function() { + return "[object ObservableSet]"; + }, t[Symbol.iterator] = function() { + return this.values(); + }, _e(e, [{ + key: "size", + get: function() { + return this.atom_.reportObserved(), this.data_.size; + } + }, { + key: Symbol.toStringTag, + get: function() { + return "Set"; + } + }]); +}(), Y = /* @__PURE__ */ Ue("ObservableSet", ta); +function wn(e) { + return e[Symbol.toStringTag] = "SetIterator", rn(e); +} +var xn = /* @__PURE__ */ Object.create(null), On = "remove", qr = /* @__PURE__ */ function() { + function e(r, n, i, a) { + n === void 0 && (n = /* @__PURE__ */ new Map()), a === void 0 && (a = No), this.target_ = void 0, this.values_ = void 0, this.name_ = void 0, this.defaultAnnotation_ = void 0, this.keysAtom_ = void 0, this.changeListeners_ = void 0, this.interceptors_ = void 0, this.proxy_ = void 0, this.isPlainObject_ = void 0, this.appliedAnnotations_ = void 0, this.pendingKeys_ = void 0, this.target_ = r, this.values_ = n, this.name_ = i, this.defaultAnnotation_ = a, this.keysAtom_ = new me(process.env.NODE_ENV !== "production" ? this.name_ + ".keys" : "ObservableObject.keys"), this.isPlainObject_ = D(this.target_), process.env.NODE_ENV !== "production" && !sa(this.defaultAnnotation_) && f("defaultAnnotation must be valid annotation"), process.env.NODE_ENV !== "production" && (this.appliedAnnotations_ = {}); + } + var t = e.prototype; + return t.getObservablePropValue_ = function(n) { + return this.values_.get(n).get(); + }, t.setObservablePropValue_ = function(n, i) { + var a = this.values_.get(n); + if (a instanceof B) + return a.set(i), !0; + if (M(this)) { + var o = j(this, { + type: Z, + object: this.proxy_ || this.target_, + name: n, + newValue: i + }); + if (!o) + return null; + i = o.newValue; + } + if (i = a.prepareNewValue_(i), i !== p.UNCHANGED) { + var s = H(this), l = process.env.NODE_ENV !== "production" && P(), c = s || l ? { + type: Z, + observableKind: "object", + debugObjectName: this.name_, + object: this.proxy_ || this.target_, + oldValue: a.value_, + name: n, + newValue: i + } : null; + process.env.NODE_ENV !== "production" && l && I(c), a.setNewValue_(i), s && X(this, c), process.env.NODE_ENV !== "production" && l && z(); + } + return !0; + }, t.get_ = function(n) { + return p.trackingDerivation && !W(this.target_, n) && this.has_(n), this.target_[n]; + }, t.set_ = function(n, i, a) { + return a === void 0 && (a = !1), W(this.target_, n) ? this.values_.has(n) ? this.setObservablePropValue_(n, i) : a ? Reflect.set(this.target_, n, i) : (this.target_[n] = i, !0) : this.extend_(n, { + value: i, + enumerable: !0, + writable: !0, + configurable: !0 + }, this.defaultAnnotation_, a); + }, t.has_ = function(n) { + if (!p.trackingDerivation) + return n in this.target_; + this.pendingKeys_ || (this.pendingKeys_ = /* @__PURE__ */ new Map()); + var i = this.pendingKeys_.get(n); + return i || (i = new Se(n in this.target_, pr, process.env.NODE_ENV !== "production" ? this.name_ + "." + Vr(n) + "?" : "ObservableObject.key?", !1), this.pendingKeys_.set(n, i)), i.get(); + }, t.make_ = function(n, i) { + if (i === !0 && (i = this.defaultAnnotation_), i !== !1) { + if (Cn(this, i, n), !(n in this.target_)) { + var a; + if ((a = this.target_[ie]) != null && a[n]) + return; + f(1, i.annotationType_, this.name_ + "." + n.toString()); + } + for (var o = this.target_; o && o !== lr; ) { + var s = Ht(o, n); + if (s) { + var l = i.make_(this, n, s, o); + if (l === 0) + return; + if (l === 1) + break; + } + o = Object.getPrototypeOf(o); + } + kn(this, i, n); + } + }, t.extend_ = function(n, i, a, o) { + if (o === void 0 && (o = !1), a === !0 && (a = this.defaultAnnotation_), a === !1) + return this.defineProperty_(n, i, o); + Cn(this, a, n); + var s = a.extend_(this, n, i, o); + return s && kn(this, a, n), s; + }, t.defineProperty_ = function(n, i, a) { + a === void 0 && (a = !1), Q(this.keysAtom_); + try { + R(); + var o = this.delete_(n); + if (!o) + return o; + if (M(this)) { + var s = j(this, { + object: this.proxy_ || this.target_, + name: n, + type: pe, + newValue: i.value + }); + if (!s) + return null; + var l = s.newValue; + i.value !== l && (i = ve({}, i, { + value: l + })); + } + if (a) { + if (!Reflect.defineProperty(this.target_, n, i)) + return !1; + } else + _(this.target_, n, i); + this.notifyPropertyAddition_(n, i.value); + } finally { + q(); + } + return !0; + }, t.defineObservableProperty_ = function(n, i, a, o) { + o === void 0 && (o = !1), Q(this.keysAtom_); + try { + R(); + var s = this.delete_(n); + if (!s) + return s; + if (M(this)) { + var l = j(this, { + object: this.proxy_ || this.target_, + name: n, + type: pe, + newValue: i + }); + if (!l) + return null; + i = l.newValue; + } + var c = En(n), d = { + configurable: p.safeDescriptors ? this.isPlainObject_ : !0, + enumerable: !0, + get: c.get, + set: c.set + }; + if (o) { + if (!Reflect.defineProperty(this.target_, n, d)) + return !1; + } else + _(this.target_, n, d); + var u = new Se(i, a, process.env.NODE_ENV !== "production" ? this.name_ + "." + n.toString() : "ObservableObject.key", !1); + this.values_.set(n, u), this.notifyPropertyAddition_(n, u.value_); + } finally { + q(); + } + return !0; + }, t.defineComputedProperty_ = function(n, i, a) { + a === void 0 && (a = !1), Q(this.keysAtom_); + try { + R(); + var o = this.delete_(n); + if (!o) + return o; + if (M(this)) { + var s = j(this, { + object: this.proxy_ || this.target_, + name: n, + type: pe, + newValue: void 0 + }); + if (!s) + return null; + } + i.name || (i.name = process.env.NODE_ENV !== "production" ? this.name_ + "." + n.toString() : "ObservableObject.key"), i.context = this.proxy_ || this.target_; + var l = En(n), c = { + configurable: p.safeDescriptors ? this.isPlainObject_ : !0, + enumerable: !1, + get: l.get, + set: l.set + }; + if (a) { + if (!Reflect.defineProperty(this.target_, n, c)) + return !1; + } else + _(this.target_, n, c); + this.values_.set(n, new B(i)), this.notifyPropertyAddition_(n, void 0); + } finally { + q(); + } + return !0; + }, t.delete_ = function(n, i) { + if (i === void 0 && (i = !1), Q(this.keysAtom_), !W(this.target_, n)) + return !0; + if (M(this)) { + var a = j(this, { + object: this.proxy_ || this.target_, + name: n, + type: On + }); + if (!a) + return null; + } + try { + var o; + R(); + var s = H(this), l = process.env.NODE_ENV !== "production" && P(), c = this.values_.get(n), d = void 0; + if (!c && (s || l)) { + var u; + d = (u = Ht(this.target_, n)) == null ? void 0 : u.value; + } + if (i) { + if (!Reflect.deleteProperty(this.target_, n)) + return !1; + } else + delete this.target_[n]; + if (process.env.NODE_ENV !== "production" && delete this.appliedAnnotations_[n], c && (this.values_.delete(n), c instanceof Se && (d = c.value_), Ri(c)), this.keysAtom_.reportChanged(), (o = this.pendingKeys_) == null || (o = o.get(n)) == null || o.set(n in this.target_), s || l) { + var v = { + type: On, + observableKind: "object", + object: this.proxy_ || this.target_, + debugObjectName: this.name_, + oldValue: d, + name: n + }; + process.env.NODE_ENV !== "production" && l && I(v), s && X(this, v), process.env.NODE_ENV !== "production" && l && z(); + } + } finally { + q(); + } + return !0; + }, t.observe_ = function(n, i) { + return process.env.NODE_ENV !== "production" && i === !0 && f("`observe` doesn't support the fire immediately property for observable objects."), Dt(this, n); + }, t.intercept_ = function(n) { + return Pt(this, n); + }, t.notifyPropertyAddition_ = function(n, i) { + var a, o = H(this), s = process.env.NODE_ENV !== "production" && P(); + if (o || s) { + var l = o || s ? { + type: pe, + observableKind: "object", + debugObjectName: this.name_, + object: this.proxy_ || this.target_, + name: n, + newValue: i + } : null; + process.env.NODE_ENV !== "production" && s && I(l), o && X(this, l), process.env.NODE_ENV !== "production" && s && z(); + } + (a = this.pendingKeys_) == null || (a = a.get(n)) == null || a.set(!0), this.keysAtom_.reportChanged(); + }, t.ownKeys_ = function() { + return this.keysAtom_.reportObserved(), mt(this.target_); + }, t.keys_ = function() { + return this.keysAtom_.reportObserved(), Object.keys(this.target_); + }, e; +}(); +function et(e, t) { + var r; + if (process.env.NODE_ENV !== "production" && t && tt(e) && f("Options can't be provided for already observable objects."), W(e, g)) + return process.env.NODE_ENV !== "production" && !(aa(e) instanceof qr) && f("Cannot convert '" + er(e) + `' into observable object: +The target is already observable of different type. +Extending builtins is not supported.`), e; + process.env.NODE_ENV !== "production" && !Object.isExtensible(e) && f("Cannot make the designated object observable; it is not extensible"); + var n = (r = t?.name) != null ? r : process.env.NODE_ENV !== "production" ? (D(e) ? "ObservableObject" : e.constructor.name) + "@" + F() : "ObservableObject", i = new qr(e, /* @__PURE__ */ new Map(), String(n), Ko(t)); + return dr(e, g, i), e; +} +var zs = /* @__PURE__ */ Ue("ObservableObjectAdministration", qr); +function En(e) { + return xn[e] || (xn[e] = { + get: function() { + return this[g].getObservablePropValue_(e); + }, + set: function(r) { + return this[g].setObservablePropValue_(e, r); + } + }); +} +function tt(e) { + return cr(e) ? zs(e[g]) : !1; +} +function kn(e, t, r) { + var n; + process.env.NODE_ENV !== "production" && (e.appliedAnnotations_[r] = t), (n = e.target_[ie]) == null || delete n[r]; +} +function Cn(e, t, r) { + if (process.env.NODE_ENV !== "production" && !sa(t) && f("Cannot annotate '" + e.name_ + "." + r.toString() + "': Invalid annotation."), process.env.NODE_ENV !== "production" && !Jt(t) && W(e.appliedAnnotations_, r)) { + var n = e.name_ + "." + r.toString(), i = e.appliedAnnotations_[r].annotationType_, a = t.annotationType_; + f("Cannot apply '" + a + "' to '" + n + "':" + (` +The field is already annotated with '` + i + "'.") + ` +Re-annotating fields is not allowed. +Use 'override' annotation for methods overridden by subclass.`); + } +} +var Us = /* @__PURE__ */ na(0), Ls = /* @__PURE__ */ function() { + var e = !1, t = {}; + return Object.defineProperty(t, "0", { + set: function() { + e = !0; + } + }), Object.create(t)[0] = 1, e === !1; +}(), Ar = 0, ra = function() { +}; +function Ms(e, t) { + Object.setPrototypeOf ? Object.setPrototypeOf(e.prototype, t) : e.prototype.__proto__ !== void 0 ? e.prototype.__proto__ = t : e.prototype = t; +} +Ms(ra, Array.prototype); +var tn = /* @__PURE__ */ function(e) { + function t(n, i, a, o) { + var s; + return a === void 0 && (a = process.env.NODE_ENV !== "production" ? "ObservableArray@" + F() : "ObservableArray"), o === void 0 && (o = !1), s = e.call(this) || this, Me(function() { + var l = new en(a, i, o, !0); + l.proxy_ = s, yi(s, g, l), n && n.length && s.spliceWithArray(0, 0, n), Ls && Object.defineProperty(s, "0", Us); + }), s; + } + Oi(t, e); + var r = t.prototype; + return r.concat = function() { + this[g].atom_.reportObserved(); + for (var i = arguments.length, a = new Array(i), o = 0; o < i; o++) + a[o] = arguments[o]; + return Array.prototype.concat.apply( + this.slice(), + //@ts-ignore + a.map(function(s) { + return br(s) ? s.slice() : s; + }) + ); + }, r[Symbol.iterator] = function() { + var n = this, i = 0; + return rn({ + next: function() { + return i < n.length ? { + value: n[i++], + done: !1 + } : { + done: !0, + value: void 0 + }; + } + }); + }, _e(t, [{ + key: "length", + get: function() { + return this[g].getArrayLength_(); + }, + set: function(i) { + this[g].setArrayLength_(i); + } + }, { + key: Symbol.toStringTag, + get: function() { + return "Array"; + } + }]); +}(ra); +Object.entries(_t).forEach(function(e) { + var t = e[0], r = e[1]; + t !== "concat" && dr(tn.prototype, t, r); +}); +function na(e) { + return { + enumerable: !1, + configurable: !0, + get: function() { + return this[g].get_(e); + }, + set: function(r) { + this[g].set_(e, r); + } + }; +} +function js(e) { + _(tn.prototype, "" + e, na(e)); +} +function ia(e) { + if (e > Ar) { + for (var t = Ar; t < e + 100; t++) + js(t); + Ar = e; + } +} +ia(1e3); +function Rs(e, t, r) { + return new tn(e, t, r); +} +function Ge(e, t) { + if (typeof e == "object" && e !== null) { + if (br(e)) + return t !== void 0 && f(23), e[g].atom_; + if (Y(e)) + return e.atom_; + if (be(e)) { + if (t === void 0) + return e.keysAtom_; + var r = e.data_.get(t) || e.hasMap_.get(t); + return r || f(25, t, er(e)), r; + } + if (tt(e)) { + if (!t) + return f(26); + var n = e[g].values_.get(t); + return n || f(27, t, er(e)), n; + } + if (Gr(e) || mr(e) || Qt(e)) + return e; + } else if (k(e) && Qt(e[g])) + return e[g]; + f(28); +} +function aa(e, t) { + if (e || f(29), Gr(e) || mr(e) || Qt(e) || be(e) || Y(e)) + return e; + if (e[g]) + return e[g]; + f(24, e); +} +function er(e, t) { + var r; + if (t !== void 0) + r = Ge(e, t); + else { + if (Ve(e)) + return e.name; + tt(e) || be(e) || Y(e) ? r = aa(e) : r = Ge(e); + } + return r.name_; +} +function Me(e) { + var t = Le(), r = hr(!0); + R(); + try { + return e(); + } finally { + q(), gr(r), oe(t); + } +} +var An = lr.toString; +function oa(e, t, r) { + return r === void 0 && (r = -1), Kr(e, t, r); +} +function Kr(e, t, r, n, i) { + if (e === t) + return e !== 0 || 1 / e === 1 / t; + if (e == null || t == null) + return !1; + if (e !== e) + return t !== t; + var a = typeof e; + if (a !== "function" && a !== "object" && typeof t != "object") + return !1; + var o = An.call(e); + if (o !== An.call(t)) + return !1; + switch (o) { + // Strings, numbers, regular expressions, dates, and booleans are compared by value. + case "[object RegExp]": + // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i') + case "[object String]": + return "" + e == "" + t; + case "[object Number]": + return +e != +e ? +t != +t : +e == 0 ? 1 / +e === 1 / t : +e == +t; + case "[object Date]": + case "[object Boolean]": + return +e == +t; + case "[object Symbol]": + return typeof Symbol < "u" && Symbol.valueOf.call(e) === Symbol.valueOf.call(t); + case "[object Map]": + case "[object Set]": + r >= 0 && r++; + break; + } + e = Sn(e), t = Sn(t); + var s = o === "[object Array]"; + if (!s) { + if (typeof e != "object" || typeof t != "object") + return !1; + var l = e.constructor, c = t.constructor; + if (l !== c && !(k(l) && l instanceof l && k(c) && c instanceof c) && "constructor" in e && "constructor" in t) + return !1; + } + if (r === 0) + return !1; + r < 0 && (r = -1), n = n || [], i = i || []; + for (var d = n.length; d--; ) + if (n[d] === e) + return i[d] === t; + if (n.push(e), i.push(t), s) { + if (d = e.length, d !== t.length) + return !1; + for (; d--; ) + if (!Kr(e[d], t[d], r - 1, n, i)) + return !1; + } else { + var u = Object.keys(e), v = u.length; + if (Object.keys(t).length !== v) + return !1; + for (var h = 0; h < v; h++) { + var m = u[h]; + if (!(W(t, m) && Kr(e[m], t[m], r - 1, n, i))) + return !1; + } + } + return n.pop(), i.pop(), !0; +} +function Sn(e) { + return br(e) ? e.slice() : Qe(e) || be(e) || ne(e) || Y(e) ? Array.from(e.entries()) : e; +} +var Pn, qs = ((Pn = Hr().Iterator) == null ? void 0 : Pn.prototype) || {}; +function rn(e) { + return e[Symbol.iterator] = Ks, Object.assign(Object.create(qs), e); +} +function Ks() { + return this; +} +function sa(e) { + return ( + // Can be function + e instanceof Object && typeof e.annotationType_ == "string" && k(e.make_) && k(e.extend_) + ); +} +["Symbol", "Map", "Set"].forEach(function(e) { + var t = Hr(); + typeof t[e] > "u" && f("MobX requires global '" + e + "' to be available or polyfilled"); +}); +typeof __MOBX_DEVTOOLS_GLOBAL_HOOK__ == "object" && __MOBX_DEVTOOLS_GLOBAL_HOOK__.injectMobx({ + spy: ls, + extras: { + getDebugName: er + }, + $mobx: g +}); +var ye = /* @__PURE__ */ ((e) => (e.INFORMATION = "information", e.WARNING = "warning", e.ERROR = "error", e))(ye || {}); +const Bs = Symbol.for("react.portal"), Fs = Symbol.for("react.fragment"), Zs = Symbol.for("react.strict_mode"), Ws = Symbol.for("react.profiler"), Hs = Symbol.for("react.provider"), Xs = Symbol.for("react.context"), la = Symbol.for("react.forward_ref"), Js = Symbol.for("react.suspense"), Gs = Symbol.for("react.suspense_list"), Ys = Symbol.for("react.memo"), Qs = Symbol.for("react.lazy"); +function _s(e, t, r) { + const n = e.displayName; + if (n) + return n; + const i = t.displayName || t.name || ""; + return i !== "" ? `${r}(${i})` : r; +} +function Dn(e) { + return e.displayName || "Context"; +} +function tr(e) { + if (e === null) + return null; + if (typeof e == "function") + return e.displayName || e.name || null; + if (typeof e == "string") + return e; + switch (e) { + case Fs: + return "Fragment"; + case Bs: + return "Portal"; + case Ws: + return "Profiler"; + case Zs: + return "StrictMode"; + case Js: + return "Suspense"; + case Gs: + return "SuspenseList"; + } + if (typeof e == "object") + switch (e.$$typeof) { + case Xs: + return `${Dn(e)}.Consumer`; + case Hs: + return `${Dn(e._context)}.Provider`; + case la: + return _s(e, e.render, "ForwardRef"); + case Ys: + const t = e.displayName || null; + return t !== null ? t : tr(e.type) || "Memo"; + case Qs: { + const r = e, n = r._payload, i = r._init; + try { + return tr(i(n)); + } catch { + return null; + } + } + } + return null; +} +let zt; +function Td() { + const e = /* @__PURE__ */ new Set(); + return Array.from(document.body.querySelectorAll("*")).flatMap(tl).filter($s).filter((r) => !r.fileName.includes("frontend/generated/")).forEach((r) => e.add(r.fileName)), Array.from(e); +} +function $s(e) { + return !!e && e.fileName; +} +function rr(e) { + if (!e) + return; + if (e._debugSource) + return e._debugSource; + const t = e._debugInfo?.source; + if (t?.fileName && t?.lineNumber) + return t; +} +function el(e) { + if (e && e.type?.__debugSourceDefine) + return e.type.__debugSourceDefine; +} +function tl(e) { + return rr(nr(e)); +} +function rl() { + return `__reactFiber$${ca()}`; +} +function nl() { + return `__reactContainer$${ca()}`; +} +function ca() { + if (!(!zt && (zt = Array.from(document.querySelectorAll("*")).flatMap((e) => Object.keys(e)).filter((e) => e.startsWith("__reactFiber$")).map((e) => e.replace("__reactFiber$", "")).find((e) => e), !zt))) + return zt; +} +function ut(e) { + const t = e.type; + return t?.$$typeof === la && !t.displayName && e.child ? ut(e.child) : tr(e.type) ?? tr(e.elementType) ?? "???"; +} +function il() { + const e = Array.from(document.querySelectorAll("body > *")).flatMap((r) => r[nl()]).find((r) => r), t = Ie(e); + return Ie(t?.child); +} +function al(e) { + const t = []; + let r = Ie(e.child); + for (; r; ) + t.push(r), r = Ie(r.sibling); + return t; +} +function ol(e) { + return e.hasOwnProperty("entanglements") && e.hasOwnProperty("containerInfo"); +} +function sl(e) { + return e.hasOwnProperty("stateNode") && e.hasOwnProperty("pendingProps"); +} +function Ie(e) { + const t = e?.stateNode; + if (t?.current && (ol(t) || sl(t))) + return t?.current; + if (!e) + return; + if (!e.alternate) + return e; + const r = e.alternate, n = e?.actualStartTime, i = r?.actualStartTime; + return i !== n && i > n ? r : e; +} +function nr(e) { + const t = rl(), r = Ie(e[t]); + if (rr(r)) + return r; + let n = r?.return || void 0; + for (; n && !rr(n); ) + n = n.return || void 0; + return n; +} +function ir(e) { + if (e.stateNode?.isConnected === !0) + return e.stateNode; + if (e.child) + return ir(e.child); +} +function Nn(e) { + const t = ir(e); + return t && Ie(nr(t)) === e; +} +function ll(e) { + return typeof e.type != "function" || da(e) ? !1 : !!(rr(e) || el(e)); +} +function da(e) { + if (!e) + return !1; + const t = e; + return typeof e.type == "function" && t.tag === 1; +} +const Nt = async (e, t, r) => window.Vaadin.copilot.comm(e, t, r), he = "copilot-", cl = "25.0.7", dl = "undefined", Vd = "attention-required", Id = "https://plugins.jetbrains.com/plugin/23758-vaadin", zd = "https://marketplace.visualstudio.com/items?itemName=vaadin.vaadin-vscode", Ud = "https://marketplace.eclipse.org/content/vaadin-tools"; +function Ld(e) { + return e === void 0 ? !1 : e.nodeId >= 0; +} +function ul(e) { + if (e.javaClass) + return e.javaClass.substring(e.javaClass.lastIndexOf(".") + 1); +} +function Ut(e) { + const t = window.Vaadin; + if (t && t.Flow) { + const { clients: r } = t.Flow, n = Object.keys(r); + for (const i of n) { + const a = r[i]; + if (a.getNodeId) { + const o = a.getNodeId(e); + if (o >= 0) { + const s = a.getNodeInfo(o); + return { + nodeId: o, + uiId: a.getUIId(), + element: e, + javaClass: s.javaClass, + styles: s.styles, + hiddenByServer: s.hiddenByServer + }; + } + } + } + } +} +function Md() { + const e = window.Vaadin; + let t; + if (e && e.Flow) { + const { clients: r } = e.Flow, n = Object.keys(r); + for (const i of n) { + const a = r[i]; + a.getUIId && (t = a.getUIId()); + } + } + return t; +} +function jd(e) { + return { + uiId: e.uiId, + nodeId: e.nodeId + }; +} +function pl(e) { + return e ? e.type?.type === "FlowContainer" : !1; +} +function fl(e) { + return e.localName.startsWith("flow-container"); +} +function Rd(e) { + const t = e.lastIndexOf("."); + return t < 0 ? e : e.substring(t + 1); +} +function ua(e, t) { + const r = e(); + r ? t(r) : setTimeout(() => ua(e, t), 50); +} +async function vl(e) { + const t = e(); + if (t) + return t; + let r; + const n = new Promise((a) => { + r = a; + }), i = setInterval(() => { + const a = e(); + a && (clearInterval(i), r(a)); + }, 10); + return n; +} +function ar(e) { + return C.box(e, { deep: !1 }); +} +function hl(e) { + return e && typeof e.lastAccessedBy_ == "number"; +} +function qd(e) { + if (e) { + if (typeof e == "string") + return e; + if (!hl(e)) + throw new Error(`Expected message to be a string or an observable value but was ${JSON.stringify(e)}`); + return e.get(); + } +} +function gl(e) { + return Array.from(new Set(e)); +} +function Tt(e) { + Promise.resolve().then(() => xc).then(({ showNotification: t }) => { + t(e); + }); +} +function ml() { + Tt({ + type: ye.INFORMATION, + message: "The previous operation is still in progress. Please wait for it to finish." + }); +} +function bl(e) { + return e.children && (e.children = e.children.filter(bl)), e.visible !== !1; +} +function Tn(e) { + const t = `--${e}`, r = /* @__PURE__ */ new Set(); + function n(c) { + return "cssRules" in c; + } + function i(c) { + return c.type === CSSRule.STYLE_RULE; + } + function a(c) { + return "cssRules" in c; + } + function o(c) { + if (!c) return !1; + for (let d = 0; d < c.length; d++) + if (c[d]?.startsWith(t)) return !0; + return !1; + } + function s(c) { + if (i(c) && o(c.style)) return !0; + if (a(c)) { + const d = c.cssRules; + for (const u of d) + if (s(u)) + return !0; + } + if (c.type === CSSRule.IMPORT_RULE) { + const d = c; + if (d.styleSheet && l(d.styleSheet)) return !0; + } + return !1; + } + function l(c) { + if (!c || r.has(c)) return !1; + r.add(c); + let d; + try { + d = c.cssRules; + } catch { + return !1; + } + if (!d) + return !1; + for (const u of d) + if (s(u)) + return !0; + return !1; + } + for (const c of Array.from([...document.adoptedStyleSheets, ...document.styleSheets])) + if (n(c) && l(c)) return !0; + return !1; +} +function Kd(e) { + return e?.replace(/^.*[\\/]/, ""); +} +async function pa() { + return vl(() => { + const e = window.Vaadin.devTools, t = e?.frontendConnection && e?.frontendConnection.status === "active"; + return e !== void 0 && t && e?.frontendConnection; + }); +} +function te(e, t) { + pa().then((r) => { + r.canSend ? r.send(e, t) : Tt({ + type: ye.INFORMATION, + message: "Connection lost", + details: "Please refresh the page and start the server if it is not running", + delay: 1e4, + dismissId: "connection-lost" + }); + }); +} +const yl = () => { + te("copilot-browser-info", { + userAgent: navigator.userAgent, + locale: navigator.language, + timezone: Intl.DateTimeFormat().resolvedOptions().timeZone + }); +}, xt = (e, t) => { + te("copilot-track-event", { event: e, properties: t }); +}, Bd = (e, t) => { + xt(e, { ...t, view: "react" }); +}, Fd = (e, t) => { + xt(e, { ...t, view: "flow" }); +}; +class wl { + constructor() { + this.welcomeActive = !1, this.loginCheckActive = !1, this.userInfo = void 0, this.active = !1, this.activatedFrom = null, this.activatedAtLeastOnce = !1, this.operationInProgress = void 0, this.operationWaitsHmrUpdate = void 0, this.operationWaitsHmrUpdateTimeout = void 0, this.idePluginState = void 0, this.notifications = [], this.infoTooltip = null, this.sectionPanelDragging = !1, this.sectionPanelResizing = !1, this.drawerResizing = !1, this.featureFlags = [], this.newVaadinVersionState = void 0, this.pointerEventsDisabledForScrolling = !1, this.editComponent = void 0, this.serverRestartRequiringToggledFeatureFlags = [], this.appTheme = void 0, this.escapeEventHandler = void 0, $e(this, { + notifications: C.shallow + }); + } + setActive(t, r) { + this.active = t, t && (this.activatedAtLeastOnce || (xt("activate"), this.idePluginState?.active && xt("plugin-active", { + pluginVersion: this.idePluginState.version, + ide: this.idePluginState.ide + })), this.activatedAtLeastOnce = !0), this.activatedFrom = r ?? null; + } + setWelcomeActive(t) { + this.welcomeActive = t; + } + setLoginCheckActive(t) { + this.loginCheckActive = t; + } + setUserInfo(t) { + this.userInfo = t; + } + startOperation(t) { + if (this.operationInProgress) + throw new Error(`An ${t} operation is already in progress`); + if (this.operationWaitsHmrUpdate) { + ml(); + return; + } + this.operationInProgress = t; + } + stopOperation(t) { + if (this.operationInProgress) { + if (this.operationInProgress !== t) + return; + } else return; + this.operationInProgress = void 0; + } + setOperationWaitsHmrUpdate(t, r) { + this.operationWaitsHmrUpdate = t, this.operationWaitsHmrUpdateTimeout = r; + } + clearOperationWaitsHmrUpdate() { + this.operationWaitsHmrUpdate = void 0, this.operationWaitsHmrUpdateTimeout = void 0; + } + setIdePluginState(t) { + this.idePluginState = t; + } + toggleActive(t) { + this.setActive(!this.active, this.active ? null : t ?? null); + } + reset() { + this.active = !1, this.activatedAtLeastOnce = !1; + } + setNotifications(t) { + this.notifications = t; + } + removeNotification(t) { + t.animatingOut = !0, setTimeout(() => { + this.reallyRemoveNotification(t); + }, 180); + } + reallyRemoveNotification(t) { + const r = this.notifications.indexOf(t); + r > -1 && this.notifications.splice(r, 1); + } + setTooltip(t, r) { + this.infoTooltip = { + text: t, + loader: r + }; + } + clearTooltip() { + this.infoTooltip = null; + } + setSectionPanelDragging(t) { + this.sectionPanelDragging = t; + } + setSectionPanelResizing(t) { + this.sectionPanelResizing = t; + } + setDrawerResizing(t) { + this.drawerResizing = t; + } + setFeatureFlags(t) { + this.featureFlags = t; + } + setVaadinVersionState(t) { + this.newVaadinVersionState = t; + } + setPointerEventsDisabledForScrolling(t) { + this.pointerEventsDisabledForScrolling = t; + } + setEditComponent(t) { + this.editComponent = t; + } + clearEditComponent() { + this.editComponent = void 0; + } + toggleServerRequiringFeatureFlag(t) { + const r = [...this.serverRestartRequiringToggledFeatureFlags], n = r.findIndex((i) => i.id === t.id); + n === -1 ? r.push(t) : r.splice(n, 1), this.serverRestartRequiringToggledFeatureFlags = r; + } + setAppTheme(t) { + this.appTheme = t; + } + setEscapeEventHandler(t) { + this.escapeEventHandler = t; + } + clearEscapeEventHandler() { + this.escapeEventHandler = void 0; + } +} +const xl = (e, t, r) => t >= e.left && t <= e.right && r >= e.top && r <= e.bottom, fa = (e) => { + const t = []; + let r = Vn(e); + for (; r; ) + t.push(r), r = Vn(r); + return t; +}, Ol = (e) => { + if (e.length === 0) + return new DOMRect(); + let t = Number.MAX_VALUE, r = Number.MAX_VALUE, n = Number.MIN_VALUE, i = Number.MIN_VALUE; + const a = new DOMRect(); + return e.forEach((o) => { + const s = o.getBoundingClientRect(); + s.x < t && (t = s.x), s.y < r && (r = s.y), s.right > n && (n = s.right), s.bottom > i && (i = s.bottom); + }), a.x = t, a.y = r, a.width = n - t, a.height = i - r, a; +}, or = (e, t) => { + let r = e; + for (; !(r instanceof HTMLElement && r.localName === `${he}main`); ) { + if (!r.isConnected) + return null; + if (r.parentNode) + r = r.parentNode; + else if (r.host) + r = r.host; + else + return null; + if (r instanceof HTMLElement && r.localName === t) + return r; + } + return null; +}; +function Vn(e) { + return e.parentElement ?? e.parentNode?.host; +} +function Br(e) { + if (e.assignedSlot) + return Br(e.assignedSlot); + if (e.parentElement) + return e.parentElement; + if (e.parentNode instanceof ShadowRoot) + return e.parentNode.host; +} +function fe(e) { + if (e instanceof Node) { + const t = fa(e); + return e instanceof HTMLElement && t.push(e), t.map((r) => r.localName).some((r) => r.startsWith(he)); + } + return !1; +} +function In(e) { + return e instanceof Element; +} +function zn(e) { + return e.startsWith("vaadin-") ? e.substring(7).split("-").map((n) => n.charAt(0).toUpperCase() + n.slice(1)).join(" ") : e; +} +function Un(e) { + if (!e) + return; + if (e.id) + return `#${e.id}`; + if (!e.children) + return; + const t = Array.from(e.children).find((n) => n.localName === "label"); + if (t) + return t.outerText.trim(); + const r = Array.from(e.childNodes).find( + (n) => n.nodeType === Node.TEXT_NODE && n.textContent && n.textContent.trim().length > 0 + ); + if (r && r.textContent) + return r.textContent.trim(); +} +function El(e) { + return e instanceof Element && typeof e.getBoundingClientRect == "function" ? e.getBoundingClientRect() : kl(e); +} +function kl(e) { + const t = document.createRange(); + t.selectNode(e); + const r = t.getBoundingClientRect(); + return t.detach(), r; +} +function Cl() { + let e = document.activeElement; + for (; e?.shadowRoot && e.shadowRoot.activeElement; ) + e = e.shadowRoot.activeElement; + return e; +} +function Al(e) { + let t = Br(e); + for (; t && t !== document.body; ) { + const r = window.getComputedStyle(t), n = r.overflowY, i = r.overflowX, a = /(auto|scroll)/.test(n) && t.scrollHeight > t.clientHeight, o = /(auto|scroll)/.test(i) && t.scrollWidth > t.clientWidth; + if (a || o) + return t; + t = Br(t); + } + return document.documentElement; +} +function Sl(e, t) { + return Pl(e, t) && Dl(t); +} +function Pl(e, t) { + const r = Al(e), n = r.getBoundingClientRect(); + if (r === document.documentElement || r === document.body) { + const i = window.innerWidth || document.documentElement.clientWidth, a = window.innerHeight || document.documentElement.clientHeight; + return t.top < a && t.bottom > 0 && t.left < i && t.right > 0; + } + return t.bottom > n.top && t.top < n.bottom && t.right > n.left && t.left < n.right; +} +function Dl(e) { + return e.bottom > 0 && e.right > 0 && e.top < window.innerHeight && e.left < window.innerWidth; +} +function Zd(e) { + return e instanceof HTMLElement; +} +function Wd(e) { + const t = va(e), r = Ol(t); + !t.every((i) => Sl(i, r)) && t.length > 0 && t[0].scrollIntoView(); +} +function va(e) { + const t = e; + if (!t) + return []; + const { element: r } = t; + if (r) { + const n = t.element; + if (r.localName === "vaadin-popover" || r.localName === "vaadin-dialog") { + const i = n._overlayElement.shadowRoot.querySelector('[part="overlay"]'); + if (i) + return [i]; + } + if (r.localName === "vaadin-login-overlay") { + const i = n.shadowRoot?.querySelector("vaadin-login-overlay-wrapper")?.shadowRoot?.querySelector('[part="card"]'); + if (i) + return [i]; + } + return [r]; + } + return t.children.flatMap((n) => va(n)); +} +function Hd(e, t) { + function r(n) { + if (n instanceof ShadowRoot) + for (const i of n.children) { + const a = r(i); + if (a) + return a; + } + else if (n instanceof Element) { + if (n.tagName.toLowerCase() === t.toLowerCase()) + return n; + for (const i of n.children) { + const a = r(i); + if (a) + return a; + } + } + } + return r(e); +} +function Nl(e) { + const { clientX: t, clientY: r } = e; + return t === 0 && r === 0 || // Safari and Firefox returns the last position where mouse left the screen with adding some offset value, something like 356, -1. + !xl(document.documentElement.getBoundingClientRect(), t, r); +} +function Ln(e) { + if (e.localName === "vaadin-login-overlay") + return !1; + const t = El(e); + return t.width === 0 || t.height === 0; +} +function Tl(e) { + return typeof e.close == "function"; +} +function Mn(e) { + return Tl(e) ? (e.close(), !0) : e.localName === "vaadin-popover" ? (e.opened = !1, !0) : !1; +} +var ha = /* @__PURE__ */ ((e) => (e["vaadin-combo-box"] = "vaadin-combo-box", e["vaadin-date-picker"] = "vaadin-date-picker", e["vaadin-dialog"] = "vaadin-dialog", e["vaadin-multi-select-combo-box"] = "vaadin-multi-select-combo-box", e["vaadin-select"] = "vaadin-select", e["vaadin-time-picker"] = "vaadin-time-picker", e["vaadin-popover"] = "vaadin-popover", e))(ha || {}); +const Re = { + "vaadin-combo-box": { + hideOnActivation: !0, + open: (e) => Lt(e), + close: (e) => Mt(e) + }, + "vaadin-select": { + hideOnActivation: !0, + open: (e) => { + const t = e; + ma(t, t._overlayElement), t.opened = !0; + }, + close: (e) => { + const t = e; + ba(t, t._overlayElement), t.opened = !1; + } + }, + "vaadin-multi-select-combo-box": { + hideOnActivation: !0, + open: (e) => Lt(e), + close: (e) => { + Mt(e), e.removeAttribute("focused"); + } + }, + "vaadin-date-picker": { + hideOnActivation: !0, + open: (e) => Lt(e), + close: (e) => Mt(e) + }, + "vaadin-time-picker": { + hideOnActivation: !0, + open: (e) => Lt(e), + close: (e) => { + Mt(e), e.removeAttribute("focused"); + } + }, + "vaadin-dialog": { + hideOnActivation: !1 + }, + "vaadin-popover": { + hideOnActivation: !1 + } +}, ga = (e) => { + e.preventDefault(), e.stopImmediatePropagation(); +}, Lt = (e) => { + e.addEventListener("focusout", ga, { capture: !0 }), ma(e), e.opened = !0; +}, Mt = (e) => { + ba(e), e.removeAttribute("focused"), e.removeEventListener("focusout", ga, { capture: !0 }), e.opened = !1; +}, ma = (e, t) => { + const r = t ?? e.$.overlay; + r.__oldModeless = r.modeless, r.modeless = !0; +}, ba = (e, t) => { + const r = t ?? e.$.overlay; + r.modeless = r.__oldModeless !== void 0 ? r.__oldModeless : r.modeless, delete r.__oldModeless; +}; +class Vl { + constructor() { + this.openedOverlayOwners = /* @__PURE__ */ new Set(), this.overlayCloseEventListener = (t) => { + fe(t.detail?.overlay) || (window.Vaadin.copilot._uiState.active || fe(t.detail.sourceEvent?.target)) && (t.preventDefault(), t.stopImmediatePropagation()); + }; + } + /** + * Modifies pointer-events property to auto if dialog overlay is present on body element.
    + * Overriding closeOnOutsideClick method in order to keep overlay present while copilot is active + * @private + */ + onCopilotActivation() { + const t = this.findComponentWithOpenOverlay(); + if (!t) + return; + const r = Re[t.localName]; + r && (r.hideOnActivation && r.close ? r.close(t) : document.body.style.getPropertyValue("pointer-events") === "none" && document.body.style.removeProperty("pointer-events")); + } + findComponentWithOpenOverlay() { + let t; + for (t in Re) { + const r = document.querySelector(`${t}[opened]`); + if (r) + return r; + } + return null; + } + /** + * Restores pointer-events state on deactivation.
    + * Closes opened overlays while using copilot. + * @private + */ + onCopilotDeactivation() { + this.openedOverlayOwners.forEach((r) => { + const n = Re[r.localName]; + n && n.close && n.close(r); + }), document.body.querySelector("vaadin-dialog[opened]") && document.body.style.setProperty("pointer-events", "none"); + } + getOwner(t) { + const r = t; + if (r._comboBox) + return r._comboBox._comboBox ?? r._comboBox; + if (r.owner) + return r.owner; + if (r?.__focusRestorationController?.focusNode?.parentElement) + return r?.__focusRestorationController?.focusNode?.parentElement; + } + addOverlayOutsideClickEvent() { + document.documentElement.addEventListener("vaadin-overlay-close", this.overlayCloseEventListener, { + capture: !0 + }); + } + removeOverlayOutsideClickEvent() { + document.documentElement.removeEventListener("vaadin-overlay-close", this.overlayCloseEventListener); + } + toggle(t) { + const r = Re[t.localName]; + this.isOverlayActive(t) ? (r.close(t), this.openedOverlayOwners.delete(t)) : (r.open(t), this.openedOverlayOwners.add(t)); + } + isOverlayActive(t) { + const r = Re[t.localName]; + return r.active ? r.active(t) : t.hasAttribute("opened"); + } + overlayStatus(t) { + if (!t) + return { visible: !1 }; + const r = t.localName; + let n = Object.keys(ha).includes(r); + if (!n) + return { visible: !1 }; + const i = Re[t.localName]; + if (!i.open || !i.close) + return { visible: !1 }; + i.hasOverlay && (n = i.hasOverlay(t)); + const a = this.isOverlayActive(t); + return { visible: n, active: a }; + } +} +class ya { + constructor() { + this.promise = new Promise((t) => { + this.resolveInit = t; + }); + } + done(t) { + this.resolveInit(t); + } +} +class Il { + constructor() { + this.dismissedNotifications = [], this.termsSummaryDismissed = !1, this.activationButtonPosition = null, this.paletteState = null, this.activationShortcut = !0, this.activationAnimation = !0, this.recentSwitchedUsernames = [], this.newVersionPreReleasesVisible = !1, this.aiUsageAllowed = "ask", this.sendErrorReportsAllowed = !0, this.feedbackDisplayedAtLeastOnce = !1, this.aiProvider = "ANY", $e(this), this.initializer = new ya(), this.initializer.promise.then(() => { + $r( + () => JSON.stringify(this), + () => { + te("copilot-set-machine-configuration", { conf: JSON.stringify(jn(this)) }); + } + ); + }), window.Vaadin.copilot.eventbus.on("copilot-machine-configuration", (t) => { + const r = t.detail.conf; + r.aiProvider || (r.aiProvider = "ANY"), Object.assign(this, jn(r)), this.initializer.done(!0), t.preventDefault(); + }), this.loadData(); + } + loadData() { + te("copilot-get-machine-configuration", {}); + } + addDismissedNotification(t) { + this.dismissedNotifications = [...this.dismissedNotifications, t]; + } + getDismissedNotifications() { + return this.dismissedNotifications; + } + clearDismissedNotifications() { + this.dismissedNotifications = []; + } + setTermsSummaryDismissed(t) { + this.termsSummaryDismissed = t; + } + isTermsSummaryDismissed() { + return this.termsSummaryDismissed; + } + getActivationButtonPosition() { + return this.activationButtonPosition; + } + setActivationButtonPosition(t) { + this.activationButtonPosition = t; + } + getPaletteState() { + return this.paletteState; + } + setPaletteState(t) { + this.paletteState = t; + } + isActivationShortcut() { + return this.activationShortcut; + } + setActivationShortcut(t) { + this.activationShortcut = t; + } + isActivationAnimation() { + return this.activationAnimation; + } + setActivationAnimation(t) { + this.activationAnimation = t; + } + getRecentSwitchedUsernames() { + return this.recentSwitchedUsernames; + } + setRecentSwitchedUsernames(t) { + this.recentSwitchedUsernames = t; + } + addRecentSwitchedUsername(t) { + this.setRecentSwitchedUsernames(gl([t, ...this.recentSwitchedUsernames])); + } + removeRecentSwitchedUsername(t) { + this.setRecentSwitchedUsernames(this.recentSwitchedUsernames.filter((r) => r !== t)); + } + getNewVersionPreReleasesVisible() { + return this.newVersionPreReleasesVisible; + } + setNewVersionPreReleasesVisible(t) { + this.newVersionPreReleasesVisible = t; + } + setSendErrorReportsAllowed(t) { + this.sendErrorReportsAllowed = t; + } + isSendErrorReportsAllowed() { + return this.sendErrorReportsAllowed; + } + setAIUsageAllowed(t) { + this.aiUsageAllowed = t; + } + isAIUsageAllowed() { + return this.aiUsageAllowed; + } + getAIProvider() { + return this.aiProvider; + } + setAIProvider(t) { + this.aiProvider = t; + } + setFeedbackDisplayedAtLeastOnce(t) { + this.feedbackDisplayedAtLeastOnce = t; + } + isFeedbackDisplayedAtLeastOnce() { + return this.feedbackDisplayedAtLeastOnce; + } +} +function jn(e) { + const t = { ...e }; + return delete t.initializer, t; +} +class zl { + constructor() { + this._previewActivated = !1, this._remainingTimeInMillis = -1, this._active = !1, this._configurationLoaded = !1, $e(this); + } + setConfiguration(t) { + this._previewActivated = t.previewActivated, t.previewActivated ? this._remainingTimeInMillis = t.remainingTimeInMillis : this._remainingTimeInMillis = -1, this._active = t.active, this._configurationLoaded = !0; + } + get previewActivated() { + return this._previewActivated; + } + get remainingTimeInMillis() { + return this._remainingTimeInMillis; + } + get active() { + return this._active; + } + get configurationLoaded() { + return this._configurationLoaded; + } + get expired() { + return this.previewActivated && !this.active; + } + reset() { + this._previewActivated = !1, this._active = !1, this._configurationLoaded = !1, this._remainingTimeInMillis = -1; + } + loadPreviewConfiguration() { + Nt(`${he}get-preview`, {}, (t) => { + const r = t.data; + this.setConfiguration(r); + }).catch((t) => { + Promise.resolve().then(() => Tc).then((r) => { + r.handleCopilotError("Load preview configuration failed", t); + }); + }); + } +} +const Rn = "copilot-conf"; +class We { + static get sessionConfiguration() { + const t = sessionStorage.getItem(Rn); + return t ? JSON.parse(t) : {}; + } + static saveCopilotActivation(t) { + const r = this.sessionConfiguration; + r.active = t, this.persist(r); + } + static getCopilotActivation() { + return this.sessionConfiguration.active; + } + static saveDrawerSize(t, r) { + const n = this.sessionConfiguration; + n.drawerSizes = n.drawerSizes ?? {}, n.drawerSizes[t] = r, this.persist(n); + } + static getDrawerSize(t) { + const r = this.sessionConfiguration; + if (r.drawerSizes) + return r.drawerSizes[t]; + } + static savePanelConfigurations(t) { + const r = this.sessionConfiguration; + r.sectionPanelState = t, this.persist(r); + } + static getPanelConfigurations() { + return this.sessionConfiguration.sectionPanelState; + } + static persist(t) { + sessionStorage.setItem(Rn, JSON.stringify(t)); + } + static savePrompts(t) { + const r = this.sessionConfiguration; + r.prompts = t, this.persist(r); + } + static getPrompts() { + return this.sessionConfiguration.prompts || []; + } + static saveCurrentSelection(t) { + const r = this.sessionConfiguration; + r.selection = r.selection ?? {}, r.selection && (r.selection.current = t, r.selection.location = window.location.pathname, this.persist(r)); + } + static savePendingSelection(t) { + const r = this.sessionConfiguration; + r.selection = r.selection ?? {}, r.selection && (r.selection.pending = t, r.selection.location = window.location.pathname, this.persist(r)); + } + static getCurrentSelection() { + const t = this.sessionConfiguration.selection; + if (t?.location === window.location.pathname) + return t.current; + } + static getPendingSelection() { + const t = this.sessionConfiguration.selection; + if (t?.location === window.location.pathname) + return t.pending; + } + static saveDrillDownContextReference(t) { + const r = this.sessionConfiguration; + r.drillDownContext = r.drillDownContext ?? {}, r.drillDownContext && (r.drillDownContext.location = window.location.pathname, r.drillDownContext.stack = t, this.persist(r)); + } + static getDrillDownContextReference() { + const t = this.sessionConfiguration; + if (t?.drillDownContext?.location === window.location.pathname) + return t.drillDownContext?.stack; + } +} +class Ul { + constructor() { + this._panels = [], this._attentionRequiredPanelTag = null, this._floatingPanelsZIndexOrder = [], this.renderedPanels = /* @__PURE__ */ new Set(), this.customTags = /* @__PURE__ */ new Map(), $e(this), this.restorePositions(); + } + shouldRender(t) { + return this.renderedPanels.has(t); + } + restorePositions() { + const t = We.getPanelConfigurations(); + t && (this._panels = this._panels.map((r) => { + const n = t.find((i) => i.tag === r.tag); + return n && (r = Object.assign(r, { ...n })), r; + })); + } + /** + * Brings a given floating panel to the front. + * + * @param panelTag the tag name of the panel + */ + bringToFront(t) { + this._floatingPanelsZIndexOrder = this._floatingPanelsZIndexOrder.filter((r) => r !== t), this.getPanelByTag(t)?.floating && this._floatingPanelsZIndexOrder.push(t); + } + /** + * Returns the focused z-index of floating panel as following order + *